Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Evaluiraj svoje agente: metrike i mjerila

Lekcija 22 od 25 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Evaluiraj svoje agente: metrike i mjerila
  2. Zašto evaluirati?
  3. Ključne metrike
  4. Evaluacija pomoću LLM-a (LLM-as-Judge)
  5. Strukturirani testni suitevi
  6. Ključne točke

Evaluiraj svoje agente: metrike i mjerila

Agent koji radi u razvojnom okruženju može pasti u produkciji. Sustavna evaluacija jedini je način da se zajamči kvaliteta prije i nakon implementacije. U ovoj lekciji naučit ćeš kako definirati metrike, stvoriti testne suiteve i automatizirati evaluaciju.

Zašto evaluirati?

Bez formalne evaluacije letiš nasumično. Preformuliraš uputu jer se korisnik požalio, ali ništa ti ne govori je li se agent poboljšao ili si upravo pokvario tri druga scenarija. Oklijevaš između Terre i Lune za svoj slučaj upotrebe – ili između dviju razina rezoniranja na istom modelu – a bez mjerenja odluka počiva na osjećaju nakon pet ručnih pokušaja. Promijeniš shemu alata, agent ga prestane zvati u specifičnom slučaju i nitko to ne primijeti dok volumen tiketa ne skoči. Evaluacijski suite svaku od ovih situacija pretvara u usporediv broj od jedne verzije do druge.

Ključne metrike

Točnost

Prvo pitanje je najizravnije: daje li agent točan odgovor? Ponoviš skup pitanja za koja znaš odgovor i provjeriš njegovu prisutnost u izlazu. Usklađivanje podnizova neosjetljivo na velika i mala slova namjerno je grubo – tolerira „Prijenosno računalo Pro košta 1.299 € s PDV-om“ gdje bi stroga jednakost pala – ali dovoljno je za provjerljive činjenice i izračunava se u sekundi.

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"])
        # Automatic or LLM-based verification
        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

# Test suite
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"},
]

Ispravna upotreba alata

Točan odgovor dobiven slučajno i dalje je problem. Agent koji recitira zapamćenu cijenu umjesto da upita katalog proći će danas test točnosti, a sutra dati zastarjelu stopu. Druga metrika stoga gleda put, a ne rezultat: zove li agent prave alate s pravim argumentima? Čitaš pozive u raw_responses, filtriraš izlaze function_call, a usporedba koristi skupove kako bi bila neosjetljiva na redoslijed.

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

        # Extract called tools from raw responses
        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"],
    },
]

Drugi testni slučaj je najpoučniji: pitanje zahtijeva lančano povezivanje dva alata, a to je upravo ona vrsta kompozicije koju promjena u opisu može tiho pokvariti.

Latencija i trošak

Konačno, tu je operativna dimenzija. Prosjek ne govori ništa o stvarnom iskustvu: rep distribucije tjera korisnike, kada jedan od sto zahtjeva traje dvadeset sekundi. Ponavljanjem svake poruke nekoliko puta dobivaš upotrebljivu distribuciju i čitaš medijan kao tipično ponašanje, a P99 kao svoj uobičajeni najgori scenarij.

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")

Evaluacija pomoću LLM-a (LLM-as-Judge)

Ove tri metrike izostavljaju sve što nema jedan točan odgovor: objašnjenje politike povrata, preformuliranje prodaje, poruka isprike. Za ove otvorene odgovore upotrijebi model za evaluaciju kvalitete. Sudac prima pitanje i odgovor, primjenjuje kriterije koje si napisao – točnost, relevantnost, profesionalnost – i vraća strukturiranu ocjenu zahvaljujući Pydantic output_type. Ograničenje formata ono je što proces čini upotrebljivim: dobivaš zbrojivi cijeli broj, a ne komentar za ponovno čitanje.

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

Polje reason zaslužuje tvoju pozornost tijekom pregleda: ovdje sudac objašnjava zašto je dao 3 od 5 i to je često formulacija mane koju nisi uspio imenovati.

Strukturirani testni suitevi

Evaluacija koja nije reproducibilna beskorisna je. Organiziraj svoje testne slučajeve u stabilan format gdje svaki unos nosi ID, kategoriju, pitanje, očekivani odgovor, očekivane alate i kvalitativne kriterije. Kategorija ovdje obavlja sav posao: ukupna ocjena od 4,2 od 5 varljivo je umirujuća, dok detaljna ocjena otkriva da kategorija „zaliha“ pada na 2,8, dok „cijena“ povlači prosjek prema gore.

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,
        })

    # Report
    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

Pokreni ovu evaluaciju u svom CI/CD pipelineu, baš kao i svoje jedinične testove, i postavi prag ispod kojeg je isporuka blokirana. Od tada se svaka promjena – novi model, podešene upute, dodani alat – uspoređuje s prethodnom na istim slučajevima, a rasprava prestaje vrtjeti oko dojmova.

Ključne točke

  • Evaluiraj točnost, upotrebu alata, latenciju i trošak
  • Evaluacija pomoću LLM-a (LLM-as-Judge) obrađuje otvorene odgovore
  • Stvori strukturirane i reproducibilne testne suiteve
  • Automatiziraj evaluaciju u svom CI/CD-u za otkrivanje regresija
  • Sustavno uspoređuj promjene (model, upute, alati)