Configurer la banque de souvenirs

Avant d'utiliser la banque de mémoire Vertex AI Agent Engine, vous devez configurer votre environnement. Notez que, bien que Memory Bank fasse partie d'Agent Engine, vous n'avez pas besoin de déployer votre code dans Agent Engine Runtime pour utiliser Memory Bank.

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 :

  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.

    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 Memory Bank.

    Configurer votre environnement

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

    Installer les bibliothèques

    Installez le SDK Vertex AI :

      pip install google-cloud-aiplatform>=1.104.0

    Authentification

    Les instructions d'authentification dépendent de l'utilisation de 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["GOOGLE_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.

    Configurer votre instance Agent Engine pour Memory Bank

    Pour commencer à utiliser Memory Bank, vous devez d'abord disposer d'une instance Agent Engine.

    Vous pouvez effectuer l'une des actions suivantes :

    Utiliser une instance existante

    Si vous n'avez pas besoin de modifier une instance Agent Engine existante, exécutez la commande suivante pour configurer l'instance pour Memory Bank :

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

    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 l'instance dans n'importe quel environnement, y compris Google Kubernetes Engine et Cloud Run. Pour commencer, vous avez besoin du nom de l'Agent Engine qui identifie la banque de données Memory Bank et des autorisations suffisantes pour appeler Memory Bank.

    Créer ou mettre à jour une instance

    Créer

    Memory Bank est activé par défaut lorsque vous créez une instance Agent Engine. La création d'un moteur d'agent sans environnement d'exécution ne devrait prendre que quelques secondes.

      agent_engine = client.agent_engines.create()

    Vous pouvez également remplacer les paramètres par défaut d'Agent Engine lorsque vous créez une instance Agent Engine pour apporter les modifications suivantes :

    • Définissez la configuration pour la façon dont la Banque de souvenirs génère et gère les souvenirs.

    • Déployez votre agent dans l'environnement d'exécution 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=...
)

      Les nouvelles instances sont vides jusqu'à ce que vous créiez ou génériez des souvenirs.

      Pour lire ou écrire des souvenirs, vous avez besoin du nom de votre Agent Engine :

      agent_engine_name = agent_engine.api_resource.name

    Mettre à jour

    Vous pouvez mettre à jour une instance Agent Engine existante si vous souhaitez mettre à jour Agent Engine tout en conservant les mémoires stockées dans l'instance. Vous pouvez effectuer des mises à jour, comme modifier la configuration de la banque de mémoire ou déployer votre agent dans Agent Engine Runtime.

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

    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.

    Configurer votre 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

    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 un 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 et résultats des tâches dans la conversation (KEY_CONVERSATION_DETAILS) : étapes importantes ou conclusions dans le 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 mémoire. 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": "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."""
        }
  ]
}

    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 pour l'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 doivent 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 par similarité

    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 ceux qui peuvent être récupérés à l'aide de 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.0-flash-001 comme modèle par défaut.

    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 durée de vie (TTL)

    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 leur durée de vie expirée, 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.

    • Valeur TTL précise (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.

    Déployer votre agent avec mémoire dans Agent Engine

    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 de kit de développement d'agent Agent Engine, l'agent utilise VertexAiMemoryBankService par défaut lorsqu'il est déployé dans Agent Engine Runtime. Cela signifie que les outils de mémoire 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_engine=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.

    Si vous souhaitez utiliser la même instance Agent Engine pour Memory Bank et Agent Engine Runtime, vous pouvez 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}"

    Étapes suivantes