DeepEval: evaluación de agentes de IA

DeepEval es el framework de código abierto más usado para evaluar y probar sistemas de IA, y su gran acierto es que se maneja igual que Pytest: en lugar de mirar a ojo si una respuesta «suena bien», escribes casos de prueba, les asignas métricas y dejas que el framework puntúe cada salida de 0 a 1. Si ya has decidido qué medir en un agente y quieres una herramienta concreta con la que medirlo, esta es la biblioteca de referencia. En esta guía verás qué es DeepEval, sus métricas principales, cómo evaluar un agente y sus herramientas, cómo integrarlo en tu CI con pytest y en qué se diferencia de promptfoo. La misma explicación está disponible en inglés.

Puntos clave

• DeepEval, de la empresa Confident AI, es un framework de código abierto para evaluar LLM y agentes; supera las 16.900 estrellas en GitHub y con él se ejecutan más de 20 millones de evaluaciones al día.
• Va por la versión 4.1.1, publicada el 16 de julio de 2026, requiere Python 3.9 o superior y se instala con un solo pip install -U deepeval.
• Ofrece más de 50 métricas respaldadas por investigación: G-Eval, fidelidad, relevancia de la respuesta, corrección de herramientas y compleción de tareas, entre otras.
• Las métricas se ejecutan en tu propia máquina y toda puntuación va de 0 a 1, con un umbral por defecto de 0,5: por encima aprueba, por debajo suspende.
• Se escribe como una prueba de pytest (deepeval test run), por lo que encaja de forma natural en integración continua para vigilar regresiones a cada cambio.

¿Qué es DeepEval?

DeepEval es una biblioteca de Python creada por Confident AI que trata cada respuesta de un modelo o de un agente como algo que puedes afirmar, puntuar y bloquear en tu CI. La documentación oficial lo resume así: «es similar a Pytest, pero especializado en probar salidas de modelos de lenguaje». Esa comparación no es casual: si alguna vez has escrito un test unitario, DeepEval te resultará familiar desde el primer minuto.

Conviene situarlo. Decidir qué hace fiable a un agente, con qué criterios juzgarlo y cómo montar el conjunto de pruebas es un problema conceptual que tratamos aparte. DeepEval es la respuesta práctica a con qué herramienta lo mido: la biblioteca concreta, instalable con pip, que convierte esos criterios en métricas ejecutables. Su unidad básica es el LLMTestCase, un objeto con la entrada, la salida real del sistema y, cuando existe, la salida esperada y el contexto recuperado.

pip install -U deepeval

¿Qué métricas ofrece: relevancia, fidelidad y G-Eval?

Aquí está el corazón de DeepEval. Una métrica recibe un caso de prueba y devuelve una puntuación entre 0 y 1; si iguala o supera el umbral (0,5 por defecto), la prueba pasa. La biblioteca agrupa más de cincuenta métricas en familias según lo que evalúas:

• Métricas de RAG: relevancia de la respuesta, fidelidad (que la salida no contradiga el contexto recuperado), y precisión, exhaustividad y relevancia contextual.
• Métricas de agentes: corrección de herramientas (¿llamó a las herramientas correctas?), compleción de la tarea, corrección de argumentos y eficiencia de pasos.
• Métricas conversacionales: retención de conocimiento, adherencia al rol y completitud de la conversación en diálogos multivuelta.
• Métricas de seguridad: sesgo, toxicidad, fuga de datos personales y uso indebido.

La estrella es G-Eval: una métrica de LLM como juez con la que defines el criterio en lenguaje natural («comprueba si la respuesta es correcta y no omite datos del texto de referencia»), y DeepEval genera por su cuenta los pasos de evaluación y le pide a un modelo juez que puntúe la salida. Para criterios que exigen una decisión determinista existe DAG, un juez basado en un árbol de decisión.

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

correccion = GEval(
    name="Correccion",
    criteria="Comprueba si la salida real responde a la entrada sin inventar datos.",
    evaluation_params=[
        LLMTestCaseParams.INPUT,
        LLMTestCaseParams.ACTUAL_OUTPUT,
    ],
    threshold=0.5,
)

caso = LLMTestCase(
    input="¿Cuál es la capital de Francia?",
    actual_output="La capital de Francia es París.",
)

evaluate(test_cases=[caso], metrics=[correccion])

Un detalle importante: las métricas se ejecutan en tu propia máquina. El modelo juez lo eliges tú (OpenAI, Gemini, Azure o uno que corras de forma local con Ollama), de modo que ninguna de tus respuestas tiene por qué salir de tu infraestructura.

¿Cómo evaluar un agente y sus herramientas?

Un agente no solo produce texto: razona, decide y llama a herramientas. DeepEval trae métricas pensadas para eso. Tool Correctness compara las herramientas que el agente usó de verdad con las que debería haber usado, y Task Completion juzga si el objetivo del usuario se cumplió al final del recorrido. Como este tipo de métrica no siempre necesita una respuesta ideal predefinida (son referenceless), sirve incluso para evaluar en producción, donde rara vez tienes la respuesta correcta a mano.

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

caso = LLMTestCase(
    input="¿Qué tiempo hace en Madrid?",
    actual_output="Ahora mismo hay 28 grados y está despejado.",
    tools_called=[ToolCall(name="obtener_tiempo")],
    expected_tools=[ToolCall(name="obtener_tiempo")],
)

metrica = ToolCorrectnessMetric()
metrica.measure(caso)
print(metrica.score)   # 1.0 si llamó a la herramienta esperada

Estas métricas de agente encajan bien con el patrón de reflexión: puedes medir si la fase de autocrítica mejora de verdad la puntuación de compleción o si solo añade coste en tokens sin ganancia real.

¿Cómo se integra en CI con pytest?

Ese es el argumento de venta de DeepEval: una evaluación no es un cuaderno que ejecutas a mano una vez, sino una prueba que corre a cada commit. Escribes el test como si fuera de pytest, usas assert_test para exigir que las métricas pasen y lo lanzas con el ejecutor propio de DeepEval.

import pytest
from deepeval import assert_test
from deepeval.metrics import AnswerRelevancyMetric
from deepeval.test_case import LLMTestCase

def test_relevancia():
    caso = LLMTestCase(
        input="Resume el artículo en una frase.",
        actual_output="El artículo explica cómo evaluar agentes con DeepEval.",
    )
    assert_test(caso, [AnswerRelevancyMetric(threshold=0.7)])

deepeval test run test_agente.py

Si alguna métrica queda por debajo de su umbral, el comando falla con un código de salida distinto de cero, exactamente como haría pytest; tu tubería de GitHub Actions o GitLab CI marca el build en rojo y frena una regresión antes de que llegue a producción. Este enfoque de evaluación como código lo comparte con herramientas de optimización como DSPy, que usa métricas parecidas para compilar prompts en lugar de solo vigilarlos.

DeepEval frente a promptfoo

DeepEval y promptfoo resuelven el mismo problema —medir la calidad de un sistema de IA— desde filosofías opuestas, y elegir bien depende de tu equipo.

En la práctica: si tu agente ya vive en Python y quieres métricas ricas y tests que fallen en CI, DeepEval encaja como un guante. Si prefieres describir decenas de combinaciones de prompt y modelo en un YAML y compararlas sin escribir código, promptfoo es más ágil. No son excluyentes: hay equipos que usan promptfoo para explorar y DeepEval para blindar en CI lo que ya funciona.

Preguntas frecuentes

¿DeepEval necesita enviar mis datos a una nube?

No. Las métricas se ejecutan en tu propia máquina y tú eliges el modelo juez, que puede ser uno local servido por Ollama. Confident AI ofrece además una plataforma en la nube (paneles, trazas y conjuntos de datos) construida sobre DeepEval, pero es opcional: la biblioteca funciona por completo sin ella.

¿Qué modelo actúa como juez en G-Eval?

El que tú configures. Por defecto DeepEval usa un modelo de OpenAI, pero admite Azure, Gemini, modelos locales vía Ollama y jueces personalizados. Elegir un juez capaz importa: G-Eval hereda tanto la fiabilidad como los sesgos del modelo que puntúa, así que conviene usar un modelo fuerte para las métricas subjetivas.

¿Sirve para evaluar en producción y no solo en pruebas?

Sí. Muchas métricas son referenceless, es decir, no exigen una respuesta ideal predefinida, y por eso pueden puntuar respuestas reales de usuarios en línea. Aun así, el uso más común es en CI: pruebas deterministas con casos fijos que frenan una regresión antes de desplegar.

Conclusión

DeepEval convierte la evaluación de agentes en algo tan rutinario como escribir un test unitario: defines casos, eliges entre más de cincuenta métricas respaldadas por investigación, obtienes puntuaciones de 0 a 1 y bloqueas cualquier regresión en tu CI, todo sin que tus datos salgan de tu máquina. Con más de 16.900 estrellas y 20 millones de evaluaciones diarias, es el estándar de facto para probar sistemas de IA en Python. El siguiente paso es instalarlo con pip install -U deepeval, escribir tu primera métrica G-Eval y compararlo con promptfoo para decidir cuál encaja mejor en tu flujo.

Fuentes: [1] Documentación oficial de DeepEval^[1], [2] DeepEval en GitHub (Confident AI)^[2], [3] Paquete deepeval en PyPI^[3], [4] Confident AI, la empresa detrás de DeepEval^[4].

Fuentes

1. Documentación oficial de DeepEval
2. DeepEval en GitHub (Confident AI)
3. Paquete deepeval en PyPI
4. Confident AI, la empresa detrás de DeepEval

Ruta: Agentes de IA en producción: evaluación y fiabilidad