Ir al contenido principal
Español— Elegir un idioma
Menú

Jueces: Evaluación automatizada de LLM

Lección 13 de 16 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Automatización de la evaluación de calidad
  2. Dos tipos de jueces
  3. Redacción de instrucciones eficaces
  4. Creación de un juez de clasificación mediante el SDK
  5. Creación de un juez de regresión mediante el SDK
  6. Validación antes del escalado
  7. Puntos clave

Lección actualizada el 2 de noviembre de 2026 según el SDK mistralai 3.7.0 y la página de Evaluadores de Mistral: judges.create ahora requiere description y tools (los ejemplos antiguos fallarían), las salidas de regresión exigen min_description y max_description, y puedes probar un juez directamente sobre una conversación mediante judge_conversation. Las variables de plantilla y las “Campañas” de versiones anteriores ya no aparecen en la documentación. Fuentes: Evaluadores · client-python.

Automatización de la evaluación de calidad

Revisar manualmente miles de conversaciones resulta imposible a escala de producción. Los jueces resuelven este problema: son evaluadores basados en LLM que configuras una única vez —definiendo instrucciones, modelo y formato de salida— para aplicarlos después a conversaciones o registros de conjuntos de datos. Cada juicio genera un análisis y un veredicto: una etiqueta o una puntuación.

Dos tipos de jueces

Clasificación

Un juez de clasificación asigna etiquetas discretas a cada respuesta. Algunos ejemplos son:

  • Binario: helpful / not_helpful
  • Multiclase: excellent / acceptable / poor
  • Categorización: code_question / general_knowledge / troubleshooting
  • Seguridad: safe / needs_review / unsafe

Regresión

Un juez de regresión asigna una puntuación numérica dentro de un rango, donde tú defines los límites:

  • Valoración de utilidad del 1 al 5
  • Puntuación de relevancia del 0 al 100
  • Nivel de confianza del 0,0 al 1,0

Redacción de instrucciones eficaces

Las instrucciones del juez determinan toda la calidad de la evaluación; la vaguedad es la causa principal de fallo. «Evalúa la calidad de la respuesta» no significa nada para un modelo: cada ejecución interpretará «calidad» de forma distinta. Una versión funcional nombra criterios observables: «Evalúa si la respuesta responde directamente a la pregunta planteada, utilizando información factualmente correcta». El mismo principio se aplica al contexto: tu juez no sabe que está evaluando un chatbot de soporte donde «bueno» significa «resuelve el problema del cliente sin enviarlo a la documentación». Si no lo indicas explícitamente, aplicará una definición genérica de calidad que no es la tuya.

Los casos límite merecen atención especial, pues es ahí donde divergen las evaluaciones. Especificar que «una puntuación de 3 significa que la respuesta es parcialmente correcta pero le falta un elemento clave» estabiliza la parte media de tu escala; sin este anclaje, la misma conversación podría recibir un 2, un 3 o un 4 según la ejecución. La prueba definitiva es sencilla: si dos evaluadores humanos que lean tus instrucciones pudieran discrepar sobre un caso dado, tu criterio es demasiado vago y el juez heredará esa ambigüedad a escala.

Creación de un juez de clasificación mediante el SDK

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Juez de clasificación de tres niveles
classifier = client.beta.observability.judges.create(
    name="Support Response Quality",
    description="Classifies each support chatbot response into three quality levels.",
    model_name="mistral-medium-latest",
    instructions="""
Evaluate the assistant's last response in the provided conversation.

Context: This is a technical support chatbot.

Criteria:
- Is the response factual and correct?
- Does it directly answer the question asked?
- Is the tone professional and empathetic?

Classify the response according to the proposed categories.
""",
    output={
        "type": "CLASSIFICATION",
        "options": [
            {"value": "excellent", "description": "Correct, complete, and professional response"},
            {"value": "acceptable", "description": "Correct but incomplete response, or tone needs improvement"},
            {"value": "poor", "description": "Incorrect, off-topic, or unprofessional response"},
        ],
    },
    tools=[],  # No tools for this judge
)

print(f"Judge created: {classifier.id}")

Creación de un juez de regresión mediante el SDK

# Juez de regresión: puntuación de utilidad del 1 al 5
scorer = client.beta.observability.judges.create(
    name="Helpfulness Score",
    description="Rates the helpfulness of the assistant's last response on a scale of 1 to 5.",
    model_name="mistral-small-latest",
    instructions="""
Evaluate the helpfulness of the assistant's last response on a scale of 1 to 5.

1 = Useless (off-topic, incorrect, or does not answer the question)
2 = Slightly helpful (partially correct but misses the main point)
3 = Moderately helpful (correct but incomplete or too vague)
4 = Helpful (correct and sufficiently detailed)
5 = Very helpful (correct, detailed, with clear examples or steps)
""",
    output={
        "type": "REGRESSION",
        "min": 1,
        "max": 5,
        "min_description": "Useless response: off-topic, incorrect, or no answer provided",
        "max_description": "Very helpful response: correct, detailed, with clear steps",
    },
    tools=[],
)

print(f"Judge created: {scorer.id}")

Validación antes del escalado

Un juez no validado genera anotaciones falsas a escala. Antes de confiar en uno, pruébalo en conversaciones donde conozcas la respuesta correcta: judge_conversation lo aplica a una lista de mensajes y devuelve su análisis y veredicto.

result = client.beta.observability.judges.judge_conversation(
    judge_id=classifier.id,
    messages=[
        {"role": "user", "content": "My printer shows error E04, what should I do?"},
        {"role": "assistant", "content": "Check the documentation."},
    ],
)

print(result.analysis)  # El razonamiento del juez
print(result.answer)    # La etiqueta o puntuación

Procede entonces de forma metódica:

  1. Prueba con 10 a 20 casos en los que hayas predeterminado el veredicto correcto.
  2. Comprueba la concordancia: ¿produce el juez los mismos resultados que tú?
  3. Prueba la estabilidad: al volver a ejecutarlo sobre los mismos casos, ¿son idénticos los resultados?
  4. Identifica patrones de fallo: ¿en qué tipos de conversación comete errores el juez?

Si la concordancia es demasiado baja, refina las instrucciones antes de cualquier uso a gran escala. Una vez validado, un juez se aplica a registros de conjuntos de datos (client.beta.observability.datasets.records.judge), y la misma lógica del juez LLM aparece en los evaluadores para evaluaciones fuera de línea (lección 14).

Puntos clave

  • Un juez LLM clasifica (etiqueta) o puntúa (valora) conversaciones, respaldado por un análisis.
  • judges.create requiere name, description, model_name, instructions, output y tools.
  • Una salida de regresión define sus límites (min_description, max_description).
  • Las instrucciones deben ser específicas, contextualizadas y ancladas con ejemplos de puntuación.
  • Valida un juez con judge_conversation sobre casos conocidos antes de confiar en él.