Memory Bank einrichten

Bevor Sie mit der Speicherbank der Vertex AI Agent Engine arbeiten, müssen Sie Ihre Umgebung einrichten. Memory Bank ist zwar Teil von Agent Engine, Sie müssen Ihren Code aber nicht in der Agent Engine-Laufzeitumgebung bereitstellen, um Memory Bank zu verwenden.

Ihr Google Cloud -Projekt einrichten

Jedes Projekt kann auf zwei Arten identifiziert werden: über die Projektnummer oder die Projekt-ID. Die PROJECT_NUMBER wird beim Erstellen des Projekts automatisch erstellt, während die PROJECT_ID von Ihnen oder dem Ersteller des Projekts erstellt wird. So richten Sie ein Projekt ein:

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API.

    Enable the API

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API.

    Enable the API

    8.

    Erforderliche Rollen abrufen

    Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Vertex AI-Nutzer (roles/aiplatform.user) für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie für die Verwendung von Vertex AI Agent Engine benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

    Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

    Wenn Sie Anfragen an Memory Bank von einem Agent senden, der in Google Kubernetes Engine oder Cloud Run bereitgestellt wird, muss Ihr Dienstkonto die erforderlichen Berechtigungen haben. Der Reasoning Engine-Dienst-Agent hat bereits die erforderlichen Berechtigungen zum Lesen und Schreiben von Erinnerungen. Ausgehende Anfragen von Agent Engine Runtime sollten also bereits die Berechtigung für den Zugriff auf Memory Bank haben.

    Umgebung einrichten

    In diesem Abschnitt wird davon ausgegangen, dass Sie eine Python-Entwicklungsumgebung eingerichtet haben oder eine Laufzeit mit einer Python-Entwicklungsumgebung verwenden (z. B. Colab).

    Bibliotheken installieren

    Installieren Sie das Vertex AI SDK:

      pip install google-cloud-aiplatform>=1.104.0

    Authentifizierung

    Die Authentifizierungsanleitung hängt davon ab, ob Sie Vertex AI im Express-Modus verwenden:

    • Wenn Sie Vertex AI nicht im Express-Modus verwenden, folgen Sie der Anleitung unter Bei Vertex AI authentifizieren.

    • Wenn Sie Vertex AI im Express-Modus verwenden, richten Sie die Authentifizierung ein, indem Sie den API-Schlüssel in der Umgebung festlegen:

        os.environ["GOOGLE_API_KEY"] = "API_KEY"

    Vertex AI SDK-Client einrichten

    Führen Sie den folgenden Code aus, um einen Vertex AI SDK-Client einzurichten:

    import vertexai

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

    Dabei gilt:

    Agent Engine-Instanz für Memory Bank konfigurieren

    Wenn Sie Memory Bank verwenden möchten, benötigen Sie zuerst eine Agent Engine-Instanz.

    Sie haben folgende Möglichkeiten:

    Vorhandene Instanz verwenden

    Wenn Sie eine vorhandene Agent Engine-Instanz nicht ändern müssen, führen Sie Folgendes aus, um die Instanz für Memory Bank zu konfigurieren:

    agent_engine = client.agent_engines.get(name="AGENT_ENGINE_NAME")

    Ersetzen Sie Folgendes:

    Sie können die Instanz in jeder Umgebung verwenden, einschließlich Google Kubernetes Engine und Cloud Run. Zuerst benötigen Sie den Namen der Agent Engine, mit dem die Memory Bank identifiziert wird, und ausreichende Berechtigungen zum Aufrufen der Memory Bank.

    Instanz erstellen oder aktualisieren

    Erstellen

    Memory Bank ist standardmäßig aktiviert, wenn Sie eine Agent Engine-Instanz erstellen. Das Erstellen einer neuen Agent Engine ohne Runtime sollte nur wenige Sekunden dauern.

      agent_engine = client.agent_engines.create()

    Sie können die Standardeinstellungen von Agent Engine auch überschreiben, wenn Sie eine Agent Engine-Instanz erstellen, um die folgenden Änderungen vorzunehmen:

    • Konfigurieren Sie, wie Memory Bank Erinnerungen generiert und verwaltet.

    • Stellen Sie Ihren Agent in der Agent Engine-Laufzeit bereit.

      agent_engine = client.agent_engines.create(
      # Optional. Set this argument if you want to deploy to Agent Engine Runtime.
      agent_engine=...,
      # Optional. Set this argument if you want to change the Memory Bank configuration.
      config=...
)

      Neue Instanzen sind leer, bis Sie Erinnerungen erstellen oder generieren.

      Sie benötigen den Namen Ihrer Agent Engine, um Erinnerungen zu lesen oder zu schreiben:

      agent_engine_name = agent_engine.api_resource.name

    Aktualisieren

    Sie können eine vorhandene Agent Engine-Instanz aktualisieren, wenn Sie die Agent Engine aktualisieren und gleichzeitig die in der Instanz gespeicherten Erinnerungen beibehalten möchten. Sie können Änderungen vornehmen, z. B. die Konfiguration des Memory Bank ändern oder Ihren Agent in der Agent Engine-Laufzeitumgebung bereitstellen.

      agent_engine = client.agent_engines.update(
        # If you have an existing AgentEngine, you can access the name using `agent_engine.api_resource.name`.
        name="AGENT_ENGINE_NAME",
        # Optional. Set this argument if you want to deploy to Agent Engine Runtime.
        agent_engine=...,
        # Optional. Set this argument if you want to change the Memory Bank configuration.
        config=...
  )

    Ersetzen Sie Folgendes:

    Memory Bank-Konfiguration festlegen

    Sie können Ihre Memory Bank konfigurieren, um anzupassen, wie Erinnerungen generiert und verwaltet werden. Wenn die Konfiguration nicht angegeben ist, verwendet Memory Bank die Standardeinstellungen für jeden Konfigurationstyp.

    Die Konfiguration der Speicherbank wird beim Erstellen oder Aktualisieren Ihrer Agent Engine-Instanz festgelegt:

    client.agent_engines.create(
      ...,
      config={
            "context_spec": {
                  "memory_bank_config": memory_bank_config
            }
      }
)

# Alternatively, update an existing Agent Engine's Memory Bank config.
agent_engine = client.agent_engines.update(
      name=agent_engine.api_resource.name,
      config={
          "context_spec": {
                "memory_bank_config": memory_bank_config
          }
      }
)

    Sie können die folgenden Einstellungen für Ihre Instanz konfigurieren:

    • Konfiguration der Anpassung: Hier wird konfiguriert, wie Erinnerungen aus Quelldaten extrahiert werden sollen.
    • Konfiguration der Ähnlichkeitssuche: Konfiguriert, welches Einbettungsmodell für die Ähnlichkeitssuche verwendet wird. Die Standardeinstellung ist text-embedding-005.
    • Konfiguration der Generierung: Konfiguriert, welches LLM für die Generierung von Erinnerungen verwendet wird. Die Standardeinstellung ist gemini-2.0-flash-001.
    • TTL-Konfiguration: Hier wird konfiguriert, wie die TTL für erstellte oder aktualisierte Erinnerungen automatisch festgelegt wird. Standardmäßig ist keine TTL festgelegt.
    Konfiguration der Anpassung

    Wenn Sie anpassen möchten, wie Erinnerungen aus Ihren Quelldaten extrahiert werden, können Sie das Verhalten der Erinnerungsextraktion beim Einrichten Ihrer Agent Engine-Instanz konfigurieren. Es gibt zwei Möglichkeiten, die Anpassung vorzunehmen:

    • Memory-Themen konfigurieren: Definieren Sie die Art von Informationen, die Memory Bank als sinnvoll erachtet, um sie zu speichern. Nur Informationen, die zu einem dieser Erinnerungsthemen passen, werden von Memory Bank gespeichert.
    • Few-Shot-Beispiele bereitstellen: Zeigen Sie das erwartete Verhalten für die Extraktion von Erinnerungen in Memory Bank.

    Optional können Sie unterschiedliches Verhalten für verschiedene Umfangsebenen konfigurieren. Die Themen, die für Erinnerungen auf Sitzungsebene relevant sind, sind möglicherweise nicht für Erinnerungen auf Nutzerebene (über mehrere Sitzungen hinweg) relevant. Wenn Sie das Verhalten für eine bestimmte Teilmenge von Erinnerungen konfigurieren möchten, legen Sie die Bereichsschlüssel der Anpassungskonfiguration fest. Nur GenerateMemories-Anfragen, die diese Bereichsschlüssel enthalten, verwenden diese Konfiguration. Sie können auch das Standardverhalten (das für alle Gruppen von Bereichsschlüsseln gilt) konfigurieren, indem Sie das Feld scope_key weglassen. Diese Konfiguration gilt für alle Anfragen, für die keine Konfiguration vorhanden ist, die genau mit den Bereichsschlüsseln einer anderen Anpassungskonfiguration übereinstimmt.

    Beispiel: Die user_level_config würde nur für GenerateMemories-Anfragen gelten, die genau den Bereichsschlüssel user_id verwenden (d.h. scope={"user_id": "123"} ohne zusätzliche Schlüssel). default_config würde für andere Anfragen gelten:

    Wörterbuch

    
user_level_config = {
  "scope_keys": ["user_id"],
  "memory_topics": [...],
  "generate_memories_examples": [...]
}

default_config = {
  "memory_topics": [...],
  "generate_memories_examples": [...]
}

config = {
  "customization_configs": [
    user_level_config,
    default_config
  ]
}

    Klassenbasiert

    from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig

user_level_config = CustomizationConfig(
  scope_keys=["user_id"],
  memory_topics=[...],
  generate_memories_examples=[...]
)
    Speicherthemen konfigurieren

    „Memory-Themen“ geben an, welche Informationen Memory Bank als wichtig erachtet und daher als generierte Erinnerungen gespeichert werden sollten. Memory Bank unterstützt zwei Arten von Memory-Themen:

    • Verwaltete Themen: Label und Anleitung werden von Memory Bank definiert. Sie müssen nur den Namen des verwalteten Themas angeben. Beispiel:

      Wörterbuch

      memory_topic = {
  "managed_memory_topic": {
    "managed_topic_enum": "USER_PERSONAL_INFO"
  }
}

      Klassenbasiert

      from vertexai.types import ManagedTopicEnum
from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic as ManagedMemoryTopic

memory_topic = MemoryTopic(
    managed_memory_topic=ManagedMemoryTopic(
        managed_topic_enum=ManagedTopicEnum.USER_PERSONAL_INFO
    )
)

      Die folgenden verwalteten Themen werden von Memory Bank unterstützt:

      • Personenbezogene Daten (USER_PERSONAL_INFO): Wichtige personenbezogene Daten des Nutzers, z. B. Namen, Beziehungen, Hobbys und wichtige Termine. Beispiele: „Ich arbeite bei Google“ oder „Mein Hochzeitstag ist am 31. Dezember“.
      • Nutzereinstellungen (USER_PREFERENCES): Angegebene oder implizierte Vorlieben, Abneigungen, bevorzugte Stile oder Muster. Beispiel: „Ich bevorzuge den mittleren Sitzplatz.“
      • Wichtige Unterhaltungsereignisse und Aufgabenergebnisse (KEY_CONVERSATION_DETAILS): Wichtige Meilensteine oder Schlussfolgerungen im Dialog. Beispiel: „Ich habe Flugtickets für einen Hin- und Rückflug zwischen JFK und SFO gebucht. Ich reise am 1. Juni 2025 ab und kehre am 7. Juni 2025 zurück.“
      • Explizite Anweisungen zum Merken / Vergessen (EXPLICIT_INSTRUCTIONS): Informationen, die der Nutzer explizit vom Agenten verlangt, dass er sie sich merkt oder vergisst. Wenn der Nutzer beispielsweise sagt: „Merke dir, dass ich hauptsächlich Python verwende“, generiert Memory Bank einen Eintrag wie „Ich verwende hauptsächlich Python“.

    • Benutzerdefinierte Themen: Label und Anleitung werden von Ihnen bei der Einrichtung Ihrer Memory Bank-Instanz definiert. Sie werden im Prompt für den Extraktionsschritt der Memory Bank verwendet. Beispiel:

      Wörterbuch

      memory_topic = {
  "custom_memory_topic": {
    "label": "business_feedback",
    "description": """Specific user feedback about their experience at
the coffee shop. This includes opinions on drinks, food, pastries, ambiance,
staff friendliness, service speed, cleanliness, and any suggestions for
improvement."""
  }
}

      Klassenbasiert

      from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic as CustomMemoryTopic

memory_topic = MemoryTopic(
  custom_memory_topic=CustomMemoryTopic(
    label="business_feedback",
    description="""Specific user feedback about their experience at
the coffee shop. This includes opinions on drinks, food, pastries, ambiance,
staff friendliness, service speed, cleanliness, and any suggestions for
improvement."""
  )
)

      Wenn Sie benutzerdefinierte Themen verwenden, sollten Sie auch Few-Shot-Beispiele angeben, die zeigen, wie Erinnerungen aus Ihrem Gespräch extrahiert werden sollen.

    Sie können beliebige Kombinationen von Erinnerungsthemen verwenden. Sie können beispielsweise eine Teilmenge der verfügbaren Themen für verwalteten Speicher verwenden:

    Wörterbuch

    {
  "memory_topics": [
    "managed_memory_topic": { "managed_topic_enum": "USER_PERSONAL_INFO" },
    "managed_memory_topic": { "managed_topic_enum": "USER_PREFERENCES" }
  ]
}

    Klassenbasiert

    from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig
from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic as ManagedMemoryTopic
from vertexai.types import ManagedTopicEnum

CustomizationConfig(
  memory_topics=[
      MemoryTopic(
          managed_memory_topic=ManagedMemoryTopic(
              managed_topic_enum=ManagedTopicEnum.USER_PERSONAL_INFO)
      ),
      MemoryTopic(
          managed_memory_topic=ManagedMemoryTopic(
              managed_topic_enum=ManagedTopicEnum.USER_PREFERENCES)
      ),
  ]
)

    Sie können auch eine Kombination aus verwalteten und benutzerdefinierten Themen verwenden oder nur benutzerdefinierte Themen:

    Wörterbuch

    {
  "memory_topics": [
    "managed_memory_topic": { "managed_topic_enum": "USER_PERSONAL_INFO" },
    "custom_memory_topic": {
      "label": "Jargon",
      "description": """Specific user feedback about their experience at
the coffee shop. This includes opinions on drinks, food, pastries, ambiance,
staff friendliness, service speed, cleanliness, and any suggestions for
improvement."""
        }
  ]
}

    Klassenbasiert

    from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig
from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic as CustomMemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic as ManagedMemoryTopic
from vertexai.types import ManagedTopicEnum

CustomizationConfig(
  memory_topics=[
      MemoryTopic(
          managed_memory_topic=ManagedMemoryTopic(
              managed_topic_enum=ManagedTopicEnum.USER_PERSONAL_INFO)
      ),
      MemoryTopic(
          custom_memory_topic=CustomMemoryTopic(
              label="business_feedback",
              description="""Specific user feedback about their experience at
the coffee shop. This includes opinions on drinks, food, pastries, ambiance,
staff friendliness, service speed, cleanliness, and any suggestions for
improvement."""
          )
    )
  ]
)
    Few-Shot-Beispiele

    Mit Few-Shot-Beispielen können Sie Memory Bank das erwartete Verhalten beim Extrahieren von Erinnerungen demonstrieren. Sie können beispielsweise eine beispielhafte Eingabeunterhaltung und die Erinnerungen angeben, die aus dieser Unterhaltung extrahiert werden sollen.

    Wir empfehlen, immer Few-Shots mit benutzerdefinierten Themen zu verwenden, damit Memory Bank das gewünschte Verhalten lernen kann. Few-Shots sind optional, wenn Sie verwaltete Themen verwenden, da Memory Bank Beispiele für jedes Thema definiert. Zeigen Sie Unterhaltungen, die voraussichtlich nicht zu Erinnerungen führen, indem Sie eine leere generated_memories-Liste angeben.

    Sie können beispielsweise Few-Shot-Beispiele bereitstellen, die zeigen, wie Sie Feedback zu Ihrem Unternehmen aus Kundennachrichten extrahieren:

    Wörterbuch

    example = {
    "conversationSource": {
      "events": [
        {
          "content": {
            "role": "model",
            "parts": [{ "text": "Welcome back to The Daily Grind! We'd love to hear your feedback on your visit." }] }
        },
        {
          "content": {
            "role": "user",
            "parts": [{ "text": "Hey. The drip coffee was a bit lukewarm today, which was a bummer. Also, the music was way too loud, I could barely hear my friend." }] }
        }
      ]
    },
    "generatedMemories": [
      {
        "fact": "The user reported that the drip coffee was lukewarm."
      },
      {
        "fact": "The user felt the music in the shop was too loud."
      }
    ]
}

    Klassenbasiert

    from google.genai.types import Content, Part
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExample as GenerateMemoriesExample
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource as ConversationSource
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent as ConversationSourceEvent
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleGeneratedMemory as ExampleGeneratedMemory

example = GenerateMemoriesExample(
    conversation_source=ConversationSource(
        events=[
            ConversationSourceEvent(
                content=Content(
                    role="model",
                    parts=[Part(text="Welcome back to The Daily Grind! We'd love to hear your feedback on your visit.")]
                )
            ),
            ConversationSourceEvent(
                content=Content(
                    role="user",
                    parts=[Part(text= "Hey. The drip coffee was a bit lukewarm today, which was a bummer. Also, the music was way too loud, I could barely hear my friend.")]
                )
            )
        ]
    ),
    generated_memories=[
        ExampleGeneratedMemory(
            fact="The user reported that the drip coffee was lukewarm."
        ),
        ExampleGeneratedMemory(
            fact="The user felt the music in the shop was too loud."
        )
    ]
)

    Sie können auch Beispiele für Unterhaltungen angeben, die nicht zu generierten Erinnerungen führen sollen, indem Sie eine leere Liste für die erwartete Ausgabe angeben (generated_memories):

    Wörterbuch

    example = {
    "conversationSource": {
        "events": [
          {
              "content": {
                  "role": "model",
                  "parts": [{ "text": "Good morning! What can I get for you at The Daily Grind?" }] }
          },
          {
              "content": {
                  "role": "user",
                  "parts": [{ "text": "Thanks for the coffee." }] }
          }
        ]
    },
    "generatedMemories": []
}

    Klassenbasiert

    from google.genai.types import Content, Part
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExample as GenerateMemoriesExample
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource as ConversationSource
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent as ConversationSourceEvent

example = GenerateMemoriesExample(
    conversation_source=ConversationSource(
        events=[
            ConversationSourceEvent(
                content=Content(
                    role="model",
                    parts=[Part(text="Welcome back to The Daily Grind! We'd love to hear your feedback on your visit.")]
                )
            ),
            ConversationSourceEvent(
                content=Content(
                    role="user",
                    parts=[Part(text= "Thanks for the coffee!")]
                )
            )
        ]
    ),
    generated_memories=[]
)
    Konfiguration der Ähnlichkeitssuche

    Mit der Konfiguration für die Ähnlichkeitssuche wird gesteuert, welches Einbettungsmodell von Ihrer Instanz für die Ähnlichkeitssuche verwendet wird. Die Ähnlichkeitssuche wird verwendet, um zu ermitteln, welche Erinnerungen für die Konsolidierung infrage kommen, und für den auf der Ähnlichkeitssuche basierenden Abruf von Erinnerungen. Wenn diese Konfiguration nicht angegeben ist, verwendet Memory Bank text-embedding-005 als Standardmodell.

    Wenn Sie erwarten, dass Nutzerunterhaltungen in anderen Sprachen als Englisch stattfinden, verwenden Sie ein Modell, das mehrere Sprachen unterstützt, z. B. gemini-embedding-001 oder text-multilingual-embedding-002, um die Qualität des Abrufs zu verbessern.

    Wörterbuch

    memory_bank_config = {
    "similarity_search_config": {
        "embedding_model": "EMBEDDING_MODEL",
    }
}

    Klassenbasiert 

    from vertexai.types import ReasoningEngineContextSpecMemoryBankConfig as MemoryBankConfig
from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigSimilaritySearchConfig as SimilaritySearchConfig

memory_bank_config = MemoryBankConfig(
    similarity_search_config=SimilaritySearchConfig(
        embedding_model="EMBEDDING_MODEL"
    )
)

    Ersetzen Sie Folgendes:

    • EMBEDDING_MODEL: Das Google-Texteinbettungsmodell, das für die Ähnlichkeitssuche verwendet werden soll, im Format projects/{project}/locations/{location}/publishers/google/models/{model}.
    Generierungskonfiguration

    Mit der Generierungskonfiguration wird gesteuert, welches LLM zum Generieren von Erinnerungen verwendet wird, einschließlich des Extrahierens von Erinnerungen und des Zusammenführens neuer Erinnerungen mit bestehenden Erinnerungen.

    Memory Bank verwendet gemini-2.0-flash-001 als Standardmodell.

    Wörterbuch

    memory_bank_config = {
      "generation_config": {
            "model": "LLM_MODEL",
      }
}

    Klassenbasiert 

    from vertexai.types import ReasoningEngineContextSpecMemoryBankConfig as MemoryBankConfig
from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigGenerationConfig as GenerationConfig

memory_bank_config = MemoryBankConfig(
    generation_config=GenerationConfig(
      model="LLM_MODEL"
    )
)

    Ersetzen Sie Folgendes:

    • LLM_MODEL: Das Google LLM-Modell, das zum Extrahieren und Konsolidieren von Erinnerungen verwendet werden soll, im Format projects/{project}/locations/{location}/publishers/google/models/{model}.
    Konfiguration der Gültigkeitsdauer (TTL)

    Mit der TTL-Konfiguration wird gesteuert, wie die Ablaufzeit von Erinnerungen in Memory Bank dynamisch festgelegt werden soll. Nach Ablauf der Gültigkeitsdauer können Erinnerungen nicht mehr abgerufen werden und werden gelöscht.

    Wenn die Konfiguration nicht angegeben wird, wird die Ablaufzeit für erstellte oder aktualisierte Erinnerungen nicht dynamisch festgelegt. Erinnerungen laufen also nur ab, wenn ihre Ablaufzeit manuell festgelegt wird.

    Es gibt zwei Optionen für die TTL-Konfiguration:

    • Standard-TTL: Die TTL wird auf alle Vorgänge angewendet, mit denen ein Speicher erstellt oder aktualisiert wird, einschließlich UpdateMemory, CreateMemory und GenerateMemories.

      Wörterbuch

      memory_bank_config = {
    "ttl_config": {
        "default_ttl": f"TTLs"
    }
}

      Klassenbasiert 

      from vertexai.types import ReasoningEngineContextSpecMemoryBankConfig as MemoryBankConfig
from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigTtlConfig as TtlConfig

memory_bank_config = MemoryBankConfig(
    ttl_config=TtlConfig(
        default_ttl=f"TTLs"
    )
)

      Ersetzen Sie Folgendes:

      • TTL: Die Dauer in Sekunden für die TTL. Bei aktualisierten Erinnerungen wird die neu berechnete Ablaufzeit (jetzt + TTL) die vorherige Ablaufzeit der Erinnerung überschreiben.

    • Granularer (vorgangsbezogener) TTL-Wert: Der TTL-Wert wird basierend darauf berechnet, durch welchen Vorgang der Speicher erstellt oder aktualisiert wurde. Wenn sie für einen bestimmten Vorgang nicht festgelegt ist, wird die Ablaufzeit des Memory nicht aktualisiert.

      Wörterbuch

      memory_bank_config = {
    "ttl_config": {
        "granular_ttl": {
            "create_ttl": f"CREATE_TTLs",
            "generate_created_ttl": f"GENERATE_CREATED_TTLs",
            "generate_updated_ttl": f"GENERATE_UPDATED_TTLs"
        }
    }
}

      Klassenbasiert 

      from vertexai.types import ReasoningEngineContextSpecMemoryBankConfig as MemoryBankConfig
from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigTtlConfig as TtlConfig
from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigTtlConfigGranularTtlConfig as GranularTtlConfig

memory_bank_config = MemoryBankConfig(
    ttl_config=TtlConfig(
        granular_ttl_config=GranularTtlConfig(
            create_ttl=f"CREATE_TTLs",
            generate_created_ttl=f"GENERATE_CREATED_TTLs",
            generate_updated_ttl=f"GENERATE_UPDATED_TTLs",
        )
    )
)

      Ersetzen Sie Folgendes:

      • CREATE_TTL: Die Dauer in Sekunden für die TTL für Erinnerungen, die mit CreateMemory erstellt wurden.
      • GENERATE_CREATED_TTL: Die Dauer in Sekunden für die TTL für Erinnerungen, die mit GeneratedMemories erstellt wurden.
      • GENERATE_UPDATED_TTL: Die Dauer in Sekunden für die TTL für Erinnerungen, die mit GeneratedMemories aktualisiert wurden. Die neu berechnete Ablaufzeit (jetzt + TTL) überschreibt die vorherige Ablaufzeit des Speichers.

    Agent mit Arbeitsspeicher in Agent Engine bereitstellen

    Memory Bank kann in jeder Laufzeit verwendet werden. Sie können Memory Bank aber auch mit der Agent Engine Runtime verwenden, um Erinnerungen aus Ihrem bereitgestellten Agent zu lesen und in ihn zu schreiben.

    Wenn Sie einen Agent mit Memory Bank in der Vertex AI Agent Engine-Laufzeit bereitstellen möchten, müssen Sie zuerst Ihre Umgebung für die Agent Engine-Laufzeit einrichten. Bereiten Sie dann Ihren Agent für die Bereitstellung in der Agent Engine-Laufzeit mit Speicherintegration vor. Ihr bereitgestellter Agent sollte bei Bedarf Aufrufe zum Lesen und Schreiben von Erinnerungen ausführen.

    AdkApp

    Wenn Sie die Vorlage für das Agent Engine Agent Development Kit verwenden, nutzt der Agent standardmäßig VertexAiMemoryBankService, wenn er in der Agent Engine-Laufzeitumgebung bereitgestellt wird. Das bedeutet, dass die ADK Memory-Tools Daten aus dem Memory Bank lesen.

    from google.adk.agents import Agent
from vertexai.preview.reasoning_engines import AdkApp

# Develop an agent using the ADK template.
agent = Agent(...)

adk_app = AdkApp(
      agent=adk_agent,
      ...
)

# Deploy the agent to Agent Engine Runtime.
agent_engine = client.agent_engines.create(
      agent_engine=adk_app,
      config={
            "staging_bucket": "STAGING_BUCKET",
            "requirements": ["google-cloud-aiplatform[agent_engines,adk]"],
            # Optional.
            **context_spec
      }
)

# Update an existing Agent Engine to add or modify the Runtime.
agent_engine = client.agent_engines.update(
      name=agent_engine.api_resource.name,
      agent_engine=adk_app,
      config={
            "staging_bucket": "STAGING_BUCKET",
            "requirements": ["google-cloud-aiplatform[agent_engines,adk]"],
            # Optional.
            **context_spec
      }
)

    Ersetzen Sie Folgendes:

    • STAGING_BUCKET: Ihr Cloud Storage-Bucket, der für das Staging Ihrer Agent Engine-Laufzeit verwendet werden soll.

    Weitere Informationen zur Verwendung von Memory Bank mit dem ADK finden Sie im Schnellstart mit dem Agent Development Kit.

    Benutzerdefinierter Agent

    Sie können Memory Bank mit Ihrem benutzerdefinierten Agenten verwenden, der in der Agent Engine-Laufzeit bereitgestellt wird. In diesem Fall sollte Ihr Agent Aufrufe an die Memory Bank orchestrieren, um Speichergenerierungs- und Speicherabruf-Aufrufe auszulösen.

    Wenn Sie dieselbe Agent Engine-Instanz sowohl für Memory Bank als auch für die Agent Engine-Laufzeit verwenden möchten, können Sie die Umgebungsvariablen GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_LOCATION,GOOGLE_CLOUD_AGENT_ENGINE_ID lesen, um den Namen der Agent Engine aus der Umgebung abzuleiten:

    project = os.environ.get("GOOGLE_CLOUD_PROJECT")
location = os.environ.get("GOOGLE_CLOUD_LOCATION")
agent_engine_id = os.environ.get("GOOGLE_CLOUD_AGENT_ENGINE_ID")

agent_engine_name = f"projects/{project}/locations/{location}/reasoningEngines/{agent_engine_id}"

    Nächste Schritte