1. Einführung
Das „Goldfisch“-Problem
Stellen Sie sich vor, Sie beauftragen ein Reisebüro, Ihren Traumurlaub in Tokio zu planen. Mit dem Session Agent können Sie sich „The Goldfish Problem“ in Aktion ansehen.
Sie gehen in das Büro der Person und sagen:
„Hallo, Ich möchte eine zweitägige Reise nach Tokio planen. Ich interessiere mich für historische Stätten und Sushi.“
Der KI-Agent antwortet begeistert:
"Great! Ich habe einen Besuch des Kaiserpalasts und ein Sushi-Abendessen im Sukiyabashi Jiro geplant.“
Sie lächeln und sagen:
„Das klingt perfekt! Kannst du mir den Reiseplan schicken?“
Der Agent sieht Sie verständnislos an und fragt:
„Hallo, Wie kann ich dir heute bei der Planung einer Reise helfen?“
Das ist das „Goldfisch-Problem“. Ohne gemerkte Informationen ist jede Interaktion ein unbeschriebenes Blatt. Die Intelligenz ist vorhanden – der Agent weiß, wie man Reisen plant –, aber die Kontinuität fehlt. Damit ein KI-Agent wirklich nützlich ist, muss er sich Dinge merken können.
Deine heutige Aufgabe
In diesem Workshop lösen Sie das Goldfisch-Problem, indem Sie einen Reisebüro-Agenten erstellen, der sich Informationen merkt, lernt und sich anpasst. Sie durchlaufen 6 Stufen des KI-Agenten-Arbeitsspeichers und erstellen ein System, das sich weniger wie ein Chatbot und mehr wie ein persönlicher Assistent verhält.
Level | Konzept | Die „Superkraft“ |
Level 1 | Sitzung und Status | Unterhaltungen führen, ohne etwas zu vergessen |
Level 2 | Multi-Agenten-Status | Notizen zwischen Teammitgliedern teilen |
Level 3 | Persistenz | Sie werden auch nach einem Neustart des Systems erkannt. |
Level 4 | Callbacks | Gemerkte Informationen werden vollständig autonom aktualisiert |
Level 5 | Benutzerdefinierte Tools | Strukturierte Nutzerprofile lesen und schreiben |
Level 6 | Multimodales Gedächtnis | Fotos und Videos „sehen“ und sich daran erinnern |
Der ADK-Speicher-Stack
Bevor wir Code schreiben, sollten wir uns mit den Tools vertraut machen, die wir verwenden. Das Google Agent Development Kit (ADK) bietet eine strukturierte Möglichkeit, mit dem Gedächtnis umzugehen:
- Sitzung: Der Container für eine Unterhaltung. Er enthält den Verlauf des Gesagten.
- Zustand: Ein Schlüssel/Wert-Paar, das an die Sitzung angehängt ist. Agenten verwenden diesen, um bestimmte Fakten zu speichern (z.B.
destination="Tokyo"). - MemoryService: Langzeitspeicher. Hier werden Daten dauerhaft gespeichert, z. B. Nutzereinstellungen oder analysierte Dokumente.
2. Erstelle ein
Für unsere KI-Agenten benötigen wir zwei Dinge: ein Google Cloud-Projekt als Grundlage
Teil 1: Rechnungskonto aktivieren
Für dieses Codelab benötigen Sie ein Rechnungskonto mit Guthaben. Verwenden Sie das Guthaben aus dem Banner oben in diesem Codelab, um loszulegen. Wenn Sie bereits mit einem Rechnungskonto verbunden sind, können Sie diesen Schritt überspringen.
Teil 2: Umgebung öffnen
- 👉 Klicken Sie auf diesen Link, um direkt zum Cloud Shell-Editor zu gelangen.
- 👉 Wenn Sie heute zu irgendeinem Zeitpunkt zur Autorisierung aufgefordert werden, klicken Sie auf Autorisieren, um fortzufahren.
- 👉 Wenn das Terminal nicht unten auf dem Bildschirm angezeigt wird, öffnen Sie es:
- Klicken Sie auf Ansehen.
- Klicken Sie auf Terminal.
- 👉💻 Prüfen Sie im Terminal mit dem folgenden Befehl, ob Sie bereits authentifiziert sind und ob das Projekt auf Ihre Projekt-ID festgelegt ist:
gcloud auth list - 👉💻 Klonen Sie das Bootstrap-Projekt von GitHub:
git clone https://github.com/cuppibla/memory_agent_starter - 👉💻 Führen Sie das Setupscript im Projektverzeichnis aus.
cd ~/memory_agent_starter ./init.sh - 👉💻 Legen Sie die erforderliche Projekt-ID fest:
gcloud config set project $(cat ~/project_id.txt) --quiet
Teil 3: Berechtigungen einrichten
- 👉💻 Aktivieren Sie die erforderlichen APIs mit dem folgenden Befehl. Dies kann einige Minuten dauern.
gcloud services enable \ cloudresourcemanager.googleapis.com \ servicenetworking.googleapis.com \ run.googleapis.com \ aiplatform.googleapis.com \ compute.googleapis.com - 👉💻 Erteilen Sie die erforderlichen Berechtigungen, indem Sie die folgenden Befehle im Terminal ausführen:
. ~/memory_agent_starter/set_env.sh
Beachten Sie, dass eine .env-Datei für Sie erstellt wird. Daraufhin werden Ihre Projektinformationen angezeigt.
3. Das Fundament – Sitzung und Status
Das Konzept: Der Kontext ist entscheidend
Die einfachste Form von Memory ist Session Memory. So kann ein KI-Agent erkennen, dass sich „es“ im Satz „Ich möchte es kaufen“ auf den Schuh bezieht, über den Sie vor 10 Sekunden gesprochen haben.
Im ADK verwalten wir dies mit dem Session-Objekt.
- Zustandsloser Ansatz: Für jede Nachricht wird eine neue Sitzung erstellt.
- Zustandsorientierter Ansatz: Es wird eine Sitzung erstellt und für die gesamte Unterhaltung wiederverwendet.
Schritt 1: Agenten prüfen
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/01_session_agent/agent.py
Öffnen Sie ~/memory_agent_starter/01_session_agent/agent.py.
👉 Suchen Sie den Kommentar # TODO: Create a root agent in der Funktion agent.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
root_agent = LlmAgent(
name="multi_day_trip_agent",
model="gemini-2.5-flash",
description="Agent that progressively plans a multi-day trip, remembering previous days and adapting to user feedback.",
instruction="""
You are the "Adaptive Trip Planner" 🗺️ - an AI assistant that builds multi-day travel itineraries step-by-step.
Your Defining Feature:
You have short-term memory. You MUST refer back to our conversation to understand the trip's context, what has already been planned, and the user's preferences. If the user asks for a change, you must adapt the plan while keeping the unchanged parts consistent.
Your Mission:
1. **Initiate**: Start by asking for the destination, trip duration, and interests.
2. **Plan Progressively**: Plan ONLY ONE DAY at a time. After presenting a plan, ask for confirmation.
3. **Handle Feedback**: If a user dislikes a suggestion (e.g., "I don't like museums"), acknowledge their feedback, and provide a *new, alternative* suggestion for that time slot that still fits the overall theme.
4. **Maintain Context**: For each new day, ensure the activities are unique and build logically on the previous days. Do not suggest the same things repeatedly.
5. **Final Output**: Return each day's itinerary in MARKDOWN format.
""",
tools=[google_search]
)
Die Anweisung weist das LLM an, sich zu erinnern, aber der Code muss die Fähigkeit zum Erinnern bereitstellen.
Schritt 2: Die beiden Szenarien
Öffnen Sie ~/memory_agent_starter/01_session_agent/main.py.
👉 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/01_session_agent/main.py
Öffnen Sie ~/memory_agent_starter/01_session_agent/main.py und suchen Sie in der Funktion main.py nach dem Kommentar # TODO: Create a runner with in memorysession service.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
runner = Runner(
agent=agent,
session_service=session_service,
app_name=agent.name
)
👉 Suchen Sie den Kommentar # TODO: create a different session to test in der Funktion main.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
tokyo_session_2 = await session_service.create_session(
app_name=multi_day_agent.name,
user_id=user_id
)
Testen
Wir haben zwei Funktionen, die den Unterschied zwischen dem „Goldfisch“- und dem „Elefanten“-Gedächtnis veranschaulichen.
Szenario 1: Stateful (gemeinsame Sitzung)
async def run_trip_same_session_scenario(session_service, user_id):
# 1. Create ONE session
trip_session = await session_service.create_session(...)
# 2. Turn 1
await run_agent_query(..., trip_session, ...)
# 3. Turn 2 - REUSING the same session!
# The agent can "see" Turn 1 because it's in the session history.
await run_agent_query(..., trip_session, ...)
Szenario 2: Zustandslos (jedes Mal eine neue Sitzung)
async def run_trip_different_session_scenario(session_service, user_id):
# Turn 1
tokyo_session = await session_service.create_session(...)
await run_agent_query(..., tokyo_session, ...)
# Turn 2 - Creating a FREASH session
# The agent has NO IDEA what happened in Turn 1.
tokyo_session_2 = await session_service.create_session(...)
await run_agent_query(..., tokyo_session_2, ...)
Schritt 3: Agent ausführen
Sehen wir uns den Unterschied einmal genauer an. Führen Sie das Script aus:
👉💻 Führen Sie in der Befehlszeile den folgenden Befehl aus:
cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/01_session_agent/main.py
Szenario 1: Der Agent merkt sich Ihre Präferenzen aus der ersten Nachricht und passt den Plan in der zweiten Nachricht an.
Szenario 2 beobachten: In der zweiten Runde („Weißt du noch, was mir am Essen gefallen hat?“) scheitert der KI-Agent vollständig, da es sich um eine neue Sitzung handelt. Das bedeutet im Grunde: „Ich weiß nicht, wovon du redest.“
Wichtigste Erkenntnis
Regel 1 für Memory: Verwenden Sie immer die session.id wieder, um den Kontext der Unterhaltung beizubehalten. Das Objekt Session ist der Kurzzeitgedächtnispuffer Ihres KI-Agenten.
4. Das Team – Multi-Agenten-Status
Das Konzept: „Stille Post“
Wenn mehrere KI-Agenten zusammenarbeiten, ist das so, als würden Kollegen einen Ordner hin- und herreichen. Wenn ein Agent eine Notiz in den Ordner schreibt, sollte der nächste Agent sie lesen können.
Im ADK ist dieser „Ordner“ der Zustand.
- State ist ein Dictionary (
{"key": "value"}), das sich in der Sitzung befindet. - Jeder KI-Agent in der Sitzung kann daraus lesen oder darin schreiben.
Schritt 1: Workflow prüfen
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/02_multi_agent/agent.py
👉 Suchen Sie in der Datei ~/memory_agent_starter/02_multi_agent/agent.py nach dem Kommentar # TODO: foodie agent.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
foodie_agent = LlmAgent(
name="foodie_agent",
model="gemini-2.5-flash",
tools=[google_search],
instruction="""You are an expert food critic. Your goal is to find the best restaurant based on a user's request.
When you recommend a place, you must output *only* the name of the establishment and nothing else.
For example, if the best sushi is at 'Jin Sho', you should output only: Jin Sho
""",
output_key="destination" # ADK will save the agent's final response to state['destination']
)
👉 Suchen Sie den Kommentar # TODO: transportation agent in der Funktion agent.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
transportation_agent = LlmAgent(
name="transportation_agent",
model="gemini-2.5-flash",
tools=[google_search],
instruction="""You are a navigation assistant. Given a destination, provide clear directions.
The user wants to go to: {destination}.
Analyze the user's full original query to find their starting point.
Then, provide clear directions from that starting point to {destination}.
""",
)
👉 Suchen Sie den Kommentar # TODO: root_agent in der Funktion agent.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
root_agent = SequentialAgent(
name="find_and_navigate_agent",
sub_agents=[foodie_agent, transportation_agent],
description="A workflow that first finds a location and then provides directions to it."
)
Jetzt haben wir zwei Agenten, die nacheinander arbeiten:
- Foodie-Agent: Sucht nach einem Restaurant.
- Transport-Agent: Gibt eine Wegbeschreibung zu diesem Restaurant.
Die magische Übergabe: Achte darauf, wie foodie_agent den Staffelstab an transportation_agent übergibt.
foodie_agent = LlmAgent(
# ...
# CRITICAL: This tells ADK to save the agent's output to state['destination']
output_key="destination"
)
transportation_agent = LlmAgent(
# ...
# CRITICAL: This injects state['destination'] into the prompt
instruction="""
The user wants to go to: {destination}.
Provide clear directions...
""",
)
output_key="destination": Die Antwort des Foodie-Agenten wird effizient gespeichert.{destination}: Der Transport-Agent liest diese Antwort automatisch.
(Keine Aktion erforderlich) Schritt 2: Der Orchestrator
Öffnen Sie 02_multi_agent/main.py.
Wir verwenden ein SequentialAgent, um sie nacheinander auszuführen.
# 1. Create a single session for the sequential agent
session = await session_service.create_session(...)
# 2. Run the query
# The SequentialAgent manages the state flow:
# Query -> Foodie -> state['destination'] -> Transportation -> Final Answer
await run_agent_query(root_agent, query, ...)
Der Nutzer sendet einen Prompt:
"Find best sushi in Palo Alto and then tell me how to get there."
Die KI-Agenten arbeiten zusammen, um die Frage zu beantworten.
Schritt 3: Team leiten
👉💻 Führen Sie im Cloud Shell-Terminal den Multi-Agenten-Workflow aus:
cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/02_multi_agent/main.py
Was passiert?
- Foodie-Agent: Findet „Jin Sho“ (oder ähnlich).
- ADK: Speichert „Jin Sho“ in
state['destination']. - Transport-Agent: Erhält „Jin Sho“ in seiner Anweisung.
- Ergebnis: „Um vom Caltrain-Bahnhof zum Jin Sho zu gelangen, gehen Sie die University Ave entlang…“
Wichtigste Erkenntnis
Regel 2 für Memory: Verwenden Sie State, um strukturierte Informationen zwischen Agents zu übergeben. Verwenden Sie output_key zum Schreiben und {placeholders} zum Lesen.
5. Der Neustart – Persistenz
Das Konzept: „Das Neustartproblem“
Bisher haben wir InMemory verwendet. Wenn Sie das Script beenden und neu starten, vergisst der Agent alles. Das ist wie ein Computer, der seine Festplatte jedes Mal löscht, wenn du ihn ausschaltest.
Um dieses Problem zu beheben, benötigen wir Persistenz. Wir tauschen InMemorySessionService gegen DatabaseSessionService.
Schritt 1: Datenbankwechsel
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/03_persistent_agent/main.py
👉 Suchen Sie in der Datei ~/memory_agent_starter/03_persistent_agent/main.py nach dem Kommentar # TODO: Configuration for Persistent Sessions.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
SESSIONS_DIR = Path(os.path.expanduser("~")) / ".adk_codelab" / "sessions"
os.makedirs(SESSIONS_DIR, exist_ok=True)
SESSION_DB_FILE = SESSIONS_DIR / "trip_planner.db"
SESSION_URL = f"sqlite:///{SESSION_DB_FILE}"
Jetzt werden alle Sitzungen und Ereignisse in einer SQLite-Datei gespeichert.
Schritt 2: Sitzungsübergreifender Abruf
Persistenz ermöglicht nicht nur das Fortsetzen einer Unterhaltung, sondern auch das Lernen aus früheren Unterhaltungen.
Sehen Sie sich in derselben Datei ~/memory_agent_starter/03_persistent_agent/main.py den Abschnitt Testlauf 3: Cross-Session Retrieval an.
👉 Suche den Kommentar „# TODO: retrieve the previous session manually“.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
old_session = await session_service.get_session(
app_name=root_agent.name, user_id="user_01", session_id=session_id
)
👉 Suchen Sie den Kommentar # TODO: Extract content from the OLD session in der Funktion main.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
previous_context += f"- {role}: {text}\n"
👉 Suchen Sie den Kommentar # TODO: Manually inject the context to the query in der Funktion main.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
query_3 = f"""
{previous_context}
I'm planning a new trip to Osaka this time.
Based on my previous preferences (above), what should I eat?
"""
Damit wird simuliert, dass ein Nutzer Monate später zurückkehrt. Nur mit einer Datenbank können Sie diesen alten Verlauf abrufen.
Schritt 3: Neustart überstehen
👉💻 Führen Sie im Terminal das Skript aus:
cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/03_persistent_agent/main.py
Dadurch wird die Datei ~/memory_agent_starter/trip_planner.db erstellt. Probieren Sie Folgendes aus: Führen Sie das Script zweimal aus.
- Suchen Sie beim zweiten Durchlauf nach „Resumed existing session“ (Bestehende Sitzung fortgesetzt).
- Der Agent erinnert sich an den Kontext aus dem ersten Durchlauf, da er aus der Datenbankdatei geladen wird.
Wichtigste Erkenntnis
Regel 3 für Memory: Verwenden Sie DatabaseSessionService für die Produktion. So bleiben Nutzerunterhaltungen auch nach Serverneustarts erhalten und es ist eine langfristige Verlaufsanalyse möglich.
6. The Spy – Callbacks
Manchmal müssen Sie die gemerkten Informationen automatisch aktualisieren, basierend auf dem, was der Agent tut, und nicht nur auf dem, was er sagt. Sie möchten einen „Spion“, der den KI-Agenten beobachtet und Notizen macht.
Im ADK ist dieser Spion der Callback. 
after_tool_callback: Eine Funktion, die jedes Mal ausgeführt wird, wenn der Agent arbeitet.ToolContext: Eine Möglichkeit, innerhalb dieser Funktion in den Status zu schreiben.
Schritt 1: Die Logik
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/04_stateful_agent/agent.py
👉 Suchen Sie in der Datei ~/memory_agent_starter/04_stateful_agent/agent.py nach dem Kommentar # TODO: Implement call back logic.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
def save_activity_type_callback(
tool,
args: Dict[str, Any],
tool_context: ToolContext,
tool_response: Dict[str, Any],
) -> Optional[Dict[str, Any]]:
"""
Callback to save the TYPE of activity just planned into the session state.
"""
# 1. Get the actual agent name.
if tool.name == "transfer_to_agent":
agent_name = args.get("agent_name")
else:
agent_name = tool.name
activity_type = "unknown"
# 2. Determine the type based on which agent was actually used
if agent_name == "museum_expert":
activity_type = "CULTURAL"
elif agent_name == "restaurant_expert":
activity_type = "FOOD"
elif agent_name == "outdoor_expert":
activity_type = "OUTDOOR"
print(f"\n🔔 [CALLBACK] The planner transferred to '{agent_name}'.")
# 3. Update the state directly
tool_context.state["last_activity_type"] = activity_type
print(f"💾 [STATE UPDATE] 'last_activity_type' is now set to: {activity_type}\n")
return tool_response
👉 Suchen Sie in derselben Datei den Kommentar # TODO: add callback to root agent in der Funktion 04_stateful_agent/agent.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
after_tool_callback=save_activity_type_callback,
Die dynamische Anweisung: Die Anweisung des Agenten ist jetzt eine Funktion, kein String. Sie ändert sich je nach Status.
def get_planner_instruction(context):
last_activity = context.state.get("last_activity_type", "None")
return f"""
The last activity was: {last_activity}
If last_activity is 'CULTURAL' -> `museum_expert` is BANNED.
"""
Schritt 3: Spy testen
👉💻 Führen Sie im Terminal das Skript aus, indem Sie den folgenden Befehl kopieren und einfügen:
cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/04_stateful_agent/main.py
Wenn Sie diesen KI-Agenten ausführen, wird eine Schleife angezeigt.
- Runde 1: Sie fragen nach einem Museum. Spion legt
last_activity="CULTURAL"fest. - Runde 2: Sie fragen nach einem anderen Museum.
- Aktualisierung der Agentenanweisung: „KULTURELL ist VERBOTEN“.
- Agent: „Ich kann mir kein Museum mehr ansehen. Wie wäre es mit einem Park?“
Beobachten Sie die Konsolenlogs für [CALLBACK] und [STATE UPDATE]. Sie können sehen, wie sich die gemerkten Informationen in Echtzeit ändern, während der KI-Agent arbeitet.
Wichtigste Erkenntnis
Regel 4 für Memory: Verwenden Sie Callbacks, um die Zustandsverwaltung zu automatisieren. Der KI-Agent baut seinen eigenen Kontext auf, indem er einfach seine Arbeit erledigt.
7. Dateiablage – Benutzerdefinierte Tools
Das Konzept: „Strukturierter Speicher“
Bisher war „Memory“ ein Chatprotokoll oder ein einfaches Schlüssel/Wert-Paar. Was aber, wenn Sie sich ein komplexes Nutzerprofil merken müssen, z. B. diet: vegan, budget: high, pets: [cat, dog]?
Dazu behandeln wir die Funktion „Memory“ als Tool. Der Agent entscheidet explizit, wann er die Dateiablage öffnet (liest) und wann er einen Bericht ablegt (schreibt). 
Schritt 1: Die Tools
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/05_profile_agent/tools.py
👉 In dieser Datei: ~/memory_agent_starter/05_profile_agent/tools.py.
Wir müssen diese beiden spezifischen Tools implementieren:
save_user_preferences: Schreibt in eine Datenbank.recall_user_preferences: Liest aus einer Datenbank.
Suchen Sie den Kommentar # TODO: implement save_user_preferences tools in der Funktion ~/memory_agent_starter/05_profile_agent/tools.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
def save_user_preferences(tool_context: ToolContext, new_preferences: Dict[str, Any]) -> str:
user_id = tool_context.session.user_id
with sqlite3.connect(USER_DB_FILE) as conn:
for key, value in new_preferences.items():
conn.execute("INSERT INTO user_preferences (user_id, pref_key, pref_value) VALUES (?, ?, ?) ON CONFLICT(user_id, pref_key) DO UPDATE SET pref_value = excluded.pref_value;",
(user_id, key, json.dumps(value)))
return f"Preferences updated: {list(new_preferences.keys())}"
👉 Suchen Sie den Kommentar # TODO: implement recall_user_preferences tools in der Funktion 05/tools.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
def recall_user_preferences(tool_context: ToolContext) -> Dict[str, Any]:
user_id = tool_context.session.user_id
preferences = {}
with sqlite3.connect(USER_DB_FILE) as conn:
rows = conn.execute("SELECT pref_key, pref_value FROM user_preferences WHERE user_id = ?", (user_id,)).fetchall()
if not rows: return {"message": "No preferences found."}
for key, value_str in rows: preferences[key] = json.loads(value_str)
return preferences
Die Anweisung erzwingt einen Workflow:
instruction="""
1. RECALL FIRST: First action MUST be `recall_user_preferences`.
3. LEARN: If a user states a new preference, use `save_user_preferences`.
"""
Schritt 2: Die Ausführung
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/05_profile_agent/main.py
Öffnen Sie ~/memory_agent_starter/05_profile_agent/main.py.
Im Gegensatz zu früheren Modulen, in denen das ADK den Status automatisch verwaltet hat, hat hier der Agent die Kontrolle.
- Sie entscheidet sich, zu Beginn
recall_user_preferencesaufzurufen. - Es entscheidet sich,
save_user_preferencesaufzurufen, wenn Sie „Ich bin Veganer“ sagen.
Schritt 3: Profil erstellen
👉💻 Führen Sie das Script aus:
cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/05_profile_agent/main.py
Probieren Sie diesen Gesprächsablauf aus:
- „Hallo, plane ein Abendessen.“ -> Der KI-Agent prüft die Datenbank und findet nichts. Fragt nach Präferenzen.
- „Ich bin Veganer.“ -> Der Agent speichert „vegan“ in der Datenbank.
- Starten Sie das Script neu.
- „Hallo, plane ein Abendessen.“ -> Der Agent prüft die Datenbank, sieht „vegan“ und schlägt sofort ein veganes Restaurant vor.
Wichtigste Erkenntnis
Regel 5 für gemerkte Informationen: Stellen Sie Ihrem Agenten für komplexe, strukturierte Daten Lese-/Schreibtools zur Verfügung. Das LLM seinen eigenen langfristigen Speicher verwalten lassen.
8. The Brain – Multimodales Gedächtnis
Das Konzept: „The Human Experience“
Menschen merken sich mehr als nur Text. Wir erinnern uns an die Stimmung eines Fotos, den Klang einer Stimme, das Gefühl eines Videos.
Mit der Vertex AI Memory Bank kann Ihr Agent multimodale gemerkte Informationen verarbeiten. Es kann Bilder, Videos und Audio aufnehmen, „verstehen“ und später abrufen.
Schritt 1: Konfiguration
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/06_multimodal_agent/main.py
👉 Öffne 06_multimodal_agent/main.py. Suchen Sie den Kommentar # TODO: Configure Memory Bank Topic.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
travel_topics = [
MemoryTopic(
managed_memory_topic=ManagedMemoryTopic(
managed_topic_enum=ManagedTopicEnum.USER_PREFERENCES
)
),
MemoryTopic(
managed_memory_topic=ManagedMemoryTopic(
managed_topic_enum=ManagedTopicEnum.USER_PERSONAL_INFO
)
),
MemoryTopic(
custom_memory_topic=CustomMemoryTopic(
label="travel_experiences",
description="""Memorable travel experiences including:
- Places visited and impressions
- Favorite restaurants, cafes, and food experiences
- Preferred accommodation types and locations
- Activities enjoyed (museums, hiking, beaches, etc.)
- Travel companions and social preferences
- Photos and videos from trips with location context""",
)
),
MemoryTopic(
custom_memory_topic=CustomMemoryTopic(
label="travel_preferences",
description="""Travel style and preferences:
- Budget preferences (luxury, mid-range, budget)
- Transportation preferences (flying, trains, driving)
- Trip duration preferences
- Season and weather preferences
- Cultural interests and language abilities
- Dietary restrictions and food preferences""",
)
),
MemoryTopic(
custom_memory_topic=CustomMemoryTopic(
label="travel_logistics",
description="""Practical travel information:
- Passport and visa information
- Frequent flyer numbers and hotel loyalty programs
- Emergency contacts
- Medical considerations and insurance
- Packing preferences and essentials
- Time zone preferences and jet lag strategies""",
)
),
]
Suchen Sie den Kommentar # TODO: Configure Memory Bank Customization.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
memory_bank_config = {
"customization_configs": [
{
"memory_topics": travel_topics,
}
],
"similarity_search_config": {
"embedding_model": f"projects/{PROJECT_ID}/locations/{LOCATION}/publishers/google/models/gemini-embedding-001"
},
"generation_config": {
"model": f"projects/{PROJECT_ID}/locations/{LOCATION}/publishers/google/models/gemini-2.5-flash"
},
}
Schritt 2: Die Welt erfassen
In test_trip_planner senden wir:
- Eine SMS („Hallo“)
- Ein Bild (Sehenswürdigkeit)
- Video (Mittelmeer)
- Ein Audioclip (Sprachnotiz über Gaeta)
Suchen Sie den Kommentar # TODO create session service and memory service in der Funktion 6_multimodal_agent/main.py.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
session_service = VertexAiSessionService(
project=PROJECT_ID, location=LOCATION, agent_engine_id=agent_engine_id
)
memory_service = VertexAiMemoryBankService(
project=PROJECT_ID, location=LOCATION, agent_engine_id=agent_engine_id
)
👉 Suchen Sie in derselben Datei 06_multimodal_agent/main.py nach dem Kommentar # TODO: create memory from session.
Ersetzen Sie diese gesamte Zeile durch den folgenden Code:
await memory_service.add_session_to_memory(final_session_state)
Das ist die magische Linie. Diese Rich Media werden an Vertex AI gesendet, wo sie verarbeitet und indexiert werden.
Schritt 3: Abruf
👉💻 Öffnen Sie die Datei im Cloud Shell-Editor, indem Sie in Ihrem Cloud Shell-Terminal Folgendes ausführen:
cloudshell edit ~/memory_agent_starter/06_multimodal_agent/agent.py
Der KI-Agent hat einen PreloadMemoryTool.
tools=[PreloadMemoryTool(), budget_tool]
Wenn eine neue Sitzung beginnt, sucht dieses Tool automatisch in der Memory Bank nach relevanten früheren Erfahrungen und fügt sie in den Kontext ein.
Schritt 4: Brain ausführen
👉💻 Führen Sie das Skript in Ihrem Cloud Shell-Terminal aus (Hinweis: Dazu ist ein Google Cloud-Projekt mit aktiviertem Vertex AI erforderlich):
cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/06_multimodal_agent/main.py
Sehen Sie sich den letzten Bestätigungsschritt an:
„Basierend auf dem Bild, dem Video UND dem Audio, das ich zuvor mit dir geteilt habe…“
Der KI-Agent antwortet:
„Du solltest Gaeta besuchen! Du hast mir ein Video vom Mittelmeer und einen Audioclip gezeigt, in dem du gesagt hast, dass du Gaeta liebst.“
Sie hat die verschiedenen Medientypen der Vergangenheit miteinander verknüpft.
Wichtigste Erkenntnis
Regel 6 für Memory: Verwenden Sie Vertex AI Memory Bank für die ultimative Memory-Erfahrung. Es vereint Text, Bilder und Videos in einem einzigen, durchsuchbaren Gehirn.
9. Fazit
Sie haben sich von einem vergesslichen Goldfisch zu einem multimodalen Elefanten entwickelt.
Sie haben erstellt | Die Funktion |
Sitzungs-Agent | Kurzzeit-Unterhaltungsprotokoll |
Multi-Agent | Geteilte Teamerinnerungen |
Persistenter Agent | Langfristiger Verlauf |
Zustandsorientierter Agent | Dynamischer, sich selbst aktualisierender Speicher |
Profil-Agent | Speicher für strukturierte Daten |
Multimodaler Agent | Menschenähnliches sensorisches Gedächtnis |
Vertrauen basiert auf Erinnerungen. Durch die Implementierung dieser Muster erstellen Sie Agenten, die die Zeit und den Verlauf des Nutzers respektieren, was zu tieferen, effektiveren Interaktionen führt.
Erstellen Sie noch heute Ihre eigenen personalisierten KI-Agenten.