Configurare Memory Bank

Prima di utilizzare Memory Bank di Vertex AI Agent Engine, devi configurare l'ambiente. Tieni presente che, sebbene Memory Bank faccia parte di Agent Engine, non è necessario eseguire il deployment del codice in Agent Engine Runtime per utilizzare Memory Bank.

Configura il progetto Google Cloud

Ogni progetto può essere identificato in due modi: tramite il numero del progetto o l'ID progetto. PROJECT_NUMBER viene creato automaticamente quando crei il progetto, mentre PROJECT_ID viene creato da te o da chiunque abbia creato il progetto. Per configurare un progetto:

  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.

    Ottenere i ruoli richiesti

    Per ottenere le autorizzazioni necessarie per utilizzare Vertex AI Agent Engine, chiedi all'amministratore di concederti il ruolo IAM Vertex AI User (roles/aiplatform.user) nel tuo progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

    Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

    Se invii richieste a Memory Bank da un agente di cui è stato eseguito il deployment su Google Kubernetes Engine o Cloud Run, assicurati che il tuo account di servizio disponga delle autorizzazioni necessarie. L'agente di servizio Reasoning Engine dispone già delle autorizzazioni necessarie per leggere e scrivere ricordi, pertanto le richieste in uscita da Agent Engine Runtime dovrebbero già disporre dell'autorizzazione per accedere a Memory Bank.

    Configura l'ambiente

    Questa sezione presuppone che tu abbia configurato un ambiente di sviluppo Python o che tu stia utilizzando un runtime con un ambiente di sviluppo Python (come Colab).

    Installare le librerie

    Installa l'SDK Vertex AI:

      pip install google-cloud-aiplatform>=1.104.0

    Autenticazione

    Le istruzioni di autenticazione dipendono dal fatto che tu stia utilizzando Vertex AI in modalità rapida:

    • Se non utilizzi Vertex AI in modalità rapida, segui le istruzioni riportate in Autenticarsi in Vertex AI.

    • Se utilizzi Vertex AI in modalità express, configura l'autenticazione impostando la chiave API nell'ambiente:

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

    Configura un client SDK Vertex AI

    Esegui il seguente codice per configurare un client SDK Vertex AI:

    import vertexai

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

    dove

    Configura l'istanza di Agent Engine per Memory Bank

    Per iniziare a utilizzare Memory Bank, devi prima avere un'istanza di Agent Engine.

    Puoi eseguire una di queste procedure:

    Utilizza un'istanza esistente

    Se non devi modificare un'istanza di Agent Engine esistente, esegui il seguente comando per configurare l'istanza per Memory Bank:

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

    Sostituisci quanto segue:

    • AGENT_ENGINE_NAME: il nome di Agent Engine. Deve essere nel formato projects/.../locations/.../reasoningEngines/.... Consulta le regioni supportate per Memory Bank.

    Puoi utilizzare l'istanza in qualsiasi ambiente, inclusi Google Kubernetes Engine e Cloud Run. Per iniziare, devi disporre del nome di Agent Engine che identifica Memory Bank e dell'autorizzazione sufficiente per chiamare Memory Bank.

    Crea o aggiorna un'istanza

    Crea

    Memory Bank è abilitato per impostazione predefinita quando crei un'istanza Agent Engine. La creazione di un nuovo Agent Engine senza un runtime dovrebbe richiedere solo pochi secondi.

      agent_engine = client.agent_engines.create()

    Puoi anche eseguire l'override dei valori predefiniti di Agent Engine quando crei un'istanza di Agent Engine per apportare le seguenti modifiche:

    • Imposta la configurazione per la modalità di generazione e gestione dei ricordi da parte di Banca dei ricordi.

    • Esegui il deployment dell'agente in Agent Engine Runtime.

      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=...
)

      Le nuove istanze sono vuote finché non crei o generi ricordi.

      Per leggere o scrivere ricordi, devi avere il nome del tuo Agent Engine:

      agent_engine_name = agent_engine.api_resource.name

    Aggiorna

    Puoi aggiornare un'istanza di Agent Engine esistente se vuoi aggiornare Agent Engine mantenendo comunque le memorie archiviate nell'istanza. Puoi apportare aggiornamenti come modificare la configurazione di Memory Bank o eseguire il deployment dell'agente in Agent Engine Runtime.

      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=...
  )

    Sostituisci quanto segue:

    • AGENT_ENGINE_NAME: il nome di Agent Engine. Deve essere nel formato projects/.../locations/.../reasoningEngines/.... Consulta le regioni supportate per Memory Bank.

    Impostare la configurazione di Memory Bank

    Puoi configurare la Banca dei ricordi per personalizzare la modalità di generazione e gestione dei ricordi. Se la configurazione non viene fornita, Memory Bank utilizza le impostazioni predefinite per ogni tipo di configurazione.

    La configurazione di Memory Bank viene impostata durante la creazione o l'aggiornamento dell'istanza di Agent Engine:

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

    Puoi configurare le seguenti impostazioni per la tua istanza:

    Configurazione della personalizzazione

    Se vuoi personalizzare la modalità di estrazione dei ricordi dai dati di origine, puoi configurare il comportamento di estrazione dei ricordi durante la configurazione dell'istanza di Agent Engine. Esistono due leve che puoi utilizzare per la personalizzazione:

    • Configurazione degli argomenti di Memory Bank: definisci il tipo di informazioni che Memory Bank deve considerare significative da conservare. Solo le informazioni che rientrano in uno di questi argomenti dei ricordi verranno conservate da Memory Bank.
    • Fornire esempi few-shot: dimostra il comportamento previsto per l'estrazione di ricordi in Memory Bank.

    Se vuoi, puoi configurare un comportamento diverso per i diversi livelli di ambito. Ad esempio, gli argomenti significativi per i ricordi a livello di sessione potrebbero non esserlo per i ricordi a livello di utente (in più sessioni). Per configurare il comportamento per un determinato sottoinsieme di ricordi, imposta le chiavi di ambito della configurazione di personalizzazione. Solo le richieste GenerateMemories che includono queste chiavi di ambito utilizzeranno questa configurazione. Puoi anche configurare il comportamento predefinito (che si applica a tutti i set di chiavi di ambito) omettendo il campo scope_key. Questa configurazione verrà applicata a tutte le richieste che non hanno una configurazione che corrisponda esattamente alle chiavi di ambito per un'altra configurazione di personalizzazione.

    Ad esempio, user_level_config si applicherebbe solo alle richieste GenerateMemories che utilizzano esattamente la chiave di ambito user_id (ovvero scope={"user_id": "123"} senza chiavi aggiuntive). default_config si applicherebbe ad altre richieste:

    Dizionario

    
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
  ]
}

    Basato sulla classe

    from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig

user_level_config = CustomizationConfig(
  scope_keys=["user_id"],
  memory_topics=[...],
  generate_memories_examples=[...]
)
    Configurazione degli argomenti di memoria

    Gli "argomenti dei ricordi" identificano le informazioni che Memory Bank considera significative e che devono quindi essere mantenute come ricordi generati. Memory Bank supporta due tipi di argomenti di memoria:

    • Argomenti gestiti: l'etichetta e le istruzioni sono definite da Memory Bank. Devi solo fornire il nome dell'argomento gestito. Ad esempio,

      Dizionario

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

      Basato sulla classe

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

      I seguenti argomenti gestiti sono supportati da Memory Bank:

      • Informazioni personali (USER_PERSONAL_INFO): informazioni personali significative sull'utente, come nomi, relazioni, hobby e date importanti. Ad esempio, "Lavoro in Google" o "Il mio anniversario di matrimonio è il 31 dicembre".
      • Preferenze degli utenti (USER_PREFERENCES): preferenze, antipatie, stili o motivi preferiti dichiarati o impliciti. Ad esempio, "Preferisco il posto centrale".
      • Eventi chiave della conversazione e risultati delle attività (KEY_CONVERSATION_DETAILS): traguardi o conclusioni importanti all'interno del dialogo. Ad esempio, "Ho prenotato biglietti aerei per un viaggio di andata e ritorno tra JFK e SFO. Parto il 1° giugno 2025 e torno il 7 giugno 2025."
      • Istruzioni esplicite per ricordare / dimenticare (EXPLICIT_INSTRUCTIONS): informazioni che l'utente chiede esplicitamente all'agente di ricordare o dimenticare. Ad esempio, se l'utente dice "Ricorda che uso principalmente Python", Memory Bank genera un ricordo come "Uso principalmente Python".

    • Argomenti personalizzati: l'etichetta e le istruzioni vengono definite da te durante la configurazione dell'istanza di Memory Bank. Verranno utilizzati nel prompt per il passaggio di estrazione di Memory Bank. Ad esempio,

      Dizionario

      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."""
  }
}

      Basato sulla classe

      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."""
  )
)

      Quando utilizzi argomenti personalizzati, ti consigliamo di fornire anche esempi few-shot che mostrino come estrarre i ricordi dalla conversazione.

    Con la personalizzazione, puoi utilizzare qualsiasi combinazione di argomenti dei ricordi. Ad esempio, puoi utilizzare un sottoinsieme degli argomenti di memoria gestita disponibili:

    Dizionario

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

    Basato sulla classe

    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)
      ),
  ]
)

    Puoi anche utilizzare una combinazione di argomenti gestiti e personalizzati (o utilizzare solo argomenti personalizzati):

    Dizionario

    {
  "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."""
        }
  ]
}

    Basato sulla classe

    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."""
          )
    )
  ]
)
    Esempi few-shot

    Gli esempi few-shot ti consentono di dimostrare a Memory Bank il comportamento di estrazione della memoria previsto. Ad esempio, puoi fornire una conversazione di input di esempio e i ricordi che dovrebbero essere estratti da quella conversazione.

    Ti consigliamo di utilizzare sempre i few-shot con argomenti personalizzati in modo che Memory Bank possa apprendere il comportamento previsto. Gli esempi di pochi scatti sono facoltativi quando utilizzi gli argomenti gestiti, poiché Memory Bank definisce esempi per ogni argomento. Mostra le conversazioni che non dovrebbero generare ricordi fornendo un elenco generated_memories vuoto.

    Ad esempio, puoi fornire esempi di pochi scatti che mostrano come estrarre feedback sulla tua attività dai messaggi dei clienti:

    Dizionario

    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."
      }
    ]
}

    Basato sulla classe

    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."
        )
    ]
)

    Puoi anche fornire esempi di conversazioni che non devono generare ricordi fornendo un elenco vuoto per l'output previsto (generated_memories):

    Dizionario

    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": []
}

    Basato sulla classe

    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=[]
)
    Configurazione della ricerca per somiglianza

    La configurazione della ricerca per similarità controlla quale modello di incorporamento viene utilizzato dalla tua istanza per la ricerca per similarità. La ricerca per similarità viene utilizzata per identificare quali ricordi devono essere candidati per il consolidamento e per il recupero dei ricordi basato sulla ricerca per similarità. Se questa configurazione non viene fornita, Memory Bank utilizza text-embedding-005 come modello predefinito.

    Se prevedi che le conversazioni degli utenti siano in lingue diverse dall'inglese, utilizza un modello che supporti più lingue, ad esempio gemini-embedding-001 o text-multilingual-embedding-002, per migliorare la qualità del recupero.

    Dizionario

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

    Basato sulla classe 

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

    Sostituisci quanto segue:

    • EMBEDDING_MODEL: il modello di incorporamento di testo di Google da utilizzare per la ricerca di similarità, nel formato projects/{project}/locations/{location}/publishers/google/models/{model}.
    Configurazione della generazione

    La configurazione della generazione controlla quale LLM viene utilizzato per generare ricordi, inclusi l'estrazione e il consolidamento di nuovi ricordi con quelli esistenti.

    Memory Bank utilizza gemini-2.0-flash-001 come modello predefinito.

    Dizionario

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

    Basato sulla classe 

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

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

    Sostituisci quanto segue:

    • LLM_MODEL: Il modello Google LLM da utilizzare per estrarre e consolidare i ricordi, nel formato projects/{project}/locations/{location}/publishers/google/models/{model}.
    Configurazione della durata (TTL)

    La configurazione TTL controlla il modo in cui Memory Bank deve impostare dinamicamente la data di scadenza dei ricordi. Una volta trascorso il periodo di scadenza, i ricordi non saranno più disponibili per il recupero e verranno eliminati.

    Se la configurazione non viene fornita, il tempo di scadenza non verrà impostato dinamicamente per i ricordi creati o aggiornati, quindi i ricordi non scadranno a meno che il tempo di scadenza non venga impostato manualmente.

    Sono disponibili due opzioni per la configurazione del TTL:

    • TTL predefinito: il TTL verrà applicato a tutte le operazioni che creano o aggiornano una memoria, inclusi UpdateMemory, CreateMemory e GenerateMemories.

      Dizionario

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

      Basato sulla classe 

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

      Sostituisci quanto segue:

      • TTL: la durata in secondi del TTL. Per i ricordi aggiornati, l'ora di scadenza appena calcolata (ora + TTL) sovrascriverà l'ora di scadenza precedente del ricordo.

    • TTL granulare (per operazione): il TTL viene calcolato in base all'operazione che ha creato o aggiornato la memoria. Se non viene impostato per una determinata operazione, l'operazione non aggiornerà la data di scadenza del ricordo.

      Dizionario

      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"
        }
    }
}

      Basato sulla classe 

      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",
        )
    )
)

      Sostituisci quanto segue:

      • CREATE_TTL: la durata in secondi del TTL per i ricordi creati utilizzando CreateMemory.
      • GENERATE_CREATED_TTL: la durata in secondi del TTL per i ricordi creati utilizzando GeneratedMemories.
      • GENERATE_UPDATED_TTL: la durata in secondi del TTL per i ricordi aggiornati utilizzando GeneratedMemories. L'ora di scadenza appena calcolata (ora + TTL) sovrascriverà l'ora di scadenza precedente del ricordo.

    Eseguire il deployment dell'agente con memoria in Agent Engine

    Sebbene Memory Bank possa essere utilizzato in qualsiasi runtime, puoi utilizzarlo anche con Agent Engine Runtime per leggere e scrivere ricordi dall'agente di cui è stato eseguito il deployment.

    Per eseguire il deployment di un agente con Memory Bank su Vertex AI Agent Engine Runtime, devi prima configurare l'ambiente per Agent Engine Runtime. Poi, prepara l'agente per il deployment su Agent Engine Runtime con l'integrazione della memoria. L'agente di cui è stato eseguito il deployment deve effettuare chiamate per leggere e scrivere ricordi in base alle necessità.

    AdkApp

    Se utilizzi il modello Agent Engine Agent Development Kit, l'agente utilizza VertexAiMemoryBankService per impostazione predefinita quando viene eseguito il deployment in Agent Engine Runtime. Ciò significa che gli strumenti di memoria dell'ADK leggono i ricordi da Memory Bank.

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

    Sostituisci quanto segue:

    • STAGING_BUCKET: il bucket Cloud Storage da utilizzare per lo staging di Agent Engine Runtime.

    Per ulteriori informazioni sull'utilizzo di Memory Bank con ADK, consulta la guida rapida di Agent Development Kit.

    Agente personalizzato

    Puoi utilizzare Memory Bank con il tuo agente personalizzato di cui è stato eseguito il deployment in Agent Engine Runtime. In questo caso, l'agente deve orchestrare le chiamate a Memory Bank per attivare le chiamate di generazione di ricordi e recupero di ricordi.

    Se vuoi utilizzare la stessa istanza di Agent Engine sia per Memory Bank che per Agent Engine Runtime, puoi leggere le variabili di ambiente GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_LOCATION,GOOGLE_CLOUD_AGENT_ENGINE_ID per dedurre il nome di Agent Engine dall'ambiente:

    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}"

    Passaggi successivi