Erinnerungen erstellen

In diesem Dokument wird beschrieben, wie das Merken von Informationen funktioniert, wie Sie die Erinnerungsextraktion mit Themen anpassen und wie Sie Anfragen zum Merken von Informationen auslösen.

Informationen zum Einrichten Ihrer Umgebung finden Sie unter Für Memory Bank einrichten.

Merken von Informationen

Memory Bank extrahiert Erinnerungen aus Quelldaten und stellt Erinnerungen für eine bestimmte Sammlung von Erinnerungen (definiert durch ein scope) selbst zusammen, indem im Laufe der Zeit Erinnerungen hinzugefügt, aktualisiert und entfernt werden.

Wenn Sie das Merken von Informationen auslösen, führt Memory Bank die folgenden Vorgänge aus:

• Extraktion: Extrahiert Informationen über den Nutzer aus seinen Unterhaltungen mit dem Agenten. Es werden nur Informationen gespeichert, die mindestens einem der Erinnerungsthemen Ihrer Instanz entsprechen.

• Konsolidierung: Hier wird anhand der extrahierten Informationen ermittelt, ob vorhandene Erinnerungen mit demselben Umfang gelöscht oder aktualisiert werden sollen. Memory Bank prüft, ob neue Erinnerungen Duplikate oder widersprüchlich sind, bevor sie mit bestehenden Erinnerungen zusammengeführt werden. Wenn sich vorhandene Erinnerungen nicht mit den neuen Informationen überschneiden, wird eine neue Erinnerung erstellt.

  • Standardmäßig berücksichtigt Memory Bank bei der Konsolidierung alle vorhandenen Erinnerungen für denselben Bereich. Wenn Sie mithilfe von Metadaten genauer einschränken möchten, welche Erinnerungen für die Konsolidierung infrage kommen, verwenden Sie die REQUIRE_EXACT_MATCH-Zusammenführungsstrategie für Metadaten.

  • Standardmäßig wird nur die letzte Version eines Speichers für den Vergleich verwendet. Wenn Sie langfristige Trends besser erkennen und Daten abgleichen möchten, können Sie revisions_per_candidate_count beim Erstellen Ihrer Agent Platform-Instanz erhöhen, um mehr historische Revisionen in die Konsolidierungslogik einzubeziehen.

Sie können die Zwischenschritte des Merkens von Informationen untersuchen und sehen, wie sich Gemerkte Informationen über mehrere Anfragen hinweg ändern, indem Sie Speicherrevisionen verwenden. Jede Überarbeitung enthält die Zwischenausgabe des Extraktionsschritts (extracted_memories) und des endgültigen Konsolidierungsschritts (fact) für jede Anfrage zur Generierung von Erinnerungen.

list(client.agent_engines.memories.revisions.list(
  name="projects/.../locations/.../reasoningEngines/.../memories/.../revisions/..."))

"""
[
  MemoryRevision(
    name="projects/123/locations/us-central1/reasoningEngines/456/memories/789/revision/456",
    fact="This is my updated fact",
    extracted_memories=[
      IntermediateExtractedMemory(
        fact='This is the output of extraction for a single request.'
      ),
    ],
    ...
  ),
  MemoryRevision(
    name="projects/123/locations/us-central1/reasoningEngines/456/memories/789/revision/123",
    fact="This is my original fact",
    extracted_memories=[
      IntermediateExtractedMemory(
        fact='This is my original fact.'
      ),
    ],
    ...
  )
]
"""

Erinnerungsthemen

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

• 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
      )
  )
  

• Benutzerdefinierte Themen: Label und Anleitung werden von Ihnen bei der Einrichtung Ihrer Memory Bank-Instanz definiert. Sie werden im Prompt für den Extraktionsschritt von 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, um zu zeigen, wie Erinnerungen aus Ihrem Gespräch extrahiert werden sollen.

Standardmäßig werden in der Memory Bank alle folgenden verwalteten Themen gespeichert:

• Nutzerinformationen (USER_PERSONAL_INFO): Wichtige Informationen zum Nutzer, 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 sitze lieber in der Mitte.“

• 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 fahre am 1. Juni 2025 los und komme am 7. Juni 2025 zurück.“

• Explizite Anweisungen zum Merken / Vergessen (EXPLICIT_INSTRUCTIONS): Informationen, die der Nutzer dem Agenten explizit mitteilt, damit er sie sich merkt oder vergisst. Wenn der Nutzer beispielsweise sagt: „Merk dir, dass ich hauptsächlich Python verwende“, generiert Memory Bank einen Eintrag wie „Ich verwende hauptsächlich Python“.

Dies entspricht der Verwendung der folgenden Themen für die verwaltete Speichernutzung:

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

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

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)),
  MemoryTopic(
      managed_memory_topic=ManagedMemoryTopic(
          managed_topic_enum=ManagedTopicEnum.KEY_CONVERSATION_DETAILS)),
  MemoryTopic(
      managed_memory_topic=ManagedMemoryTopic(
          managed_topic_enum=ManagedTopicEnum.EXPLICIT_INSTRUCTIONS)),
]

Wenn Sie anpassen möchten, welche Themen in Memory Bank gespeichert werden, legen Sie die Memory-Themen bei der Einrichtung von Memory Bank in Ihrer Konfiguration für die Anpassung fest.

Metadaten bei der Konsolidierung verwenden

Sie können generierten Erinnerungen Metadaten hinzufügen. Mit Metadaten können Sie strukturierte Informationen (Strings, Doubles, Booleans oder Zeitstempel) zusammen mit einem Memory-Fakt speichern. Das ist nützlich, um Erinnerungen zu filtern oder ihren Lebenszyklus zu verwalten.

import datetime

client.agent_engines.memories.generate(
    ...,
    config={
        "metadata": {
            "my_string_key": {"string_value": "my_string_value"},
            "my_double_key": {"double_value": 123.456},
            "my_boolean_key": {"bool_value": True},
            "my_timestamp_key": {
                "timestamp_value": datetime.datetime(
                    2027, 1, 1, 12, 30, 00, tzinfo=datetime.timezone.utc
                )
            }
        },
        "metadata_merge_strategy": "MERGE"
    },
)

import datetime

from vertexai import types

client.agent_engines.memories.generate(
    ...,
    config=types.GenerateAgentEngineMemoriesConfig(
        metadata={
            "my_string_key": types.MemoryMetadataValue(string_value="my_string_value"),
            "my_double_key": types.MemoryMetadataValue(double_value=123.456),
            "my_boolean_key": types.MemoryMetadataValue(bool_value=True),
            "my_timestamp_key": types.MemoryMetadataValue(
                timestamp_value=datetime.datetime(
                    2027, 1, 1, 12, 30, 00, tzinfo=datetime.timezone.utc
                )
            ),
        },
        metadata_merge_strategy=types.MemoryMetadataMergeStrategy.MERGE,
    )
)

Mit einem metadata_merge_strategy können Sie steuern, wie neue Metadaten bei der Konsolidierung mit vorhandenen Erinnerungen interagieren:

• MERGE: (Standard) Neue Metadaten mit vorhandenen Metadaten kombinieren. Wenn ein Schlüssel bereits vorhanden ist, wird der alte Wert durch den neuen überschrieben.

• OVERWRITE: Ersetze die Metadaten der aktualisierten Erinnerungen durch die neuen Metadaten.

• REQUIRE_EXACT_MATCH: Die Konsolidierung wird auf Erinnerungen beschränkt, die genau dieselben Metadaten wie die Anfrage haben. Wenn ein Erinnerungsbild nicht dieselben Metadaten hat, kann es nicht zusammengefasst werden und wird nicht aktualisiert.

Erinnerungen für eine Teilmenge von Themen generieren

Standardmäßig werden beim Merken von Informationen Daten für alle Erinnerungsthemen extrahiert, die Sie beim Einrichten Ihrer Memory Bank-Instanz konfiguriert haben. Bei einer bestimmten GenerateMemories-Anfrage können Sie die Extraktion auf eine Teilmenge der konfigurierten Themen beschränken. Verwenden Sie das Feld allowed_topics, um zulässige Themen zu konfigurieren.

client.agent_engines.memories.generate(
    ...,
    config={
        "allowed_topics": [
            {"managed_memory_topic": "USER_PERSONAL_INFO"},
            {"custom_memory_topic_label": "business_feedback"}
        ]
    },
)

from vertexai import types

client.agent_engines.memories.generate(
    ...,
    config=types.GenerateAgentEngineMemoriesConfig(
        allowed_topics=[
            types.MemoryTopicId(
                managed_memory_topic=types.ManagedTopicEnum.USER_PERSONAL_INFO
            ),
            types.MemoryTopicId(
                custom_memory_topic_label="business_feedback"
            )
        ]
    )
)

Merken von Informationen auslösen

Sie können das Merken von Informationen mit einer der folgenden Methoden auslösen:

• GenerateMemories: Daten in Memory Bank aufnehmen und sofort das Merken von Informationen auslösen. Diese Methode ist nützlich, wenn Sie Erinnerungen zu einem bestimmten Zeitpunkt generieren möchten, z. B. am Ende einer Sitzung oder in regelmäßigen Abständen innerhalb einer Sitzung.
• IngestEvents: Daten kontinuierlich in Memory Bank aufnehmen und von Memory Bank verarbeiten lassen, wenn Ihre Triggerkriterien erfüllt sind. Diese Methode ist nützlich, wenn Sie einen kontinuierlichen Stream von Ereignissen haben und Memory Bank das Puffern automatisch verarbeiten und das Merken von Informationen basierend auf Volumen oder Zeit auslösen soll. Weitere Informationen finden Sie unter Ereignisse erfassen.

Beim Merken von Informationen wird der wichtigste Kontext aus Quellunterhaltungen extrahiert und mit vorhandenen gemerkten Informationen für denselben Bereich kombiniert. Sie können beispielsweise Erinnerungen auf Sitzungsebene erstellen, indem Sie einen Bereich wie {"user_id": "123", "session_id": "456"} verwenden. Erinnerungen mit demselben Umfang können zusammengefasst und gemeinsam abgerufen werden.

GenerateMemories ist ein Vorgang mit langer Ausführungszeit. Wenn der Vorgang abgeschlossen ist, enthält AgentEngineGenerateMemoriesOperation eine Liste der generierten Erinnerungen, sofern welche generiert wurden:

AgentEngineGenerateMemoriesOperation(
  name="projects/.../locations/.../reasoningEngines/.../operations/...",
  done=True,
  response=GenerateMemoriesResponse(
    generatedMemories=[
      GenerateMemoriesResponseGeneratedMemory(
        memory=Memory(
          "name": "projects/.../locations/.../reasoningEngines/.../memories/..."
        ),
        action="CREATED",
      ),
      GenerateMemoriesResponseGeneratedMemory(
        memory=Memory(
          "name": "projects/.../locations/.../reasoningEngines/.../memories/..."
        ),
        action="UPDATED",
      ),
      GenerateMemoriesResponseGeneratedMemory(
        memory=Memory(
          "name": "projects/.../locations/.../reasoningEngines/.../memories/..."
        ),
        action="DELETED",
      ),
    ]
  )
)

Jede generierte Erinnerung enthält die action, die für diese Erinnerung ausgeführt wurde:

• CREATED: Gibt an, dass eine neue Erinnerung hinzugefügt wurde, die ein neues Konzept darstellt, das nicht von vorhandenen Erinnerungen erfasst wurde.

• UPDATED: Gibt an, dass ein vorhandener Speicher aktualisiert wurde. Dies geschieht, wenn der Speicher ähnliche Konzepte wie die neu extrahierten Informationen abdeckt. Die Fakten des Memorys können mit neuen Informationen aktualisiert werden oder gleich bleiben.

• DELETED: Gibt an, dass die vorhandenen gemerkten Informationen gelöscht wurden, weil sie im Widerspruch zu neuen Informationen standen, die aus der Unterhaltung extrahiert wurden.

Für CREATED- oder UPDATED-Erinnerungen können Sie GetMemories verwenden, um den vollständigen Inhalt der Erinnerung abzurufen. Beim Abrufen von DELETED-Erinnerungen wird ein 404-Fehler ausgegeben.

Erinnerungen im Hintergrund generieren

GenerateMemories ist ein Vorgang mit langer Ausführungszeit. Standardmäßig ist client.agent_engines.generate_memories eine Blockierfunktion, die den Vorgang abfragt, bis er abgeschlossen ist. Die Ausführung des Merkens von Informationen als blockierende Operation ist hilfreich, wenn Sie die generierten gemerkten Informationen manuell prüfen oder Endnutzer darüber informieren möchten, welche gemerkten Informationen generiert wurden.

Bei Produktions-Agents sollten Sie das Merken von Informationen jedoch in der Regel im Hintergrund als asynchronen Prozess ausführen. In den meisten Fällen muss der Client die Ausgabe für den aktuellen Lauf nicht verwenden. Es ist daher nicht erforderlich, zusätzliche Latenzzeiten durch Warten auf eine Antwort in Kauf zu nehmen. Wenn das Merken von Informationen im Hintergrund erfolgen soll, setzen Sie wait_for_completion auf False:

client.agent_engines.memories.generate(
    ...,
    config={
        "wait_for_completion": False
    }
)

Alternativ zum asynchronen Aufrufen von GenerateMemories können Sie IngestEvents verwenden. Dadurch wird die Ereignisaufnahme vom Merken von Informationen entkoppelt und Ereignisse werden standardmäßig im Hintergrund verarbeitet.

Datenquellen

Es gibt mehrere Möglichkeiten, Quelldaten für das Merken von Informationen bereitzustellen:

• Ereignisse direkt in der Nutzlast angeben:

• Ereignisse über Agent Platform-Sitzungen in Agent Runtime bereitstellen

• Vorab extrahierte Fakten bereitstellen, um sie mit vorhandenen Erinnerungen für denselben Umfang zusammenzuführen.

Wenn Sie Ereignisse direkt in der Nutzlast angeben oder Agent Runtime Sessions verwenden, werden Informationen aus der Unterhaltung extrahiert und mit vorhandenen gemerkten Informationen zusammengeführt. Wenn Sie nur Informationen aus diesen Datenquellen extrahieren möchten, können Sie die Konsolidierung deaktivieren:

client.agent_engines.memories.generate(
    ...
    config={
        "disable_consolidation": True
    }
)

Ereignisse in der Nutzlast als Datenquelle verwenden

Verwenden Sie direct_contents_source, wenn Sie Erinnerungen anhand von Ereignissen erstellen möchten, die direkt in der Nutzlast angegeben sind. Aus diesen Ereignissen werden aussagekräftige Informationen extrahiert und mit vorhandenen Informationen für denselben Bereich zusammengeführt. Dieser Ansatz kann verwendet werden, wenn Sie einen anderen Sitzungsspeicher als Agent Platform Sessions verwenden.

events =  [
  {
    "content": {
      "role": "user",
      "parts": [
        {"text": "I work with LLM agents!"}
      ]
    }
  }
]

client.agent_engines.memories.generate(
    name=agent_engine.api_resource.name,
    direct_contents_source={
      "events": EVENTS
    },
    # For example, `scope={"user_id": "123"}`.
    scope=SCOPE,
    config={
        "wait_for_completion": True
    }
)

from google import genai
import vertexai

events = [
  vertexai.types.GenerateMemoriesRequestDirectContentsSourceEvent(
    content=genai.types.Content(
      role="user",
      parts=[
        genai.types.Part.from_text(text="I work with LLM agents!")
      ]
    )
  )
]

client.agent_engines.memories.generate(
    name=agent_engine.api_resource.name,
    direct_contents_source={
      "events": events
    },
    # For example, `scope={"user_id": "123"}`.
    scope=SCOPE,
    config={
        "wait_for_completion": True
    }
)

Agent Runtime-Sitzungen als Datenquelle verwenden

Bei Sessions verwendet Memory Bank Sitzungsereignisse als Quellunterhaltung für das Merken von Informationen.

Um die generierten Erinnerungen einzugrenzen, extrahiert und verwendet Memory Bank standardmäßig die Nutzer-ID aus der Sitzung. Der Umfang der Erinnerungen wird beispielsweise als {"user_id": "123"} gespeichert, wenn die Sitzunguser_id"123" ist. Sie können auch direkt ein scope angeben. In diesem Fall wird der user_id der Sitzung nicht als Bereich verwendet.

client.agent_engines.memories.generate(
  name=agent_engine.api_resource.name,
  vertex_session_source={
      # For example, projects/.../locations/.../reasoningEngines/.../sessions/...
      "session": "SESSION_NAME"
  },
  # Optional when using Sessions. Defaults to {"user_id": session.user_id}.
  scope=SCOPE,
  config={
      "wait_for_completion": True
  }
)

client.agent_engines.memories.generate(
  name=agent_engine.api_resource.name,
  vertex_session_source=vertexai.types.GenerateMemoriesRequestVertexSessionSource(
      # For example, projects/.../locations/.../reasoningEngines/.../sessions/...
      session="SESSION_NAME"
  ),
  # Optional when using Sessions. Defaults to {"user_id": session.user_id}.
  scope=SCOPE,
  config={
      "wait_for_completion": True
  }
)

Optional können Sie einen Zeitraum angeben, der angibt, welche Ereignisse in die Sitzung einbezogen werden sollen. Wenn nichts angegeben ist, werden alle Ereignisse in der Sitzung berücksichtigt.

import datetime

client.agent_engines.memories.generate(
  name=agent_engine.api_resource.name,
  vertex_session_source={
      "session": "SESSION_NAME",
      # Extract memories from the last hour of events.
      "start_time": datetime.datetime.now(tz=datetime.timezone.utc) - datetime.timedelta(seconds=24 * 60),
      "end_time": datetime.datetime.now(tz=datetime.timezone.utc)
  },
  scope=SCOPE
)

import datetime

client.agent_engines.memories.generate(
  name=agent_engine.api_resource.name,
  vertex_session_source=vertexai.types.GenerateMemoriesRequestVertexSessionSource(
      session="SESSION_NAME",
      # Extract memories from the last hour of events.
      start_time=datetime.datetime.now(tz=datetime.timezone.utc) - datetime.timedelta(seconds=24 * 60),
      end_time=datetime.datetime.now(tz=datetime.timezone.utc)
  ),
  scope=SCOPE
)

Zusammenführen von vorab extrahierten Erinnerungen

Alternativ zum automatischen Extraktionsprozess von Memory Bank können Sie auch direkt vorab extrahierte Erinnerungen bereitstellen. Erinnerungen aus direkten Quellen werden mit vorhandenen Erinnerungen für denselben Bereich zusammengeführt. Das kann nützlich sein, wenn Sie möchten, dass Ihr Agent oder ein Mensch in der Schleife für das Extrahieren von Erinnerungen verantwortlich ist, Sie aber trotzdem die Konsolidierung der Memory Bank nutzen möchten, um doppelte oder widersprüchliche Erinnerungen zu vermeiden.

client.agent_engines.memories.generate(
    name=agent_engine.api_resource.name,
    direct_memories_source={"direct_memories": [{"fact": "FACT"}]},
    scope=SCOPE
)

Ersetzen Sie Folgendes:

• FACT: Die vorab extrahierte Information, die mit vorhandenen Erinnerungen konsolidiert werden soll. Sie können bis zu fünf vorab extrahierte Fakten in einer Liste wie der folgenden angeben:

  {"direct_memories": [{"fact": "fact 1"}, {"fact": "fact 2"}]}
  

• SCOPE: Ein Dictionary, das den Umfang der generierten Erinnerungen darstellt. Beispiel: {"session_id": "MY_SESSION"}. Für die Konsolidierung werden nur Erinnerungen mit demselben Umfang berücksichtigt.

Multimodale Eingabe verwenden

Sie können Erinnerungen aus multimodalen Eingaben extrahieren. Erinnerungen werden jedoch nur aus Text, Inline-Dateien und Dateidaten im Quellinhalt extrahiert. Alle anderen Inhalte, einschließlich Funktionsaufrufe und Antworten, werden beim Generieren von Erinnerungen ignoriert.

Erinnerungen können aus Bildern, Videos und Audioinhalten extrahiert werden, die vom Nutzer bereitgestellt werden. Wenn der durch die multimodale Eingabe bereitgestellte Kontext von Memory Bank als sinnvoll für zukünftige Interaktionen eingestuft wird, kann ein textueller Speicher erstellt werden, der aus der Eingabe extrahierte Informationen enthält. Wenn der Nutzer beispielsweise ein Bild eines Golden Retrievers mit dem Text „Das ist mein Hund“ bereitstellt, generiert Memory Bank eine Erinnerung wie „Mein Hund ist ein Golden Retriever“.

Sie können beispielsweise ein Bild und Kontext für das Bild in der Nutzlast angeben:

with open(file_name, "rb") as f:
    inline_data = f.read()

events =  [
  {
    "content": {
      "role": "user",
      "parts": [
        {"text": "This is my dog"},
        {
          "inline_data": {
            "mime_type": "image/jpeg",
            "data": inline_data
          }
        },
        {
          "file_data": {
            "file_uri": "gs://cloud-samples-data/generative-ai/image/dog.jpg",
            "mime_type": "image/jpeg"
          }
        },
      ]
    }
  }
]

from google import genai
import vertexai

with open(file_name, "rb") as f:
    inline_data = f.read()

events = [
  vertexai.types.GenerateMemoriesRequestDirectContentsSourceEvent(
    content=genai.types.Content(
      role="user",
      parts=[
        genai.types.Part.from_text(text="This is my dog"),
        genai.types.Part.from_bytes(
          data=inline_data,
          mime_type="image/jpeg",
        ),
        genai.types.Part.from_uri(
          file_uri="gs://cloud-samples-data/generative-ai/image/dog.jpg",
          mime_type="image/jpeg",
        )
      ]
    )
  )
]

Wenn Sie Sitzungen der Agent Runtime als Datenquelle verwenden, werden die multimodalen Inhalte direkt in den Ereignissen der Sitzung bereitgestellt.

Nächste Schritte