Configure o banco de memórias

Para usar o Memory Bank do Vertex AI Agent Engine, precisa de uma instância do Vertex AI Agent Engine. Esta página demonstra como configurar o seu ambiente e criar uma instância do Vertex AI Agent Engine.

Começar

Antes de trabalhar com o banco de memória do motor de agentes do Vertex AI, tem de configurar o seu ambiente.

Configure o seu Google Cloud projeto

Cada projeto pode ser identificado de duas formas: o número do projeto ou o ID do projeto. O PROJECT_NUMBER é criado automaticamente quando cria o projeto, enquanto o PROJECT_ID é criado por si 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.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

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

  4. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

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

  7. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

    8.

    Obtenha as funções necessárias

    Para receber as autorizações de que precisa para usar o Vertex AI Agent Engine, peça ao seu administrador para lhe conceder a função IAM de utilizador do Vertex AI (roles/aiplatform.user) no seu projeto. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

    Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

    Se estiver a fazer pedidos ao Memory Bank a partir de um agente implementado no Google Kubernetes Engine ou no Cloud Run, certifique-se de que a sua conta de serviço tem as autorizações necessárias. O agente do serviço do motor de raciocínio já tem as autorizações necessárias para ler e escrever memórias, pelo que os pedidos de saída do tempo de execução do motor do agente já devem ter autorização para aceder ao banco de memória.

    Instale bibliotecas

    Esta secção pressupõe que configurou um ambiente de programação Python ou que está a usar um ambiente de execução com um ambiente de programação Python (como o Colab).

    Instale o SDK Vertex AI:

      pip install google-cloud-aiplatform>=1.111.0

    Autenticação

    As instruções de autenticação dependem de estar a usar o Vertex AI no modo expresso:

    • Se não estiver a usar o Vertex AI no modo expresso, siga as instruções em Autentique-se no Vertex AI.

    • Se estiver a usar o Vertex AI no modo expresso, configure a autenticação definindo a chave da API no ambiente:

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

    Configure um cliente do SDK Vertex AI

    Execute o seguinte código para configurar um cliente do SDK do Vertex AI:

    import vertexai

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

    onde

    • PROJECT_ID é o ID do seu projeto.
    • LOCATION é uma das regiões suportadas para o Banco de memórias.

    Crie ou atualize uma instância do Agent Engine

    Para começar a usar o banco de memória, precisa primeiro de uma instância do Agent Engine. Se ainda não tiver uma instância, pode criá-la através da configuração predefinida:

    agent_engine = client.agent_engines.create()

    Se quiser personalizar a configuração do comportamento da instância do Memory Bank nova ou existente, consulte o artigo Configure a instância do Agent Engine para o Memory Bank. Por exemplo, pode especificar que informações o banco de memória considera significativas para persistir.

    A sua instância do Agent Engine suporta sessões e o Memory Bank de forma imediata. Não é implementado nenhum agente quando cria a instância. Para usar o Vertex AI Agent Engine Runtime, tem de fornecer o agente que deve ser implementado quando cria ou atualiza a sua instância do Agent Engine.

    Depois de ter uma instância do Agent Engine, pode usar o nome da instância para ler ou escrever memórias. Por exemplo:

    # Generate memories using your Memory Bank instance.
client.agent_engines.memories.generate(
  # `name` should have the format `projects/.../locations/.../reasoningEngines/...`.
  name=agent_engine.api_resource.name,
  ...
)

    Use com o tempo de execução do Vertex AI Agent Engine

    Embora o banco de memória possa ser usado em qualquer tempo de execução, também pode usar o banco de memória com o tempo de execução do motor de agentes para ler e escrever memórias do seu agente implementado.

    Para implementar um agente com o banco de memória no tempo de execução do Agent Engine do Vertex AI, primeiro configure o seu ambiente para o tempo de execução do Agent Engine. Em seguida, prepare o seu agente para ser implementado no tempo de execução do Agent Engine com integração de memória. O agente implementado deve fazer chamadas para ler e escrever memórias, conforme necessário.

    AdkApp

    Se estiver a usar o modelo do kit de desenvolvimento de agentes do Agent Engine, o agente usa o VertexAiMemoryBankService por predefinição quando implementado no tempo de execução do Agent Engine. Isto 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=adk_app,
      config={
            "staging_bucket": "STAGING_BUCKET",
            "requirements": ["google-cloud-aiplatform[agent_engines,adk]"],
            # Optional.
            **context_spec
      }
)

    Substitua o seguinte:

    • STAGING_BUCKET: o seu contentor do Cloud Storage a usar para preparar o tempo de execução do Agent Engine.

    Para mais informações sobre a utilização do banco de memória com o ADK, consulte o Início rápido com o Agent Development Kit.

    Agente personalizado

    Pode usar o banco de memória com o seu agente personalizado implementado no tempo de execução do Agent Engine. Neste caso, o seu agente deve orquestrar chamadas para o banco de memória para acionar chamadas de geração de memória e obtenção de memória.

    A sua aplicação implementada no tempo de execução do Vertex AI Agent Engine pode ler as variáveis de ambiente GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_LOCATION e GOOGLE_CLOUD_AGENT_ENGINE_ID para inferir o nome do Agent Engine a partir do 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}"

    Se estiver a usar o agente do serviço predefinido para o seu agente no Vertex AI Agent Engine Runtime, o seu agente já tem autorização para ler e escrever memórias. Se estiver a usar uma conta de serviço ao cliente, tem de conceder autorizações à sua conta de serviço para ler e escrever memórias. As autorizações necessárias dependem das operações que o seu agente deve poder realizar. Se só quiser que o seu agente obtenha e gere memórias, aiplatform.memories.generate e aiplatform.memories.retrieve são suficientes.

    Use em todos os outros tempos de execução

    Se quiser usar o Memory Bank num ambiente diferente, como o Cloud Run ou o Colab, crie um Agent Engine sem fornecer um agente. A criação de um novo Agent Engine sem um tempo de execução só deve demorar alguns segundos. Se não fornecer uma configuração, o banco de memórias é criado com as predefinições para gerir a geração e a obtenção de memórias:

    agent_engine = client.agent_engines.create()

    Se quiser configurar o comportamento, forneça uma configuração do banco de memória:

    Criar

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

    Atualizar

    Se quiser alterar a configuração do banco de memória, pode atualizar a instância do Vertex AI Agent Engine.

    agent_engine = client.agent_engines.update(
  # You can access the name using `agent_engine.api_resource.name` for an AgentEngine object.
  name="AGENT_ENGINE_NAME",
  config={
    "context_spec": {
      "memory_bank_config": ...
    }
  }
)

    Substitua o seguinte:

    • AGENT_ENGINE_NAME: o nome do motor do agente. Deve estar no formato projects/.../locations/.../reasoningEngines/.... Consulte as regiões suportadas para o Banco de memória.

    Pode usar o banco de memórias em qualquer ambiente que tenha autorização para ler e escrever memórias. Por exemplo, para usar o Memory Bank com o Cloud Run, conceda autorizações à identidade do serviço do Cloud Run para ler e escrever memórias. As autorizações necessárias dependem das operações que o seu agente deve poder realizar. Se só quiser que o seu agente obtenha e gere memórias, aiplatform.memories.generate e aiplatform.memories.retrieve são suficientes.

    Configure a instância do Agent Engine para o Memory Bank

    Opcionalmente, pode configurar o banco de memórias para personalizar a forma como as memórias são geradas e geridas. Se a configuração não for fornecida, o banco de memória usa as predefinições para cada tipo de configuração.

    A configuração do banco de memória é definida quando cria ou atualiza 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
          }
      }
)

    Pode configurar as seguintes definições para a sua instância:

    Configuração de personalização

    Se quiser personalizar a forma como as memórias são extraídas dos seus dados de origem, pode configurar o comportamento de extração de memórias quando configurar a instância do Agent Engine. Existem dois elementos que pode usar para a personalização:

    • Configurar tópicos de memória: defina o tipo de informações que o banco de memória deve considerar significativas para persistir. A funcionalidade Banco de memórias só mantém as informações que se enquadram num destes tópicos de memórias.
    • Fornecer exemplos de poucos disparos: demonstrar o comportamento esperado para a extração de memória para o banco de memória.

    Pode pensar na personalização do comportamento de extração do banco de memória em dois passos: dizer e mostrar. Os tópicos da memória indicam ao banco de memória que informações devem ser mantidas. Os exemplos com poucos dados mostram ao banco de memória que tipo de informações devem resultar numa memória específica, ajudando-o a aprender os padrões, as nuances e as expressões que espera que compreenda.

    Opcionalmente, pode configurar um comportamento diferente para diferentes níveis de âmbito. Por exemplo, os tópicos relevantes para as memórias ao nível da sessão podem não ser relevantes para as memórias ao nível do utilizador (em várias sessões). Para configurar o comportamento de um determinado subconjunto de memórias, defina as chaves de âmbito da configuração de personalização. Apenas os pedidos GenerateMemories que incluam essas chaves de âmbito vão usar essa configuração. Também pode configurar o comportamento predefinido (aplicável a todos os conjuntos de chaves de âmbito) omitindo o campo scope_key. Esta configuração aplica-se a todos os pedidos que não tenham uma configuração que corresponda exatamente às chaves de âmbito de outra configuração de personalização.

    Por exemplo, o user_level_config só se aplicaria a pedidos GenerateMemories que usassem exatamente a chave de âmbito user_id (ou seja, scope={"user_id": "123"} sem chaves adicionais). default_config aplicar-se-ia a outros pedidos:

    Dicionário

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

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

memory_bank_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=[...]
)

    Configurar tópicos de memórias

    Os "tópicos de memória" identificam as informações que o banco de memórias considera significativas e que, por isso, devem ser mantidas como memórias geradas. O banco de memórias suporta dois tipos de tópicos de memórias:

    • Tópicos geridos: a etiqueta e as instruções são definidas pelo banco de memória. Só tem de indicar o nome do tópico gerido. 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
    )
)

      Os seguintes tópicos geridos são suportados pelo banco de memórias:

      • Informações pessoais (USER_PERSONAL_INFO): informações pessoais significativas sobre o utilizador, como nomes, relações, passatempos e datas importantes. Por exemplo, "Trabalho no Google" ou "O meu aniversário de casamento é a 31 de dezembro".
      • Preferências do utilizador (USER_PREFERENCES): gostos, não gostos, estilos ou padrões preferidos declarados ou implícitos. Por exemplo, "Prefiro o lugar do meio."
      • Eventos de conversa principais e resultados de tarefas (KEY_CONVERSATION_DETAILS): marcos ou conclusões importantes no diálogo. Por exemplo, "Reservei bilhetes de avião para uma viagem de ida e volta entre JFK e SFO. Parto a 1 de junho de 2025 e regresso a 7 de junho de 2025."
      • Instruções explícitas para lembrar / esquecer (EXPLICIT_INSTRUCTIONS): informações que o utilizador pede explicitamente ao agente para lembrar ou esquecer. Por exemplo, se o utilizador disser "Memoriza que uso principalmente Python", o banco de memória gera uma memória como "Uso principalmente Python".

    • Tópicos personalizados: a etiqueta e as instruções são definidas por si quando configura a sua instância do banco de memória. Vão ser usadas no comando para o passo 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."""
  )
)

      Quando usar tópicos personalizados, recomenda-se que também forneça exemplos de poucos disparos que demonstrem como as memórias devem ser extraídas da sua conversa.

    Com a personalização, pode usar qualquer combinação de tópicos de memória. Por exemplo, pode usar um subconjunto dos tópicos de memória gerida disponíveis:

    Dicionário

    customization_config = {
  "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

customization_config = 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 pode usar uma combinação de tópicos geridos e personalizados (ou usar apenas tópicos personalizados):

    Dicionário

    customization_config = {
  "memory_topics": [
    { "managed_memory_topic": { "managed_topic_enum": "USER_PERSONAL_INFO" } },
    {
      "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 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

customization_config = 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 de poucos disparos

    Os exemplos de poucos disparos permitem-lhe demonstrar o comportamento de extração de memória esperado ao banco de memória. Por exemplo, pode fornecer uma conversa de entrada de exemplo e as memórias que se espera que sejam extraídas dessa conversa.

    Recomendamos que use sempre exemplos com poucos dados com tópicos personalizados para que o banco de memória possa aprender o comportamento pretendido. Os exemplos são opcionais quando usa tópicos geridos, uma vez que o banco de memória define exemplos para cada tópico. Demonstre conversas que não se espera que resultem em memórias, fornecendo uma lista generated_memories vazia.

    Por exemplo, pode fornecer exemplos de poucos disparos que demonstrem como extrair feedback sobre a sua empresa a partir de mensagens de 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."
        )
    ]
)

    Também pode fornecer exemplos de conversas que não devem resultar em memórias geradas, fornecendo uma lista vazia para o resultado esperado (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 semelhança

    A configuração da pesquisa de semelhanças controla o modelo de incorporação usado pela sua instância para a pesquisa de semelhanças. A pesquisa de semelhanças é usada para identificar que memórias devem ser candidatas à consolidação e para a obtenção de memórias baseada na pesquisa de semelhanças. Se esta configuração não for fornecida, o Memory Bank usa o text-embedding-005 como modelo predefinido.

    Se espera que as conversas dos utilizadores sejam em idiomas que não o inglês, use um modelo que suporte vários idiomas, como o gemini-embedding-001 ou o text-multilingual-embedding-002, para melhorar a qualidade da obtençã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 o seguinte:

    • EMBEDDING_MODEL: O modelo de incorporação de texto da Google a usar para a pesquisa de semelhanças, no formato projects/{project}/locations/{location}/publishers/google/models/{model}.

    Configuração da geração

    A configuração de geração controla o MDG usado para gerar memórias, incluindo a extração de memórias e a consolidação de novas memórias com memórias existentes.

    O Memory Bank usa o modelo gemini-2.5-flash como predefinição. Para regiões que não têm disponibilidade regional do Gemini, é usado o ponto final global.

    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 o seguinte:

    • LLM_MODEL: o modelo LLM da Google a usar para extrair e consolidar memórias, no formato projects/{project}/locations/{location}/publishers/google/models/{model}.

    Configuração do tempo de vida (TTL)

    A configuração de TTL controla a forma como o banco de memória deve definir dinamicamente o tempo de expiração das memórias. Após o tempo de expiração, as memórias não estão disponíveis para obtenção e são eliminadas.

    Se a configuração não for fornecida, a hora de validade não é definida dinamicamente para as memórias criadas ou atualizadas. Por isso, as memórias não expiram, a menos que a respetiva hora de validade seja definida manualmente.

    Existem duas opções para a configuração do TTL:

    • TTL predefinido: o TTL é 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 o seguinte:

      • TTL: a duração em segundos do TTL. Para memórias atualizadas, o tempo de validade recém-calculado (agora + TTL) substitui o tempo 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 definida para uma determinada operação, a operação não atualiza a hora de expiração 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 o seguinte:

      • CREATE_TTL: a duração em segundos do TTL para memórias criadas com CreateMemory.
      • GENERATE_CREATED_TTL: a duração em segundos do TTL para memórias criadas com GeneratedMemories.
      • GENERATE_UPDATED_TTL: a duração em segundos do TTL para memórias atualizadas através da API GeneratedMemories. O tempo de expiração recém-calculado (agora + TTL) substitui o tempo de expiração anterior da memória.

    O que se segue?