Cómo configurar el Banco de recuerdos

Cómo comenzar

Antes de trabajar con el banco de memoria de Vertex AI Agent Engine, debes configurar tu entorno.

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.

    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.

    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.

    Instala bibliotecas

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

    Crea o actualiza una instancia de Agent Engine

    Si ya tienes una instancia de Agent Engine, puedes omitir el paso Configura tu instancia de Agent Engine para Memory Bank.

    Para comenzar a usar Memory Bank, primero necesitas una instancia de Agent Engine. Tu instancia de Agent Engine admite sesiones y el banco de memoria de Vertex AI Agent Engine de forma predeterminada. No se implementa ningún agente cuando creas la instancia. Para usar el entorno de ejecución de Vertex AI Agent Engine, debes proporcionar el agente que se debe implementar cuando crees o actualices tu instancia de Agent Engine.

    Una vez que tengas una instancia de Agent Engine, puedes usar su nombre para leer o escribir recuerdos. Por ejemplo:

    agent_engine = client.agent_engines.create()

client.agent_engines.memories.generate(
  name=agent_engine.api_resource.name,
  ...
)

    Uso con el entorno de ejecución de Vertex AI 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 memorias 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=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 del Kit de desarrollo de agentes.

    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.

    Tu aplicación implementada en el entorno de ejecución de Agent Engine de Vertex AI 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 para tu agente en el entorno de ejecución de Agent Engine de Vertex AI, tu agente ya tiene permiso para leer y escribir recuerdos. Si usas una cuenta de servicio al cliente, debes otorgarle permisos a tu cuenta de servicio para leer y escribir recuerdos. Los permisos necesarios dependen de las operaciones que tu agente debería poder realizar. Si solo quieres que tu agente recupere y genere recuerdos, aiplatform.memories.generate y aiplatform.memories.retrieve son suficientes.

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

    Si quieres usar Memory Bank en un entorno diferente, 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 tardar unos segundos. Si no proporcionas una configuración, Memory Bank se crea con la configuración predeterminada para administrar 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 deseas cambiar la configuración del banco de memoria, 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": ...
    }
  }
)

    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 Memory Bank en cualquier entorno que tenga permiso para leer y escribir recuerdos. Por ejemplo, para usar Memory Bank con Cloud Run, otorga permisos a la identidad del servicio de Cloud Run para leer y escribir recuerdos. Los permisos necesarios dependen de las operaciones que tu agente debería poder realizar. Si solo quieres que tu agente recupere y genere recuerdos, aiplatform.memories.generate y aiplatform.memories.retrieve son suficientes.

    Configura tu instancia de Agent Engine para Memory Bank

    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 de origen, puedes configurar el comportamiento de extracción de recuerdos cuando configures tu instancia de Agent Engine. Existen dos variables que puedes usar para la personalización:

    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 de 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 boda es el 31 de diciembre".
      • Preferencias del usuario (USER_PREFERENCES): Me gusta, No me gusta, estilos preferidos o patrones declarados 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 Python principalmente", Memory Bank genera un recuerdo como "Uso Python principalmente".

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

    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 datos 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 ningún recuerdo 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.5-flash como modelo predeterminado. Para las regiones que no tienen disponibilidad regional de Gemini, se usa el extremo 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"
    )
)

    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, no se podrán recuperar los recuerdos 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.

    ¿Qué sigue?