Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Context met meerdere beurten: opslag en versleuteling

Les 9 van 12 Bijgewerkt op 30 juli 2026 Gevorderd
Op deze pagina
  1. Het probleem van context tussen verzoeken
  2. Methode 1: store_messages en previous_response_id
  3. Methode 2: use_encrypted_content
  4. Keuze tussen de twee methoden
  5. Combineren met de hybride workflow
  6. Belangrijkste punten

Het probleem van context tussen verzoeken

Bij een gesprek met meerdere beurten waarbij tools worden gebruikt, groeit de contextomvang snel. Elke tool-aanroep voegt de resultaten toe aan de berichtthread en de interne redenering van het model moet behouden blijven voor consistentie. Twee mechanismen lossen dit probleem op: externe opslag en client-side versleuteling.

Methode 1: store_messages en previous_response_id

Bij externe opslag wordt het contextbeheer gedelegeerd aan de xAI-servers. U schakelt store_messages=True in bij uw eerste verzoek en koppelt vervolgens daaropvolgende verzoeken met previous_response_id:

# Eerste verzoek: opslag inschakelen
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  # sla de ID op

# Volgend verzoek: gebruik de opgeslagen 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
)

Met deze aanpak hoeft u de volledige berichtgeschiedenis niet opnieuw te verzenden. De xAI-server bewaart de context en koppelt deze automatisch. Dit verkleint de verzoekgrootte en vereenvoudigt uw code.

Voordelen

  • Lichtere verzoeken (geen behoefte om de volledige geschiedenis opnieuw te verzenden)
  • Interne redenering van het model wordt automatisch behouden
  • Geen complex statusbeheer nodig aan de clientkant

Beperkingen

  • Berichten worden opgeslagen op xAI-servers (privacy-overweging)
  • De response_id moet tussen verzoeken worden bewaard
  • Opslag heeft een beperkte bewaartermijn

Methode 2: use_encrypted_content

Versleuteling aan de clientkant biedt een alternatief voor gevallen waarin u de controle over de context wilt behouden zonder uw gegevens op xAI-servers op te slaan:

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

# Redenering en tool-uitvoer worden versleuteld teruggegeven
# U voegt ze ongewijzigd toe aan daaropvolgende berichten
messages = [
    {"role": "user", "content": "Analyze this contract"},
    response.choices[0].message,  # bevat versleutelde inhoud
    {"role": "user", "content": "What are the termination clauses?"}
]

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

Met use_encrypted_content=True worden interne redenering en tool-resultaten in versleutelde vorm teruggegeven. U kunt ze niet lezen, maar u verzendt ze wel opnieuw in daaropvolgende verzoeken. De server decrypteert ze om de continuïteit van de redenering te behouden.

Voordelen

  • Context blijft onder uw controle (geen externe opslag)
  • Interne redenering wordt behouden zonder in platte tekst zichtbaar te zijn
  • Compatibel met strikte privacybeleidsregels

Beperkingen

  • Verzoeken zijn groter (versleutelde inhoud is inbegrepen)
  • U moet de berichtgeschiedenis aan de clientkant beheren

Keuze tussen de twee methoden

De keuze hangt af van uw context:

  • store_messages: te verkiezen voor chat-toepassingen, interactieve assistenten en gevallen waar eenvoud voorop staat. De context wordt automatisch beheerd.
  • use_encrypted_content: te verkiezen voor gevoelige toepassingen, verwerking van vertrouwelijke documenten en gevallen waarin gegevens uw infrastructuur niet mogen verlaten (voorbij API-transit).

Combineren met de hybride workflow

Beide methoden integreren in het luspatroon dat in de vorige les aan bod kwam:

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

Dit patroon koppelt vragen aan elkaar terwijl de volledige gesprekcontext behouden blijft, inclusief tool-resultaten en de interne redenering van het model.

Belangrijkste punten

  • store_messages=True + previous_response_id delegeert contextbeheer aan xAI
  • use_encrypted_content=True behoudt redenering zonder externe opslag
  • De keuze hangt af van uw privacy- en eenvoudvereisten
  • Beide methoden zijn compatibel met workflows met meerdere beurten en hybride tools
  • previous_response_id elimineert de noodzaak om de volledige berichtgeschiedenis opnieuw te verzenden