Información general sobre conversaciones y memoria

Use AgentSession para mantener el contexto de conversación entre invocaciones.

Cuando una sesión usa almacenamiento administrado por el servicio, puede contener un identificador de sesión opaco del lado del servicio. Las respuestas y los identificadores de conversación de OpenAI tienen como ámbito la clave de API de respaldo o el proyecto de forma predeterminada; si un agente hospedado usa la misma clave o proyecto para varios usuarios finales, almacene esos identificadores en el lado servidor y compruebe el usuario o inquilino autenticado antes de reanudar. Para obtener más información, consulte Sesión.

Patrón de uso principal

La mayoría de las aplicaciones siguen el mismo flujo:

1. Crear una sesión (CreateSessionAsync())
2. Pasar esa sesión a cada uno de los RunAsync(...)
3. Rehidrata desde el estado serializado (DeserializeSessionAsync(...))
4. Continúe con un ID de conversación de servicio (varía según el agente, por ejemplo, myChatClientAgent.CreateSessionAsync("existing-id"))

1. Crear una sesión (create_session())
2. Pasar esa sesión a cada uno de los run(...)
3. Rehidratar con el identificador de conversación de servicio (get_session(...)) o desde el estado serializado

1. Crear una sesión (CreateSession(...))
2. Pasa esa sesión a cada RunText(...) con agent.WithSession(session)
3. Rehidratar a partir del estado serializado con json.Unmarshal(...) en agent.Session

El paquete Go agent proporciona los tipos principales para el estado de conversación: agent.Session para el estado clave-valor asociado a una conversación y agent.ContextProvider para la inserción de contexto y la persistencia.

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

Usa una sesión para conversaciones de varios turnos

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

Mantener las sesiones

Las sesiones se pueden serializar en JSON para el almacenamiento y se reanudan posteriormente:

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

Mapa de guía

Página	Enfoque
Sesión	AgentSession estructura y serialización
Proveedores de contexto	Patrones de proveedor de contexto/historial personalizados y integrados
Compactación de contexto	Administrar eficazmente el crecimiento de la conversación
Almacenamiento	Modos de almacenamiento integrados y estrategias de persistencia externa

Pasos siguientes

Sesión