Κλιμάκωση και Αρχιτεκτονικές Πολλαπλών Πρακτόρων
Σε αυτήν τη σελίδα
Κλιμάκωση και Αρχιτεκτονικές Πολλαπλών Πρακτόρων
Ο πράκτοράς σας λειτουργεί για 10 χρήστες. Πώς θα τον κάνετε να λειτουργήσει για 10.000; Οι προκλήσεις αλλάζουν: δεν αφορά πλέον αποτυχημένες οδηγίες, αλλά όρια ρυθμού (rate limits) του παρόχου, μνήμη διακομιστή και τον μηνιαίο λογαριασμό σας. Σε αυτό το τελικό μάθημα, θα μάθετε πώς να κλιμακώνετε τους πράκτορές σας, να σχεδιάζετε αρχιτεκτονικές πολλαπλών πρακτόρων υψηλής απόδοσης και να διαχειρίζεστε τους περιορισμούς παραγωγής σε μεγάλη κλίμακα.
Αρχιτεκτονική Παραγωγής
Το Backend Πράκτορα με FastAPI
Η πρώτη δομική απόφαση αφορά τον κύκλο ζωής του πράκτορα. Η δημιουργία ενός Agent για κάθε αίτημα σπαταλά χρόνο και διασκορπίζει τη διαμόρφωση· το lifespan του FastAPI σάς επιτρέπει να τα δημιουργείτε μία φορά κατά την εκκίνηση και να τα διατηρείτε σε ένα μητρώο ευρετηριασμένο ανά τύπο. Η διαδρομή (route) διαβάζει τον ζητούμενο τύπο, τον απορρίπτει καθαρά αν δεν υπάρχει και στη συνέχεια μεταδίδει (stream) την απάντηση: το run_streamed εκπέμπει διαφορές (deltas) καθώς προχωρά η δημιουργία, κάνοντας το κείμενο να εμφανίζεται στην οθόνη αμέσως, αντί να αφήνει τον χρήστη να κοιτάζει έναν δείκτη φόρτωσης για οκτώ δευτερόλεπτα.
from fastapi import FastAPI, Request, Depends, HTTPException
from fastapi.responses import StreamingResponse
from agents import Agent, Runner, function_tool
from contextlib import asynccontextmanager
import asyncio
# Pool of pre-configured agents
agents_registry = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# Initialize agents at startup
agents_registry["sales"] = Agent(
name="Sales Agent",
instructions="You assist customers with their purchases.",
model="gpt-5.6-terra",
tools=[search_product, calculate_price],
)
agents_registry["support"] = Agent(
name="Support Agent",
instructions="You provide technical support.",
model="gpt-5.6-terra",
tools=[check_ticket, create_ticket],
)
yield
agents_registry.clear()
app = FastAPI(lifespan=lifespan)
@app.post("/api/chat/{agent_type}")
async def chat(agent_type: str, request: Request):
agent = agents_registry.get(agent_type)
if not agent:
raise HTTPException(404, f"Agent '{agent_type}' not found")
body = await request.json()
async def stream():
result = Runner.run_streamed(agent, body["messages"])
async for event in result.stream_events():
if event.type == "raw_response_event":
if hasattr(event.data, "delta") and event.data.delta:
yield f"data: {event.data.delta}\n\n"
yield "data: [DONE]\n\n"
return StreamingResponse(stream(), media_type="text/event-stream")
Διαχείριση Συγχρονισμού
Η κοινή χρήση αντικειμένων Agent σε όλα τα αιτήματα με αυτόν τον τρόπο είναι ασφαλής, επειδή κάθε αίτημα δημιουργεί έναν ανεξάρτητο Runner: ο πράκτορας κατέχει τη διαμόρφωση, ενώ ο Runner κατέχει την κατάσταση εκτέλεσης. Το SDK διαχειρίζεται εγγενώς τον συγχρονισμό και η επεξεργασία μιας δέσμης μηνυμάτων σημαίνει στοίβαξη συρoutines στο asyncio.gather. Η βασική λεπτομέρεια εδώ είναι το return_exceptions=True: χωρίς αυτό, ένα μόνο αποτυχημένο αίτημα ακυρώνει ολόκληρη τη δέσμη. Με αυτό, λαμβάνετε τα σφάλματα ως τιμές, τα αντιστοιχίζετε στο αρχικό τους μήνυμα και επεξεργάζεστε τα ενενήντα εννέα έγκυρα αποτελέσματα.
import asyncio
from agents import Agent, Runner
agent = Agent(
name="Concurrent Agent",
instructions="You answer questions.",
model="gpt-5.6-terra",
)
async def process_parallel_requests(messages: list[str]):
"""Process multiple requests in parallel."""
tasks = [Runner.run(agent, msg) for msg in messages]
results = await asyncio.gather(*tasks, return_exceptions=True)
for msg, res in zip(messages, results):
if isinstance(res, Exception):
print(f"Error for '{msg}': {res}")
else:
print(f"'{msg}' -> {res.final_output[:50]}...")
return results
Πρότυπα Πολλαπλών Πρακτόρων
Πρότυπο Επόπτη (Supervisor Pattern)
Πέρα από μια συγκεκριμένη κλίμακα, ένας μοναδικός πράκτορας με δεκαπέντε εργαλεία γίνεται απρόβλεπτος: οι οδηγίες του διογκώνονται και οι επιλογές του υποβαθμίζονται. Το πρότυπο επόπτη κατανέμει την εργασία σε εξειδικευμένους πράκτορες—έρευνα, ανάλυση, συγγραφή—και αναθέτει τη δρομολόγηση σε έναν αφιερωμένο πράκτορα μέσω handoff. Κάθε ειδικός διατηρεί σύντομες οδηγίες και ένα μοντέλο κατάλληλο για το έργο του: η ανάλυση κληρονομεί ένα μοντέλο συλλογισμού, ενώ ο επόπτης, ο οποίος απλώς επιλέγει έναν παραλήπτη, εκτελείται σε ένα γρήγορο μοντέλο, καθώς η απόφασή του εξαρτάται από λίγες λέξεις.
from agents import Agent, Runner, Handoff
search_agent = Agent(
name="Search",
instructions="You search for information on the web and in databases.",
tools=[WebSearchTool(), search_crm],
model="gpt-5.6-terra",
)
analysis_agent = Agent(
name="Analysis",
instructions="You analyze data and produce insights.",
model="gpt-5.6-sol",
)
writing_agent = Agent(
name="Writing",
instructions="You write professional reports in English.",
model="gpt-5.6-terra",
)
supervisor_agent = Agent(
name="Supervisor",
instructions="""You coordinate a team of specialized agents.
For each request:
1. Analyze what is needed
2. Delegate to specialized agents via handoff
3. The last agent produces the final response
Available agents:
- Search: to collect data
- Analysis: to analyze and interpret
- Writing: to produce the final deliverable""",
handoffs=[
Handoff(agent=search_agent, description="Collect data"),
Handoff(agent=analysis_agent, description="Analyze data"),
Handoff(agent=writing_agent, description="Write a report"),
],
model="gpt-5.6-terra", # Fast for routing
)
Πρότυπο Αγωγού (Pipeline Pattern)
Όταν η ακολουθία είναι γνωστή εκ των προτέρων, το να αφήνετε ένα μοντέλο να αποφασίζει την αλυσίδα αποτελεί περιττό έξοδο. Το πρότυπο αγωγού συνδέει τα βήματα στον κώδικά σας: συλλογή, ανάλυση, συγγραφή. Μια ανταγωνιστική ανάλυση ξεκινά λοιπόν με δύο συλλογές που εκτοξεύονται ταυτόχρονα—ο ιστός και το CRM δεν έχουν λόγο να περιμένουν ο ένας τον άλλον—και στη συνέχεια περνά τα πάντα στην ανάλυση, της οποίας η έξοδος τροφοδοτεί τη συγγραφή. Αποκτάτε μια αναπαραγώγιμη ροή εργασίας, ιχνηλατήσιμη βήμα προς βήμα, της οποίας η συνολική διάρκεια είναι αυτή της πιο αργής συλλογής συν τα δύο επόμενα βήματα.
async def competitive_analysis_pipeline(company: str):
# Step 1: Parallel data collection
web_task = Runner.run(search_agent, f"Search for information about {company}")
crm_task = Runner.run(crm_agent, f"CRM data for {company}")
results = await asyncio.gather(web_task, crm_task)
data = f"""Web data: {results[0].final_output}
CRM data: {results[1].final_output}"""
# Step 2: Analysis
analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")
# Step 3: Report
report = await Runner.run(
writing_agent,
f"Write a competitive analysis report: {analysis.final_output}"
)
return report.final_output
Πρότυπο Map-Reduce
Το τρίτο πρότυπο αντιμετωπίζει ένα πρόβλημα όγκου και όχι πολυπλοκότητας. Δύο χιλιάδες σχόλια πελατών (verbatims) δεν χωρούν σε ένα μόνο αίτημα και δεν μπορούν να αναλυθούν διαδοχικά σε λογικό χρόνο. Η φάση MAP ταξινομεί κάθε σχόλιο παράλληλα με ένα γρήγορο μοντέλο και τυποποιημένη έξοδο· η φάση REDUCE συγκεντρώνει αυτές τις ταξινομήσεις, οι οποίες είναι πολύ πιο συμπαγείς από τα αρχικά κείμενα, και αναθέτει τη σύνθεση σε ένα πιο ικανό μοντέλο. Το κόστος καταρρέει σε σύγκριση με την πλήρη ανάλυση, επειδή ο κύριος όγκος επεξεργάζεται από το φθηνότερο μοντέλο.
async def analyze_feedbacks(feedbacks: list[str]):
# MAP: analyze each feedback in parallel
classifier_agent = Agent(
name="Classifier",
instructions="Classify the feedback: positive, negative, or neutral. Identify the main theme.",
model="gpt-5.6-terra",
output_type=FeedbackClassification,
)
tasks = [Runner.run(classifier_agent, fb) for fb in feedbacks]
classifications = await asyncio.gather(*tasks)
# REDUCE: synthesize results
summary_data = [
{"feedback": fb, "class": c.final_output.dict()}
for fb, c in zip(feedbacks, classifications)
]
synthesizer_agent = Agent(
name="Synthesizer",
instructions="Synthesize the feedback classifications into a report with statistics and insights.",
model="gpt-5.6-terra",
)
import json
report = await Runner.run(
synthesizer_agent,
f"Synthesize these {len(feedbacks)} classified feedbacks: {json.dumps(summary_data, ensure_ascii=False)}"
)
return report.final_output
Διαχείριση Ορίων Ρυθμού (Rate Limits)
Η εκτόξευση δύο χιλιάδων ταυτόχρονων κλήσεων δεν τις κάνει να ολοκληρωθούν γρηγορότερα: ο πάροχος σας απορρίπτει και χάνετε τη δέσμη. Ένας σηματοφόρος (semaphore) οριοθετεί τον αριθμό των ταυτόχρονων εκτελέσεων και ο παρακάτω διαχειριστής προσθέτει εκθετική επαναφορά (exponential backoff) με ανώτατο όριο τα εξήντα δευτερόλεπτα όταν συμβαίνει ένα σφάλμα ορίου. Ο μετρητής σφαλμάτων μηδενίζεται μόλις μια κλήση επιτύχει, αποφεύγοντας τη μακροχρόνια ποινή στην υπηρεσία για ένα παροδικό incident.
import asyncio
from agents import Runner
class RateLimitManager:
def __init__(self, max_concurrent: int = 10):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.error_count = 0
async def execute(self, agent, message, **kwargs):
async with self.semaphore:
try:
result = await Runner.run(agent, message, **kwargs)
self.error_count = 0
return result
except Exception as e:
if "rate_limit" in str(e).lower():
self.error_count += 1
wait_time = min(2 ** self.error_count, 60)
await asyncio.sleep(wait_time)
return await self.execute(agent, message, **kwargs)
raise
manager = RateLimitManager(max_concurrent=20)
Βελτιστοποίηση Κόστους σε Κλίμακα
Έπειτα υπάρχει ο λογαριασμός. Δύο μοχλοί τον μειώνουν χωρίς να υποβαθμίζουν την υπηρεσία. Ο πρώτος είναι να μην πληρώνετε για ένα μοντέλο συλλογισμού ώστε να απαντήσει στο «ποιες είναι οι ώρες λειτουργίας σας»: ένας πίνακας αναζήτησης αντιστοιχίζει το επίπεδο πολυπλοκότητας στο κατάλληλο μοντέλο, από το πιο οικονομικό για απλές ερωτήσεις έως το πιο ικανό για κρίσιμες περιπτώσεις, με μια προεπιλογή για οτιδήποτε δεν έχει ταξινομηθεί. Ο δεύτερος εκμεταλλεύεται την επανάληψη—στην εξυπηρέτηση πελατών, οι ίδιες ερωτήσεις επιστρέφουν εκατοντάδες φορές την ημέρα, και μια cache ευρετηριασμένη σε ένα hash μηνύματος επιστρέφει την απάντηση ακαριαία και δωρεάν. Κρατήστε αυτή την cache για ερωτήσεις των οποίων η απάντηση δεν εξαρτάται ούτε από τον χρήστη ούτε από τον χρόνο: μια πολιτική επιστροφών κάνει καλή cache, μια κατάσταση παραγγελίας ποτέ.
# Model strategy by complexity
def choose_model(complexity: str) -> str:
models = {
"simple": "gpt-5.6-terra", # Simple questions: cheap
"medium": "gpt-5.6-terra", # Most cases
"complex": "gpt-5.6-terra", # Fast reasoning
"critical": "gpt-5.6-sol", # Critical cases: maximum quality
}
return models.get(complexity, "gpt-5.6-terra")
# Cache for frequent responses
from functools import lru_cache
import hashlib
response_cache = {}
async def execute_with_cache(agent, message: str):
key = hashlib.md5(message.encode()).hexdigest()
if key in response_cache:
return response_cache[key]
result = await Runner.run(agent, message)
response_cache[key] = result.final_output
return result.final_output
Βασικά σημεία
- Διαμορφώστε εκ των προτέρων τους πράκτορές σας κατά την εκκίνηση και επαναχρησιμοποιήστε τους στα αιτήματα
- Το SDK διαχειρίζεται εγγενώς τον συγχρονισμό μέσω του
asyncio.gather() - Το πρότυπο επόπτη συντονίζει εξειδικευμένους πράκτορες μέσω handoffs
- Το πρότυπο map-reduce παραλληλοποιεί την επεξεργασία μεγάλου όγκου
- Διαχειριστείτε τα όρια ρυθμού με έναν σηματοφόρο και εκθετική επαναφορά
- Βελτιστοποιήστε το κόστος με επιλογή μοντέλου βάσει πολυπλοκότητας και caching
Δοκιμάστε τις Γνώσεις σας
Πριν προχωρήσετε στην κλιμάκωση, ελέγξτε τις γνώσεις σας για την αρχιτεκτονική πρακτόρων.
1. Ποια είναι τα δομικά στοιχεία του Agents SDK;
Απάντηση: Agent (ο ρόλος και οι οδηγίες του), Runner (ο βρόχος εκτέλεσης), Tool (οι δυνατότητες) και Guardrail (επικυρώσεις εισόδου/εξόδου)—η ανατομία οποιουδήποτε πράκτορα SDK.
2. Σε τι χρησιμεύουν τα Guardrails;
Απάντηση: Για να επικυρώνουν τι εισέρχεται και τι εξέρχεται από τον πράκτορα: φιλτράρουν αιτήματα εκτός πεδίου εφαρμογής, ελέγχουν τις εξόδους πριν ενεργήσουν—ασφάλεια δηλωμένη στην αρχιτεκτονική, όχι ελπιζόμενη από το prompt.
3. Τι είναι ένα handoff;
Απάντηση: Η μεταφορά μιας συνομιλίας από έναν πράκτορα σε έναν άλλον, πιο εξειδικευμένο: ορχήστρωση πολλαπλών πρακτόρων όπου κάθε πράκτορας κάνει αυτό που γνωρίζει καλύτερα, με το πλαίσιο να ακολουθεί.
4. Γιατί είναι απαραίτητη η ιχνηλασία (tracing) στην παραγωγή;
Απάντηση: Επειδή ένας πράκτορας αποφασίζει δυναμικά: χωρίς ίχνη βημάτων, εργαλείων που κλήθηκαν και αποφάσεων, η αποσφαλμάτωση ή η αξιολόγηση είναι αδύνατη—η βαθμολόγηση ιχνηλασίας βαθμολογεί με ακρίβεια αυτές τις εκτελέσεις.
5. Πότε πρέπει να μεταβείτε σε αρχιτεκτονική πολλαπλών πρακτόρων;
Απάντηση: Όταν ένας μοναδικός πράκτορας συσσωρεύει πάρα πολλούς ρόλους και εργαλεία: εξειδικεύετε (διαλογή, εμπειρογνωμοσύνη, εκτέλεση) και ορχηστρώνετε μέσω handoffs—κάθε πράκτορας γίνεται και πάλι απλός και ελέγξιμος.
SDK, guardrails, handoffs, ιχνηλασία: η σκαλωσιά είναι πλήρης—η παραπάνω κλιμάκωση σάς λέει πώς να την αναπτύξετε χωρίς να την αποδυναμώσετε.