Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Κλήσεις Παράλληλων Συναρτήσεων

Μάθημα 8 / 14 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Όταν το μοντέλο χρειάζεται πολλαπλά δεδομένα ταυτόχρονα
  2. Ανάγνωση μιας απάντησης με πολλαπλές κλήσεις
  3. Επιστροφή κάθε αποτελέσματος στην αρχική του κλήση
  4. Μετάβαση από την φαινομενική στην πραγματική παραλληλία
  5. Ανάκτηση ελέγχου με το parallel_tool_calls
  6. Τι αλλάζει πραγματικά η παραλληλία
  7. Βασικά σημεία

Όταν το μοντέλο χρειάζεται πολλαπλά δεδομένα ταυτόχρονα

Μέχρι στιγμής, κάθε βήμα στη συνομιλία είχε ως αποτέλεσμα μία μόνο κλήση συνάρτησης. Πολλές ερωτήσεις του πραγματικού κόσμου δεν εμπίπτουν σε αυτό το πρότυπο. Σκεφτείτε έναν χρήστη που ρωτά: «Ποια είναι η κατάσταση και η ημερομηνία της πληρωμής T1001;». Το μοντέλο χρειάζεται δύο πληροφορίες που βρίσκονται σε δύο διακριτές συναρτήσεις: retrieve_payment_status και retrieve_payment_date. Θα μπορούσε να τις ζητήσει τη μία μετά την άλλη, περιμένοντας την απάντησή σας στο ενδιάμεσο. Ωστόσο, εδώ καθορίζει ότι καμία δεν εξαρτάται από την άλλη, επομένως παράγει πολλαπλά tool_calls σε μία μόνο απάντηση. Εσείς λαμβάνετε ολόκληρο το φόρτο εργασίας ταυτόχρονα και εσείς αποφασίζετε πώς θα τον εκτελέσετε.

Ανάγνωση μιας απάντησης με πολλαπλές κλήσεις

Η πρακτική συνέπεια είναι απλή: το message.tool_calls δεν είναι πλέον μια λίστα με ένα μόνο στοιχείο. Πρέπει να κάνετε επανάληψη (iterate) πάνω σε αυτό αντί να αρπάζετε το tool_calls[0], μια κοινή αντανακλαστική κίνηση όταν μαθαίνετε την κλήση συναρτήσεων από παραδείγματα μίας συνάρτησης.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message

# Πολλαπλά tool_calls στην ίδια απάντηση
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Πιθανή έξοδος:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Σημειώστε ότι και οι δύο κλήσεις χρησιμοποιούν το ίδιο όρισμα, T1001, αλλά έχουν διαφορετικά IDs: call_abc123 και call_def456. Αυτά τα IDs είναι ο μόνος τρόπος με τον οποίο το μοντέλο γνωρίζει ποιο αποτέλεσμα αντιστοιχεί σε ποιο αίτημα.

Επιστροφή κάθε αποτελέσματος στην αρχική του κλήση

Ο κανόνας είναι αυστηρός: πρέπει να εκτελέσετε κάθε συνάρτηση και να επιστρέψετε κάθε αποτέλεσμα σε ένα ξεχωριστό μήνυμα tool που φέρει το αντίστοιχο tool_call_id. Αν ξεχάσετε ή ανταλλάξετε ένα ID, το μοντέλο μπορεί να αποδώσει την ημερομηνία στο πεδίο κατάστασης ή μπορεί να αρνηθεί να απαντήσει.

message = response.choices[0].message
messages.append(message)

# Εκτέλεση όλων των ζητούμενων συναρτήσεων
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Εκτέλεση της συνάρτησης
    result = available_functions[function_name](**function_params)

    # Προσθήκη του αποτελέσματος με το σωστό tool_call_id
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Αποστολή όλων των αποτελεσμάτων πίσω στο μοντέλο
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."

Το μοντέλο στη συνέχεια ράβει τα δύο κομμάτια σε μία μόνο πρόταση, σαν οι πληροφορίες να προέρχονταν από μία πηγή. Αυτό είναι ακριβώς το αποτέλεσμα που θέλετε από την οπτική γωνία του χρήστη.

Μετάβαση από την φαινομενική στην πραγματική παραλληλία

Μια λεπτομέρεια συχνά διαφεύγει από τους αναγνώστες στην πρώτη ανάγνωση: στον παραπάνω βρόχο for, οι συναρτήσεις εκτελούνται η μία μετά την άλλη. Το μοντέλο ζήτησε τις κλήσεις του παράλληλα, αλλά ο κώδικάς σας παραμένει σειριακός. Όσο οι συναρτήσεις σας διαβάζουν ένα DataFrame στη μνήμη, αυτό δεν έχει σημασία. Ωστόσο, μόλις κάνουν ερώτημα σε εξωτερικό API ή βάση δεδομένων, δύο κλήσεις των 300 ms γίνονται 600 ms αντιληπτής καθυστέρησης και το όφελος της παραλληλίας εξαφανίζεται. Αν οι συναρτήσεις σας είναι ασύγχρονες, το asyncio.gather τις εκκινεί όλες μαζί και περιμένει ολόκληρη τη δέσμη.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Executes tool_calls in parallel and returns the results."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # If your functions are async:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Execute all functions in parallel
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Οι περισσότερες υπάρχουσες βάσεις κώδικα εκθέτουν συγχρονισμένες συναρτήσεις που δεν θα θέλατε να ξαναγράψετε ως async μόνο γι’ αυτό. Μια ομάδα νημάτων (thread pool) παράγει το ίδιο αποτέλεσμα χωρίς να αγγίξετε την επιχειρηματική σας λογική.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Executes tool_calls using a thread pool."""
    def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        result = available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(execute_one, tool_calls))

    return results

Ανάκτηση ελέγχου με το parallel_tool_calls

Η παραλληλία δεν είναι πάντα επιθυμητή. Η παράμετρος parallel_tool_calls σας επιτρέπει να την επιτρέψετε ή να την απαγορεύσετε. Όταν ορίζεται σε True (η προεπιλογή), το μοντέλο αποφασίζει αν θα ομαδοποιήσει τις κλήσεις του. Όταν ορίζεται σε False, μπορεί να παράγει μόνο ένα tool_call ανά απάντηση.

# Επιτρέπονται οι παράλληλες κλήσεις (προεπιλογή)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Το μοντέλο αποφασίζει
)

# Εξαναγκασμός σειριακών κλήσεων
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Μόνο ένα tool_call ανά απάντηση
)

Τρεις καταστάσεις δικαιολογούν την ρύθμιση αυτής της παραμέτρου σε False. Η πρώτη είναι όταν η σειρά εκτέλεσης έχει σημασία: η χρέωση πριν τον έλεγχο του αποθέματος δίνει διαφορετικό αποτέλεσμα από το αντίστροφο. Η δεύτερη αφορά εξαρτήσεις δεδομένων, όπου το αποτέλεσμα μιας συνάρτησης απαιτείται για να κληθεί η επόμενη—για παράδειγμα, η εύρεση μιας επαφής για να ληφθεί το ID της πριν τροποποιηθεί η εγγραφή της. Η τρίτη αφορά απλώς την ανάγκη για λεπτομερέστερο έλεγχο της ροής, συνήθως κατά την αποσφαλμάτωση, όταν θέλετε να παρατηρήσετε κάθε κλήση μεμονωμένα πριν ανοίξετε τις «πύλες».

Τι αλλάζει πραγματικά η παραλληλία

Το κέρδος δεν αφορά μόνο τα νήματα· αφορά κυρίως τον αριθμό των γύρων επικοινωνίας (round trips) με το API, οι οποίοι κυριαρχούν στη συνολική καθυστέρηση.

# Σειριακό (2 κλήσεις API στο μοντέλο)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Παράλληλο (μόνο 1 επιπλέον κλήση API)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

Στο σειριακό μοτίβο, το μοντέλο πρέπει να ολοκληρώσει δύο πλήρεις γύρους συλλογισμού πριν την τελική απάντηση. Στο παράλληλο μοτίβο, ένα μόνο αίτημα ανακτά όλα τα tool_calls και χρειάζεται μόνο ένα επιπλέον αίτημα για την απάντηση. Για μια ερώτηση που εμπλέκει δύο ή τρεις συναρτήσεις, αυτό συνήθως εξοικονομεί στον χρήστη αρκετά δευτερόλεπτα.

Βασικά σημεία

  • Το μοντέλο μπορεί να παράγει πολλαπλά tool_calls σε μία μόνο απάντηση
  • Κάθε αποτέλεσμα πρέπει να επιστρέφεται με το σωστό tool_call_id
  • Για συναρτήσεις δικτύου, χρησιμοποιήστε asyncio ή ThreadPoolExecutor για πραγματική παράλληλη εκτέλεση
  • Η παράμετρος parallel_tool_calls ελέγχει αυτή τη συμπεριφορά (True από προεπιλογή)
  • Το παράλληλο μοτίβο μειώνει τα αιτήματα API και βελτιώνει την καθυστέρηση