Συνομιλία Πολλαπλών Γύρων
Σε αυτήν τη σελίδα
Πέρα από τις Μεμονωμένες Κλήσεις
Σε μια εφαρμογή του πραγματικού κόσμου, οι χρήστες δεν κάνουν μια ερώτηση και εξαφανίζονται. Συνδέουν αιτήματα, επιστρέφουν σε προηγούμενα θέματα και αφήνουν υπαινιγμούς όπως «τι γίνεται με αυτό;» που η πρόταση από μόνη της δεν μπορεί να επιλύσει. Η κλήση συναρτήσεων πρέπει να λειτουργεί εντός αυτού του πλαισίου συνομιλίας πολλαπλών γύρων, όπου το μοντέλο μπορεί να καλεί συναρτήσεις σε κάθε βήμα του διαλόγου χωρίς ποτέ να χάνει την επαφή με το τι προηγήθηκε.
Η Αρχή: Διατήρηση του Ιστορικού
Το κλειδί συνοψίζεται σε μια φράση: κρατήστε όλα τα μηνύματα σε μια λίστα που μεγαλώνει με κάθε ανταλλαγή. Το μοντέλο δεν έχει δική του μνήμη μεταξύ των κλήσεων API· το μόνο πλαίσιο που διαθέτει είναι αυτό που στέλνετε πίσω. Αυτό το πλήρες ιστορικό είναι που του επιτρέπει να κατανοεί τις έμμεσες αναφορές.
import os
import json
from mistralai.client import Mistral
from functools import partial
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
# Ιστορικό συνομιλίας
messages = [
{
"role": "system",
"content": "Είστε ένας βοηθός παρακολούθησης πληρωμών. "
"Απαντήστε σε συνοπτικά Αγγλικά."
}
]
Πλήρης Βρόχος Συνομιλίας
Ο παρακάτω κώδικας λειτουργεί σε δύο στάδια. Το process_tool_calls εκτελεί όλες τις κλήσεις που ζητήθηκαν από το μοντέλο και επανεκκινεί τη συνομιλία με τα αποτελέσματα· το chat διαχειρίζεται έναν πλήρη γύρο, από την είσοδο του χρήστη μέχρι την τελική απάντηση κειμένου.
def process_tool_calls(response, messages, available_functions, tools):
"""Επεξεργάζεται τις tool_calls και επιστρέφει την τελική απάντηση."""
message = response.choices[0].message
messages.append(message)
# Εκτέλεση κάθε tool_call
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
if function_name in available_functions:
result = available_functions[function_name](**function_params)
else:
result = json.dumps({"error": f"Άγνωστη συνάρτηση {function_name}"})
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Κλήση του μοντέλου ξανά με τα αποτελέσματα
return client.chat.complete(
model=model, messages=messages, tools=tools
)
def chat(user_input: str, messages: list, tools: list,
available_functions: dict) -> str:
"""Διαχειρίζεται έναν πλήρη γύρο συνομιλίας."""
messages.append({"role": "user", "content": user_input})
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
# Επανάληψη όσο το μοντέλο θέλει να καλέσει συναρτήσεις
while message.tool_calls and len(message.tool_calls) > 0:
response = process_tool_calls(
response, messages, available_functions, tools
)
message = response.choices[0].message
# Το μοντέλο τελείωσε—απαντά με κείμενο
messages.append(message)
return message.content
Ο βρόχος while είναι το κρίσιμο στοιχείο. Αφού λάβει ένα αποτέλεσμα συνάρτησης, το μοντέλο μπορεί κάλλιστα να ζητήσει ένα άλλο: ο βρόχος συνεχίζεται όσο παράγει tool_calls και σταματά μόνο όταν τελικά επιστρέψει κείμενο. Ένα απλό if θα διαχειριζόταν την πρώτη κλήση και στη συνέχεια θα επέστρεφε μια κενή απάντηση σε οποιαδήποτε περίπτωση που απαιτούνταν δύο κλήσεις.
Παράδειγμα Συνομιλίας Πολλαπλών Γύρων
Ας δούμε πώς φαίνεται αυτός ο βρόχος σε τέσσερις συνδεδεμένους γύρους.
# Γύρος 1
reponse = chat("Ποια είναι η κατάσταση της πληρωμής T1001;",
messages, tools, available_functions)
print(f"Βοηθός : {reponse}")
# → "Κατάσταση πληρωμής T1001: εξοφλημένη."
# Γύρος 2 — ερώτηση παρακολούθησης
reponse = chat("Πότε έγινε;",
messages, tools, available_functions)
print(f"Βοηθός : {reponse}")
# → "Η πληρωμή T1001 έγινε στις 15 Μαρτίου 2026."
# Γύρος 3 — νέα συναλλαγή
reponse = chat("Σύγκρινέ την με την πληρωμή T1003.",
messages, tools, available_functions)
print(f"Βοηθός : {reponse}")
# → "Η πληρωμή T1003 εκκρεμεί, σε αντίθεση με την T1001 που είναι εξοφλημένη."
# Γύρος 4 — ερώτηση χωρίς συνάρτηση
reponse = chat("Ευχαριστώ, αυτό ήταν για σήμερα.",
messages, tools, available_functions)
print(f"Βοηθός : {reponse}")
# → "Παρακαλώ! Μη διστάσετε να ρωτήσετε αν έχετε άλλες ερωτήσεις."
Ο Γύρος 2 είναι αυτός που πρέπει να εξετάσετε προσεκτικά. Η φράση «Πότε έγινε;» δεν περιέχει κανένα αναγνωριστικό· το ιστορικό είναι αυτό που επιτρέπει στο μοντέλο να καταλάβει ότι αυτό αναφέρεται ακόμα στο T1001 και να καλέσει τη retrieve_payment_date με το σωστό όρισμα. Αφαιρέστε τα μηνύματα από τον Γύρο 1 και αυτή η πρόταση γίνεται άλυτη. Στον Γύρο 3, το μοντέλο μπορεί να αποφασίσει να καλέσει πολλαπλές συναρτήσεις—κατάσταση και ημερομηνία για το T1003—για να δημιουργήσει τη σύγκριση με τα αποτελέσματα που έχουν ήδη ληφθεί για το T1001. Ο Γύρος 4 δεν ενεργοποιεί καθόλου κλήσεις: το μοντέλο γνωρίζει πότε να κρατηθεί επίσης.
Αλυσιδωτές Διαδοχικές Κλήσεις
Ορισμένα αιτήματα απαιτούν από το μοντέλο να περιμένει ένα αποτέλεσμα πριν μάθει τι να ζητήσει στη συνέχεια. Ο βρόχος while στο chat() διαχειρίζεται αυτή την περίπτωση χωρίς ούτε μία επιπλέον γραμμή κώδικα.
# Ο χρήστης ζητά κάτι που απαιτεί 2 διαδοχικές κλήσεις
reponse = chat(
"Δείξε μου την κατάσταση και την ημερομηνία της πληρωμής T1002.",
messages, tools, available_functions
)
# Το μοντέλο μπορεί:
# 1. Να καλέσει retrieve_payment_status(T1002)
# 2. Να λάβει το αποτέλεσμα
# 3. Να καλέσει retrieve_payment_date(T1002)
# 4. Να λάβει το αποτέλεσμα
# 5. Να διατυπώσει την τελική απάντηση και με τα δύο κομμάτια πληροφορίας
Παρατηρώντας το από την πλευρά του ιστορικού μηνυμάτων, η διαδοχική ροή μοιάζει με αυτήν:
user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)
Μετρήστε τους γύρους του βοηθού: τρεις, που σημαίνει τρία αιτήματα χρεωμένα στο API. Αυτό είναι το κόστος της διαδοχικής εκτέλεσης και ο λόγος για τον οποίο το επόμενο μάθημα εστιάζει στις παράλληλες κλήσεις.
Διαχείριση του Μεγέθους του Ιστορικού
Σε περιβάλλον παραγωγής, μια συνομιλία μεγάλης διάρκειας γίνεται δαπανηρή: κάθε γύρος στέλνει πίσω ολόκληρο το σύνολο των προηγούμενων μηνυμάτων και ο λογαριασμός tokens αυξάνεται τετραγωνικά. Μια απλή στρατηγική είναι να κρατάτε μόνο το μήνυμα συστήματος και τις πιο πρόσφατες ανταλλαγές.
def trim_messages(messages: list, max_messages: int = 20) -> list:
"""Κρατά το μήνυμα συστήματος και τα τελευταία N μηνύματα."""
system_messages = [m for m in messages if hasattr(m, "role")
and m.get("role") == "system"
or (isinstance(m, dict) and m.get("role") == "system")]
non_system = [m for m in messages if m not in system_messages]
if len(non_system) > max_messages:
non_system = non_system[-max_messages:]
return system_messages + non_system
Μια προφύλαξη πριν συνδέσετε αυτή τη συνάρτηση: μην κόψετε ποτέ ένα tool_call χωρίς το αντίστοιχο μήνυμα tool. Αν η περικοπή πέσει ανάμεσα στα δύο, το API λαμβάνει ένα αίτημα κλήσης χωρίς απάντηση και απορρίπτει το ερώτημα. Προσαρμόστε το σημείο κοπής για να διατηρήσετε πλήρη ζεύγη αντί να μετράτε τυφλά τα μηνύματα.
Βασικά σημεία
- Διατηρήστε ένα πλήρες ιστορικό μηνυμάτων ώστε το μοντέλο να κατανοεί το πλαίσιο
- Χρησιμοποιήστε έναν βρόχο while για τη διαχείριση διαδοχικών κλήσεων συναρτήσεων
- Το μοντέλο κατανοεί τις έμμεσες αναφορές («αυτό», «το προηγούμενο») χάρη στο πλαίσιο
- Σε περιβάλλον παραγωγής, περιορίστε το μέγεθος του ιστορικού διατηρώντας άθικτα τα ζεύγη tool_call/tool
- Η συνάρτηση
chat()που παρουσιάζεται εδώ είναι ένα επαναχρησιμοποιήσιμο πρότυπο για οποιαδήποτε εφαρμογή κλήσης συναρτήσεων