¿Tu agente funciona bien? Así puedes medirlo

Cada vez es más fácil construir un sistema de chatbot o agente, pero una de las mayores dificultades, una vez desarrollado, es medir realmente el éxito de la implementación. En general, las empresas evalúan el desempeño de los chatbots mediante encuestas a los usuarios (nivel de satisfacción), el cumplimiento de los objetivos planteados para el agente (leads, conversiones, etc.) u otras métricas de negocio. No obstante, es fundamental contar con métricas técnicas a nivel interno que respalden el proceso, ya que son la base para cualquier mejora o ajuste en la arquitectura de la solución.

Debido a mi trabajo, tuvimos que construir un chatbot con contexto adicional (RAG) y planteamos la utilización de la librería RAGAS para medir el rendimiento tanto del contexto recuperado como de la respuesta entregada al usuario. Dado mi experiencia, empleamos las siguientes métricas:

1. Context Precision: Mide que tan "limpio" o bueno son tus chunks recuperados en base a la pregunta del usuario. Si tu sistema es capaz de obtener buen contexto para responder la pregunta sera más cercano a 1, sino más cercano a 0.
2. Context Recall: Mide la cantidad de contexto realmente necesario que se logro recuperar de la base de conocimientos.
3. Faithfulness: Mide que tan consistente es la respuesta en base al contexto recuperado. Si la respuesta es fuertemente hecha en base al contexto recuperado sera más cercano a 1, sino 0.
4. Response Relevancy: Mide que tan cercana es la respuesta en base a la pregunta del usuario.

En el caso de las métricas de RAGAS, optamos por calcular un promedio ponderado, lo que nos permitió contar con una métrica única de control y, en base a ella, decidir si convenía mantener una implementación o reemplazarla por otra.

Adicionalmente a estas métricas, nos enfocamos en el tiempo de respuesta del chatbot, evaluando si este aumentaba o disminuía según la arquitectura de solución utilizada.

Spoiler: como en cualquier modelo de Machine Learning, si no hay datos, no se puede evaluar. Si realmente quieres medir el rendimiento de tu sistema, tendrás que construir un dataset que contenga: la pregunta, la respuesta correcta, las tools llamadas o el contexto recuperado (si aplica), y la respuesta generada por el modelo de lenguaje.

Pero..

¿Qué es RAGAS?

RAGAS es una librería en Python que ha ido creciendo con el tiempo. Al principio solo contaba con métricas para medir chatbots con RAG (Retrieval-Augmented Generation), pero hace poco le incorporaron algunas métricas para evaluar agentes. Siendo honesto, creo que las métricas aún tienen algunas imperfecciones, pero sí pueden darte ideas y un punto de partida para evaluar este tipo de sistemas.

El sitio es: https://docs.ragas.io/en/stable/

Si estás construyendo un sistema agéntico, creo que hay dos métricas de la librería que resultan muy útiles para evaluar el rendimiento de tu sistema:

1. Tool Accuracy: Es una métrica que se utiliza para evaluar el desempeño del LLM en identificar e invocación de las tools para completar una tarea.
2. Agent Goal Accuracy: es una métrica que se utiliza para evaluar el desempeño de un LLM en identificar y cumplir los objetivos del usuario. Es una métrica binaria en base si el agente logro cumplir con el objetivo trazado o no. Esta métrica es útil, pero encontré que en algunas ocasiones no entregaba resultados correctos. Creo que tiende a ser demasiado literal. Te lo demostraré con el ejemplo (pienso que lo importante es la idea general, más que la métrica en sí misma).

Creo que estas dos métricas son muy buenas para comenzar a medir un sistema, ya que, si cuentas con un conjunto de preguntas y respuestas junto con todas las tools necesarias para responderlas, puedes generar un score que te permita ir midiendo los cambios a tu lógica de implementación.

Ejemplo Practico

Antes de empezar el ejercicio práctico, es bueno recordar qué es un agente. En términos simples, un agente es un modelo de lenguaje al que se le agrega un conjunto de “cajas de herramientas” (tools), que le permiten:

• Tools: son las herramientas del agente que le permiten conectarse con el mundo exterior, como APIs, bases de datos u otras fuentes de información.
• Memory: es la memoria del agente, donde guarda información de interacciones pasadas para recordar contexto y dar respuestas más coherentes.
• System Prompts: son las instrucciones iniciales que definen cómo debe comportarse el agente (su personalidad, estilo de respuesta, reglas, etc.).

Luego de esta breve definición de un sistema de agentico, escribí un ejemplo práctico de cómo implementar las métricas en un agente utilizando el framework LangGraph. Este ejemplo corresponde a un agente experto en matemáticas, que consta de las siguientes tools:

• Divide: Tool que le da al agente la capacidad de dividir dos números. Requiere dos parámetros: numerador y denominador.
• Sum: Tool que le da al agente la capacidad de sumar dos números. Consta de dos parámetros numéricos como inputs.
• Sub: Tool que le da al agente la capacidad de restar un número de otro. Requiere dos parámetros numéricos: minuendo y sustraendo.
• Multiply: Tool que le da al agente la capacidad de multiplicar dos números. Consta de dos parámetros numéricos como inputs.

El prompt de sistema es:

                        You are a helpful assistant that can perform basic arithmetic operations.

Key capabilities:
- Perform multiplication
- Perform division
- Perform addition
- Perform subtraction

The tool you should use is:
- multiply: Multiplies two numbers. The arguments should be passed as 'a' and 'b'. Must not be like arg1: 2422*6454656
- divide: Divides two numbers. The arguments should be passed as 'a' and 'b'. Must not be like arg1: 2422/6454656
- sum: Sums two numbers. The arguments should be passed as 'a' and 'b'. Must not be like arg1: 2422+6454656
- sub: Subtracts two numbers. The arguments should be passed as 'a' and 'b'. Must not be like arg1: 2422-6454656

Consideration
- You must follow the rules of the mathematics for calling the tool sequentially. If you have to perform a division, you must first perform obtian the 
values in the numerator and denominator. and then perform the division.

When users ask vague questions, ask for clarification. Be conversational and helpful.
Always format your responses clearly, using bullet points or numbered lists when showing multiple items.
You only must show the result of the operation as final answer. Not show the process to get the result.
Your answer always must be in Spanish.
                    

Y su pregunta es:

"Cuanto es la resultados de la siguiente operaciones:(1645+1223)/344"

Es un ejemplo ilustrativo, pero lo que busco es que el agente pueda invocar sus tools en un orden específico, junto con sus parámetros. El orden es el siguiente:

• Sum call tool: Debe llamar a la función sum con los parámetros 1645 y 1223. Su resultado debería ser 2868.
• Divide call tool: Debe llamar al a función divide con los parámetros 2868 y 344. Su resultado debería ser 8,34.

Este problema podría haber sido resuelto por el modelo de lenguaje sin utilizar tools (aunque los modelos suelen equivocarse en problemas matemáticos). Sin embargo, quise armar una pequeña secuencia de pasos para mostrar el resultado si le implementará estas métricas al agente.

Importante: No quise ir en detalles como construir el agente, pero esta dentro del github al final del articulo. Es un simple agente con tools, y que logra ejecutarlas. Si necesitas más detalles, revisa el jupyter antes. ❤️

Tool Accuracy

Como revisamos anteriormente, el Tool Accuracy es una excelente métrica si queremos evaluar la secuencia de acciones y las tools que debería utilizar nuestro sistema para responder una pregunta.

Una de las cosas más rescatables de este framework es que permite entregar toda la conversación, incluyendo tanto la interacción del usuario como la del asistente, además de las tools invocadas para llegar a la respuesta.

En este ejemplo, la idea sería la siguiente:

                        import pandas as pd
from ragas.metrics import ToolCallAccuracy
from ragas.dataset_schema import MultiTurnSample
from ragas.integrations.langgraph import convert_to_ragas_messages
import ragas.messages as r

results_json = {
    'question': 'Cual es el resultado de (1645+1223)/344',
    'result': 'El resultado de la operacion es el siguiente: 8.34',
    'references_tool_calls': [
        ToolCall(name="sum", args={"__arg1": 1645, "__arg2": 1223}),
        ToolCall(name="divide", args={"__arg1": 2868, "__arg2": 344})
    ]
}
df = pd.DataFrame([results_json])

sample = MultiTurnSample(
    user_input=ragas_trace,
    reference_tool_calls=df['references_tool_calls'][0]
)

scorer = ToolCallAccuracy()
await scorer.multi_turn_ascore(sample)


                    

El score es 1, ya que el agente logra ejecutar las siguiente tools:

                        [HumanMessage(content='Cual es el resultado de (1645+1223)/344', metadata=None, type='human'),
 AIMessage(content='', metadata=None, type='ai', tool_calls=[ToolCall(name='sum', args={'__arg1': '1645', '__arg2': '1223'})]),
 AIMessage(content='', metadata=None, type='ai', tool_calls=[ToolCall(name='divide', args={'__arg1': '2868', '__arg2': '344'})]),
 AIMessage(content='El resultado es 8.34.', metadata=None, type='ai', tool_calls=[])]
                    

Que coinciden con las tools de referencia, tanto con su orden como sus parametros.

Agent Goal accuracy

Como mencioné, esta métrica es bastante útil para determinar si el objetivo de tu sistema se logró en la conversación con el usuario. La implementación es la siguiente:

                        from langchain_openai import ChatOpenAI
from ragas.dataset_schema import MultiTurnSample
from ragas.messages import HumanMessage, AIMessage, ToolMessage, ToolCall
from ragas.metrics import AgentGoalAccuracyWithReference
from ragas.llms import LangchainLLMWrapper

# 1️⃣ Define the evaluator LLM
evaluator_llm = LangchainLLMWrapper(ChatOpenAI(model="gpt-4.1-mini"))

# 2️⃣ Create your MultiTurnSample
sample = MultiTurnSample(
    user_input=ragas_trace,
    reference=df['result'][0]
)

# 3️⃣ Create the scorer with the evaluator_llm
scorer = AgentGoalAccuracyWithReference(llm=evaluator_llm)

# 4️⃣ Run the evaluation
result = await scorer.multi_turn_ascore(sample)
print(result)
                    

Con un resultado de 1, debido a que el resultado de la ejecución es "El resultado es 8.34", y el resultado de referencia es: "El resultado de la operación es el siguiente: 8.34". No obstante, si el resultado de referencia incluyera todos los decimales, la métrica dará 0. Esto se debe a que es binaria, por lo que, es bueno corregir esta métrica con otras más tradicionales de RAGAS como Answer Accuracy. u otras.

Mi reflexión

Este framework, aunque es útil, no siempre debe tomarse como una regla fija. Cada caso de uso es distinto y puede requerir diferentes métricas. Sin embargo, creo que hay algunos puntos que se comparten en común en cualquier sistema:

• Si quieres mejorar tu sistema conversacional agéntico, mídelo y preocupate de contar con un conjunto de preguntas bien definido.
• Si tu sistema utiliza tools, deberás medir de alguna forma que se invoquen correctamente, tanto en su orden como en sus parámetros.
• Si tu sistema tiene objetivos claros, busca la manera de poder medirlos.
• Los frameworks son referenciales, pero pueden ayudar. Incluso podrías contar con un prompt de sistema que actúe como validador, al cual le entregues directamente las preguntas, respuestas, contexto y tools para generar un score, y luego usarlo como guía para posibles mejoras.

Este es solo un framework, pero es útil para buscar idea y lugares comunes.

El repositorio esta en el siguiente link:

https://github.com/Foco22/FA_Posts

Y su pregunta es:

"Cuanto es la resultados de la siguiente operaciones:(1645+1223)/344"

Es un ejemplo ilustrativo, pero lo que busco es que el agente pueda invocar sus tools en un orden específico, junto con sus parámetros. El orden es el siguiente:

• Sum call tool: Debe llamar a la función sum con los parámetros 1645 y 1223. Su resultado debería ser 2868.
• Divide call tool: Debe llamar al a función divide con los parámetros 2868 y 344. Su resultado debería ser 8,34.

Este problema podría haber sido resuelto por el modelo de lenguaje sin utilizar tools (aunque los modelos suelen equivocarse en problemas matemáticos). Sin embargo, quise armar una pequeña secuencia de pasos para mostrar el resultado si le implementará estas métricas al agente.

Sistema Agentico

LangGraph es un excelente framework para construir agentes, pero no mostraré el detalle específico de cómo construir un agente. Lo que sí quiero mostrar es la respuesta dada por el sistema en base a la pregunta planteada.

Pregunta: Cuanto es la resultados de la siguiente operaciones: (1645+1223)/344

Y la respuesta es:

En la respuesta del agente se observa que primero consulta a la tool de suma, y luego a la división, con los argumentos correctos. Finalmente, el agente procesa la información de las tools, y genera una respuesta en lenguaje natural. Este es un simple ejemplo de como un agente con tools puede ejecutar una secuencia de pasos y resolver un problema. Vayamos a la métricas en base a la respuesta obtenida.

Importante: No quise ir en detalles como construir el agente, ya que no es objetivo del articulo, pero esta dentro del github al final del articulo. Si necesitas más detalles, revisa el jupyter antes (perdón). ❤️

Tool Accuracy

Como revisamos anteriormente, el Tool Accuracy es una excelente métrica si queremos evaluar si la secuencia de tools ejecutadas con sus parámetros fueron los correctos para responder la pregunta del usuario.

Una de las cosas más rescatables de este framework (RAGAS) es que puede darle toda la conversación, incluyendo tanto la interacción del usuario como la del asistente, además de las tools invocadas para llegar a la respuesta.

En este ejemplo, la idea sería la siguiente:

El score es 1, ya que el agente logra ejecutar las siguiente tools:

Que coinciden con las tools de referencia, tanto con su orden como sus parámetros.

Agent Goal accuracy

Como mencioné, esta métrica es bastante útil para determinar si el objetivo de tu sistema se logró en la conversación con el usuario. La forma de calcular esta métrica es la siguiente:

La respuesta del agente es "El resultado es 8.34", y la respuesta de referencia es: "El resultado de la operación es el siguiente: 8.34", dando un score de 1. No obstante, si el resultado de referencia incluyera todos los decimales, la métrica dará 0. Esto se debe a que es binaria, por lo que, es bueno corregir esta métrica con otras más tradicionales de RAGAS como Answer Accuracy u otras.

Mi reflexión

Este framework, aunque es útil, no siempre debe tomarse como una regla fija. Cada caso de uso es distinto y puede requerir diferentes métricas. Sin embargo, creo que los siguientes puntos en común se comparten en cualquier entorno:

• Si quieres mejorar tu sistema conversacional agéntico, mídelo y preocupate de contar con un conjunto o un dataset para evaluarlo.
• Si tu sistema utiliza tools, deberás medir de alguna forma que se invoquen correctamente, tanto en su orden como en sus parámetros.
• Si tu sistema tiene objetivos claros, busca la manera de poder medirlos.
• Los frameworks son referenciales, pero pueden ayudar. Incluso podrías contar con un prompt de sistema que actúe como validador, al cual le entregues directamente las preguntas, respuestas, contexto y tools para generar un score, y luego usarlo como guía para posibles mejoras.

RAGAS es buen framework para buscar idea y lugares comunes para medir a tus agentes.

El repositorio esta en el siguiente link:

https://github.com/Foco22/FA_Posts