Vue d’ensemble des conversations et de la mémoire

1. Créer une session (CreateSessionAsync())
2. Passez cette session à chacun d’eux RunAsync(...)
3. Réhydrater à partir de l’état sérialisé (DeserializeSessionAsync(...))
4. Continuer avec un ID de conversation de service (varie selon l’agent, par exemple myChatClientAgent.CreateSessionAsync("existing-id"))

1. Créer une session (create_session())
2. Passez cette session à chacun d’eux run(...)
3. Réhydrater à l'aide de l'ID de conversation du service (get_session(...)) ou à partir d’un état sérialisé

1. Créer une session (CreateSession(...))
2. Transmettez cette session à chaque RunText(...) avec agent.WithSession(session)
3. Réhydrater à partir de l’état sérialisé avec json.Unmarshal(...) dans agent.Session

Le package Go agent fournit les types principaux pour l’état de conversation : agent.Session pour l’état clé-valeur lié à une conversation et agent.ContextProvider pour l’injection de contexte et la persistance.

// Create and reuse a session
AgentSession session = await agent.CreateSessionAsync();

var first = await agent.RunAsync("My name is Alice.", session);
var second = await agent.RunAsync("What is my name?", session);

// Persist and restore later
var serialized = agent.SerializeSession(session);
AgentSession resumed = await agent.DeserializeSessionAsync(serialized);

# Create and reuse a session
session = agent.create_session()

first = await agent.run("My name is Alice.", session=session)
second = await agent.run("What is my name?", session=session)

# Rehydrate by service conversation ID when needed
service_session = agent.get_session(service_session_id="<service-conversation-id>")

# Persist and restore later
serialized = session.to_dict()
resumed = AgentSession.from_dict(serialized)

session, err := a.CreateSession(ctx)
if err != nil {
    panic(err)
}

Utiliser une session pour les conversations à plusieurs tours

resp, _ := a.RunText(ctx, "My name is Alice.", agent.WithSession(session)).Collect()
resp, _ = a.RunText(ctx, "What is my name?", agent.WithSession(session)).Collect()

Maintenir les sessions

Les sessions peuvent être sérialisées au format JSON pour le stockage et reprise ultérieurement :

data, err := json.Marshal(session)
if err != nil {
    panic(err)
}
// store data...

// later:
var resumed agent.Session
if err := json.Unmarshal(data, &resumed); err != nil {
    panic(err)
}

resp, err := a.RunText(ctx, "Continue from where we left off.", agent.WithSession(&resumed)).Collect()