Esta página se ha traducido con Cloud Translation API.

Configurar el banco de memoria

Para usar Memory Bank de Vertex AI Agent Engine, necesitas una instancia de Vertex AI Agent Engine. En esta página se muestra cómo configurar tu entorno y crear una instancia de Vertex AI Agent Engine.

Primeros pasos

Antes de trabajar con Memory Bank de Vertex AI Agent Engine, debes configurar tu entorno.

Configurar un Google Cloud proyecto

Cada proyecto se puede identificar de dos formas: mediante el número o el ID del proyecto. El PROJECT_NUMBER se crea automáticamente al crear el proyecto, mientras que el PROJECT_ID lo creas tú o la persona que lo haya creado. Para configurar un proyecto, sigue estos pasos:

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.

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

Verify that billing is enabled for your Google Cloud project.

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

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

Verify that billing is enabled for your Google Cloud project.

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

Obtener los roles necesarios

Para obtener los permisos que necesitas para usar Vertex AI Agent Engine, pide a tu administrador que te asigne el rol de gestión de identidades y accesos Usuario de Vertex AI (roles/aiplatform.user) en tu proyecto. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Si envías solicitudes a Memory Bank desde un agente desplegado en Google Kubernetes Engine o Cloud Run, asegúrate de que tu cuenta de servicio tenga los permisos necesarios. El agente de servicio de Reasoning Engine ya tiene los permisos necesarios para leer y escribir en la memoria, por lo que las solicitudes salientes de Agent Engine Runtime ya deberían tener permiso para acceder a Memory Bank.

Instalar bibliotecas

En esta sección se presupone que has configurado un entorno de desarrollo de Python o que usas un entorno de ejecución con un entorno de desarrollo de Python (como Colab).

Instala el SDK de Vertex AI:

  pip install google-cloud-aiplatform>=1.111.0

Autenticación

Las instrucciones de autenticación dependen de si usas Vertex AI en modo Exprés:

Si no usas Vertex AI en modo exprés, sigue las instrucciones que se indican en Autenticarse en Vertex AI.
Si usas Vertex AI en modo rápido, configura la autenticación definiendo la clave de API en el entorno:
```
  os.environ["API_KEY"] = "API_KEY"
```
Nota: Vertex AI en modo exprés no se puede usar para desplegar un agente en el tiempo de ejecución de Agent Engine. Si quieres implementar tu agente en el entorno de ejecución de Agent Engine, debes pasar del modo exprés.

Configurar un cliente del SDK de Vertex AI

Ejecuta el siguiente código para configurar un cliente del SDK de Vertex AI:

import vertexai

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

donde

PROJECT_ID es el ID del proyecto.
LOCATION es una de las regiones admitidas para Memory Bank.

Crear o actualizar una instancia de Agent Engine

Para empezar a usar Memory Bank, primero necesitas una instancia de Agent Engine. Si aún no tiene ninguna instancia, puede crearla con la configuración predeterminada:

agent_engine = client.agent_engines.create()

Si quieres personalizar la configuración del comportamiento de tu instancia de Memory Bank nueva o actual, consulta el artículo Configurar tu instancia de Agent Engine para Memory Bank. Por ejemplo, puedes especificar qué información considera Memoria que es significativa para conservarla.

Tu instancia de Agent Engine admite las sesiones y Memory Bank de Vertex AI Agent Engine de forma predeterminada. No se despliega ningún agente al crear la instancia. Para usar el tiempo de ejecución de Vertex AI Agent Engine, debes proporcionar el agente que se debe desplegar al crear o actualizar tu instancia de Agent Engine.

Una vez que tenga una instancia de Agent Engine, puede usar el nombre de la instancia para leer o escribir recuerdos. Por ejemplo:

# 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,
  ...
)

Usar con el tiempo de ejecución de Vertex AI Agent Engine

Aunque se puede usar Memory Bank en cualquier entorno de ejecución, también puedes usarlo con el entorno de ejecución de Agent Engine para leer y escribir recuerdos de tu agente implementado.

Para desplegar un agente con Memory Bank en el tiempo de ejecución de Vertex AI Agent Engine, primero configura tu entorno para el tiempo de ejecución de Agent Engine. A continuación, prepara tu agente para desplegarlo en el entorno de ejecución de Agent Engine con la integración de memoria. El agente implementado debe hacer llamadas para leer y escribir recuerdos según sea necesario.

AdkApp

Si usas la plantilla Agent Development Kit de Agent Engine, el agente usa VertexAiMemoryBankService de forma predeterminada cuando se implementa en el tiempo de ejecución de Agent Engine. Esto significa que las herramientas de memoria del ADK leen recuerdos de 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=adk_app,
      config={
            "staging_bucket": "STAGING_BUCKET",
            "requirements": ["google-cloud-aiplatform[agent_engines,adk]"],
            # Optional.
            **context_spec
      }
)

Haz los cambios siguientes:

STAGING_BUCKET: el segmento de Cloud Storage que se usará para organizar el tiempo de ejecución de Agent Engine.

Para obtener más información sobre cómo usar Memory Bank con ADK, consulta la guía de inicio rápido de Agent Development Kit.

Agente personalizado

Puedes usar Memory Bank con tu agente personalizado implementado en el tiempo de ejecución de Agent Engine. En este caso, tu agente debe coordinar las llamadas a Memory Bank para activar las llamadas de generación de memoria y recuperación de memoria.

Tu aplicación desplegada en el tiempo de ejecución de Vertex AI Agent Engine puede leer las variables de entorno GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_LOCATION y GOOGLE_CLOUD_AGENT_ENGINE_ID para inferir el nombre de Agent Engine del entorno:

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

Si usas el agente de servicio predeterminado de tu agente en el tiempo de ejecución de Vertex AI Agent Engine, tu agente ya tiene permiso para leer y escribir recuerdos. Si usas una cuenta de servicio de cliente, debes conceder permisos a tu cuenta de servicio para leer y escribir recuerdos. Los permisos necesarios dependen de las operaciones que deba poder realizar tu agente. Si solo quieres que tu agente recupere y genere recuerdos, aiplatform.memories.generate y aiplatform.memories.retrieve son suficientes.

Usar en todos los demás entornos de ejecución

Si quieres usar Memory Bank en otro entorno, como Cloud Run o Colab, crea un Agent Engine sin proporcionar un agente. Crear un nuevo Agent Engine sin un tiempo de ejecución solo debería llevarte unos segundos. Si no proporcionas una configuración, Memory Bank se creará con los ajustes predeterminados para gestionar la generación y la recuperación de memoria:

agent_engine = client.agent_engines.create()

Si quieres configurar el comportamiento, proporciona una configuración de Memory Bank:

Crear

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

Actualizar

Si quieres cambiar la configuración de Memory Bank, puedes actualizar tu instancia de 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": ...
    }
  }
)

Haz los cambios siguientes:

AGENT_ENGINE_NAME: el nombre del Agent Engine. Debe tener el formato projects/.../locations/.../reasoningEngines/.... Consulta las regiones admitidas para Banco de recuerdos.

Puedes usar Banco de recuerdos en cualquier entorno que tenga permiso para leer y escribir recuerdos. Por ejemplo, para usar Memory Bank con Cloud Run, concede permisos a la identidad de servicio de Cloud Run para leer y escribir recuerdos. Los permisos necesarios dependen de las operaciones que deba poder realizar tu agente. Si solo quieres que tu agente recupere y genere recuerdos, aiplatform.memories.generate y aiplatform.memories.retrieve son suficientes.

Configurar la instancia de Agent Engine para Memory Bank

También puedes configurar tu banco de recuerdos para personalizar cómo se generan y gestionan los recuerdos. Si no se proporciona la configuración, Memory Bank usará los ajustes predeterminados de cada tipo de configuración.

La configuración de Memory Bank se define al crear o actualizar tu instancia de 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
          }
      }
)

Puedes configurar los siguientes ajustes de tu instancia:

Configuración de personalización: configura cómo se deben extraer los recuerdos de los datos de origen.
Configuración de la búsqueda por similitud: configura qué modelo de inserción se usa para la búsqueda por similitud. El valor predeterminado es text-embedding-005.
Configuración de la generación: configura qué LLM se usa para la generación de memoria. El valor predeterminado es gemini-2.5-flash.
Configuración de TTL: configura cómo se establece automáticamente el TTL de los recuerdos creados o actualizados. El valor predeterminado es sin TTL.

Configuración de personalización

Si quieres personalizar cómo se extraen los recuerdos de tus datos de origen, puedes configurar el comportamiento de extracción de recuerdos al configurar tu instancia de Agent Engine. Puedes usar dos palancas para personalizar los mensajes:

Configurar temas de memoria: define el tipo de información que Memory Bank debe considerar significativa para conservarla. Memory Bank solo conservará la información que se ajuste a uno de estos temas de recuerdos.
Proporcionar ejemplos de pocos disparos: muestra el comportamiento esperado de la extracción de memoria a Memory Bank.

Puedes personalizar el comportamiento de extracción de tu banco de memoria en dos pasos: indicar y mostrar. Los temas de Memoria indican a Memoria qué información debe conservar. Los ejemplos muestran a Memory Bank qué tipo de información debe dar lugar a una memoria específica, lo que le ayuda a aprender los patrones, los matices y las expresiones que quieres que entienda.

También puedes configurar un comportamiento diferente para cada nivel de ámbito. Por ejemplo, los temas que son significativos para los recuerdos a nivel de sesión pueden no serlo para los recuerdos a nivel de usuario (en varias sesiones). Para configurar el comportamiento de un subconjunto de recuerdos, define las claves de ámbito de la configuración de personalización. Solo las solicitudes GenerateMemories que incluyan esas claves de ámbito usarán esa configuración. También puedes configurar el comportamiento predeterminado (que se aplica a todos los conjuntos de claves de ámbito) omitiendo el campo scope_key. Esta configuración se aplicará a todas las solicitudes que no tengan una configuración que coincida exactamente con las claves de ámbito de otra configuración de personalización.

Por ejemplo, user_level_config solo se aplicaría a las solicitudes de GenerateMemories que usen exactamente la clave de ámbito user_id (es decir, scope={"user_id": "123"} sin claves adicionales). default_config se aplicaría a otras solicitudes:

Diccionario


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

Basado en clases

from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig

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

Configurar temas de memoria

Los "temas de memoria" identifican qué información considera Memory Bank que es significativa y, por lo tanto, debe conservarse como recuerdos generados. Memory Bank admite dos tipos de temas de memoria:

Temas gestionados: la etiqueta y las instrucciones las define Memory Bank. Solo tienes que proporcionar el nombre del tema gestionado. Por ejemplo,
Diccionario
```
memory_topic = {
  "managed_memory_topic": {
    "managed_topic_enum": "USER_PERSONAL_INFO"
  }
}
```
Basado en clases
```
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
    )
)
```
Memory Bank admite los siguientes temas gestionados:
- Información personal (USER_PERSONAL_INFO): información personal importante sobre el usuario, como nombres, relaciones, aficiones y fechas importantes. Por ejemplo, "Trabajo en Google" o "Mi aniversario de boda es el 31 de diciembre".
- Preferencias de los usuarios (USER_PREFERENCES): gustos, rechazos, estilos o patrones preferidos, ya sean explícitos o implícitos. Por ejemplo, "Prefiero el asiento del medio".
- Eventos clave de la conversación y resultados de las tareas (KEY_CONVERSATION_DETAILS): hitos o conclusiones importantes de la conversación. Por ejemplo, "He reservado billetes de avión de ida y vuelta entre JFK y SFO. Me voy el 1 de junio del 2025 y vuelvo el 7 de junio del 2025".
- Instrucciones explícitas para recordar o olvidar (EXPLICIT_INSTRUCTIONS): información que el usuario pide explícitamente al agente que recuerde o que olvide. Por ejemplo, si el usuario dice "Recuerda que uso principalmente Python", Memory Bank genera un recuerdo como "Uso principalmente Python".

Temas personalizados: tú defines la etiqueta y las instrucciones al configurar tu instancia de Memory Bank. Se usarán en la petición del paso de extracción de Memory Bank. Por ejemplo,

Diccionario

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

Basado en clases

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

Cuando se usan temas personalizados, se recomienda proporcionar ejemplos con pocos ejemplos que muestren cómo se deben extraer los recuerdos de la conversación.

Con la personalización, puedes usar cualquier combinación de temas de recuerdos. Por ejemplo, puedes usar un subconjunto de los temas de memoria gestionada disponibles:

Diccionario

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

Basado en clases

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

También puedes usar una combinación de temas gestionados y personalizados (o solo temas personalizados):

Diccionario

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

Basado en clases

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

Ejemplos de few-shot

Los ejemplos de pocos disparos te permiten mostrar a Memory Bank el comportamiento esperado de extracción de memoria. Por ejemplo, puedes proporcionar una conversación de entrada de muestra y los recuerdos que se espera que se extraigan de esa conversación.

Te recomendamos que siempre uses ejemplos con temas personalizados para que Memory Bank pueda aprender el comportamiento deseado. Los pocos ejemplos son opcionales cuando se usan temas gestionados, ya que Memory Bank define ejemplos para cada tema. Demuestra conversaciones que no deberían dar lugar a recuerdos proporcionando una lista generated_memories vacía.

Por ejemplo, puedes proporcionar ejemplos de pocos disparos que muestren cómo extraer comentarios sobre tu empresa de los mensajes de los clientes:

Diccionario

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

Basado en clases

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

También puedes proporcionar ejemplos de conversaciones que no deberían generar recuerdos. Para ello, proporciona una lista vacía en la salida esperada (generated_memories):

Diccionario

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

Basado en clases

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

Configuración de la búsqueda por similitud

La configuración de búsqueda por similitud controla qué modelo de inserción utiliza tu instancia para la búsqueda por similitud. La búsqueda de similitud se usa para identificar qué recuerdos deben ser candidatos a la consolidación y para la recuperación de recuerdos basada en la búsqueda de similitud. Si no se proporciona esta configuración, Memory Bank usará text-embedding-005 como modelo predeterminado.

Si prevés que las conversaciones de los usuarios sean en idiomas distintos del inglés, usa un modelo que admita varios idiomas, como gemini-embedding-001 o text-multilingual-embedding-002, para mejorar la calidad de la recuperación.

Diccionario

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

Basado en clases

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

Haz los cambios siguientes:

EMBEDDING_MODEL: el modelo de inserción de texto de Google que se va a usar para la búsqueda de similitud, con el formato projects/{project}/locations/{location}/publishers/google/models/{model}.

Configuración de generación

La configuración de generación controla qué LLM se usa para generar recuerdos, lo que incluye extraer recuerdos y consolidar recuerdos nuevos con los que ya existen.

Memory Bank usa gemini-2.5-flash como modelo predeterminado. En las regiones en las que Gemini no está disponible a nivel regional, se usa el endpoint global.

Diccionario

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

Basado en clases

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

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

Haz los cambios siguientes:

LLM_MODEL: el modelo LLM de Google que se va a usar para extraer y consolidar recuerdos, en el formato projects/{project}/locations/{location}/publishers/google/models/{model}.

Configuración del tiempo de vida (TTL)

La configuración del TTL controla cómo debe establecer Memory Bank de forma dinámica el tiempo de vencimiento de los recuerdos. Una vez que haya transcurrido el tiempo de vencimiento, los recuerdos no se podrán recuperar y se eliminarán.

Si no se proporciona la configuración, el tiempo de vencimiento no se definirá de forma dinámica para los recuerdos creados o actualizados, por lo que no caducarán a menos que se defina manualmente.

Hay dos opciones para configurar el TTL:

TTL predeterminado: el TTL se aplicará a todas las operaciones que creen o actualicen una memoria, incluidas UpdateMemory, CreateMemory y GenerateMemories.

Diccionario

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

Basado en clases

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

Haz los cambios siguientes:

TTL: duración del TTL en segundos. En el caso de los recuerdos actualizados, el tiempo de vencimiento recién calculado (ahora + TTL) sobrescribirá el tiempo de vencimiento anterior del recuerdo.

TTL granular (por operación): el TTL se calcula en función de la operación que haya creado o actualizado la memoria. Si no se define para una operación determinada, la operación no actualizará el tiempo de vencimiento de la memoria.

Diccionario

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

Basado en clases

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

Haz los cambios siguientes:

CREATE_TTL: duración en segundos del TTL de los recuerdos creados con CreateMemory.
GENERATE_CREATED_TTL: duración en segundos del TTL de los recuerdos creados con GeneratedMemories.
GENERATE_UPDATED_TTL: duración en segundos del TTL de los recuerdos actualizados mediante GeneratedMemories. El tiempo de vencimiento recién calculado (ahora + TTL) sobrescribirá el tiempo de vencimiento anterior de la memoria.

Configurar el banco de memoria Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Primeros pasos

Configurar un Google Cloud proyecto

Obtener los roles necesarios

Instalar bibliotecas

Autenticación

Configurar un cliente del SDK de Vertex AI

Crear o actualizar una instancia de Agent Engine

Usar con el tiempo de ejecución de Vertex AI Agent Engine

AdkApp

Agente personalizado

Usar en todos los demás entornos de ejecución

Crear

Actualizar

Configurar la instancia de Agent Engine para Memory Bank

Configuración de personalización

Diccionario

Basado en clases

Configurar temas de memoria

Diccionario

Basado en clases

Diccionario

Basado en clases

Diccionario

Basado en clases

Diccionario

Basado en clases

Ejemplos de few-shot

Diccionario

Basado en clases

Diccionario

Basado en clases

Configuración de la búsqueda por similitud

Diccionario

Basado en clases

Configuración de generación

Diccionario

Basado en clases

Configuración del tiempo de vida (TTL)

Diccionario

Basado en clases

Diccionario

Basado en clases

Siguientes pasos

Configurar el banco de memoria