Memory Bank-Kurzanleitung mit ADK

Mit der Agent Platform Memory Bank können Ihre Agenten langfristig gemerkte Informationen über Sitzungen hinweg verwalten. Wenn Sie das Agent Development Kit (ADK) verwenden, kann Ihr KI-Agent automatisch Aufrufe an Memory Bank orchestrieren, um gemerkte Informationen basierend auf Nutzerinteraktionen zu speichern und abzurufen.

In diesem Dokument wird beschrieben, wie Sie einen ADK-Agenten erstellen, ihn für die Verwendung von Memory Bank konfigurieren und mit ihm interagieren, um gemerkte Informationen zu generieren und darauf zuzugreifen.

Informationen zum direkten Aufrufen der API ohne ADK finden Sie in der Kurzanleitung für die Memory Bank API.

Wichtig: Im ADK werden hauptsächlich asynchrone Funktionen verwendet. Wenn Sie Code in einem Notebook wie Colaboratory ausführen, können Sie await-Async-Funktionen direkt aufrufen, da bereits eine Ereignisschleife ausgeführt wird. Wenn Sie diesen Code als Standard-Python-Skript ausführen, müssen Sie Ihre asynchronen Funktionsaufrufe mit asyncio.run() umschließen. So können Sie eine Ereignisschleife zum Ausführen Ihrer asynchronen Funktionen erstellen und verwalten. Andernfalls wird möglicherweise ein Fehler wie 'await' outside function angezeigt.

Wenn Sie ein Beispiel für die Verwendung von Memory Bank mit dem ADK sehen möchten, führen Sie das Notebook „Erste Schritte mit Memory Bank im ADK“ in einer der folgenden Umgebungen aus:

In Colab öffnen | In Colab Enterprise öffnen | In Agent Platform Workbench öffnen | Auf GitHub ansehen

Gemerkte Informationen mit dem ADK-Memory-Service und der Memory Bank verwalten

VertexAiMemoryBankService ist ein ADK-Wrapper für Memory Bank, der durch die BaseMemoryService des ADK definiert wird. Sie können Callbacks und Tools definieren, die mit dem Memory-Dienst interagieren, um gemerkte Informationen zu lesen und zu schreiben.

Die VertexAiMemoryBankService-Schnittstelle umfasst Folgendes:

• memory_service.add_session_to_memory löst eine GenerateMemories-Anfrage an Memory Bank aus, wobei alle Ereignisse in der angegebenen adk.Session als Quellinhalt verwendet werden. Sie können Aufrufe dieser Methode mit callback_context.add_session_to_memory in Ihren Callbacks orchestrieren.

  from google.adk.agents.callback_context import CallbackContext
  
  async def add_session_to_memory_callback(callback_context: CallbackContext):
      await callback_context.add_session_to_memory()
      return None
  

• memory_service.add_events_to_memory, wodurch eine GenerateMemories-Anfrage an Memory Bank mit einer Teilmenge von Ereignissen ausgelöst wird. Sie können Aufrufe dieser Methode mit callback_context.add_events_to_memory in Ihren Callbacks orchestrieren.

  from google.adk.agents.callback_context import CallbackContext
  
  async def add_events_to_memory_callback(callback_context: CallbackContext):
      await callback_context.add_events_to_memory(events=callback_context.session.events[-5:-1])
      return None
  

• memory_service.search_memory löst eine RetrieveMemories-Anfrage an Memory Bank aus, um relevante gemerkte Informationen für die aktuelle user_id und app_name abzurufen. Sie können Aufrufe dieser Methode mit integrierten Memory-Tools (LoadMemoryTool oder PreloadMemoryTool) oder einem benutzerdefinierten Tool, das tool_context.search_memory aufruft, orchestrieren.

Hinweis

Wenn Sie dieser Anleitung folgen möchten, sollten Sie zuerst die Schritte im Abschnitt „Erste Schritte“ auf der Seite „Memory Bank einrichten“ ausführen.

Umgebungsvariablen festlegen

Zwecks Verwendung des ADK legen Sie Ihre Umgebungsvariablen fest:

import os

os.environ["GOOGLE_GENAI_USE_ENTERPRISE"] = "TRUE"
os.environ["GOOGLE_CLOUD_PROJECT"] = "PROJECT_ID"
os.environ["GOOGLE_CLOUD_LOCATION"] = "LOCATION"

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID.
• LOCATION: Ihre Region. Sehen Sie sich die unterstützten Regionen für Memory Bank an.

ADK-Agenten erstellen

Wenn Sie einen KI-Agenten mit gemerkten Informationen erstellen möchten, richten Sie Tools und Callbacks ein, die Aufrufe an Ihren Memory-Dienst orchestrieren.

Callback für die Generierung von gemerkten Informationen definieren

Wenn Sie Aufrufe für das Merken von Informationen orchestrieren möchten, erstellen Sie eine Callback-Funktion, die das Merken von Informationen auslöst. Sie können entweder eine Teilmenge von Ereignissen (mit callback_context.add_events_to_memory) oder alle Ereignisse in einer Sitzung (mit callback_context.add_session_to_memory) senden, die im Hintergrund verarbeitet werden sollen:

from google.adk.agents.callback_context import CallbackContext

async def generate_memories_callback(callback_context: CallbackContext):
    # Option 1 (Recommended): Send events to Memory Bank for memory generation,
    # which is ideal for incremental processing of events.
    await callback_context.add_events_to_memory(
      events=callback_context.session.events[-5:-1])

    # Option 2: Send the full session to Memory Bank for memory generation.
    # It's recommended to only call this at the end of a session to minimize
    # how many times a single event is re-processed.
    await callback_context.add_session_to_memory()

    return None

Tool zum Abrufen von gemerkten Informationen definieren

Wenn Sie Ihren ADK-Agenten entwickeln, fügen Sie ein Memory-Tool ein. Dieses legt fest, wann der Agent gemerkte Informationen abruft und wie diese in den Prompt aufgenommen werden.

Wenn Sie PreloadMemoryTool verwenden, ruft Ihr KI-Agent zu Beginn jedes Turns gemerkte Informationen ab und fügt sie in die Systemanweisung ein. Das ist hilfreich, um einen grundlegenden Kontext zum Nutzer herzustellen. Wenn Sie LoadMemoryTool verwenden, ruft das Modell dieses Tool auf, wenn es entscheidet, dass gemerkte Informationen erforderlich sind, um die Nutzeranfrage zu beantworten.

from google import adk
from google.adk.tools.load_memory_tool import LoadMemoryTool
from google.adk.tools.preload_memory_tool import PreloadMemoryTool

memory_retrieval_tools = [
  # Option 1: Retrieve memories at the start of every turn.
  PreloadMemoryTool(),
  # Option 2: Retrieve memories via tool calls. The model will only call this tool
  # when it decides that memories are necessary to respond to the user query.
  LoadMemoryTool()
]

agent = adk.Agent(
    model="gemini-3.5-flash",
    name='stateful_agent',
    instruction="""You are a Vehicle Voice Agent, designed to assist users with information and in-vehicle actions.

1.  **Direct Action:** If a user requests a specific vehicle function (e.g., "turn on the AC"), execute it immediately using the corresponding tool. You don't have the outcome of the actual tool execution, so provide a hypothetical tool execution outcome.
2.  **Information Retrieval:** Respond concisely to general information requests with your own knowledge (e.g., restaurant recommendation).
3.  **Clarity:** When necessary, try to seek clarification to better understand the user's needs and preference before taking an action.
4.  **Brevity:** Limit responses to under 30 words.
""",
    tools=memory_retrieval_tools,
    after_agent_callback=generate_memories_callback
)

Alternativ können Sie ein eigenes benutzerdefiniertes Tool zum Abrufen von gemerkten Informationen erstellen. Das ist hilfreich, wenn Sie Ihrem Agenten Anweisungen geben möchten, wann er gemerkte Informationen abrufen soll:

from google import adk
from google.adk.tools import ToolContext, FunctionTool

async def search_memories(query: str, tool_context: ToolContext):
  """Query this tool when you need to fetch information about user preferences."""
  return await tool_context.search_memory(query)

agent = adk.Agent(
    model="gemini-3.5-flash",
    name='stateful_agent',
    instruction="""...""",
    tools=[FunctionTool(func=search_memories)],
    after_agent_callback=generate_memories_callback
)

ADK-Memory Bank-Speicherdienst und Memory Bank-Instanz definieren

Nachdem Sie Ihren KI-Agenten mit gemerkten Informationen erstellt haben, müssen Sie ihn mit einem Dienst für gemerkte Informationen verknüpfen. Die Konfiguration des ADK-Memory-Dienstes hängt davon ab, wo Ihr ADK-Agent ausgeführt wird. Die Laufzeit orchestriert die Ausführung Ihrer KI-Agenten, Tools und Callbacks.

Memory Bank-Instanz erstellen

Hinweis: Überspringen Sie diesen Abschnitt, wenn Sie bereits eine Memory Bank-Instanz haben.

Sie müssen zuerst eine Memory Bank-Instanz erstellen. Dieser Schritt ist optional, wenn Sie Ihren KI-Agenten mit der Agent Runtime bereitstellen. Weitere Informationen zum Anpassen des Verhaltens Ihrer Memory Bank finden Sie im Abschnitt Memory Bank-Instanz konfigurieren auf der Seite „Memory Bank einrichten“.

import agentplatform

client = agentplatform.Client(
  project="PROJECT_ID",
  location="LOCATION"
)
# If you don't have a Memory Bank instance already, create a
# Memory Bank instance using the default configuration.
memory_bank = client.memory_banks.create()

# Optionally, print out the resource name. You will need the
# resource name if you want to interact with your Memory Bank instance later on.
print(memory_bank.name)

memory_bank_id = memory_bank.name.split("/")[-1]

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID.
• LOCATION: Ihre Region. Sehen Sie sich die unterstützten Regionen für Memory Bank an.

ADK-Laufzeit erstellen

Übergeben Sie die Memory Bank-Instanz-ID an die Laufzeit- oder Bereitstellungsskripts, damit Ihr KI-Agent Memory Bank als ADK-Speicherdienst verwendet.

Lokaler Runner

adk.Runner wird im Allgemeinen in einer lokalen Umgebung wie Colab verwendet. In diesem Fall müssen Sie den Speicherdienst und den Runner direkt erstellen.

import asyncio

from google.adk.memory import VertexAiMemoryBankService
from google.adk.sessions import VertexAiSessionService
from google.genai import types

memory_service = VertexAiMemoryBankService(
    project="PROJECT_ID",
    location="LOCATION",
    agent_engine_id="MEMORY_BANK_ID",
)

# You can use any ADK session service. This example uses Sessions.
session_service = VertexAiSessionService(
    project="PROJECT_ID",
    location="LOCATION",
    agent_engine_id="SESSIONS_ID",
)

runner = adk.Runner(
    agent=agent,
    app_name="APP_NAME",
    session_service=session_service,
    memory_service=memory_service
)

async def call_agent(query, session, user_id):
  content = types.Content(role='user', parts=[types.Part(text=query)])
  events = runner.run_async(
    user_id=user_id, session_id=session, new_message=content)

  async for event in events:
      if event.is_final_response():
          final_response = event.content.parts[0].text
          print("Agent Response: ", final_response)

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID.
• LOCATION: Ihre Region. Sehen Sie sich die unterstützten Regionen für Memory Bank an.
• APP_NAME: ADK-App-Name. Der App-Name wird in das scope-Wörterbuch der generierten gemerkten Informationen aufgenommen, damit die gemerkten Informationen sowohl für Nutzer als auch für Apps isoliert sind.
• MEMORY_BANK_ID: Die Instanz-ID der Memory Bank. Beispiel: 456 in projects/my-project/locations/us-central1/reasoningEngines/456.
• SESSIONS_ID: Die Instanz-ID der Agent Platform-Sitzungen. Beispiel: 789 in projects/my-project/locations/us-central1/reasoningEngines/789.

Agent Runtime auf der Gemini Enterprise Agent Platform

Die Agent Runtime ADK-Vorlage (AdkApp) kann sowohl lokal als auch zum Bereitstellen eines ADK-Agenten in der Agent Runtime verwendet werden. Wenn das Memory Bank ADK-Template auf der Agent Platform bereitgestellt wird, wird VertexAiMemoryBankService als Standardspeicherdienst verwendet. Sie können also Ihre Memory Bank-Instanz erstellen und in einem einzigen Schritt in einer Laufzeit bereitstellen.

Weitere Informationen zum Einrichten Ihrer Memory Bank-Instanz, einschließlich der Anpassung des Verhaltens Ihrer Memory Bank, finden Sie unter Memory Bank konfigurieren.

Verwenden Sie den folgenden Code, um Ihren ADK-Agenten mit Memory-Funktion in der Agent Runtime bereitzustellen:

import asyncio

import agentplatform
from agentplatform.frameworks import AdkApp

client = agentplatform.Client(
  project="PROJECT_ID",
  location="LOCATION"
)

adk_app = AdkApp(agent=agent)

# Create a new resource with your agent deployed to Agent Runtime.
# The Agent Runtime instance will also include an empty Memory Bank instance.
runtime_instance = client.runtimes.create(
      agent=adk_app,
      config={
            "staging_bucket": "STAGING_BUCKET",
            "requirements": ["google-cloud-agentplatform[runtimes,adk]"]
      }
)

# Alternatively, update an existing resource to deploy your agent to Agent Platform.
# Your agent will have access to the Runtime instance's existing memories.
runtime_instance = client.runtimes.update(
      name=agent_engine.api_resource.name,
      agent=adk_app,
      config={
            "staging_bucket": "STAGING_BUCKET",
            "requirements": ["google-cloud-agentplatform[runtimes,adk]"]
      }
)

async def call_agent(query, session_id, user_id):
    async for event in agent_engine.async_stream_query(
        user_id=user_id,
        session_id=session_id,
        message=query,
    ):
        print(event)

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID.
• LOCATION: Ihre Region. Sehen Sie sich die unterstützten Regionen für Memory Bank an.
• STAGING_BUCKET: Ihr Cloud Storage-Bucket, der für das Staging Ihrer Agent Runtime verwendet werden soll.

Wenn die ADK-Vorlage lokal ausgeführt wird, wird InMemoryMemoryService als Standardspeicherdienst verwendet. Sie können den Standard-Memory-Dienst jedoch überschreiben, um VertexAiMemoryBankService zu verwenden:

def memory_bank_service_builder():
    return VertexAiMemoryBankService(
        project="PROJECT_ID",
        location="LOCATION",
        agent_engine_id="MEMORY_BANK_ID"
    )

adk_app = AdkApp(
      agent=adk_agent,
      # Override the default memory service.
      memory_service_builder=memory_bank_service_builder
)

async def call_agent(query, session_id, user_id):
  # adk_app is a local agent. If you want to deploy it to Agent Runtime,
  # use `client.runtimes.create(...)` or `client.runtimes.update(...)`
  # and call the returned Agent Runtime instance instead.
  async for event in adk_app.async_stream_query(
      user_id=user_id,
      session_id=session_id,
      message=query,
  ):
      print(event)

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID.
• LOCATION: Ihre Region. Sehen Sie sich die unterstützten Regionen für Memory Bank an.
• MEMORY_BANK_ID: Die Memory Bank-Instanz-ID, die für Memory Bank verwendet werden soll. Beispiel: 456 in projects/my-project/locations/us-central1/reasoningEngines/456.

Cloud Run

Wenn Sie ein Beispiel für die Verwendung von Memory Bank mit Cloud Run sehen möchten, führen Sie das Notebook „Erste Schritte mit Sitzungen und Memory Bank für ADK-Agenten in Cloud Run“ in einer der folgenden Umgebungen aus:

In Colab öffnen | In Colab Enterprise öffnen | In Agent Platform Workbench öffnen | Auf GitHub ansehen

Wenn Sie Ihren Agenten in Cloud Run bereitstellen möchten, finden Sie in der ADK-Dokumentation eine Anleitung dazu, wie Sie Ihren Agenten für die Bereitstellung in Cloud Run definieren.

adk deploy cloud_run \
    ...
    --memory_service_uri=agentengine://AGENT_ENGINE_ID

Google Kubernetes Engine (GKE)

Wenn Sie ein Beispiel für die Verwendung von Memory Bank mit der Google Kubernetes Engine sehen möchten, führen Sie das Notebook „Erste Schritte mit Sitzungen und Memory Bank für ADK-Agenten in GKE“ in einer der folgenden Umgebungen aus:

In Colab öffnen | In Colab Enterprise öffnen | In Agent Platform Workbench öffnen | Auf GitHub ansehen

Wenn Sie Ihren Agent in GKE bereitstellen möchten, folgen Sie der Anleitung in der ADK-Dokumentation, um zu erfahren, wie Sie Ihren Agent für die Bereitstellung in GKE definieren.

adk deploy gke \
    ...
    --memory_service_uri=agentengine://AGENT_ENGINE_ID

ADK Web

Wichtig: ADK Web ist nicht für die Verwendung in Produktionsbereitstellungen vorgesehen. Sie sollten ADK Web nur für Entwicklungs- und Fehlerbehebungszwecke verwenden.

Mit der ADK-Weboberfläche können Sie Ihre KI-Agenten direkt im Browser testen.

export GOOGLE_CLOUD_PROJECT="PROJECT_ID"
export GOOGLE_CLOUD_LOCATION="LOCATION"

adk web --memory_service_uri=agentengine://MEMORY_BANK_ID

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID.
• LOCATION: Ihre Region. Sehen Sie sich die unterstützten Regionen für Memory Bank an.
• MEMORY_BANK_ID: Die Instanz-ID der Memory Bank. Beispiel: 456 in projects/my-project/locations/us-central1/reasoningEngines/456.

Mit dem Agent interagieren

Nachdem Sie Ihren Agenten definiert und die Memory Bank eingerichtet haben, können Sie mit Ihrem Agenten interagieren. Wenn Sie bei der Initialisierung Ihres KI-Agenten einen Callback zum Auslösen der Generierung von gemerkten Informationen angegeben haben, wird die Generierung von gemerkten Informationen jedes Mal ausgelöst, wenn der KI-Agent aufgerufen wird.

Gemerkte Informationen werden im Bereich {"user_id": USER_ID, "app_name": APP_NAME} gespeichert, der der Nutzer-ID und dem App-Namen entspricht, die zum Ausführen Ihres KI-Agenten verwendet werden.

Die Methode zur Interaktion mit Ihrem Agenten hängt von seiner Ausführungsumgebung ab:

Lokaler Runner

# Use `asyncio.run(session_service.create(...))` if you're running this
# code as a standard Python script.
session = await session_service.create_session(
    app_name="APP_NAME",
    user_id="USER_ID"
)

# Use `asyncio.run(call_agent(...))` if you're running this code as a
# standard Python script.
await call_agent(
    "Can you fix the temperature?",
    session.id,
    "USER_ID"
)

Ersetzen Sie Folgendes:

• APP_NAME: App-Name für Ihren Runner.
• USER_ID: Eine Kennung für den Nutzer. In dieser Sitzung generierte Erinnerungen werden mit dieser intransparenten Kennung verschlüsselt. Der Bereich der generierten gemerkten Informationen wird als {"user_id": "USER_ID"} gespeichert.

Agent Runtime

Wenn Sie die ADK-Vorlage verwenden, können Sie die Agent Runtime aufrufen, um mit dem Speicher und den Sitzungen zu interagieren.

# Use `asyncio.run(agent_engine.async_create_session(...))` if you're
# running this code as a standard Python script.
session = await agent_engine.async_create_session(user_id="USER_ID")

# Use `asyncio.run(call_agent(...))` if you're running this code as a
# standard Python script.
await call_agent(
    "Can you fix the temperature?",
    session.get("id"),
    "USER_ID"
)

Ersetzen Sie Folgendes:

• USER_ID: Eine Kennung für den Nutzer. Die aus dieser Sitzung generierten gemerkten Informationen werden durch diese intransparente Kennung verschlüsselt. Der Bereich der generierten gemerkten Informationen wird als {"user_id": "USER_ID"} gespeichert.

Cloud Run

Weitere Informationen finden Sie im Abschnitt Agent testen der ADK Cloud Run-Bereitstellungsdokumentation.

GKE

Weitere Informationen finden Sie im Abschnitt Agent testen der ADK-GKE-Bereitstellungsdokumentation.

ADK Web

Wenn Sie ADK Web verwenden möchten, rufen Sie den lokalen Server unter http://localhost:8000 auf.

Standardmäßig wird die Nutzer-ID von ADK Web auf user festgelegt. Wenn Sie die Standard-Nutzer-ID überschreiben möchten, fügen Sie userId in die Suchparameter ein, z. B. http://localhost:8000?userId=YOUR_USER_ID.

Weitere Informationen finden Sie auf der Seite ADK Web in der ADK-Dokumentation.

Beispielinteraktion

Erste Sitzung

Wenn Sie PreloadMemoryTool verwendet haben, versucht der KI-Agent zu Beginn jedes Turns, gemerkte Informationen abzurufen, um auf Einstellungen zuzugreifen, die der Nutzer zuvor dem KI-Agenten mitgeteilt hat. Bei der ersten Interaktion des KI-Agenten mit dem Nutzer sind keine gemerkten Informationen verfügbar, die abgerufen werden könnten. Der Agent kennt also keine Nutzerpräferenzen wie die bevorzugte Temperatur, wie im folgenden Beispiel gezeigt:

1. Erste Abbiegung:

   • Nutzer: „Kannst du die Temperatur anpassen?“

   • (Toolaufruf): Das ADK versucht, gemerkte Informationen abzurufen. Es sind keine gemerkten Informationen verfügbar.

   • Modell: „Welche Temperatur bevorzugst du?“

   • (Callback): Das ADK löst die Generierung von Erinnerungen aus. Es werden keine gemerkten Informationen extrahiert.

2. Zweiter Schritt:

   • Nutzer: Ich fühle mich bei 22 Grad wohl.

   • (Toolaufruf): Das ADK versucht, gemerkte Informationen abzurufen. Es sind keine gemerkten Informationen verfügbar.

   • Modell: Okay, ich habe die Temperatur auf 21 Grad eingestellt.

   • (Callback): Das ADK löst die Generierung von Erinnerungen aus. Die gemerkte Information „Ich mag eine Temperatur von 22 Grad“ wird erstellt.

Zweite Sitzung

Die extrahierten gemerkten Informationen sind für die nächste Sitzung mit demselben App-Namen und derselben Nutzer-ID verfügbar. Wenn der Nutzer ähnliche oder widersprüchliche Informationen zu bestehenden gemerkten Informationen angibt, werden die neuen Informationen mit den bestehenden gemerkten Informationen zusammengeführt.

1. Erster Schritt

   • Nutzer: Pass die Temperatur an. Das ist so unangenehm!

   • (Toolaufruf): Das ADK versucht, gemerkte Informationen abzurufen. Die gemerkte Information „Ich mag eine Temperatur von 21 Grad“ wird abgerufen.

   • Modell: Okay, ich habe die Temperatur auf 21 Grad eingestellt.

   • (Callback): Das ADK löst die Generierung von Erinnerungen aus. Es werden keine gemerkten Informationen extrahiert, da der Nutzer keine relevanten Informationen zum Speichern angegeben hat.

2. Zweite Abbiegung

   • Nutzer: Eigentlich habe ich es morgens lieber etwas wärmer.

   • (Toolaufruf): Das ADK versucht, gemerkte Informationen abzurufen. Die gemerkte Information „Ich mag eine Temperatur von 21 Grad“ wird abgerufen.

   • Modell: Okay, ich habe die Temperatur erhöht.

   • (Callback): Das ADK löst die Generierung von Informationen aus. Die vorhandene gemerkte Information „Ich mag eine Temperatur von 22 Grad“ wird zu „Ich mag im Allgemeinen eine Temperatur von 22 Grad, aber morgens mag ich es wärmer“ aktualisiert.

Hinweis: Je nach verwendetem Modell können die Antworten des Agents und der Memory Bank variieren.

Multiregionale Memory Bank mit einer regionalen Laufzeit verwenden

Wenn Sie die Laufzeit mit integrierter Memory Bank verwenden, werden Ihr KI-Agent und die Memory Bank standardmäßig in derselben Region bereitgestellt. Sie können sie jedoch entkoppeln, um eine multiregionale Memory Bank (z. B. us) mit einer regionalen Laufzeit (z. B. us-central1) zu verwenden. Mit dieser Konfiguration können Sie eine zentrale Memory Bank für verschiedene regionale Bereitstellungen verwalten.

Wenn Sie eine multiregionale Memory Bank verwenden möchten, müssen Sie den Standard-ADK-Memory-Service-Builder so überschreiben, dass er auf den multiregionalen Standort und die entsprechende Memory Bank-ID verweist.

import agentplatform
from google.adk.memory import VertexAiMemoryBankService
from agentplatform.frameworks import AdkApp

# Create the Memory Bank instance in a multi-region location (for example, 'us')
client_mb = agentplatform.Client(project="PROJECT_ID", location="us")
memory_bank = client_mb.memory_banks.create()
memory_bank_id = memory_bank.name.split("/")[-1]


# Point your memory service to the 'us' location, 'us' Memory Bank
def memory_bank_service_builder():
    return VertexAiMemoryBankService(
        project="PROJECT_ID",
        location="us",
        agent_engine_id=memory_bank_id
    )

# Create the AdkApp with the overridden builder
adk_app = AdkApp(
    agent=agent,
    memory_service_builder=memory_bank_service_builder
)

# Deploy the runtime to a specific region (for example, 'us-central1')
client_runtime = agentplatform.Client(project="PROJECT_ID", location="us-central1")
runtime_instance = client_runtime.runtimes.create(
    agent=adk_app,
    config={
        "staging_bucket": "STAGING_BUCKET",
        "requirements": ["google-cloud-agentplatform[runtimes,adk]"]
    }
)

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID.
• STAGING_BUCKET: Ihr Cloud Storage-Bucket, der für das Staging Ihrer Agent Runtime verwendet werden soll.

Bereinigen

Wenn Sie alle in diesem Projekt verwendeten Ressourcen bereinigen möchten, können Sie das Google Cloud-Projekt löschen, das Sie für die Kurzanleitung verwendet haben.

Andernfalls können Sie die einzelnen Ressourcen, die Sie in dieser Anleitung erstellt haben, so löschen:

1. Verwenden Sie das folgende Codebeispiel, um die Agent Runtime-Instanz zu löschen. Dadurch werden auch alle Sitzungen oder gemerkten Informationen gelöscht, die zu dieser Laufzeit gehören.

   client_runtime.runtimes.delete(name=runtime_instance.api_resource.name, force=True)
   client_mb.memory_banks.delete(name=memory_bank.name, force=True)
   

2. Löschen Sie alle lokal erstellten Dateien.

Nächste Schritte

Kurzanleitung

Kurzanleitung: Memory Bank API

Erste Schritte mit der Memory Bank API zum Verwalten von Langzeitinformationen.