Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Kontext över flera omgångar: Lagring och kryptering

Lektion 9 av 12 Uppdaterad 30 juli 2026 Avancerad
På denna sida
  1. Problemet med kontext mellan förfrågningar
  2. Metod 1: store_messages och previous_response_id
  3. Metod 2: use_encrypted_content
  4. Val mellan de två metoderna
  5. Kombinera med det hybrida arbetsflödet
  6. Viktiga punkter

Problemet med kontext mellan förfrågningar

I en konversation över flera omgångar med verktyg växer kontextvolymen snabbt. Varje verktygsanrop lägger till sina resultat i meddelandetråden, och modellens interna resonemang måste bevaras för att säkerställa konsekvens. Två mekanismer löser detta problem: fjärrlagring och klientsidig kryptering.

Metod 1: store_messages och previous_response_id

Fjärrlagring delegerar kontexthanteringen till xAI:s servrar. Du aktiverar store_messages=True i din första förfrågan och länkar sedan efterföljande förfrågningar med previous_response_id:

# First request: enable storage
response = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": "Analyze this sales dataset"}],
    tools=my_tools,
    store_messages=True
)

response_id = response.id  # save the ID

# Next request: use stored context
response2 = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": "What are the top 3 selling products?"}],
    previous_response_id=response_id,
    store_messages=True
)

Med detta tillvägagångssätt behöver du inte skicka om hela meddelandehistoriken. xAI-servern behåller kontexten och bifogar den automatiskt. Detta minskar storleken på förfrågningarna och förenklar din kod.

Fördelar

  • Lättare förfrågningar (behöver inte skicka om hela historiken)
  • Modellens interna resonemang bevaras automatiskt
  • Ingen komplex tillståndshantering på klientsidan

Begränsningar

  • Meddelanden lagras på xAI:s servrar (integritetsaspekt)
  • response_id måste sparas mellan förfrågningar
  • Lagringen har en begränsad behållningstid

Metod 2: use_encrypted_content

Klientsidig kryptering erbjuder ett alternativ för fall där du vill behålla kontrollen över kontexten utan att lagra dina data på xAI:s servrar:

# Enable encrypted content
response = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": "Analyze this contract"}],
    tools=my_tools,
    use_encrypted_content=True
)

# Reasoning and tool outputs are returned encrypted
# You add them as-is to subsequent messages
messages = [
    {"role": "user", "content": "Analyze this contract"},
    response.choices[0].message,  # contains encrypted content
    {"role": "user", "content": "What are the termination clauses?"}
]

response2 = await client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    use_encrypted_content=True
)

Med use_encrypted_content=True returneras interna resonemang och verktygsresultat i krypterad form. Du kan inte läsa dem, men du skickar vidare dem oförändrade i efterföljande förfrågningar. Servern dekrypterar dem för att upprätthålla kontinuiteten i resonemanget.

Fördelar

  • Kontexten förblir under din kontroll (ingen fjärrlagring)
  • Interna resonemang bevaras utan att exponeras i klartext
  • Kompatibelt med strikta integritetspolicyer

Begränsningar

  • Förfrågningarna blir större (krypterat innehåll inkluderas)
  • Du måste hantera meddelandehistoriken på klientsidan

Val mellan de två metoderna

Valet beror på ditt sammanhang:

  • store_messages: att föredra för chattapplikationer, interaktiva assistenter och fall där enkelhet går först. Kontexten hanteras automatiskt.
  • use_encrypted_content: att föredra för känsliga applikationer, bearbetning av konfidentiella dokument och fall där data inte får lämna din infrastruktur (utöver API-trafiken).

Kombinera med det hybrida arbetsflödet

Båda metoderna integreras i den loop-mönster som sågs i föregående lektion:

async def multi_turn_conversation(questions: list[str]) -> list[str]:
    responses = []
    previous_id = None

    for question in questions:
        kwargs = {
            "model": "grok-4.5",
            "messages": [{"role": "user", "content": question}],
            "tools": my_tools,
            "store_messages": True,
        }
        if previous_id:
            kwargs["previous_response_id"] = previous_id

        response = await client.chat.completions.create(**kwargs)
        previous_id = response.id
        responses.append(response.choices[0].message.content)

    return responses

Detta mönster länkar samman frågor samtidigt som hela konversationskontexten bevaras, inklusive verktygsresultat och modellens interna resonemang.

Viktiga punkter

  • store_messages=True + previous_response_id delegerar kontexthanteringen till xAI
  • use_encrypted_content=True bevarar resonemang utan fjärrlagring
  • Valet beror på dina krav på integritet och enkelhet
  • Båda metoderna är kompatibla med arbetsflöden över flera omgångar och hybrida verktyg
  • previous_response_id eliminerar behovet av att skicka om hela meddelandehistoriken