Gesprekken met meerdere beurten met tools
Op deze pagina
Gesprekken met meerdere beurten met functieaanroepen
In een echt gesprek moet het model mogelijk meerdere keren tools aanroepen tijdens de uitwisseling. Elke beurt kan nieuwe aanroepen inhouden, resultaten die andere aanroepen activeren, of verzoeken om verduidelijking aan de gebruiker voordat een tool wordt gebruikt.
De parameter max_turns
De parameter max_turns beperkt het aantal assistent/tool-beurten aan de serverzijde in één enkel verzoek. Dit geldt alleen voor ingebouwde tools (web_search, code_interpreter, enz.).
response = client.responses.create(
model="grok-4.5",
input="Analyze 2026 tech trends",
tools=[{"type": "web_search"}],
max_turns=5 # Maximum 5 web searches before responding
)
Belangrijk punt: aanroepen van tools aan de clientzijde stellen de teller opnieuw in. Wanneer u een function_call_output terugstuurt, begint een nieuwe toewijzing van max_turns.
Lus met meerdere beurten aan de clientzijde
Om gesprekken te beheren waarbij het model meerdere keren tools aanroept, implementeert u een lus:
import json
def multi_turn_chat(user_message, tools, max_iterations=10):
messages = [{"role": "user", "content": user_message}]
for i in range(max_iterations):
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
message = response.choices[0].message
messages.append(message)
# If no tool_call, the conversation is over
if not message.tool_calls:
return message.content
# Execute all requested tools
for tool_call in message.tool_calls:
args = json.loads(tool_call.function.arguments)
result = execute_function(tool_call.function.name, args)
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result)
})
return "Maximum number of iterations reached"
De variabele max_iterations is een essentiële beveiliging om oneindige lussen te voorkomen. Stel in een productieomgeving een redelijke limiet in (5–10 beurten).
Context met meerdere beurten met de Responses API
De Responses API biedt twee mechanismen om context te behouden:
1. Externe opslag
# First message
r1 = client.responses.create(
model="grok-4.5",
input="What's the weather like in Paris?",
tools=tools,
store_messages=True
)
# Tool result
r2 = client.responses.create(
model="grok-4.5",
input=[{
"type": "function_call_output",
"call_id": r1.output[0].call_id,
"output": {temp: 18}
}],
previous_response_id=r1.id,
store_messages=True
)
# Follow-up question (context is preserved)
r3 = client.responses.create(
model="grok-4.5",
input="What about tomorrow?",
previous_response_id=r2.id,
tools=tools,
store_messages=True
)
Het voordeel: u hoeft de berichtengeschiedenis niet zelf te beheren. xAI slaat deze automatisch op en haalt deze op via previous_response_id.
2. Versleutelde inhoud aan de clientzijde
response = client.responses.create(
model="grok-4.5",
input="Search for flight prices to Nice",
tools=tools,
use_encrypted_content=True
)
Met use_encrypted_content=True ontvangt u redeneringen en tool-uitvoer in versleutelde vorm. U stuurt deze ongewijzigd terug in daaropvolgende verzoeken, zonder ze te kunnen lezen. Dit is nuttig wanneer u niet wilt dat gegevens in klare tekst via uw server worden verstuurd.
Patronen voor gesprekken met meerdere beurten
Patroon: Zoeken en vervolgens actie ondernemen
Turn 1 : User → "Find a cheap Paris-Nice flight"
Model → tool_call: search_flights(from="CDG", to="NCE")
Client → result : [{flight1}, {flight2}, {flight3}]
Turn 2 : Model → "I found 3 flights. The cheapest is €89. Do you want to book it?"
User → "Yes, book the €89 flight"
Turn 3 : Model → tool_call: book_flight(flight_id="FL123", passengers=1)
Patroon: Data-aggregatie
Turn 1 : Model → tool_call: get_sales(month="march")
Turn 2 : Model → tool_call: get_expenses(month="march")
Turn 3 : Model → tool_call: get_headcount(month="march")
Turn 4 : Model → "Here is the monthly report: sales +12%, expenses -3%, headcount stable."
Patroon: Progressieve verfijning
Turn 1 : Model → tool_call: search_products(query="running shoes")
Result → 150 products
Turn 2 : Model → "I found 150 products. What size and budget?"
User → "42, max €120"
Turn 3 : Model → tool_call: search_products(query="running shoes", size=42, max_price=120)
Result → 8 products
Geheugenbeheer
Bij lange gesprekken groeit de geschiedenis – die elke tool_call en elk tool-resultaat bevat – snel, en daarmee ook de kosten van elke beurt. Er staan u drie strategieën ter beschikking, variërend van handmatig tot volledig gedelegeerd. Periodieke samenvatting verdicht oudere beurten tot één alinea die in de systeemprompt wordt ingevoegd: u behoudt de kern van eerdere uitwisselingen voor een fractie van hun tokengewicht, ten koste van enig detailverlies. Het schuifvenster is brutaler maar eenvoudiger: houd alleen de laatste N beurten bij, met de acceptatie dat het model het begin van het gesprek vergeet – geschikt wanneer oudere uitwisselingen geen operationeel belang meer hebben. Externe opslag delegeteert het probleem ten slotte aan xAI met store_messages=True: de geschiedenis leeft aan de serverzijde en uw applicatie bewaart slechts een referentie. De juiste keuze hangt af van wat uw applicatie moet onthouden en hoe lang.
Belangrijkste punten
max_turnsbeperkt tool-beurten aan de serverzijde – tools aan de clientzijde stellen de teller opnieuw in- Implementeer een lus met
max_iterationsom oneindige lussen te voorkomen previous_response_idkoppelt gesprekken zonder de geschiedenis opnieuw te verzendenstore_messages=Truedelegeert contextopslag aan xAIuse_encrypted_content=Truebeschermt gegevens tijdens verzending- Beheer het geheugen bij lange gesprekken (samenvatting, schuifvenster)