Configurar el banco de memoria

Antes de trabajar con Memory Bank de Vertex AI Agent Engine, debes configurar tu entorno. Ten en cuenta que, aunque Memory Bank forma parte de Agent Engine, no es necesario que implementes tu código en el tiempo de ejecución de Agent Engine para usar Memory Bank.

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:

  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.

    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 el 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.

    Configurar un entorno

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

    Instalar bibliotecas

    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 el modo Exprés, configura la autenticación definiendo la clave de API en el entorno:

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

    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.

    Configurar la instancia de Agent Engine para Memory Bank

    Para empezar a usar Memory Bank, primero necesitas una instancia de Agent Engine.

    Puedes hacer lo siguiente:

    Usar una instancia ya creada

    Si no necesitas modificar una instancia de Agent Engine, ejecuta lo siguiente para configurar la instancia de Memory Bank:

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

    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 la instancia en cualquier entorno, incluidos Google Kubernetes Engine y Cloud Run. Para empezar, necesitas el nombre de Agent Engine que identifica el banco de memoria y permiso suficiente para llamar al banco de memoria.

    Crear o actualizar una instancia

    Crear

    Memory Bank está habilitado de forma predeterminada cuando creas una instancia de Agent Engine. Crear un nuevo Agent Engine sin un tiempo de ejecución solo debería llevarte unos segundos.

      agent_engine = client.agent_engines.create()

    También puedes anular los valores predeterminados de Agent Engine al crear una instancia para hacer las siguientes modificaciones:

    • Configura cómo genera y gestiona recuerdos Memory Bank.

    • Despliega tu agente en el entorno de ejecución de 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=...
)

      Las nuevas instancias están vacías hasta que crees o generes recuerdos.

      Necesitas el nombre de tu Agent Engine para leer o escribir recuerdos:

      agent_engine_name = agent_engine.api_resource.name

    Actualizar

    Puedes actualizar una instancia de Agent Engine si quieres actualizar Agent Engine y, al mismo tiempo, conservar las memorias que se almacenaron en la instancia. Puedes hacer cambios como cambiar la configuración de Memory Bank o desplegar tu agente en el tiempo de ejecución de 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=...
  )

    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.

    Configurar tu banco de memoria

    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

    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:

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

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

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

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

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

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.

    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 de 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.

    Desplegar un agente con memoria en Agent Engine

    Aunque Memory Bank se puede usar 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_engine=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.

    Si quieres usar la misma instancia de Agent Engine tanto para Memory Bank como para el tiempo de ejecución de Agent Engine, puedes 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}"

    Siguientes pasos