Configurer la banque de souvenirs

Premiers pas

Avant d'utiliser la banque de mémoire Vertex AI Agent Engine, vous devez configurer votre environnement.

Configurer votre projet Google Cloud

Chaque projet peut être identifié de deux manières : par son numéro ou par son ID. PROJECT_NUMBER est automatiquement généré lorsque vous créez le projet, tandis que PROJECT_ID est défini par vous ou par le créateur du projet. Pour configurer un projet :

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

Obtenir les rôles requis

Pour obtenir les autorisations nécessaires à l'utilisation de Vertex AI Agent Engine, demandez à votre administrateur de vous accorder le rôle IAM Utilisateur Vertex AI (roles/aiplatform.user) sur votre projet. Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Si vous envoyez des requêtes à Memory Bank depuis un agent déployé sur Google Kubernetes Engine ou Cloud Run, assurez-vous que votre compte de service dispose des autorisations nécessaires. L'agent de service Reasoning Engine dispose déjà des autorisations nécessaires pour lire et écrire des souvenirs. Les requêtes sortantes d'Agent Engine Runtime devraient donc déjà être autorisées à accéder à la banque de mémoire.

Installer les bibliothèques

Cette section suppose que vous avez configuré un environnement de développement Python ou que vous utilisez un environnement d'exécution avec un environnement de développement Python (tel que Colab).

Installez le SDK Vertex AI :

  pip install google-cloud-aiplatform>=1.111.0

Authentification

Les instructions d'authentification dépendent de si vous utilisez Vertex AI en mode Express :

• Si vous n'utilisez pas Vertex AI en mode Express, suivez les instructions de la section S'authentifier auprès de Vertex AI.

• Si vous utilisez Vertex AI en mode Express, configurez l'authentification en définissant la clé API dans l'environnement :

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

Configurer un client SDK Vertex AI

Exécutez le code suivant pour configurer un client SDK Vertex AI :

import vertexai

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

Où :

• PROJECT_ID est l'ID de votre projet.
• LOCATION désigne l'une des régions compatibles avec Memory Bank.

Créer ou mettre à jour une instance Agent Engine

Si vous disposez déjà d'une instance Agent Engine, vous pouvez passer à la section Configurer votre instance Agent Engine pour Memory Bank.

Pour commencer à utiliser Memory Bank, vous devez d'abord disposer d'une instance Agent Engine. Votre instance Agent Engine est compatible avec les sessions et la banque de mémoire Vertex AI Agent Engine prêtes à l'emploi. Aucun agent n'est déployé lorsque vous créez l'instance. Pour utiliser l'environnement d'exécution Vertex AI Agent Engine, vous devez fournir l'agent à déployer lorsque vous créez ou mettez à jour votre instance Agent Engine.

Une fois que vous disposez d'une instance Agent Engine, vous pouvez utiliser son nom pour lire ou écrire des souvenirs. Exemple :

agent_engine = client.agent_engines.create()

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

Utiliser avec Vertex AI Agent Engine Runtime

Bien que Memory Bank puisse être utilisé dans n'importe quel environnement d'exécution, vous pouvez également l'utiliser avec Agent Engine Runtime pour lire et écrire des souvenirs à partir de votre agent déployé.

Pour déployer un agent avec la banque de mémoire sur l'environnement d'exécution Vertex AI Agent Engine, commencez par configurer votre environnement pour l'environnement d'exécution Agent Engine. Ensuite, préparez votre agent à être déployé sur Agent Engine Runtime avec l'intégration de la mémoire. Votre agent déployé doit appeler les fonctions de lecture et d'écriture de souvenirs selon les besoins.

AdkApp

Si vous utilisez le modèle Agent Development Kit Agent Engine, l'agent utilise VertexAiMemoryBankService par défaut lorsqu'il est déployé sur Agent Engine Runtime. Cela signifie que les outils de mémoire de l'ADK lisent les mémoires de la banque de mémoire.

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

Remplacez les éléments suivants :

• STAGING_BUCKET : bucket Cloud Storage à utiliser pour préparer votre Agent Engine Runtime.

Pour en savoir plus sur l'utilisation de Memory Bank avec ADK, consultez le guide de démarrage rapide avec Agent Development Kit.

Agent personnalisé

Vous pouvez utiliser Memory Bank avec votre agent personnalisé déployé sur Agent Engine Runtime. Dans ce cas, votre agent doit orchestrer les appels à la banque de mémoire pour déclencher les appels de génération de mémoire et de récupération de mémoire.

Votre application déployée dans l'environnement d'exécution Vertex AI Agent Engine peut lire les variables d'environnement GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_LOCATION et GOOGLE_CLOUD_AGENT_ENGINE_ID pour déduire le nom Agent Engine de l'environnement :

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 vous utilisez l'agent de service par défaut pour votre agent sur Vertex AI Agent Engine Runtime, votre agent est déjà autorisé à lire et à écrire des mémoires. Si vous utilisez un compte de service client, vous devez accorder à votre compte de service les autorisations de lecture et d'écriture des souvenirs. Les autorisations requises dépendent des opérations que votre agent doit pouvoir effectuer. Si vous souhaitez uniquement que votre agent récupère et génère des souvenirs, aiplatform.memories.generate et aiplatform.memories.retrieve suffisent.

Utiliser dans tous les autres environnements d'exécution

Si vous souhaitez utiliser Memory Bank dans un autre environnement, comme Cloud Run ou Colab, créez un Agent Engine sans fournir d'agent. La création d'un moteur d'agent sans environnement d'exécution ne devrait prendre que quelques secondes. Si vous ne fournissez pas de configuration, Memory Bank est créé avec les paramètres par défaut pour la gestion de la génération et de la récupération de la mémoire :

agent_engine = client.agent_engines.create()

Si vous souhaitez configurer le comportement, fournissez une configuration de la banque de mémoire :

Créer

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

Mettre à jour

Si vous souhaitez modifier la configuration de votre banque de mémoire, vous pouvez mettre à jour votre instance 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": ...
    }
  }
)

Remplacez les éléments suivants :

• AGENT_ENGINE_NAME : nom de l'Agent Engine. Il doit être au format projects/.../locations/.../reasoningEngines/.... Consultez les régions disponibles pour la banque de souvenirs.

Vous pouvez utiliser Memory Bank dans n'importe quel environnement autorisé à lire et à écrire des souvenirs. Par exemple, pour utiliser Memory Bank avec Cloud Run, accordez à l'identité de service Cloud Run les autorisations de lecture et d'écriture des souvenirs. Les autorisations requises dépendent des opérations que votre agent doit pouvoir effectuer. Si vous souhaitez uniquement que votre agent récupère et génère des souvenirs, aiplatform.memories.generate et aiplatform.memories.retrieve suffisent.

Configurer votre instance Agent Engine pour Memory Bank

Vous pouvez configurer votre banque de souvenirs pour personnaliser la façon dont les souvenirs sont générés et gérés. Si la configuration n'est pas fournie, Memory Bank utilise les paramètres par défaut pour chaque type de configuration.

La configuration de la Memory Bank est définie lors de la création ou de la mise à jour de votre instance 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
          }
      }
)

Vous pouvez configurer les paramètres suivants pour votre instance :

• Configuration de la personnalisation : configure la façon dont les souvenirs doivent être extraits des données sources.
• Configuration de la recherche de similarité : configure le modèle d'embedding utilisé pour la recherche de similarité. La valeur par défaut est text-embedding-005.
• Configuration de la génération : configure le LLM utilisé pour la génération de la mémoire. La valeur par défaut est gemini-2.5-flash.
• Configuration de la valeur TTL : configure la façon dont la valeur TTL est automatiquement définie pour les souvenirs créés ou modifiés. Par défaut, aucune valeur TTL n'est définie.

Configuration de la personnalisation

Si vous souhaitez personnaliser la façon dont les souvenirs sont extraits de vos données sources, vous pouvez configurer le comportement d'extraction des souvenirs lorsque vous configurez votre instance Agent Engine. Vous pouvez utiliser deux leviers pour personnaliser votre expérience :

• Configurer les thèmes de mémoire : définissez le type d'informations que la banque de mémoire doit considérer comme significatives pour la persistance. Seules les informations correspondant à l'un de ces thèmes de mémoire seront conservées par la Banque de souvenirs.
• Fournir des exemples few-shot : montrez le comportement attendu pour l'extraction de la mémoire vers la banque de mémoire.

Vous pouvez éventuellement configurer différents comportements pour différents niveaux de portée. Par exemple, les thèmes qui ont du sens pour les souvenirs au niveau de la session peuvent ne pas en avoir pour les souvenirs au niveau de l'utilisateur (sur plusieurs sessions). Pour configurer le comportement d'un certain sous-ensemble de souvenirs, définissez les clés de portée de la configuration de personnalisation. Seules les requêtes GenerateMemories qui incluent ces clés de portée utiliseront cette configuration. Vous pouvez également configurer le comportement par défaut (qui s'applique à tous les ensembles de clés de champ d'application) en omettant le champ scope_key. Cette configuration s'appliquera à toutes les requêtes qui ne disposent pas d'une configuration correspondant exactement aux clés de portée d'une autre configuration de personnalisation.

Par exemple, user_level_config ne s'appliquerait qu'aux requêtes GenerateMemories qui utilisent exactement la clé d'étendue user_id (c'est-à-dire scope={"user_id": "123"} sans clé supplémentaire). default_config s'appliquerait aux autres demandes :

Dictionnaire

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

Basé sur les classes

from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig

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

Configurer les thèmes de la mémoire

Les "thèmes de la mémoire" identifient les informations que la mémoire considère comme importantes et qui doivent donc être conservées en tant que souvenirs générés. La banque de mémoire accepte deux types de thèmes de mémoire :

• Sujets gérés : le libellé et les instructions sont définis par la Banque de souvenirs. Il vous suffit d'indiquer le nom du thème géré. Par exemple,

  Dictionnaire

  memory_topic = {
    "managed_memory_topic": {
      "managed_topic_enum": "USER_PERSONAL_INFO"
    }
  }
  

  Basé sur les classes

  from vertexai.types import ManagedTopicEnum
  from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
  from vertexai.types import MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic as ManagedMemoryTopic
  
  memory_topic = MemoryTopic(
      managed_memory_topic=ManagedMemoryTopic(
          managed_topic_enum=ManagedTopicEnum.USER_PERSONAL_INFO
      )
  )
  

  Voici les thèmes gérés compatibles avec la Banque de souvenirs :

  • Informations personnelles (USER_PERSONAL_INFO) : informations personnelles importantes sur l'utilisateur, comme son nom, ses relations, ses loisirs et les dates importantes. Par exemple, "Je travaille chez Google" ou "Mon anniversaire de mariage est le 31 décembre".
  • Préférences utilisateur (USER_PREFERENCES) : préférences, styles ou motifs exprimés ou implicites. Par exemple, "Je préfère le siège du milieu".
  • Événements clés de la conversation et résultats des tâches (KEY_CONVERSATION_DETAILS) : étapes ou conclusions importantes du dialogue. Par exemple : "J'ai réservé des billets d'avion aller-retour entre JFK et SFO. Je pars le 1er juin 2025 et reviens le 7 juin 2025."
  • Instructions explicites pour se souvenir d'une information ou l'oublier (EXPLICIT_INSTRUCTIONS) : informations que l'utilisateur demande explicitement à l'agent de mémoriser ou d'oublier. Par exemple, si l'utilisateur dit "Souviens-toi que j'utilise principalement Python", la Banque de mémoire génère un souvenir tel que "J'utilise principalement Python".

• Thèmes personnalisés : le libellé et les instructions sont définis par vous lorsque vous configurez votre instance Memory Bank. Elles seront utilisées dans la requête pour l'étape d'extraction de la banque de données. Par exemple,

  Dictionnaire

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

  Basé sur les classes

  from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
  from vertexai.types import MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic as CustomMemoryTopic
  
  memory_topic = MemoryTopic(
    custom_memory_topic=CustomMemoryTopic(
      label="business_feedback",
      description="""Specific user feedback about their experience at
  the coffee shop. This includes opinions on drinks, food, pastries, ambiance,
  staff friendliness, service speed, cleanliness, and any suggestions for
  improvement."""
    )
  )
  

  Lorsque vous utilisez des thèmes personnalisés, nous vous recommandons également de fournir des exemples few-shot montrant comment les souvenirs doivent être extraits de votre conversation.

La personnalisation vous permet d'utiliser n'importe quelle combinaison de thèmes de souvenirs. Par exemple, vous pouvez utiliser un sous-ensemble des thèmes de mémoire gérée disponibles :

Dictionnaire

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

Basé sur les classes

from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig
from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic as ManagedMemoryTopic
from vertexai.types import ManagedTopicEnum

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

Vous pouvez également combiner des thèmes gérés et personnalisés (ou n'utiliser que des thèmes personnalisés) :

Dictionnaire

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

Basé sur les classes

from vertexai.types import MemoryBankCustomizationConfig as CustomizationConfig
from vertexai.types import MemoryBankCustomizationConfigMemoryTopic as MemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic as CustomMemoryTopic
from vertexai.types import MemoryBankCustomizationConfigMemoryTopicManagedMemoryTopic as ManagedMemoryTopic
from vertexai.types import ManagedTopicEnum

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

Exemples few-shot

Les exemples few-shot vous permettent de montrer à la Memory Bank le comportement attendu en matière d'extraction de souvenirs. Par exemple, vous pouvez fournir un exemple de conversation et les souvenirs qui doivent en être extraits.

Nous vous recommandons de toujours utiliser des few-shots avec des thèmes personnalisés pour que la banque de mémoire puisse apprendre le comportement souhaité. Les few-shots sont facultatifs lorsque vous utilisez des thèmes gérés, car la banque de mémoire définit des exemples pour chaque thème. Indiquez les conversations qui ne devraient pas générer de souvenirs en fournissant une liste generated_memories vide.

Par exemple, vous pouvez fournir des exemples few-shot qui montrent comment extraire les commentaires sur votre entreprise à partir des messages des clients :

Dictionnaire

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

Basé sur les classes

from google.genai.types import Content, Part
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExample as GenerateMemoriesExample
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource as ConversationSource
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent as ConversationSourceEvent
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleGeneratedMemory as ExampleGeneratedMemory

example = GenerateMemoriesExample(
    conversation_source=ConversationSource(
        events=[
            ConversationSourceEvent(
                content=Content(
                    role="model",
                    parts=[Part(text="Welcome back to The Daily Grind! We'd love to hear your feedback on your visit.")]
                )
            ),
            ConversationSourceEvent(
                content=Content(
                    role="user",
                    parts=[Part(text= "Hey. The drip coffee was a bit lukewarm today, which was a bummer. Also, the music was way too loud, I could barely hear my friend.")]
                )
            )
        ]
    ),
    generated_memories=[
        ExampleGeneratedMemory(
            fact="The user reported that the drip coffee was lukewarm."
        ),
        ExampleGeneratedMemory(
            fact="The user felt the music in the shop was too loud."
        )
    ]
)

Vous pouvez également fournir des exemples de conversations qui ne devraient générer aucun souvenir en fournissant une liste vide pour le résultat attendu (generated_memories) :

Dictionnaire

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

Basé sur les classes

from google.genai.types import Content, Part
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExample as GenerateMemoriesExample
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource as ConversationSource
from vertexai.types import MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent as ConversationSourceEvent

example = GenerateMemoriesExample(
    conversation_source=ConversationSource(
        events=[
            ConversationSourceEvent(
                content=Content(
                    role="model",
                    parts=[Part(text="Welcome back to The Daily Grind! We'd love to hear your feedback on your visit.")]
                )
            ),
            ConversationSourceEvent(
                content=Content(
                    role="user",
                    parts=[Part(text= "Thanks for the coffee!")]
                )
            )
        ]
    ),
    generated_memories=[]
)

Configuration de la recherche de similarités

La configuration de la recherche de similarité contrôle le modèle d'embedding utilisé par votre instance pour la recherche de similarité. La recherche de similarités permet d'identifier les souvenirs qui peuvent être consolidés et pour la récupération de souvenirs basée sur la recherche de similarités. Si cette configuration n'est pas fournie, Memory Bank utilise text-embedding-005 comme modèle par défaut.

Si vous pensez que les conversations des utilisateurs seront dans des langues autres que l'anglais, utilisez un modèle compatible avec plusieurs langues, comme gemini-embedding-001 ou text-multilingual-embedding-002, pour améliorer la qualité de la récupération.

Dictionnaire

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

Basé sur les classes

from vertexai.types import ReasoningEngineContextSpecMemoryBankConfig as MemoryBankConfig
from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigSimilaritySearchConfig as SimilaritySearchConfig

memory_bank_config = MemoryBankConfig(
    similarity_search_config=SimilaritySearchConfig(
        embedding_model="EMBEDDING_MODEL"
    )
)

Remplacez les éléments suivants :

• EMBEDDING_MODEL : modèle d'embedding de texte Google à utiliser pour la recherche par similarité, au format projects/{project}/locations/{location}/publishers/google/models/{model}.

Configuration de génération

La configuration de la génération contrôle le LLM utilisé pour générer des souvenirs, y compris pour extraire des souvenirs et consolider de nouveaux souvenirs avec des souvenirs existants.

La Banque de mémoire utilise gemini-2.5-flash comme modèle par défaut. Pour les régions où Gemini n'est pas disponible au niveau régional, le point de terminaison mondial est utilisé.

Dictionnaire

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

Basé sur les classes

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

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

Remplacez les éléments suivants :

• LLM_MODEL : modèle LLM Google à utiliser pour extraire et consolider les souvenirs, au format projects/{project}/locations/{location}/publishers/google/models/{model}.

Configuration de la valeur TTL (Time to Live)

La configuration du TTL contrôle la façon dont la Banque de souvenirs doit définir dynamiquement le délai d'expiration des souvenirs. Une fois le délai d'expiration écoulé, les souvenirs ne pourront plus être récupérés et seront supprimés.

Si la configuration n'est pas fournie, le délai d'expiration ne sera pas défini de manière dynamique pour les souvenirs créés ou modifiés. Par conséquent, les souvenirs n'expireront pas, sauf si leur délai d'expiration est défini manuellement.

Deux options s'offrent à vous pour configurer le TTL :

• Valeur TTL par défaut : la valeur TTL sera appliquée à toutes les opérations qui créent ou mettent à jour une mémoire, y compris UpdateMemory, CreateMemory et GenerateMemories.

  Dictionnaire

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

  Basé sur les classes

  from vertexai.types import ReasoningEngineContextSpecMemoryBankConfig as MemoryBankConfig
  from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigTtlConfig as TtlConfig
  
  memory_bank_config = MemoryBankConfig(
      ttl_config=TtlConfig(
          default_ttl=f"TTLs"
      )
  )
  

  Remplacez les éléments suivants :

  • TTL : durée en secondes de la valeur TTL. Pour les souvenirs modifiés, le nouveau délai d'expiration calculé (maintenant + TTL) remplacera le délai d'expiration précédent du souvenir.

• TTL précis (par opération) : la valeur TTL est calculée en fonction de l'opération qui a créé ou mis à jour la mémoire. Si elle n'est pas définie pour une opération donnée, l'opération ne met pas à jour le délai d'expiration du souvenir.

  Dictionnaire

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

  Basé sur les classes

  from vertexai.types import ReasoningEngineContextSpecMemoryBankConfig as MemoryBankConfig
  from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigTtlConfig as TtlConfig
  from vertexai.types import ReasoningEngineContextSpecMemoryBankConfigTtlConfigGranularTtlConfig as GranularTtlConfig
  
  memory_bank_config = MemoryBankConfig(
      ttl_config=TtlConfig(
          granular_ttl_config=GranularTtlConfig(
              create_ttl=f"CREATE_TTLs",
              generate_created_ttl=f"GENERATE_CREATED_TTLs",
              generate_updated_ttl=f"GENERATE_UPDATED_TTLs",
          )
      )
  )
  

  Remplacez les éléments suivants :

  • CREATE_TTL : durée en secondes de la valeur TTL pour les souvenirs créés à l'aide de CreateMemory.
  • GENERATE_CREATED_TTL : durée en secondes de la valeur TTL pour les souvenirs créés à l'aide de GeneratedMemories.
  • GENERATE_UPDATED_TTL : durée en secondes de la valeur TTL pour les souvenirs mis à jour à l'aide de GeneratedMemories. La nouvelle date d'expiration calculée (maintenant + TTL) remplacera la précédente.

Étapes suivantes

• Guide de démarrage rapide avec le SDK Vertex AI Agent Engine
• Guide de démarrage rapide avec Agent Development Kit