Αρχιτεκτονικές πολλαπλών εργαλείων σε παραγωγή
Σε αυτήν τη σελίδα
Ενημερώθηκε στις 2 Νοεμβρίου 2026 με βάση την τεκμηρίωση της OpenAI: το εργαλείο Code Interpreter απαιτεί πλέον μια παράμετρο
container(προστέθηκε σε όλα τα παραδείγματα), τα μέρη εισόδου κειμένου έχουν τύποinput_text, και η αναζήτηση ιστού χρησιμοποιεί το εργαλείοweb_search(τοweb_search_previewείναι πλέον ένα παρωχημένο εργαλείο χωρίς φίλτρα τομέα). Τα παραγόμενα αρχεία ανακτώνται χρησιμοποιώντας τις συναρτήσειςfichiers_generesκαιtelechargerαπό το Μάθημα 10. Πηγές: Code Interpreter · Web search.
Αρχιτεκτονικές πολλαπλών εργαλείων σε παραγωγή
Ένα πρωτότυπο πολλαπλών εργαλείων λειτουργεί επειδή ένα μόνο άτομο το χρησιμοποιεί, γνωρίζει τα όριά του και το επανεκκινεί όταν αποτύχει. Η παραγωγή καταργεί και τις τρεις αυτές συνθήκες ταυτόχρονα. Αυτό που γίνεται κρίσιμο δεν είναι η ποιότητα της απάντησης—αυτό υπήρχε ήδη—αλλά τρεις ιδιότητες που lacked το πρωτότυπο: να γνωρίζετε τι συνέβη όταν μια κλήση αποτύχει, να αποτρέψετε έναν βρόχο που ξέφυγε από τον έλεγχο να εξαντλήσει τον προϋπολογισμό σας και να μπορείτε να τροποποιήσετε τη συμπεριφορά χωρίς επαναδιάθεση.
Τα παρακάτω μοτίβα αντιμετωπίζουν το καθένα μία από αυτές τις απαιτήσεις. Μην τα υιοθετήσετε όλα ταυτόχρονα: ξεκινήστε με την παρατηρησιμότητα, γιατί χωρίς αυτήν δεν θα ξέρετε καν ποιο από τα άλλα σας λείπει.
Διαστρωματωμένη αρχιτεκτονική
Ο διαχωρισμός των ευθυνών σε στρώματα δεν είναι αρχιτεκτονική κομψότητα: κάνει κάθε μέρος αντικαταστάσιμο. Το συγκεκριμένο όφελος είναι ότι μπορείτε να αλλάξετε την ενορχήστρωση χωρίς να αγγίξετε τη διεπαφή, ή να προσθέσετε ένα εργαλείο χωρίς να ξαναγράψετε την επιχειρηματική λογική. Τα τέσσερα στρώματα παρακάτω αποτελούν την ελάχιστη ανάλυση που αντέχει στην πράξη.
# Στρώμα 1: Διεπαφή - λήψη αιτήματος
# Στρώμα 2: Ενορχήστρωση - διαχείριση βρόχου και δρομολόγηση
# Στρώμα 3: Εκτέλεση - κλήσεις εργαλείων και συναρτήσεων
# Στρώμα 4: Παρατηρησιμότητα - αρχεία καταγραφής, μετρικές, ίχνη
from openai import OpenAI
from dataclasses import dataclass, field
from datetime import datetime
import json
import time
import logging
logger = logging.getLogger("multi-outils")
@dataclass
class TraceExecution:
"""Ίχνος εκτέλεσης για παρακολούθηση."""
requete_id: str
debut: float = field(default_factory=time.time)
tours: list = field(default_factory=list)
outils_utilises: list = field(default_factory=list)
tokens_total: int = 0
erreurs: list = field(default_factory=list)
duree_totale: float = 0.0
Ενορχηστρωτής παραγωγής
class OrchestreurProduction:
def __init__(self, config: dict):
self.client = OpenAI()
self.config = config
self.tools = self._construire_tools(config)
self.dispatcher = self._construire_dispatcher(config)
def _construire_tools(self, config: dict) -> list:
"""Δημιουργεί τον πίνακα εργαλείων από τη διαμόρφωση."""
tools = []
if config.get("file_search"):
tools.append({
"type": "file_search",
"vector_store_ids": config["file_search"]["vector_stores"],
"max_num_results": config["file_search"].get("max_results", 10)
})
if config.get("web_search"):
tools.append({
"type": "web_search",
"search_context_size": config["web_search"].get("context_size", "medium")
})
if config.get("code_interpreter"):
tools.append({"type": "code_interpreter", "container": {"type": "auto"}})
for func in config.get("fonctions", []):
tools.append(func)
return tools
def _construire_dispatcher(self, config: dict) -> dict:
"""Αντιστοιχίζει ονόματα συναρτήσεων στις υλοποιήσεις τους."""
return config.get("implementations", {})
def executer(self, requete: str, fichiers: list = None,
max_tours: int = 10) -> dict:
"""Εκτελεί ένα αίτημα με πλήρη ιχνηλασία."""
trace = TraceExecution(
requete_id=f"req_{int(time.time()*1000)}"
)
content = [{"type": "input_text", "text": requete}]
if fichiers:
for fid in fichiers:
content.append({"type": "input_file", "file_id": fid})
messages = [{"role": "user", "content": content}]
try:
for tour in range(max_tours):
debut_tour = time.time()
response = self.client.responses.create(
model=self.config.get("model", "gpt-5.6-terra"),
input=messages,
tools=self.tools,
instructions=self.config.get("instructions", "")
)
trace.tokens_total += response.usage.total_tokens
# Εντοπισμός κλήσεων συναρτήσεων
appels = [
item for item in response.output
if item.type == "function_call"
]
# Καταγραφή χρησιμοποιούμενων εργαλείων
for item in response.output:
if hasattr(item, "type"):
trace.outils_utilises.append(item.type)
trace.tours.append({
"numero": tour + 1,
"appels_fonction": len(appels),
"duree": time.time() - debut_tour
})
if not appels:
trace.duree_totale = time.time() - trace.debut
return {
"reponse": response.output_text,
"trace": trace
}
# Εκτέλεση προσαρμοσμένων συναρτήσεων
resultats = self._executer_fonctions(appels, trace)
messages = response.output + resultats
except Exception as e:
trace.erreurs.append(str(e))
trace.duree_totale = time.time() - trace.debut
logger.error(f"Erreur requête {trace.requete_id}: {e}")
return {"reponse": None, "erreur": str(e), "trace": trace}
trace.duree_totale = time.time() - trace.debut
return {"reponse": "Limite de tours", "trace": trace}
def _executer_fonctions(self, appels: list, trace: TraceExecution) -> list:
"""Εκτελεί συναρτήσεις με χειρισμό σφαλμάτων."""
resultats = []
for appel in appels:
try:
func = self.dispatcher.get(appel.name)
if not func:
raise ValueError(f"Fonction inconnue : {appel.name}")
args = json.loads(appel.arguments)
resultat = func(**args)
resultats.append({
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps(resultat)
})
except Exception as e:
trace.erreurs.append(f"{appel.name}: {str(e)}")
resultats.append({
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps({"error": str(e)})
})
return resultats
Δηλωτική διαμόρφωση
Η μεταφορά των ορισμών του συστήματος εκτός κώδικα και στη διαμόρφωση αλλάζει το ποιος μπορεί να παρέμβει. Η προσαρμογή ενός prompt συστήματος, η αφαίρεση ενός εργαλείου ή η τροποποίηση ενός ορίου κόστους γίνεται μια αλλαγή αρχείου—ελέγξιμη και αναστρέψιμη—αντί για μια διάθεση. Σε ένα σύστημα που εξελίσσεται εβδομαδιαία, αυτή είναι η διαφορά μεταξύ της επανάληψης και της αντίδρασης.
config_assistant_commercial = {
"model": "gpt-5.6-terra",
"instructions": (
"You are a sales assistant. You have access to CRM data, "
"product documentation, the web, and data analysis. "
"Prioritize internal data, enrich with web data."
),
"file_search": {
"vector_stores": ["vs_fiches_produit", "vs_propositions"],
"max_results": 10
},
"web_search": {
"context_size": "medium"
},
"code_interpreter": True,
"fonctions": [
{
"type": "function",
"name": "creer_opportunite",
"description": "Create an opportunity in the CRM",
"parameters": {
"type": "object",
"properties": {
"client": {"type": "string"},
"montant": {"type": "number"},
"probabilite": {"type": "integer"}
},
"required": ["client", "montant", "probabilite"],
"additionalProperties": False
},
"strict": True
}
],
"implementations": {
"creer_opportunite": lambda client, montant, probabilite:
crm_service.creer_opportunite(client, montant, probabilite)
}
}
orchestreur = OrchestreurProduction(config_assistant_commercial)
resultat = orchestreur.executer("Prepare a proposal for Acme Corp")
Παρατηρησιμότητα και παρακολούθηση
Πίνακας ελέγχου μετρικών
Τρεις μετρικές αρκούν για να ξεκινήσετε, και η καθεμία απαντά σε μια διαφορετική ερώτηση: ο λανθάνων χρόνος ανά εργαλείο σας λέει ποιο επιβραδύνει το σύστημα, το ποσοστό αποτυχίας ανά εργαλείο σας λέει ποιο είναι εύθραυστο, και το κόστος ανά αίτημα σας λέει ποιο εκτοξεύεται. Ένας παγκόσμιος μέσος όρος και στις τρεις δεν απαντά σε καμία από αυτές τις ερωτήσεις.
class MetriquesMultiOutils:
def __init__(self):
self.requetes = []
def enregistrer(self, trace: TraceExecution):
self.requetes.append({
"id": trace.requete_id,
"timestamp": datetime.now().isoformat(),
"duree": trace.duree_totale,
"tours": len(trace.tours),
"tokens": trace.tokens_total,
"outils": list(set(trace.outils_utilises)),
"erreurs": len(trace.erreurs),
"cout_estime": self._estimer_cout(trace)
})
def _estimer_cout(self, trace: TraceExecution) -> float:
"""Εκτιμά το κόστος σε δολάρια της εκτέλεσης."""
# Κατά προσέγγιση τιμές για gpt-5.6-terra: $2 / $12 ανά εκατομμύριο
cout_input = trace.tokens_total * 0.6 * 0.000002
cout_output = trace.tokens_total * 0.4 * 0.000012
return round(cout_input + cout_output, 4)
def rapport(self) -> dict:
if not self.requetes:
return {}
durees = [r["duree"] for r in self.requetes]
tokens = [r["tokens"] for r in self.requetes]
couts = [r["cout_estime"] for r in self.requetes]
return {
"total_requetes": len(self.requetes),
"duree_moyenne": sum(durees) / len(durees),
"tokens_moyen": sum(tokens) / len(tokens),
"cout_total": sum(couts),
"taux_erreur": sum(1 for r in self.requetes if r["erreurs"] > 0) / len(self.requetes),
"outils_les_plus_utilises": self._outils_frequents()
}
def _outils_frequents(self) -> dict:
compteur = {}
for r in self.requetes:
for outil in r["outils"]:
compteur[outil] = compteur.get(outil, 0) + 1
return dict(sorted(compteur.items(), key=lambda x: -x[1]))
Διαχείριση κόστους
class GestionnaireCouts:
def __init__(self, budget_quotidien: float = 50.0):
self.budget = budget_quotidien
self.depenses_jour = 0.0
self.date_reset = datetime.now().date()
def peut_executer(self, cout_estime: float) -> bool:
"""Ελέγχει εάν ο προϋπολογισμός επιτρέπει την εκτέλεση."""
aujourdhui = datetime.now().date()
if aujourdhui > self.date_reset:
self.depenses_jour = 0.0
self.date_reset = aujourdhui
return (self.depenses_jour + cout_estime) <= self.budget
def enregistrer_depense(self, cout: float):
self.depenses_jour += cout
def budget_restant(self) -> float:
return self.budget - self.depenses_jour
# Ενσωμάτωση στον ενορχηστρωτή
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)
def executer_avec_budget(orchestreur, requete, **kwargs):
cout_estime = 0.05 # Συντηρητική εκτίμηση
if not gestionnaire_couts.peut_executer(cout_estime):
return {"erreur": "Daily budget reached", "restant": 0}
resultat = orchestreur.executer(requete, **kwargs)
cout_reel = resultat["trace"].tokens_total * 0.000002
gestionnaire_couts.enregistrer_depense(cout_reel)
return resultat
Μοτίβο: Έξυπνος δρομολογητής
Καθώς οι περιπτώσεις χρήσης πολλαπλασιάζονται, ο πειρασμός είναι να αναθέσετε τα πάντα σε ένα ενιαίο σύστημα εξοπλισμένο με κάθε εργαλείο. Αυτή είναι η πιο ακριβή επιλογή: κάθε αίτημα, ακόμη και τα τετριμμένα, κουβαλά το πλήρες σύνολο των ορισμών εργαλείων. Ένας δρομολογητής που ταξινομεί πρώτα το αίτημα και στη συνέχεια καλεί έναν εξειδικευμένο ενορχηστρωτή, διατηρεί τα συμφραζόμενα σύντομα και κάνει κάθε ροή μετρήσιμη ξεχωριστά.
class RouteurIntelligent:
def __init__(self):
self.client = OpenAI()
self.orchestreurs = {}
def enregistrer(self, domaine: str, orchestreur: OrchestreurProduction):
self.orchestreurs[domaine] = orchestreur
def router(self, requete: str) -> dict:
"""Προσδιορίζει τον τομέα και δρομολογεί στον σωστό ενορχηστρωτή."""
# Γρήγορη ταξινόμηση με ένα ελαφρύ μοντέλο
response = self.client.responses.create(
model="gpt-5.6-terra",
input=f"Classify this request into a domain: {requete}\n"
f"Available domains: {list(self.orchestreurs.keys())}\n"
f"Respond only with the domain name.",
)
domaine = response.output_text.strip().lower()
if domaine not in self.orchestreurs:
domaine = "general" # Fallback
logger.info(f"Requête routee vers : {domaine}")
return self.orchestreurs[domaine].executer(requete)
# Διαμόρφωση
routeur = RouteurIntelligent()
routeur.enregistrer("commercial", OrchestreurProduction(config_assistant_commercial))
routeur.enregistrer("support", OrchestreurProduction(config_support))
routeur.enregistrer("rh", OrchestreurProduction(config_rh))
# Χρήση
resultat = routeur.router("How many vacation days do I have left?")
# -> Δρομολογεί αυτόματα στον ενορχηστρωτή HR
Λίστα ελέγχου παραγωγής
Αυτή η λίστα ελέγχου είναι σκόπιμα σύντομη. Δεν στοχεύει στην εξαντλητικότητα, αλλά καλύπτει τα σημεία των οποίων η απουσία σας κοστίζει σε περιστατικά και όχι σε δυσφορία—και που δεν μπορείτε να προσθέσετε βιαστικά την ημέρα που το σύστημα βρίσκεται ήδη στα χέρια των χρηστών.
checklist = {
"securite": [
"Validate arguments for each function",
"Rate limiting per user",
"Sanitize inputs and outputs",
"No sensitive data in logs"
],
"fiabilite": [
"Retry with backoff on transient errors",
"Circuit breaker per external service",
"Timeout per tool and per global request",
"Fallback when a tool is unavailable"
],
"performance": [
"Parallel execution of independent calls",
"Cache frequent search results",
"Limit the number of loop iterations",
"Choose the model adapted to complexity (gpt-5.6-terra vs gpt-5.6-terra)"
],
"observabilite": [
"Structured logging for each call",
"Latency and cost metrics",
"Alerts on error rate",
"Complete trace of each request"
],
"couts": [
"Daily budget with circuit breaker",
"Cost estimation before execution",
"Weekly spending report",
"Model choice optimization by complexity"
]
}
Βασικά σημεία
- Αποσύνθεση σε στρώματα: διεπαφή, ενορχήστρωση, εκτέλεση, παρατηρησιμότητα
- Χρήση δηλωτικής διαμόρφωσης για τον ορισμό συστημάτων
- Ιχνηλασία κάθε εκτέλεσης για παρακολούθηση και αποσφαλμάτωση
- Υλοποίηση διαχειριστή κόστους με ημερήσιο προϋπολογισμό
- Ένας έξυπνος δρομολογητής διανέμει αιτήματα στους σωστούς ενορχηστρωτές
Δοκιμάστε τις γνώσεις σας
Κλήση συναρτήσεων, αναζήτηση, εκτέλεση: το πλήρες οπλοστάσιο σε πέντε ερωτήσεις.
1. Τι πρέπει να περιέχει ένα καλό σχήμα συνάρτησης;
Απάντηση: Αυστηρούς τύπους και λειτουργικές περιγραφές ανά παράμετρο—αυτή είναι η σύμβαση που χρησιμοποιεί το μοντέλο για να αποφασίσει πότε να καλέσει και πώς να συμπληρώσει· η επικύρωση απορρίπτει τα υπόλοιπα.
2. Web Search ή File Search: πώς να επιλέξετε;
Απάντηση: Web Search για δημόσιες, πρόσφατες πληροφορίες· File Search για τα ευρετηριασμένα έγγραφά σας (τμηματοποίηση + ενσωματωμένη κατάταξη)—και η υβριδική αναζήτηση συνδυάζει και τα δύο όταν η απάντηση καλύπτει και τους δύο κόσμους.
3. Τι επιτρέπει το Code Interpreter στο API;
Απάντηση: Εκτέλεση κώδικα σε sandbox: επεξεργασία CSV/Excel/εικόνων, ακριβείς υπολογισμοί, παραγωγή γραφημάτων—το μοντέλο συλλογίζεται, ο κώδικας υπολογίζει, το sandbox απομονώνει.
4. Σε τι χρησιμεύει το Tool Search;
Απάντηση: Για τη δυναμική έκθεση ενός μεγάλου καταλόγου εργαλείων: το μοντέλο αναζητά το σχετικό εργαλείο αντί να λαμβάνει εκατό σχήματα ταυτόχρονα—το συμφραζόμενο παραμένει ελαφρύ, οι δυνατότητες παραμένουν vast.
5. Ποιοι κανόνες ισχύουν για μια αρχιτεκτονική πολλαπλών εργαλείων σε παραγωγή;
Απάντηση: Εργαλεία με σαφές πεδίο εφαρμογής, χειρισμό σφαλμάτων και εναλλακτικές λύσεις ανά εργαλείο, παράλληλες κλήσεις όταν είναι ανεξάρτητες, και παρατηρησιμότητα για κάθε κλήση—η ευρωστία σχεδιάζεται εργαλείο προς εργαλείο.
Κάθε εργαλείο έχει το δικό του έδαφος· η παραγωγή τα συνδυάζει—η τελική αρχιτεκτονική παραπάνω είναι το σχέδιο αναφοράς σας.