Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Ügynökeid kiértékelése: Metrikák és benchmarkok

22. lecke 25 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Ügynökeid kiértékelése: Metrikák és benchmarkok
  2. Miért érdemes kiértékelni?
  3. Alapvető metrikák
  4. LLM-alapú kiértékelés (LLM-as-Judge)
  5. Strukturált tesztkészletek
  6. Főbb megállapítások

Ügynökeid kiértékelése: Metrikák és benchmarkok

Egy fejlesztői környezetben működő ügynök a éles rendszerben elbukhat. A szisztematikus kiértékelés az egyetlen módja annak, hogy a telepítés előtt és után is garantáld a minőséget. Ebben a leckében megtanulod, hogyan definiálj metrikákat, hozz létre tesztkészleteket, és automatizáld a kiértékelést.

Miért érdemes kiértékelni?

Formális kiértékelés nélkül vakrepülést végzel. Átfogalmazol egy utasítást, mert egy felhasználó panaszkodott, de semmi nem árulja el, hogy az ügynök tényleg javult-e, vagy csak elrontottál három másik forgatókönyvet. Hezitálsz, hogy a Terra vagy a Luna jobb-e az esetedben – vagy ugyanazon a modellen két különböző következtetési szint között –, és mérés nélkül a döntésed öt manuális próba utáni megérzésen alapul. Módosítasz egy eszköz sémáját, az ügynök egy adott esetben megszűnik meghívni azt, és senki nem veszi észre, amíg a jegyek száma meg nem ugrik. Egy kiértékelési készlet minden ilyen helyzetet összehasonlítható számmá alakít az egyik verzióról a másikra.

Alapvető metrikák

Pontosság

Az első kérdés a legközvetlenebb: az ügynök a helyes választ adja-e? Lejátszasz egy olyan kérdéssort, ahol ismered a választ, és ellenőrzöd annak jelenlétét a kimenetben. A kis- és nagybetűktől független részegyezés szándékosan durva – elnézi például, hogy „A Pro laptop ára 1299 euró, ÁFÁ-val“, ahol a szigorú egyenlőség megbukna –, de ellenőrizhető tényekhez elegendő, és másodpercek alatt kiszámolható.

from agents import Agent, Runner

async def evaluate_accuracy(agent, test_cases):
    results = []
    for case in test_cases:
        result = await Runner.run(agent, case["question"])
        # Automatikus vagy LLM-alapú ellenőrzés
        is_correct = case["expected_answer"].lower() in result.final_output.lower()
        results.append({
            "question": case["question"],
            "answer": result.final_output,
            "expected": case["expected_answer"],
            "correct": is_correct,
        })

    rate = sum(1 for r in results if r["correct"]) / len(results)
    print(f"Accuracy: {rate:.1%} ({sum(1 for r in results if r['correct'])}/{len(results)})")
    return results

# Tesztkészlet
test_cases = [
    {"question": "What is the price of the Pro laptop?", "expected_answer": "1299"},
    {"question": "How many laptops are in stock?", "expected_answer": "45"},
    {"question": "What is the cheapest product?", "expected_answer": "tablet"},
]

Helyes eszközhasználat

A véletlenül megszerzett helyes válasz is probléma marad. Egy ügynök, amely bemagolt árat szaval a katalógus lekérdezése helyett, ma átmenő pontosságot produkál, holnap pedig elavult árat ad. A második metrika ezért nem az eredményt, hanem az utat vizsgálja: az ügynök a megfelelő eszközöket hívja meg a megfelelő argumentumokkal? Kiolvasod a hívásokat a raw_responses elemből, kiszűröd a function_call kimeneteket, és a comparison halmazokat használ, hogy független maradj a sorrendtől.

async def evaluate_tools(agent, test_cases):
    results = []
    for case in test_cases:
        result = await Runner.run(agent, case["question"])

        # Meghívott eszközök kinyerése a nyers válaszokból
        called_tools = []
        for response in result.raw_responses:
            for output in getattr(response, "output", []):
                if hasattr(output, "type") and output.type == "function_call":
                    called_tools.append(output.name)

        tools_correct = set(case["expected_tools"]) == set(called_tools)
        results.append({
            "question": case["question"],
            "called_tools": called_tools,
            "expected_tools": case["expected_tools"],
            "correct": tools_correct,
        })

    rate = sum(1 for r in results if r["correct"]) / len(results)
    print(f"Correct tools: {rate:.1%}")
    return results

tool_cases = [
    {
        "question": "What is the price of the laptop?",
        "expected_tools": ["search_product"],
    },
    {
        "question": "Price of the laptop with 10% discount",
        "expected_tools": ["search_product", "calculate_discount"],
    },
]

A második teszteset a legtanulságosabb: a kérdés két eszköz láncolását igényli, és pontosan ez az a fajta összetétel, amelyet egy leírás módosítása csendben elronthat.

Késleltetés és költség

Végül ott van az operatív dimenzió. Egy átlag semmit nem mond a valós élményről: az eloszlás farokvége űzi el a felhasználókat, amikor száz kérésből egy húsz másodpercig tart. Minden üzenetet többször megismételve használható eloszlást kapsz, ahol a medián a tipikus viselkedést, a P99 pedig a gyakori legrosszabb esetet mutatja.

import time

async def evaluate_performance(agent, messages, iterations=10):
    latencies = []
    for message in messages:
        for _ in range(iterations):
            start = time.perf_counter()
            result = await Runner.run(agent, message)
            duration = time.perf_counter() - start
            latencies.append(duration)

    import statistics
    print(f"Average latency: {statistics.mean(latencies):.2f}s")
    print(f"P50 latency: {statistics.median(latencies):.2f}s")
    print(f"P99 latency: {sorted(latencies)[int(len(latencies) * 0.99)]:.2f}s")

LLM-alapú kiértékelés (LLM-as-Judge)

Ez a három metrika kihagy mindent, aminek nincs egyetlen helyes válasza: egy visszaküldési szabályzat magyarázata, egy értékesítési szöveg átfogalmazása, egy bocsánatkérő üzenet. Ezekre a nyitott végű válaszokra használj egy modellt a minőség értékelésére. A bíró megkapja a kérdést és a választ, alkalmazza az általad írt kritériumokat – pontosság, relevancia, professzionalizmus –, majd egy strukturált pontszámot ad vissza egy Pydantic output_type segítségével. A formátumkényszer teszi használhatóvá a folyamatot: aggregálható egész számot kapsz, nem pedig újraolvasandó kommentárt.

from pydantic import BaseModel

class Evaluation(BaseModel):
    score: int  # 1-5
    reason: str
    is_correct: bool
    is_relevant: bool
    is_professional: bool

evaluator_agent = Agent(
    name="Evaluator",
    instructions="""Evaluate the quality of the agent's response.
    Criteria:
    - Accuracy: Is the response factual and correct?
    - Relevance: Does the response answer the question asked?
    - Professionalism: Is the tone appropriate?
    Score from 1 (very poor) to 5 (excellent).""",
    model="gpt-5.6-sol",
    output_type=Evaluation,
)

async def evaluate_quality(question, agent_response):
    prompt = f"""Question asked: {question}
    Agent response: {agent_response}
    Evaluate this response."""

    result = await Runner.run(evaluator_agent, prompt)
    return result.final_output

A reason mező figyelmet érdemel az átvizsgálások során: itt magyarázza el a bíró, miért adott 3-at ötből, és ez gyakran egy olyan hiba megfogalmazása, amelyet korábban nem sikerült néven nevezned.

Strukturált tesztkészletek

Egy nem reprodukálható kiértékelés haszontalan. Szervezd a teszteseteidet stabil formátumba, ahol minden bejegyzés tartalmaz egy azonosítót, egy kategóriát, a kérdést, a várt választ, a várt eszközöket és a minőségi kritériumokat. Itt a kategória végzi a legtöbb munkát: egy 4,2-es átlagpontszám ötből megtévesztően megnyugtató, míg a részletes pontszám feltárja, hogy a „készlet“ kategória 2,8-ra omlik össze, miközben az „ár“ felfelé húzza az átlagot.

import json

# evaluation_dataset.json
DATASET = [
    {
        "id": "test_001",
        "category": "price",
        "question": "What is the price of the Pro laptop?",
        "expected_answer": "€1,299",
        "expected_tools": ["search_product"],
        "criteria": ["contains_price", "professional_tone"],
    },
    {
        "id": "test_002",
        "category": "stock",
        "question": "Is the Tablet Air in stock?",
        "expected_answer": "yes",
        "expected_tools": ["search_product"],
        "criteria": ["clear_answer", "stock_information"],
    },
]

async def run_complete_evaluation(agent):
    results = []
    for case in DATASET:
        result = await Runner.run(agent, case["question"])
        eval_result = await evaluate_quality(case["question"], result.final_output)
        results.append({
            **case,
            "agent_response": result.final_output,
            "score": eval_result.score,
            "evaluation": eval_result.reason,
        })

    # Jelentés
    average_score = sum(r["score"] for r in results) / len(results)
    print(f"\nAverage score: {average_score:.1f}/5")
    for cat in set(r["category"] for r in results):
        cat_scores = [r["score"] for r in results if r["category"] == cat]
        print(f"  {cat}: {sum(cat_scores)/len(cat_scores):.1f}/5")

    return results

Futtasd ezt a kiértékelést a folyamatos integrációs (CI) folyamatodban, akárcsak az egységteszteket, és állíts be egy küszöbértéket, amely alatt a kézbesítés blokkolva van. Innentől kezdve minden változás – új modell, hangolt utasítások, hozzáadott eszköz – összehasonlítható az előzővel ugyanazon eseteken, és a vita többé nem az benyomások körül forog.

Főbb megállapítások

  • Értékeld a pontosságot, az eszközhasználatot, a késleltetést és a költséget
  • Az LLM-alapú kiértékelés (LLM-as-Judge) kezeli a nyitott végű válaszokat
  • Hozz létre strukturált és reprodukálható tesztkészleteket
  • Automatizáld a kiértékelést a CI/CD folyamatodban a regressziók észlelésére
  • Hasonlítsd össze szisztematikusan a változásokat (modell, utasítások, eszközök)