Session

AgentSession är containern för konversationstillstånd som används mellan agentkörningar.

Vad AgentSession innehåller

Fält Avsikt
StateBag Flexibel tillståndsbehållare för sessionen

C# AgentSession är en abstrakt basklass. Konkreta implementeringar (skapade via CreateSessionAsync()) kan lägga till ytterligare tillstånd, t.ex. ett ID för lagring av fjärrchatthistorik, när tjänsthanterad historik används.

Fält Avsikt
session_id Lokal unik identifierare för den här sessionen
service_session_id Identifierare för fjärrtjänstsession, till exempel en konversation eller ett svars-ID, när tjänsthanterad historik används
state Föränderlig ordlista som delas med kontext-/historikprovidrar
Fält Avsikt
agent.Session Nyckelvärdestillståndscontainer kopplad till en konversation

Sessioner tillhandahåller typad lagring av nyckel/värde-par:

type UserPrefs struct {
    Theme    string `json:"theme"`
    Language string `json:"language"`
}

session.Set("user_prefs", UserPrefs{Theme: "dark", Language: "en"})

var prefs UserPrefs
session.Get("user_prefs", &prefs)

session.Delete("user_prefs")

Omfång för tjänstsessions-ID

När tjänsthanterad historik används kan en session innehålla en tjänst utfärdad sessionsidentifierare. Till exempel kan OpenAI-svar använda ett resp_* svars-ID som previous_response_idoch OpenAI-konversations-API:et kan använda ett conv_* konversations-ID som konversation.

OpenAI begränsar som standard dessa ID:n till den underliggande API-nyckeln eller projektet. Detta räcker vanligtvis när nyckeln eller projektet redan matchar programgränsen, till exempel en app med en användare eller en separat nyckel/ett separat projekt per klientorganisation. Det riskfyllda hostade mönstret innebär att man använder en underliggande nyckel eller ett projekt för flera slutanvändare, skickar vidare råa tjänstside-ID:n till klienter och accepterar dessa ID:n tillbaka utan att verifiera ägarskapet. I värdbaserade appar eller appar med flera användare som återanvänder en säkerhetskopieringsnyckel eller ett projekt ska du inte behandla service_session_id, previous_response_ideller conversation/conversation_id som auktoriseringsgränser för slutanvändare. Lagra ID:n på tjänstsidan i betrodd applikationslagring, koppla klientsynliga sessions-ID:n till dessa ID:n och verifiera den autentiserade användaren eller klientorganisationen innan du återupptar en konversation.

Inbyggt användningsmönster

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

session = agent.create_session()

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

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

resp, _ := a.RunText(ctx, "Hello!", agent.WithSession(session)).Collect()
resp, _ = a.RunText(ctx, "Follow-up question.", agent.WithSession(session)).Collect()

Skapa en session från ett befintligt tjänstkonversations-ID

Skapa en ny session från ett befintligt konversations-ID varierar beroende på agenttyp. Här följer några exempel.

När du använder ChatClientAgent

AgentSession session = await chatClientAgent.CreateSessionAsync(conversationId);

När du använder en A2AAgent

AgentSession session = await a2aAgent.CreateSessionAsync(contextId, taskId);

Använd detta när den stödjande tjänsten redan har konversationstillstånd.

session = agent.get_session(service_session_id="<service-conversation-id>")
response = await agent.run("Continue this conversation.", session=session)

I värdbaserade appar hämtar du <service-conversation-id> från programmets egen lagring efter att ha kontrollerat den aktuella användaren eller klientorganisationen. Undvik att acceptera obearbetade ID:n på tjänstsidan från en klient om du inte först verifierar att anroparen äger konversationen.

Serialisering och återställning

var serialized = agent.SerializeSession(session);
AgentSession resumed = await agent.DeserializeSessionAsync(serialized);

serialized = session.to_dict()
resumed = AgentSession.from_dict(serialized)

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

// Save to disk, database, etc.
if err := os.WriteFile("session.json", data, 0o644); err != nil {
    panic(err)
}

// Later, restore the session.
loaded, err := os.ReadFile("session.json")
if err != nil {
    panic(err)
}

var resumedSession agent.Session
if err := json.Unmarshal(loaded, &resumedSession); err != nil {
    panic(err)
}

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

Tip

Se det bevarade konversationsexemplet för ett fullständigt exempel.

Viktigt!

Sessioner är agent-/tjänstspecifika. Om du återanvänder en session med en annan agentkonfiguration eller leverantör kan det leda till en ogiltig kontext. Om den serialiserade sessionen innehåller ett sessions-ID på tjänstsidan återställer du det endast för programanvändaren eller klientorganisationen som äger det ID:t.

Nästa steg

Kontextprovidrar

  • Last updated on