Cómo configurar el Banco de recuerdos

Antes de trabajar con el banco de memoria de Vertex AI Agent Engine, debes configurar tu entorno. Ten en cuenta que, si bien Memory Bank forma parte de Agent Engine, no es necesario que implementes tu código en Agent Engine Runtime para usar Memory Bank.

Configura tu Google Cloud proyecto

Cada proyecto se puede identificar de dos maneras: con el número o con el ID del proyecto. El PROJECT_NUMBER se crea automáticamente cuando creas el proyecto, mientras que el PROJECT_ID lo creas tú o la persona que haya creado el proyecto. Sigue estos pasos para configurar un proyecto:

  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.

    Obtén los roles necesarios

    Para obtener los permisos que necesitas para usar Vertex AI Agent Engine, pídele a tu administrador que te otorgue el rol de IAM de Usuario de Vertex AI (roles/aiplatform.user) en tu proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

    También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

    Si realizas solicitudes a Memory Bank desde un agente implementado 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 recuerdos, por lo que las solicitudes salientes de Agent Engine Runtime ya deberían tener permiso para acceder a Memory Bank.

    Configura tu entorno

    En esta sección, se supone que configuraste un entorno de desarrollo de Python o que usas un tiempo de ejecución con un entorno de desarrollo de Python (como Colab).

    Instala bibliotecas

    Instala el SDK de Vertex AI:

      pip install google-cloud-aiplatform>=1.104.0

    Autenticación

    Las instrucciones de autenticación dependen de si usas Vertex AI en modo rápido:

    • Si no usas Vertex AI en modo express, sigue las instrucciones en Autentícate en Vertex AI.

    • Si usas Vertex AI en modo exprés, configura la autenticación estableciendo la clave de API en el entorno:

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

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

    Configura tu instancia de Agent Engine para Memory Bank

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

    Puedes realizar una de las siguientes acciones:

    Usar una instancia existente

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

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

    Reemplaza lo siguiente:

    • AGENT_ENGINE_NAME: Es el nombre del motor de agentes. Debe tener el formato projects/.../locations/.../reasoningEngines/.... Consulta las regiones admitidas para Memory Bank.

    Puedes usar la instancia en cualquier entorno, incluidos Google Kubernetes Engine y Cloud Run. Para comenzar, necesitas el nombre de Agent Engine que identifica el banco de memoria y el permiso suficiente para llamar al banco de memoria.

    Crea o actualiza 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 tardar unos segundos.

      agent_engine = client.agent_engines.create()

    También puedes anular los valores predeterminados de Agent Engine cuando creas una instancia de Agent Engine para realizar las siguientes modificaciones:

    • Establece la configuración para determinar cómo Memory Bank genera y administra los recuerdos.

    • Implementa 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 instancias nuevas 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 existente de Agent Engine si deseas actualizar Agent Engine y, al mismo tiempo, conservar los recuerdos que se almacenaron en la instancia. Puedes realizar actualizaciones, como cambiar la configuración de Memory Bank o implementar tu agente en el entorno 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=...
  )

    Reemplaza lo siguiente:

    • AGENT_ENGINE_NAME: Es el nombre del motor de agentes. Debe tener el formato projects/.../locations/.../reasoningEngines/.... Consulta las regiones admitidas para Memory Bank.

    Cómo configurar tu Banco de recuerdos

    Puedes configurar tu Banco de recuerdos para personalizar la forma en que se generan y administran los recuerdos. Si no se proporciona la configuración, Memory Bank usa la configuración predeterminada para cada tipo de configuración.

    La configuración del banco de memoria se establece cuando creas o actualizas 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 parámetros para tu instancia:

    Configuración de personalización

    Si deseas personalizar la forma en que se extraen los recuerdos de tus datos fuente, puedes configurar el comportamiento de extracción de recuerdos cuando configures tu instancia de Agent Engine. Existen dos variables de ajuste que puedes usar para la personalización:

    • Configura 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 memoria.
    • Proporcionar ejemplos de pocas tomas: Demuestra el comportamiento esperado para la extracción de memoria en Memory Bank.

    De manera opcional, puedes configurar un comportamiento diferente para los distintos niveles de alcance. Por ejemplo, los temas que son significativos para los recuerdos a nivel de la sesión pueden no serlo para los recuerdos a nivel del usuario (en varias sesiones). Para configurar el comportamiento de un subconjunto determinado de recuerdos, establece las claves de alcance de la configuración de personalización. Solo las solicitudes GenerateMemories que incluyan esas claves de alcance usarán esa configuración. También puedes configurar el comportamiento predeterminado (que se aplica a todos los conjuntos de claves de alcance) si omites 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 alcance 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 alcance 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=[...]
)
    Cómo configurar temas de memoria

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

    • Temas administrados: La etiqueta y las instrucciones las define Memory Bank. Solo debes proporcionar el nombre del tema administrado. 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 administrados:

      • Información personal (USER_PERSONAL_INFO): Es la información personal importante sobre el usuario, como nombres, relaciones, pasatiempos y fechas importantes. Por ejemplo, "Trabajo en Google" o "Mi aniversario de bodas es el 31 de diciembre".
      • Preferencias del usuario (USER_PREFERENCES): Me gusta, No me gusta, estilos preferidos o patrones explícitos o implícitos Por ejemplo, "Prefiero el asiento del medio".
      • Eventos clave de la conversación y resultados de tareas (KEY_CONVERSATION_DETAILS): Son los hitos o las conclusiones importantes dentro del diálogo. Por ejemplo, "Reservé boletos de avión para un viaje de ida y vuelta entre JFK y SFO. Me voy el 1 de junio de 2025 y regreso el 7 de junio de 2025".
      • Instrucciones explícitas para recordar o olvidar (EXPLICIT_INSTRUCTIONS): Es la información que el usuario le pide explícitamente al agente que recuerde o 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 cuando configuras tu instancia de Memory Bank. Se usarán en la instrucció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 uses temas personalizados, te recomendamos que también proporciones ejemplos de aprendizaje con pocos datos que demuestren cómo se deben extraer los recuerdos de tu conversación.

    Con la personalización, puedes usar cualquier combinación de temas de la memoria. Por ejemplo, puedes usar un subconjunto de los temas de memoria administrada 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 administrados y personalizados (o solo temas personalizados):

    Diccionario

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

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

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

    Recomendamos usar siempre ejemplos con pocos datos con temas personalizados para que Memory Bank pueda aprender el comportamiento previsto. Los ejemplos de pocos disparos son opcionales cuando se usan temas administrados, ya que Memory Bank define ejemplos para cada tema. Demuestra conversaciones que no se espera que generen recuerdos proporcionando una lista generated_memories vacía.

    Por ejemplo, puedes proporcionar ejemplos con pocos ejemplos que demuestren cómo extraer comentarios sobre tu empresa a partir 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 proporcionando una lista vacía para el resultado esperado (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 la búsqueda de similitud controla qué modelo de embedding usa tu instancia para la búsqueda de similitud. La búsqueda de similitud se usa para identificar qué recuerdos deberían ser candidatos para 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 usa text-embedding-005 como modelo predeterminado.

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

    Reemplaza lo siguiente:

    • EMBEDDING_MODEL: Es el modelo de incorporación de texto de Google que se usará para la búsqueda de similitud, en 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 existentes.

    Memory Bank usa gemini-2.0-flash-001 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"
    )
)

    Reemplaza lo siguiente:

    • LLM_MODEL: Es el modelo de LLM de Google que se usará para extraer y consolidar recuerdos, en el formato projects/{project}/locations/{location}/publishers/google/models/{model}.
    Configuración del tiempo de actividad (TTL)

    La configuración del TTL controla cómo Memory Bank debe establecer de forma dinámica el tiempo de vencimiento de los recuerdos. Después de que transcurra el tiempo de vencimiento, los recuerdos no estarán disponibles para recuperarse y se borrarán.

    Si no se proporciona la configuración, no se establecerá de forma dinámica la fecha de vencimiento de los recuerdos creados o actualizados, por lo que los recuerdos no vencerán a menos que se establezca manualmente su fecha de vencimiento.

    Existen dos opciones para la configuración del 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"
    )
)

      Reemplaza lo siguiente:

      • TTL: Es la duración en segundos del TTL. En el caso de los recuerdos actualizados, la fecha de vencimiento recién calculada (ahora + TTL) reemplazará la fecha de vencimiento anterior del recuerdo.

    • TTL granular (por operación): El TTL se calcula en función de la operación que creó o actualizó la memoria. Si no se configura para una operación determinada, la operación no actualizará la fecha 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",
        )
    )
)

      Reemplaza lo siguiente:

      • CREATE_TTL: Es la duración en segundos del TTL de los recuerdos creados con CreateMemory.
      • GENERATE_CREATED_TTL: Es la duración en segundos del TTL de los recuerdos creados con GeneratedMemories.
      • GENERATE_UPDATED_TTL: Es la duración en segundos del TTL de los recuerdos actualizados con GeneratedMemories. La fecha de vencimiento recién calculada (ahora + TTL) reemplazará la fecha de vencimiento anterior de la memoria.

    Implementa tu agente con memoria en Agent Engine

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

    Para implementar un agente con el banco de memoria en el entorno de ejecución de Vertex AI Agent Engine, primero configura tu entorno para el entorno de ejecución de Agent Engine. Luego, prepara tu agente para implementarlo en el entorno de ejecución de Agent Engine con integración de memoria. Tu agente implementado debe realizar llamadas para leer y escribir recuerdos según sea necesario.

    AdkApp

    Si usas la plantilla del kit de desarrollo de agentes de Agent Engine, el agente usa VertexAiMemoryBankService de forma predeterminada cuando se implementa en el entorno de ejecución de Agent Engine. Esto significa que las herramientas de memoria del ADK leen memorias del banco de memoria.

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

    Reemplaza lo siguiente:

    • STAGING_BUCKET: Es tu bucket de Cloud Storage que se usará para la etapa intermedia de tu Agent Engine Runtime.

    Para obtener más información sobre el uso de Memory Bank con el ADK, consulta la Guía de inicio rápido con el Agent Development Kit.

    Agente personalizado

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

    Si deseas usar la misma instancia de Agent Engine para Memory Bank y Agent Engine Runtime, 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}"

    ¿Qué sigue?