Étape 4 : Mémoire et persistance

Ajoutez un contexte à votre agent pour qu’il puisse mémoriser les préférences utilisateur, les interactions passées ou les connaissances externes.

Configurez la mémoire avec un ChatHistoryProvider personnalisé :

using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("Set AZURE_OPENAI_ENDPOINT");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";

AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new AzureCliCredential())
    .GetChatClient(deploymentName)
    .AsAIAgent(instructions: "You are a friendly assistant. Keep your answers brief.", name: "MemoryAgent");

Utilisez une session pour conserver le contexte entre les exécutions :

AgentSession session = await agent.CreateSessionAsync();

Console.WriteLine(await agent.RunAsync("Hello! What's the square root of 9?", session));
Console.WriteLine(await agent.RunAsync("My name is Alice", session));
Console.WriteLine(await agent.RunAsync("What is my name?", session));

Conseil / Astuce

Consultez l’exemple complet du fichier exécutable complet.

Définissez un fournisseur de contexte qui injecte un contexte supplémentaire dans chaque appel d’agent :

class UserNameProvider(BaseContextProvider):
    """A simple context provider that remembers the user's name."""

    def __init__(self) -> None:
        super().__init__(source_id="user-name-provider")
        self.user_name: str | None = None

    async def before_run(
        self,
        *,
        agent: Any,
        session: AgentSession,
        context: SessionContext,
        state: dict[str, Any],
    ) -> None:
        """Called before each agent invocation — add extra instructions."""
        if self.user_name:
            context.instructions.append(f"The user's name is {self.user_name}. Always address them by name.")
        else:
            context.instructions.append("You don't know the user's name yet. Ask for it politely.")

    async def after_run(
        self,
        *,
        agent: Any,
        session: AgentSession,
        context: SessionContext,
        state: dict[str, Any],
    ) -> None:
        """Called after each agent invocation — extract information."""
        for msg in context.input_messages:
            text = msg.text if hasattr(msg, "text") else ""
            if isinstance(text, str) and "my name is" in text.lower():
                # Simple extraction — production code should use structured extraction
                self.user_name = text.lower().split("my name is")[-1].strip().split()[0].capitalize()

Créez un agent avec le fournisseur de contexte :

credential = AzureCliCredential()
client = AzureOpenAIResponsesClient(
    project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
    deployment_name=os.environ["AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME"],
    credential=credential,
)

memory = UserNameProvider()

agent = client.as_agent(
    name="MemoryAgent",
    instructions="You are a friendly assistant.",
    context_providers=[memory],
)

Note

Dans Python, la persistance/mémoire est gérée par les fournisseurs d’historique. A BaseHistoryProvider est également un BaseContextProvider, et InMemoryHistoryProvider est l’implémentation locale intégrée. RawAgent peut ajouter InMemoryHistoryProvider("memory") automatiquement des cas spécifiques (par exemple, lors de l’utilisation d’une session sans fournisseur de contexte configuré et aucun indicateur de stockage côté service), mais cela n’est pas garanti dans tous les scénarios. Si vous souhaitez toujours une persistance locale, ajoutez une InMemoryHistoryProvider valeur explicite. Assurez-vous également qu’un seul fournisseur d’historique ait load_messages=True, afin que vous ne rejouiez pas plusieurs bases de données dans une même invocation.

Vous pouvez également ajouter un magasin d’audit en ajoutant un autre fournisseur d’historique à la fin de context_providers, avec store_context_messages=True :

from agent_framework import InMemoryHistoryProvider

memory_store = InMemoryHistoryProvider("memory", load_messages=True)
audit_store = InMemoryHistoryProvider(
    "audit",
    load_messages=False,
    store_context_messages=True,  # include context added by other providers
)

agent = client.as_agent(
    name="MemoryAgent",
    instructions="You are a friendly assistant.",
    context_providers=[memory, memory_store, audit_store],  # audit store last
)

Exécutez-le : l’agent a désormais accès au contexte :

session = agent.create_session()

# The provider doesn't know the user yet — it will ask for a name
result = await agent.run("Hello! What's the square root of 9?", session=session)
print(f"Agent: {result}\n")

# Now provide the name — the provider extracts and stores it
result = await agent.run("My name is Alice", session=session)
print(f"Agent: {result}\n")

# Subsequent calls are personalized
result = await agent.run("What is 2 + 2?", session=session)
print(f"Agent: {result}\n")

print(f"[Memory] Stored user name: {memory.user_name}")

Conseil / Astuce

Consultez l’exemple complet du fichier exécutable complet.

Prochaines étapes

Étape 5 : Flux de travail

Aller plus loin :

• Stockage persistant : stocker des conversations dans des bases de données
• Historique des conversations : gérer l’historique des conversations et la mémoire