Context met meerdere beurten: opslag en versleuteling
Op deze pagina
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_idmoet 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_iddelegeert contextbeheer aan xAIuse_encrypted_content=Truebehoudt 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_idelimineert de noodzaak om de volledige berichtgeschiedenis opnieuw te verzenden