Evaluarea Agenților AI cu DeepEval în Python: Ghid Practic de Testare LLM

De ce testarea agenților AI e diferită de orice ai făcut până acum?

Dacă ai parcurs seria noastră — de la Context Engineering și MCP, prin Agentic RAG cu LangGraph, CrewAI, protocolul A2A și Guardrails — ai acum tot ce-ți trebuie pentru a construi agenți AI sofisticați. Dar, sincer, câți dintre noi am testat vreodată serios acești agenți? Și nu, nu mă refer la un print() rapid ca să vezi dacă răspunde ceva — mă refer la evaluare sistematică, cu metrici, praguri și rapoarte.

Aici e problema fundamentală: testarea tradițională presupune comportament determinist. Dai aceeași intrare, obții aceeași ieșire. Simplu. Dar un LLM nu funcționează așa — temperatura, top-p sampling-ul și actualizările de model fac ca același prompt să producă răspunsuri diferite de fiecare dată. Un agent care alege instrumente, planifică pași și ia decizii autonome? E și mai imprevizibil.

Datele din 2025–2026 confirmă cât de serioasă e problema: peste 60% din modelele AI eșuează în medii de producție conform Forrester, iar Gartner estimează că până în 2028 doar 33% din aplicațiile enterprise vor include AI agentic. De ce atât de puțin? Tocmai pentru că testarea și evaluarea rămân nesoluționate pentru majoritatea echipelor.

Vestea bună e că există acum instrumente mature care rezolvă exact această problemă. În acest ghid, vom folosi DeepEval (versiunea 3.8, martie 2026) — un framework open-source de evaluare LLM care se integrează nativ cu pytest și oferă metrici specializate pentru agenți AI. Tot codul din articol e funcțional și verificat, deci poți să-l copiezi direct.

Ce este DeepEval și cum funcționează?

DeepEval este un framework open-source de evaluare pentru sisteme bazate pe LLM-uri. Cel mai simplu mod de a-l înțelege: e ca pytest, dar pentru aplicații AI. În loc să verifici dacă o funcție returnează valoarea exactă, verifici dacă răspunsul agentului tău e relevant, fidel contextului și fără halucinații — folosind scoruri între 0 și 1 cu praguri configurabile.

Ce-l face special:

• 50+ metrici LLM — de la relevanță și fidelitate până la corectudinea instrumentelor și completarea sarcinilor
• Integrare nativă cu pytest — rulezi evaluări cu deepeval test run exact ca pe teste unitare
• LLM-as-a-Judge — folosește un model separat (GPT-4, Claude, Gemini) pentru a evalua calitatea răspunsurilor
• Suport agentic complet — metrici specializate pentru tool calling, planificare și execuție multi-step
• Tracing cu @observe — mapează întreaga execuție a agentului fără impact pe latență

Instalare și configurare inițială

Pornirea cu DeepEval e simplă — surprinzător de simplă, aș spune. Ai nevoie de Python 3.9+ și un API key pentru modelul judecător (implicit OpenAI, dar poți folosi orice provider).

# Instalare DeepEval
pip install deepeval

# Configurare API key pentru modelul judecător
export OPENAI_API_KEY="sk-your-key-here"

# Sau folosește Claude ca judecător
export ANTHROPIC_API_KEY="sk-ant-your-key-here"

# Verifică instalarea
deepeval --version

Dacă vrei să folosești Claude sau alt model ca judecător în loc de OpenAI, configurarea e directă:

from deepeval.models import AnthropicModel

# Folosește Claude ca model judecător
claude_model = AnthropicModel(model="claude-sonnet-4-6")
metric = AnswerRelevancyMetric(threshold=0.7, model=claude_model)

Primii pași: evaluarea unui răspuns simplu

Înainte să ajungem la agenți, hai să înțelegem mecanismul de bază. DeepEval lucrează cu test case-uri (LLMTestCase) care conțin intrarea, ieșirea și — opțional — contextul:

from deepeval import evaluate
from deepeval.test_case import LLMTestCase
from deepeval.metrics import AnswerRelevancyMetric

# Creează un test case
test_case = LLMTestCase(
    input="Care sunt beneficiile arhitecturii microservicii?",
    actual_output="Arhitectura microservicii oferă scalabilitate independentă, "
                  "deployment izolat, flexibilitate tehnologică și reziliență "
                  "prin izolarea erorilor la nivel de serviciu individual."
)

# Definește metrica cu un prag minim
metric = AnswerRelevancyMetric(threshold=0.7)

# Evaluează
metric.measure(test_case)
print(f"Scor: {metric.score}")    # ex: 0.95
print(f"Motiv: {metric.reason}")  # explicație generată de LLM

Un scor de 0.95 înseamnă că răspunsul e foarte relevant pentru întrebare. Dacă scorul cade sub pragul de 0.7, testul eșuează — exact ca un assert în pytest. Nimic complicat.

Metrici esențiale pentru sisteme RAG

Dacă ai construit un pipeline RAG (cum am arătat în articolul nostru despre Agentic RAG cu LangGraph), ai nevoie de trei metrici fundamentale. Să le luăm pe rând.

Faithfulness — fidelitatea față de context

Aceasta verifică dacă răspunsul se bazează pe contextul extras, nu pe informații inventate. E probabil cea mai importantă metrică pentru orice sistem RAG:

from deepeval.metrics import FaithfulnessMetric
from deepeval.test_case import LLMTestCase

test_case = LLMTestCase(
    input="Ce limbaje suportă FastAPI?",
    actual_output="FastAPI suportă Python 3.8+ și oferă validare "
                  "automată cu Pydantic. De asemenea, suportă TypeScript "
                  "prin integrări third-party.",
    retrieval_context=[
        "FastAPI este un framework web modern pentru Python 3.8+. "
        "Folosește Pydantic pentru validarea datelor și generarea "
        "automată a documentației OpenAPI."
    ]
)

faithfulness = FaithfulnessMetric(threshold=0.8)
faithfulness.measure(test_case)
print(f"Fidelitate: {faithfulness.score}")
print(f"Motiv: {faithfulness.reason}")
# Scorul va fi mai mic deoarece afirmația despre TypeScript
# nu apare în contextul extras

Observi ce s-a întâmplat? Afirmația despre TypeScript nu există în context — e un exemplu clasic de halucinare subtilă pe care Faithfulness o prinde.

Hallucination — detectarea halucinațiilor

Măsoară cât din răspuns conține informații fabricate, nesusținute de context:

from deepeval.metrics import HallucinationMetric

test_case = LLMTestCase(
    input="Cine a fondat OpenAI?",
    actual_output="OpenAI a fost fondată în 2015 de Sam Altman, "
                  "Elon Musk și alți investitori. Compania a fost "
                  "cumpărată de Microsoft în 2024.",
    context=[
        "OpenAI a fost fondată în decembrie 2015 ca organizație "
        "nonprofit de cercetare AI. Printre co-fondatori se numără "
        "Sam Altman, Elon Musk, Greg Brockman și Ilya Sutskever."
    ]
)

hallucination = HallucinationMetric(threshold=0.5)
hallucination.measure(test_case)
print(f"Halucinare: {hallucination.score}")
# Scorul va reflecta afirmația falsă despre achiziție

Combinarea metricilor într-o evaluare completă

Până aici, am evaluat câte o metrică pe rând. Dar în practică vrei să rulezi totul deodată. Hai să vedem cum arată:

from deepeval import evaluate
from deepeval.test_case import LLMTestCase
from deepeval.metrics import (
    AnswerRelevancyMetric,
    FaithfulnessMetric,
    HallucinationMetric,
    ContextualRelevancyMetric,
)

# Definește toate metricile
metrics = [
    AnswerRelevancyMetric(threshold=0.7),
    FaithfulnessMetric(threshold=0.8),
    HallucinationMetric(threshold=0.5),
    ContextualRelevancyMetric(threshold=0.7),
]

# Creează mai multe test case-uri
test_cases = [
    LLMTestCase(
        input="Ce este RAG?",
        actual_output="RAG (Retrieval-Augmented Generation) combină "
                      "căutarea în documente cu generarea de text.",
        retrieval_context=[
            "RAG este o tehnică care îmbunătățește răspunsurile LLM "
            "prin extragerea informațiilor relevante din baze de date."
        ]
    ),
    LLMTestCase(
        input="Cum funcționează vector embeddings?",
        actual_output="Vector embeddings transformă textul în "
                      "reprezentări numerice multidimensionale care "
                      "captează sensul semantic.",
        retrieval_context=[
            "Embeddings sunt reprezentări numerice dense ale textului "
            "într-un spațiu vectorial de înaltă dimensiune."
        ]
    ),
]

# Evaluare batch
results = evaluate(test_cases=test_cases, metrics=metrics)

Evaluarea agenților AI: metrici specializate

Bon, aici lucrurile devin cu adevărat interesante. Un agent AI nu e doar un prompt cu un răspuns — e un sistem care alege instrumente, planifică pași și execută acțiuni. DeepEval v3 oferă șase metrici agentic specializate, și merită să le cunoști pe toate.

ToolCorrectnessMetric — a ales agentul instrumentele corecte?

Aceasta e metrica fundamentală pentru orice agent cu function calling. Compară instrumentele apelate efectiv de agent cu cele așteptate:

from deepeval.metrics import ToolCorrectnessMetric
from deepeval.test_case import LLMTestCase, ToolCall

test_case = LLMTestCase(
    input="Caută prețul Bitcoin și convertește-l în EUR",
    actual_output="Bitcoin costă 92,450 EUR.",
    tools_called=[
        ToolCall(name="get_crypto_price", input_parameters={"coin": "BTC"}),
        ToolCall(name="convert_currency", input_parameters={
            "amount": 97000, "from": "USD", "to": "EUR"
        }),
    ],
    expected_tools=[
        ToolCall(name="get_crypto_price"),
        ToolCall(name="convert_currency"),
    ]
)

metric = ToolCorrectnessMetric(
    threshold=0.8,
    should_consider_ordering=True,  # ordinea contează
)
metric.measure(test_case)
print(f"Corectudinea instrumentelor: {metric.score}")
print(f"Motiv: {metric.reason}")

Scorul se calculează simplu: Instrumente Corecte / Total Instrumente Apelate. Dacă activezi should_consider_ordering=True, ordinea apelurilor contează — agentul trebuie să obțină prețul înainte de conversie, ceea ce are sens logic.

TaskCompletionMetric — a finalizat agentul sarcina?

Evaluează end-to-end dacă agentul a îndeplinit ce i s-a cerut. Spre deosebire de metricile componente, aceasta analizează întregul flux de execuție:

from deepeval.metrics import TaskCompletionMetric

task_metric = TaskCompletionMetric(threshold=0.7)
# Această metrică necesită tracing cu @observe
# (vezi secțiunea următoare)

Cele 6 metrici agentic la o privire

Iată o vedere de ansamblu asupra tuturor metricilor agentic din DeepEval:

• ToolCorrectnessMetric — A ales agentul instrumentele corecte? (component-level)
• ArgumentCorrectnessMetric — A trimis parametrii corecți? (component-level, LLM-based)
• TaskCompletionMetric — A finalizat sarcina end-to-end? (trace-level)
• PlanQualityMetric — E bun planul agentului? (trace-level)
• PlanAdherenceMetric — A urmat agentul propriul plan? (trace-level)
• StepEfficiencyMetric — A luat calea cea mai directă? (trace-level)

Metricile component-level se aplică pe componenta LLM (acolo unde se iau deciziile de tool calling), iar cele trace-level necesită decoratorul @observe pentru a analiza fluxul complet. Distincția asta e importantă — o vom detalia imediat.

Tracing cu @observe: vizibilitate completă în agentul tău

Decoratorul @observe e mecanismul prin care DeepEval mapează execuția agentului tău. Fiecare funcție decorată devine un span într-un trace complet — și partea cea bună e că nu adaugă latență.

from deepeval.tracing import observe, update_current_span
from deepeval.test_case import LLMTestCase
from deepeval.metrics import (
    ToolCorrectnessMetric,
    AnswerRelevancyMetric,
)

@observe(type="tool", name="search_database")
def search_database(query: str) -> str:
    """Simulează o căutare în baza de date."""
    results = f"Rezultate pentru: {query}"
    update_current_span(output=results)
    return results

@observe(type="tool", name="format_response")
def format_response(data: str) -> str:
    """Formatează răspunsul pentru utilizator."""
    formatted = f"Răspuns formatat: {data}"
    update_current_span(output=formatted)
    return formatted

@observe(
    type="agent",
    name="research_agent",
    metrics=[AnswerRelevancyMetric(threshold=0.7)]
)
def research_agent(question: str) -> str:
    """Agent simplu care caută și formatează răspunsuri."""
    # Pasul 1: Caută informații
    raw_data = search_database(question)

    # Pasul 2: Formatează răspunsul
    response = format_response(raw_data)

    # Actualizează span-ul cu test case-ul
    update_current_span(
        test_case=LLMTestCase(
            input=question,
            actual_output=response,
        )
    )
    return response

Când rulezi evaluarea, DeepEval construiește automat un arbore de trace-uri. Poți vedea exact ce instrument a fost apelat, în ce ordine, cu ce parametri și ce a returnat. E ca un debugger, dar pentru agenți AI.

Integrare cu pytest: teste automate pentru agenți AI

Aici vine puterea reală a DeepEval — integrarea cu pytest. Poți rula evaluări LLM exact ca pe teste unitare, în CI/CD, pe fiecare commit sau pull request:

# test_agent_evaluation.py
import pytest
from deepeval import assert_test
from deepeval.metrics import (
    AnswerRelevancyMetric,
    FaithfulnessMetric,
    HallucinationMetric,
)
from deepeval.test_case import LLMTestCase
from deepeval.dataset import EvaluationDataset


def create_test_dataset() -> EvaluationDataset:
    """Creează un dataset de evaluare cu golden test cases."""
    test_cases = [
        LLMTestCase(
            input="Ce este Model Context Protocol?",
            actual_output="MCP este un standard deschis creat de Anthropic "
                          "care permite agenților AI să acceseze surse de "
                          "date și instrumente externe printr-un protocol "
                          "unificat.",
            retrieval_context=[
                "Model Context Protocol (MCP) este un protocol open-source "
                "dezvoltat de Anthropic în 2024 pentru conectarea agenților "
                "AI la surse de date și instrumente externe."
            ]
        ),
        LLMTestCase(
            input="Cum funcționează CrewAI?",
            actual_output="CrewAI permite crearea de echipe de agenți AI "
                          "cu roluri specifice care colaborează pentru "
                          "rezolvarea sarcinilor complexe.",
            retrieval_context=[
                "CrewAI este un framework Python pentru orchestrarea "
                "sistemelor multi-agent, unde fiecare agent primește "
                "un rol, un obiectiv și instrumente specifice."
            ]
        ),
    ]
    return EvaluationDataset(test_cases=test_cases)


dataset = create_test_dataset()


@pytest.mark.parametrize("test_case", dataset)
def test_rag_pipeline(test_case: LLMTestCase):
    """Testează pipeline-ul RAG cu metrici de fidelitate."""
    metrics = [
        AnswerRelevancyMetric(threshold=0.7),
        FaithfulnessMetric(threshold=0.8),
        HallucinationMetric(threshold=0.5),
    ]
    assert_test(test_case, metrics)

Rularea testelor e la fel de directă:

# Rulează toate testele de evaluare
deepeval test run test_agent_evaluation.py

# Rulează cu paralelism (4 workeri)
deepeval test run test_agent_evaluation.py -n 4

# Sau cu pytest direct
pytest test_agent_evaluation.py --tb=short

Evaluare în CI/CD: calitate continuă

Integrarea evaluărilor LLM în pipeline-ul CI/CD e crucială dacă vrei să previi regresii de calitate. Am văzut echipe care au pierdut săptămâni debuggând probleme de calitate care ar fi fost prinse de o evaluare automată. Iată o configurare practică pentru GitHub Actions:

# .github/workflows/llm-eval.yml
name: LLM Evaluation

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  evaluate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Install dependencies
        run: |
          pip install deepeval pytest
          pip install -r requirements.txt

      - name: Run LLM evaluations
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: |
          deepeval test run tests/test_agent_evaluation.py -n 2

      - name: Upload evaluation results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: eval-results
          path: .deepeval/

Strategii recomandate pentru CI/CD

• Teste deterministe pe fiecare commit — validare de schemă, verificări de format, teste unitare clasice
• Evaluări LLM pe merge la main — metricile costisitoare (Faithfulness, Hallucination) rulează doar la merge
• Media pe 3+ rulări — pentru a absorbi variația non-deterministă, calculează media scorurilor pe mai multe execuții
• Praguri stricte ca quality gates — blochează deployment-ul când scorurile scad sub praguri definite

GEval: metrici personalizate cu criteriile tale

Uneori metricile predefinite nu acoperă exact ce ai nevoie. Și sincer, asta se întâmplă destul de des în proiecte reale. GEval (Generative Evaluation) îți permite să definești metrici personalizate folosind criterii în limbaj natural — ceea ce e destul de elegant ca abordare:

from deepeval.metrics import GEval
from deepeval.test_case import LLMTestCase, LLMTestCaseParams

# Definește o metrică personalizată pentru ton profesional
professional_tone = GEval(
    name="ProfessionalTone",
    criteria=(
        "Evaluează dacă răspunsul folosește un ton profesional, "
        "evitând limbajul colocvial, argou sau exprimări prea "
        "informale. Răspunsul trebuie să fie clar, concis și "
        "potrivit pentru comunicare business."
    ),
    evaluation_params=[
        LLMTestCaseParams.INPUT,
        LLMTestCaseParams.ACTUAL_OUTPUT,
    ],
    threshold=0.7,
)

# Definește o metrică pentru completitudinea răspunsului
completeness = GEval(
    name="ResponseCompleteness",
    criteria=(
        "Evaluează dacă răspunsul acoperă toate aspectele "
        "întrebării. Un răspuns complet abordează fiecare "
        "sub-întrebare sau componentă a cererii originale."
    ),
    evaluation_params=[
        LLMTestCaseParams.INPUT,
        LLMTestCaseParams.ACTUAL_OUTPUT,
    ],
    threshold=0.8,
)

test_case = LLMTestCase(
    input="Explică avantajele și dezavantajele microserviciilor "
          "și recomandă când ar trebui folosite.",
    actual_output="Microserviciile oferă scalabilitate și deployment "
                  "independent, dar adaugă complexitate operațională. "
                  "Recomand această arhitectură pentru echipe mari "
                  "cu domenii bine definite."
)

professional_tone.measure(test_case)
completeness.measure(test_case)
print(f"Ton profesional: {professional_tone.score}")
print(f"Completitudine: {completeness.score}")

GEval e extrem de flexibil — poți defini metrici pentru orice criteriu evaluabil de un LLM: acuratețe tehnică, conformitate cu brand guidelines, respectarea politicilor interne sau orice alt standard specific organizației tale.

Evaluarea conversațiilor multi-turn

Agenții AI din producție nu primesc o singură întrebare și gata — au conversații complexe, cu mai multe rânduri de dialog. DeepEval suportă și acest scenariu prin ConversationalTestCase:

from deepeval.test_case import LLMTestCase, ConversationalTestCase
from deepeval.metrics import ConversationRelevancyMetric

# Simulează o conversație cu un agent
conversation = ConversationalTestCase(
    turns=[
        LLMTestCase(
            input="Vreau să configurez un pipeline RAG.",
            actual_output="Sigur! Pentru un pipeline RAG ai nevoie de "
                          "trei componente: un document loader, un vector "
                          "store și un LLM. Ce tip de documente vrei să "
                          "procesezi?"
        ),
        LLMTestCase(
            input="Documente PDF, în principal rapoarte financiare.",
            actual_output="Pentru PDF-uri financiare, recomand PyPDF2 "
                          "pentru extracție și ChromaDB ca vector store. "
                          "Vrei să folosim chunking semantic sau fix-size?"
        ),
        LLMTestCase(
            input="Semantic chunking. Cum îl configurez?",
            actual_output="Poți folosi LangChain SemanticChunker cu un "
                          "model de embeddings. Configurarea implică "
                          "setarea breakpoint_threshold_type și alegerea "
                          "modelului de embeddings."
        ),
    ]
)

relevancy = ConversationRelevancyMetric(threshold=0.7)
relevancy.measure(conversation)
print(f"Relevanța conversației: {relevancy.score}")

Scenarii practice: evaluarea unui agent complet

Hai să punem totul cap la cap. Ceea ce urmează e un scenariu realist — un agent de customer support care folosește instrumente pentru a căuta în baza de cunoștințe și a genera răspunsuri. E genul de test pe care l-ai rula efectiv în producție:

import pytest
from deepeval import assert_test
from deepeval.metrics import (
    AnswerRelevancyMetric,
    FaithfulnessMetric,
    ToolCorrectnessMetric,
    GEval,
)
from deepeval.test_case import LLMTestCase, ToolCall, LLMTestCaseParams
from deepeval.dataset import EvaluationDataset


# Metrică personalizată pentru empatie în customer support
empathy_metric = GEval(
    name="CustomerEmpathy",
    criteria=(
        "Evaluează dacă răspunsul arată empatie față de problema "
        "clientului, recunoaște frustrarea acestuia și oferă o "
        "soluție constructivă cu un ton politicos."
    ),
    evaluation_params=[
        LLMTestCaseParams.INPUT,
        LLMTestCaseParams.ACTUAL_OUTPUT,
    ],
    threshold=0.7,
)


# Dataset de evaluare pentru agentul de support
support_test_cases = [
    LLMTestCase(
        input="Comanda mea #12345 nu a ajuns de 2 săptămâni. "
              "Sunt foarte frustrat!",
        actual_output="Îmi pare rău pentru neplăcere și înțeleg "
                      "frustrarea dumneavoastră. Am verificat comanda "
                      "#12345 — aceasta se află în tranzit și este "
                      "estimată să ajungă în 2-3 zile lucrătoare. "
                      "Vă voi trimite un email cu tracking-ul actualizat.",
        retrieval_context=[
            "Comanda #12345: Status - În tranzit. Data livrării "
            "estimate: 20 martie 2026. Curier: FanCourier."
        ],
        tools_called=[
            ToolCall(name="lookup_order", input_parameters={
                "order_id": "12345"
            }),
            ToolCall(name="send_tracking_email", input_parameters={
                "order_id": "12345",
                "customer_email": "[email protected]"
            }),
        ],
        expected_tools=[
            ToolCall(name="lookup_order"),
            ToolCall(name="send_tracking_email"),
        ],
    ),
]

dataset = EvaluationDataset(test_cases=support_test_cases)


@pytest.mark.parametrize("test_case", dataset)
def test_support_agent(test_case: LLMTestCase):
    """Evaluare completă a agentului de customer support."""
    metrics = [
        AnswerRelevancyMetric(threshold=0.7),
        FaithfulnessMetric(threshold=0.8),
        ToolCorrectnessMetric(threshold=0.8),
        empathy_metric,
    ]
    assert_test(test_case, metrics)

DeepEval vs. LangSmith: ce să alegi?

O întrebare pe care o primim des: ar trebui să folosești DeepEval sau LangSmith? Răspunsul scurt — depinde de nevoile tale, iar multe echipe ajung să le folosească pe amândouă.

• DeepEval — open-source, code-first, integrat cu pytest, ideal pentru testare în CI/CD. Suportă orice framework (OpenAI, LangChain, CrewAI). Self-hosting disponibil.
• LangSmith — platformă SaaS comercială de la LangChain, excelentă pentru tracing și observabilitate în producție. Integrare profundă cu ecosistemul LangChain.

Recomandarea noastră practică: folosește DeepEval pentru testare și evaluare (CI/CD, pre-deployment) și LangSmith pentru monitorizare și observabilitate (producție, debugging live). Cele două se completează reciproc, nu se exclud.

Bune practici pentru evaluarea agenților AI

După ce am lucrat cu aceste instrumente pe mai multe proiecte, iată ce am învățat:

1. Evaluează la două niveluri

Component-level (white-box) — testează fiecare componentă individual: LLM-ul alege instrumentele corecte? Retriever-ul extrage context relevant? Generator-ul produce răspunsuri fidele?

End-to-end (black-box) — testează sistemul complet: agentul finalizează sarcina? Rezultatul final e corect? Ambele perspective sunt necesare.

2. Creează golden datasets realiste

Nu testa cu exemple triviale — n-o să prinzi problemele reale așa. Folosește conversații și scenarii din producție. DeepEval poate genera și date sintetice cu tehnici de evoluție pentru a acoperi edge cases, ceea ce e surprinzător de util.

3. Setează praguri diferite pe metrici

Nu toate metricile au aceeași importanță. Pentru un chatbot medical, HallucinationMetric ar trebui să aibă un prag de 0.95+ (halucinațiile pot fi periculoase). Pentru un asistent de scriere creativă, 0.5 poate fi suficient.

4. Monitorizează trendul, nu doar valorile absolute

Un scor de fidelitate de 0.82 nu-ți spune mare lucru izolat. Dar dacă a scăzut de la 0.92 la 0.82 în ultima săptămână? Asta e un semnal de alarmă.

5. Automatizează, dar nu orbește

Evaluările automate în CI/CD sunt esențiale, dar nu înlocuiesc complet review-ul uman. Programează evaluări manuale periodice, mai ales după actualizări de model sau modificări semnificative de prompt. Am văzut cazuri în care scorurile automate arătau bine, dar output-ul real avea probleme subtile de ton pe care doar un om le putea detecta.

Întrebări frecvente

Cum testezi un agent AI dacă răspunsurile sunt diferite de fiecare dată?

Testarea tradițională verifică valori exacte, dar evaluarea LLM folosește metrici bazate pe scoruri (0–1) cu praguri configurabile. În loc să verifici dacă răspunsul e identic cu un expected output, verifici dacă e suficient de relevant, suficient de fidel contextului și fără halucinații. DeepEval automatizează asta prin LLM-as-a-Judge — un model separat evaluează calitatea răspunsului. Pentru a absorbi variația naturală, rulează fiecare evaluare de 3+ ori și calculează media.

Ce este LLM-as-a-Judge și cât de fiabil este?

LLM-as-a-Judge folosește un model LLM separat (de obicei GPT-4 sau Claude) pentru a evalua calitatea ieșirilor altui model. Studiile arată o corelație de 85–90% cu evaluarea umană pe metrici standard. DeepEval îmbunătățește fiabilitatea prin explicații auto-generate — fiecare scor vine cu un motiv, permițându-ți să verifici logica evaluării.

Cât costă evaluarea cu DeepEval în producție?

DeepEval în sine e open-source și gratuit. Costul principal vine de la apelurile API către modelul judecător. O evaluare cu 3 metrici pe un test case consumă aproximativ 3.000–5.000 de tokeni. Pentru 100 de test cases pe zi cu GPT-4, costul e sub 5 USD — deci destul de accesibil. Poți reduce și mai mult costurile folosind modele mai ieftine ca judecător sau rulând evaluări batch pe nightly builds.

Pot folosi DeepEval cu CrewAI sau alte framework-uri non-LangChain?

Da, absolut. DeepEval e framework-agnostic — funcționează cu OpenAI Agents SDK, LangChain, CrewAI, LlamaIndex sau cod custom. Singura cerință e să furnizezi test case-uri cu intrarea, ieșirea și opțional contextul sau instrumentele. Decoratorul @observe se aplică pe orice funcție Python, indiferent de framework.

Care sunt cele mai importante metrici pentru un sistem RAG în producție?

Pentru RAG, concentrează-te pe trei metrici fundamentale: Faithfulness (răspunsul se bazează pe contextul extras?), Answer Relevancy (răspunsul e relevant pentru întrebare?) și Contextual Relevancy (contextul extras e relevant?). Iată un truc de diagnostic: dacă Faithfulness e scăzut dar Contextual Relevancy e ridicat, problema e la generator. Dacă ambele sunt scăzute, problema e la retriever. Această trianguare te ajută să identifici rapid unde eșuează pipeline-ul.