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

Κλιμάκωση και Αρχιτεκτονικές Πολλαπλών Πρακτόρων

Μάθημα 25 / 25 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Κλιμάκωση και Αρχιτεκτονικές Πολλαπλών Πρακτόρων
  2. Αρχιτεκτονική Παραγωγής
  3. Πρότυπα Πολλαπλών Πρακτόρων
  4. Διαχείριση Ορίων Ρυθμού (Rate Limits)
  5. Βελτιστοποίηση Κόστους σε Κλίμακα
  6. Βασικά σημεία
  7. Δοκιμάστε τις Γνώσεις σας

Κλιμάκωση και Αρχιτεκτονικές Πολλαπλών Πρακτόρων

Ο πράκτοράς σας λειτουργεί για 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, ιχνηλασία: η σκαλωσιά είναι πλήρης—η παραπάνω κλιμάκωση σάς λέει πώς να την αναπτύξετε χωρίς να την αποδυναμώσετε.