Visão geral de Conversas e Memória

Use AgentSession para manter o contexto da conversa entre as invocações.

Quando uma sessão utiliza armazenamento gerido por serviços, pode conter um ID opaco do lado do serviço. Os IDs de Responses e Conversations da OpenAI estão, por predefinição, associados à chave da API ou ao projeto subjacente; se um agente alojado usar a mesma chave ou projeto para vários utilizadores finais, armazene esses IDs no lado do servidor e verifique o utilizador autenticado ou o tenant antes de retomar. Para mais detalhes, veja Sessão.

Padrão de utilização dos núcleos

A maioria das candidaturas segue o mesmo fluxo:

1. Criar uma sessão (CreateSessionAsync())
2. Passar essa sessão a cada um RunAsync(...)
3. Reidratar a partir do estado serializado (DeserializeSessionAsync(...))
4. Continue com um ID de conversa de serviço (varia consoante o agente, por exemplo) myChatClientAgent.CreateSessionAsync("existing-id")

1. Criar uma sessão (create_session())
2. Passar essa sessão a cada um run(...)
3. Reidratar por ID de conversa de serviço (get_session(...)) ou a partir do estado serializado

1. Criar uma sessão (CreateSession(...))
2. Passe essa sessão a cada RunText(...) com agent.WithSession(session)
3. Reidratar do estado serializado com json.Unmarshal(...) em agent.Session

O pacote Go agent fornece os tipos base para o estado da conversa: agent.Session para estado de chave-valor associado a uma conversa e agent.ContextProvider para injeção de contexto e persistência.

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

Use uma sessão para conversas com vários 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()

Manter as sessões

As sessões podem ser serializadas para JSON para armazenamento e posteriormente retomadas:

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-guia

Página	Foco
Sessão	AgentSession Estrutura e serialização
Fornecedores de Contexto	Padrões incorporados e personalizados de fornecedores de contexto/histórico
Compactação do Contexto	Gerir eficientemente o crescimento da conversa
Armazenamento	Modos de armazenamento incorporados e estratégias externas de persistência

Próximos passos

Sessão