Conversazioni multi-turno con strumenti
In questa pagina
Conversazioni multi-turno con chiamata di funzioni
In una conversazione reale, il modello potrebbe dover chiamare gli strumenti più volte durante lo scambio. Ogni turno può implicare nuove chiamate, risultati che ne attivano altre o richieste di chiarimenti all’utente prima di utilizzare uno strumento.
Il parametro max_turns
Il parametro max_turns limita il numero di turni assistente/strumento lato server in una singola richiesta. Si applica solo agli strumenti integrati (web_search, code_interpreter, ecc.).
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
)
Punto importante: le invocazioni di strumenti lato client azzerano il contatore. Quando invii un function_call_output, inizia una nuova allocazione di max_turns.
Loop multi-turno lato client
Per gestire conversazioni in cui il modello chiama gli strumenti più volte, implementa un ciclo:
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"
La variabile max_iterations è una salvaguardia essenziale per prevenire loop infiniti. In produzione, imposta un limite ragionevole (5–10 turni).
Contesto multi-turno con le Responses API
Le Responses API offrono due meccanismi per mantenere il contesto:
1. Archiviazione remota
# 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
)
Il vantaggio: non devi gestire lo storico dei messaggi. xAI lo archivia e lo recupera automaticamente tramite previous_response_id.
2. Contenuto crittografato lato client
response = client.responses.create(
model="grok-4.5",
input="Search for flight prices to Nice",
tools=tools,
use_encrypted_content=True
)
Con use_encrypted_content=True, ricevi il ragionamento e gli output degli strumenti in forma crittografata. Li rimandi così come sono nelle richieste successive, senza poterli leggere. Questo è utile quando non vuoi che i dati transitino in chiaro attraverso il tuo server.
Pattern di conversazione multi-turno
Pattern: Ricerca poi azione
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)
Pattern: Aggregazione dati
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."
Pattern: Affinamento progressivo
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
Gestione della memoria
Nelle conversazioni lunghe, lo storico — che include ogni tool_call e ogni risultato dello strumento — cresce rapidamente, e con esso il costo di ogni turno. Hai a disposizione tre strategie, dalla manuale alla completamente delegata. La riassunzione periodica condensa i turni più vecchi in un paragrafo iniettato nel prompt di sistema: mantieni la sostanza degli scambi passati per una frazione del loro peso in token, al costo di perdere qualche dettaglio. La finestra scorrevole è più brutale ma più semplice: mantieni solo gli ultimi N turni, accettando che il modello dimentichi l’inizio della conversazione; adatta quando gli scambi più vecchi non hanno più importanza operativa. L’archiviazione remota, infine, delega il problema a xAI con store_messages=True: lo storico vive lato server e la tua applicazione porta solo un riferimento. La scelta giusta dipende da ciò che la tua applicazione deve ricordare e per quanto tempo.
Punti chiave
max_turnslimita i turni degli strumenti lato server; gli strumenti client azzerano il contatore- Implementa un ciclo con
max_iterationsper prevenire loop infiniti previous_response_idconcatena le conversazioni senza reinviare lo storicostore_messages=Truedelega l’archiviazione del contesto a xAIuse_encrypted_content=Trueprotegge i dati in transito- Gestisci la memoria nelle conversazioni lunghe (riassunzione, finestra scorrevole)