Configurar o banco de memória

Antes de trabalhar com o Memory Bank do Vertex AI Agent Engine, é necessário configurar seu ambiente. Embora o Memory Bank faça parte do Agent Engine, não é necessário implantar seu código no ambiente de execução do Agent Engine para usar o Memory Bank.

Configurar o projeto do Google Cloud

Cada projeto pode ser identificado de duas formas: pelo número ou pelo ID. O PROJECT_NUMBER é criado automaticamente quando você cria o projeto, enquanto o PROJECT_ID é criado por você ou por quem criou o projeto. Para configurar um projeto:

  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.

    Ter os papéis necessários

    Para receber as permissões necessárias para usar o Vertex AI Agent Engine, peça ao administrador para conceder a você o papel do IAM de Usuário da Vertex AI (roles/aiplatform.user) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

    Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

    Se você estiver fazendo solicitações ao Memory Bank de um agente implantado no Google Kubernetes Engine ou no Cloud Run, verifique se a conta de serviço tem as permissões necessárias. O agente de serviço do Reasoning Engine já tem as permissões necessárias para ler e gravar memórias. Portanto, as solicitações de saída do tempo de execução do Agent Engine já têm permissão para acessar o banco de memória.

    Configurar o ambiente

    Nesta seção, pressupomos que você configurou um ambiente de desenvolvimento em Python ou está usando um ambiente de execução com um ambiente de desenvolvimento em Python, como o Colab.

    Instalar bibliotecas

    Instale o SDK da Vertex AI:

      pip install google-cloud-aiplatform>=1.104.0

    Autenticação

    As instruções de autenticação dependem de você estar usando a Vertex AI no modo rápido:

    • Se você não estiver usando a Vertex AI no modo express, siga as instruções em Autenticar na Vertex AI.

    • Se você estiver usando a Vertex AI no modo express, configure a autenticação definindo a chave de API no ambiente:

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

    Configurar um cliente do SDK da Vertex AI

    Execute o código a seguir para configurar um cliente do SDK da Vertex AI:

    import vertexai

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

    em que

    Configurar sua instância do Agent Engine para o Memory Bank

    Para começar a usar o Memory Bank, primeiro você precisa de uma instância do Agent Engine.

    Você tem estas três opções:

    Usar uma instância atual

    Se você não precisar modificar uma instância do Agent Engine, execute o seguinte para configurar a instância para o Memory Bank:

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

    Substitua:

    • AGENT_ENGINE_NAME: o nome do mecanismo de agente. Ele precisa estar no formato projects/.../locations/.../reasoningEngines/.... Consulte as regiões compatíveis com o Memory Bank.

    É possível usar a instância em qualquer ambiente, incluindo o Google Kubernetes Engine e o Cloud Run. Para começar, você precisa do nome do Agent Engine que identifica o banco de memória e permissão suficiente para chamar o banco de memória.

    Criar ou atualizar uma instância

    Criar

    O Memory Bank é ativado por padrão quando você cria uma instância do Agent Engine. A criação de um novo Agent Engine sem um ambiente de execução leva apenas alguns segundos.

      agent_engine = client.agent_engines.create()

    Também é possível substituir os padrões do Agent Engine ao criar uma instância para fazer as seguintes modificações:

    • Defina a configuração de como o Banco de memórias gera e gerencia memórias.

    • Implante o agente no ambiente de execução do Agent Engine.

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

      As novas instâncias ficam vazias até você criar ou gerar recordações.

      Você precisa do nome do seu mecanismo de agente para ler ou gravar memórias:

      agent_engine_name = agent_engine.api_resource.name

    Atualizar

    É possível atualizar uma instância do Agent Engine se você quiser atualizar o Agent Engine e manter as memórias armazenadas na instância. É possível fazer atualizações como mudar a configuração do banco de memória ou implantar seu agente no ambiente de execução do Agent Engine.

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

    Substitua:

    • AGENT_ENGINE_NAME: o nome do mecanismo de agente. Ele precisa estar no formato projects/.../locations/.../reasoningEngines/.... Consulte as regiões compatíveis com o Memory Bank.

    Definir a configuração do Memory Bank

    Você pode configurar o Banco de Memórias para personalizar como as recordações são geradas e gerenciadas. Se a configuração não for fornecida, o Memory Bank usará as configurações padrão para cada tipo de configuração.

    A configuração do banco de memória é definida ao criar ou atualizar a instância do 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
          }
      }
)

    É possível configurar as seguintes opções para sua instância:

    Configuração de personalização

    Se quiser personalizar a extração de recordações dos dados de origem, configure o comportamento de extração ao configurar a instância do Agent Engine. Há duas alavancas que podem ser usadas para personalização:

    • Configurar tópicos de memória: defina o tipo de informação que o Banco de Memórias deve considerar relevante para manter. Somente as informações que se encaixam em um desses tópicos de memória serão mantidas pelo Banco de memórias.
    • Fornecer exemplos de poucos disparos: demonstre o comportamento esperado para a extração de memória do Memory Bank.

    Você também pode configurar comportamentos diferentes para níveis de escopo diferentes. Por exemplo, os tópicos relevantes para as memórias no nível da sessão podem não ser relevantes para as memórias no nível do usuário (em várias sessões). Para configurar o comportamento de um determinado subconjunto de recordações, defina as chaves de escopo da configuração de personalização. Somente as solicitações GenerateMemories que incluem essas chaves de escopo usam essa configuração. Também é possível configurar o comportamento padrão (aplicado a todos os conjuntos de chaves de escopo) omitindo o campo scope_key. Essa configuração será aplicada a todas as solicitações que não tiverem uma configuração que corresponda exatamente às chaves de escopo de outra configuração de personalização.

    Por exemplo, o user_level_config só se aplicaria a solicitações GenerateMemories que usam exatamente a chave de escopo user_id (ou seja, scope={"user_id": "123"} sem chaves adicionais). default_config se aplicaria a outras solicitações:

    Dicionário

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

    Com base em classes

    from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig

user_level_config = CustomizationConfig(
  scope_keys=["user_id"],
  memory_topics=[...],
  generate_memories_examples=[...]
)
    Como configurar tópicos de memória

    Os "Temas de recordação" identificam quais informações o Banco de recordações considera significativas e, portanto, devem ser mantidas como recordações geradas. O Memory Bank é compatível com dois tipos de temas de memória:

    • Tópicos gerenciados: o rótulo e as instruções são definidos pelo Memory Bank. Basta informar o nome do tópico gerenciado. Por exemplo,

      Dicionário

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

      Com base em classes

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

      O Memory Bank oferece suporte aos seguintes tópicos gerenciados:

      • Informações pessoais (USER_PERSONAL_INFO): informações pessoais significativas sobre o usuário, como nomes, relacionamentos, hobbies e datas importantes. Por exemplo, "Trabalho no Google" ou "Meu aniversário de casamento é em 31 de dezembro".
      • Preferências do usuário (USER_PREFERENCES): gostos, não gostos, estilos ou padrões declarados ou implícitos. Por exemplo, "Prefiro o assento do meio".
      • Principais eventos de conversa e resultados de tarefas (KEY_CONVERSATION_DETAILS): marcos ou conclusões importantes no diálogo. Por exemplo, "Comprei passagens aéreas de ida e volta entre JFK e SFO. Vou sair em 1º de junho de 2025 e voltar em 7 de junho de 2025".
      • Instruções explícitas de lembrar / esquecer (EXPLICIT_INSTRUCTIONS): informações que o usuário pede explicitamente ao agente para lembrar ou esquecer. Por exemplo, se o usuário disser "Lembre-se de que eu uso principalmente Python", o Banco de memória vai gerar uma memória como "Eu uso principalmente Python".

    • Tópicos personalizados: o rótulo e as instruções são definidos por você ao configurar sua instância do Memory Bank. Eles serão usados no comando da etapa de extração do Banco de memória. Por exemplo,

      Dicionário

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

      Com base em classes

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

      Ao usar tópicos personalizados, também é recomendável fornecer exemplos few-shot que demonstrem como as memórias devem ser extraídas da conversa.

    Com a personalização, você pode usar qualquer combinação de temas de memória. Por exemplo, é possível usar um subconjunto dos tópicos disponíveis sobre memória gerenciada:

    Dicionário

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

    Com base em classes

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

    Também é possível usar uma combinação de temas gerenciados e personalizados (ou apenas temas personalizados):

    Dicionário

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

    Com base em classes

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

    Com exemplos de poucas imagens, você pode demonstrar o comportamento esperado de extração de memória para o Memory Bank. Por exemplo, você pode fornecer uma conversa de entrada de amostra e as memórias que devem ser extraídas dela.

    Recomendamos sempre usar poucos exemplos com temas personalizados para que o Memory Bank possa aprender o comportamento pretendido. Os poucos exemplos são opcionais ao usar tópicos gerenciados, já que o Memory Bank define exemplos para cada tópico. Demonstre conversas que não devem resultar em recordações fornecendo uma lista generated_memories vazia.

    Por exemplo, você pode fornecer exemplos few-shot que demonstram como extrair feedback sobre sua empresa das mensagens dos clientes:

    Dicionário

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

    Com base em classes

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

    Você também pode fornecer exemplos de conversas que não devem resultar em memórias geradas. Para isso, inclua uma lista vazia na saída esperada (generated_memories):

    Dicionário

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

    Com base em classes

    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=[]
)
    Configuração da pesquisa por similaridade

    A configuração de pesquisa de similaridade controla qual modelo de embedding é usado pela sua instância para essa pesquisa. A pesquisa de similaridade é usada para identificar quais memórias devem ser candidatas à consolidação e à recuperação de memória baseada em pesquisa de similaridade. Se essa configuração não for fornecida, o Memory Bank vai usar text-embedding-005 como o modelo padrão.

    Se você espera que as conversas dos usuários sejam em idiomas diferentes do inglês, use um modelo que ofereça suporte a vários idiomas, como gemini-embedding-001 ou text-multilingual-embedding-002, para melhorar a qualidade da recuperação.

    Dicionário

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

    Com base em classes 

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

    Substitua:

    • EMBEDDING_MODEL: o modelo de embedding de texto do Google a ser usado para a pesquisa de similaridade, no formato projects/{project}/locations/{location}/publishers/google/models/{model}.
    Configuração de geração

    A configuração de geração controla qual LLM é usado para gerar memórias, incluindo extrair e consolidar memórias novas com as atuais.

    O Memory Bank usa o gemini-2.0-flash-001 como modelo padrão.

    Dicionário

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

    Com base em classes 

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

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

    Substitua:

    • LLM_MODEL: o modelo de LLM do Google a ser usado para extrair e consolidar memórias, no formato projects/{project}/locations/{location}/publishers/google/models/{model}.
    Configuração de time to live (TTL)

    A configuração de TTL controla como o Memory Bank define dinamicamente o tempo de expiração das memórias. Depois que o tempo de expiração expirar, as recordações não estarão mais disponíveis para recuperação e serão excluídas.

    Se a configuração não for fornecida, o prazo de validade não será definido dinamicamente para as recordações criadas ou atualizadas. Portanto, elas não vão expirar, a menos que o prazo de validade seja definido manualmente.

    Há duas opções para a configuração de TTL:

    • TTL padrão: o TTL será aplicado a todas as operações que criam ou atualizam uma memória, incluindo UpdateMemory, CreateMemory e GenerateMemories.

      Dicionário

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

      Com base em classes 

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

      Substitua:

      • TTL: a duração em segundos do TTL. Para memórias atualizadas, o prazo de validade recém-calculado (agora + TTL) vai substituir o prazo de validade anterior da memória.

    • TTL granular (por operação): o TTL é calculado com base na operação que criou ou atualizou a memória. Se não for definido para uma determinada operação, ela não vai atualizar o prazo de validade da memória.

      Dicionário

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

      Com base em classes 

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

      Substitua:

      • CREATE_TTL: a duração em segundos do TTL para recordações criadas usando CreateMemory.
      • GENERATE_CREATED_TTL: a duração em segundos do TTL para recordações criadas usando GeneratedMemories.
      • GENERATE_UPDATED_TTL: a duração em segundos do TTL para memórias atualizadas usando GeneratedMemories. O prazo de validade recém-calculado (agora + TTL) vai substituir o prazo de validade anterior da memória.

    Implantar seu agente com memória no Agent Engine

    Embora o Memory Bank possa ser usado em qualquer ambiente de execução, você também pode usá-lo com o ambiente de execução do Agent Engine para ler e gravar memórias do seu agente implantado.

    Para implantar um agente com o Memory Bank no ambiente de execução do Vertex AI Agent Engine, primeiro configure seu ambiente para o ambiente de execução do Agent Engine. Em seguida, prepare o agente para ser implantado no ambiente de execução do Agent Engine com integração de memória. O agente implantado precisa fazer chamadas para ler e gravar memórias conforme necessário.

    AdkApp

    Se você estiver usando o modelo do kit de desenvolvimento de agentes do Agent Engine, o agente usará o VertexAiMemoryBankService por padrão quando for implantado no ambiente de execução do Agent Engine. Isso significa que as ferramentas de memória do ADK leem memórias do banco de memória.

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

    Substitua:

    • STAGING_BUCKET: o bucket do Cloud Storage que você vai usar para preparar o tempo de execução do mecanismo de agente.

    Para mais informações sobre como usar o Memory Bank com o ADK, consulte o Guia de início rápido com o Agent Development Kit.

    Agente personalizado

    É possível usar o Memory Bank com seu agente personalizado implantado no ambiente de execução do Agent Engine. Nesse caso, o agente precisa orquestrar chamadas ao Memory Bank para acionar chamadas de geração de memória e recuperação de memória.

    Se quiser usar a mesma instância do Agent Engine para o banco de memória e o ambiente de execução do Agent Engine, leia as variáveis de ambiente GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_LOCATION,GOOGLE_CLOUD_AGENT_ENGINE_ID para inferir o nome do Agent Engine no 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}"

    A seguir