En el campo en constante evolución de las solicitudes de LLM, lograr una observabilidad sólida es crucial para garantizar un rendimiento y una confiabilidad óptimos. Sin embargo, debido a su complejidad y escala, rastrear y almacenar eventos en tiempo de ejecución en las solicitudes de LLM no es fácil. Para abordar estos desafíos, hemos lanzado MyScale Telemetry (opens new window), que se integra con LangChain Callbacks (opens new window).
Este callback captura de manera fluida los datos de rastreo de las solicitudes de LLM basadas en LangChain y los almacena en la MyScaleDB (opens new window), lo que facilita el diagnóstico de problemas, la optimización del rendimiento y la comprensión del comportamiento del modelo. MyScale Telemetry proporciona capacidades similares a LangSmith (opens new window), incluyendo el rastreo y la evaluación de solicitudes de LLM, y sirve como una alternativa de código abierto a LangSmith. Además, dado que MyScaleDB es compatible con ClickHouse, MyScale Telemetry se puede utilizar directamente con ClickHouse.
En las siguientes secciones, detallaremos las funciones y el uso de MyScale Telemetry.
# Cómo Funciona MyScale Telemetry
La integración de MyScale Telemetry con LangChain es sencilla. El Controlador de Callback crea automáticamente un rastreo anidado para cada evento en tiempo de ejecución de tus solicitudes de LangChain. Estos eventos en tiempo de ejecución incluyen:
on_chain_starton_chain_endon_llm_starton_llm_endon_chat_model_starton_retriever_starton_retriever_endon_tool_starton_tool_endon_tool_erroron_chain_erroron_retriever_erroron_llm_error
Los datos de eventos en tiempo de ejecución recopilados se organizan en datos de rastreo, similares a los datos de rastreo de OpenTelemetry (opens new window), y se almacenan en la base de datos de MyScale en una tabla de datos de rastreo dedicada. La estructura de la tabla es la siguiente:
CREATE TABLE tu_nombre_de_base_de_datos.tu_nombre_de_tabla
(
`TraceId` String CODEC(ZSTD(1)),
`SpanId` String CODEC(ZSTD(1)),
`ParentSpanId` String CODEC(ZSTD(1)),
`StartTime` DateTime64(9) CODEC(Delta(8), ZSTD(1)),
`EndTime` DateTime64(9) CODEC(Delta(8), ZSTD(1)),
`Duration` Int64 CODEC(ZSTD(1)),
`SpanName` LowCardinality(String) CODEC(ZSTD(1)),
`SpanKind` LowCardinality(String) CODEC(ZSTD(1)),
`ServiceName` LowCardinality(String) CODEC(ZSTD(1)),
`SpanAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)),
`ResourceAttributes` Map(LowCardinality(String), String) CODEC(ZSTD(1)),
`StatusCode` LowCardinality(String) CODEC(ZSTD(1)),
`StatusMessage` String CODEC(ZSTD(1)),
INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 1,
INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_span_attr_key mapKeys(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_span_attr_value mapValues(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
INDEX idx_duration Duration TYPE minmax GRANULARITY 1
)
ENGINE = MergeTree()
PARTITION BY toDate(StartTime)
ORDER BY (SpanName, toUnixTimestamp(StartTime), TraceId);
Luego, los usuarios pueden analizar estos datos de rastreo para depurar y mejorar sus solicitudes de LLM de manera efectiva. MyScale Telemetry garantiza un impacto mínimo en el rendimiento al tiempo que proporciona información de observabilidad detallada, lo que permite a los desarrolladores obtener una comprensión más profunda del comportamiento y el rendimiento de sus aplicaciones.
# Uso de Ejemplo
Te guiaremos a través de un ejemplo completo para ayudarte a comenzar con MyScale Telemetry. Este ejemplo incluye la configuración de MyScaleDB (opens new window) y Grafana Dashboard (opens new window) para almacenar y monitorear los datos de rastreo y el uso de Ragas (opens new window) para evaluarlos. Sigue estos pasos para configurarlo y utilizarlo de manera efectiva:
# Configurar MyScaleDB y Grafana
Primero, configura una instancia de MyScaleDB y Grafana utilizando Docker Compose. El archivo docker-compose.yml se puede encontrar aquí (opens new window). Ejecuta el siguiente comando para iniciar los contenedores:
docker-compose up -d
# Instalar los Paquetes Requeridos
A continuación, instala el paquete MyScale Telemetry junto con LangChain y la integración de LangChain con OpenAI y Ragas utilizando pip:
pip install myscale-telemetry langchain_openai ragas
# Construir una Cadena Simple
Luego, construye una cadena simple de LangChain e intégrala con MyScaleCallbackHandler para la recopilación de datos de rastreo.
import os
from myscale_telemetry.handler import MyScaleCallbackHandler
from operator import itemgetter
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import MyScale
from langchain_community.vectorstores.myscale import MyScaleSettings
from langchain_core.runnables import RunnableConfig
# Configura las variables de entorno para OpenAI y MyScale Cloud/MyScaleDB:
os.environ["OPENAI_API_KEY"] = "TU_CLAVE_DE_OPENAI"
os.environ["MYSCALE_HOST"] = "YOUR_MYSCALE_HOST"
os.environ["MYSCALE_PORT"] = "YOUR_MYSCALE_HOST"
os.environ["MYSCALE_USERNAME"] = "YOUR_MYSCALE_USERNAME"
os.environ["MYSCALE_PASSWORD"] = "YOUR_MYSCALE_PASSWORD"
# Crea una tienda de vectores y un recuperador utilizando MyScale y los vectores de OpenAI:
texts = [
"Harrison trabajó en Kensho.",
"Alice es una ingeniera de software.",
"Bob disfruta hacer senderismo los fines de semana.",
"Claire está estudiando ciencia de datos.",
"David trabaja en una startup de tecnología.",
"Eva ama tocar el piano.",
"Frank es un diseñador gráfico.",
"Grace es una investigadora de inteligencia artificial.",
"Henry es un escritor independiente.",
"Isabel está aprendiendo aprendizaje automático."
]
myscale_settings = MyScaleSettings()
myscale_settings.index_type = 'SCANN'
vectorstore = MyScale.from_texts(texts, embedding=OpenAIEmbeddings(), config=myscale_settings)
retriever = vectorstore.as_retriever()
# Configura el llm y la plantilla de la solicitud:
model = ChatOpenAI()
template = """Responde la pregunta basándote únicamente en el siguiente contexto:
{context}
Pregunta: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
# Crea la cadena
chain = (
{
"context": itemgetter("question") | retriever,
"question": itemgetter("question"),
}
| prompt
| model
| StrOutputParser()
)
# Integra MyScaleCallbackHandler para capturar datos de rastreo durante la ejecución de la cadena:
chain.invoke({"question": "¿Dónde trabajó Harrison?"}, config=RunnableConfig(
callbacks=[
MyScaleCallbackHandler()
]
))
Después de ejecutarlo correctamente, podrás encontrar los datos de rastreo correspondientes en la tabla otel.otel_traces en MyScaleDB.
Para personalizar MyScaleCallbackHandler, consulta la documentación: Parámetros Personalizados de MyScale Telemetry (opens new window).
# Observabilidad
Para mostrar los datos de rastreo recopilados a través de MyScale Telemetry de la ejecución de la Aplicación de LLM de manera fácil y clara, también proporcionamos un Tablero de Rastreo de Grafana (opens new window). El tablero permite a los usuarios monitorear el estado de la Aplicación de LLM, similar a LangSmith, lo que facilita la depuración y mejora de su rendimiento.
El ejemplo de Docker Compose lanza una instancia de Grafana en http://localhost:3000 (opens new window). Usa el nombre de usuario admin y la contraseña admin para iniciar sesión.
# Configurar el Tablero de Rastreo
Después de haber recopilado datos de rastreo utilizando el Controlador de MyScale Telemetry, sigue estos pasos para configurar el Tablero de Rastreo de MyScale:
Instalar el complemento Grafana-clickhouse-datasource (opens new window):
Agregar un nuevo Origen de Datos ClickHouse en Grafana:
En la configuración del Origen de Datos de Grafana, agrega un nuevo Origen de Datos ClickHouse. La Dirección del Servidor, el Puerto del Servidor, el Nombre de Usuario y la Contraseña deben corresponder al Host, Puerto, Nombre de Usuario y Contraseña de MyScaleDB utilizado. Para el ejemplo de Docker Compose proporcionado, estos valores son:
- Address:
myscaledb - Port:
9000 - Username:
default - Password:
default
- Address:
Importar el Tablero de Rastreo de MyScale:
Una vez que se haya agregado el Origen de Datos ClickHouse, puedes importar el Tablero de Rastreo de MyScale (opens new window).
Configurar el Tablero:
Después de importarlo, selecciona el Clúster de MyScale (Nombre del Origen de Datos ClickHouse), el nombre de la base de datos, el nombre de la tabla y el TraceID del rastreo que deseas analizar. El tablero mostrará la Tabla de Rastreos y el Panel de Detalles del Rastreo del rastreo seleccionado.
# Información del Tablero de Rastreo de MyScale
El Tablero de Rastreo de MyScale proporciona información completa sobre el comportamiento en tiempo de ejecución de tus solicitudes de LLM, similar a LangSmith. Muestra información crítica que ayuda en la depuración, la optimización y la comprensión del rendimiento de tus aplicaciones.
# Tiempos de Ejecución de las Funciones
El tablero muestra el tiempo de ejecución de cada función en tu aplicación de LangChain, lo que te ayuda a identificar cuellos de botella de rendimiento.
# Entrada y Salida
El tablero proporciona una vista detallada de la entrada y salida general de tu cadena, lo que facilita el seguimiento del flujo de datos a través de tu aplicación.
# Retornos del Recuperador de la Base de Datos
Muestra los datos específicos devueltos por el recuperador de la base de datos, lo que te permite verificar que se están recuperando y utilizando los datos correctos en tus solicitudes.
# Información de la Solicitud
Puedes ver las solicitudes exactas que se generan y se envían al LLM, lo cual es esencial para garantizar la corrección y relevancia de las preguntas formuladas.
# Salidas de ChatOpenAI
También se muestran las salidas generadas por ChatOpenAI, lo que proporciona claridad sobre cómo responde el LLM a las solicitudes.
Además, se muestran detalles del uso de tokens para ayudarte a monitorear y optimizar el costo asociado con las llamadas a la API del LLM.
# Evaluación con Ragas
Los datos de rastreo almacenados en MyScaleDB se pueden utilizar para analizar y evaluar su canalización RAG con Ragas (opens new window), que es un popular marco de evaluación RAG de código abierto.
El siguiente código en Python ilustra cómo puntuar un rastreo con RAGAS evaluando los contextos recuperados y la respuesta generada:
import os
from datasets import Dataset
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_utilization
from clickhouse_connect import get_client
def score_with_ragas(query, chunks, answer):
test_dataset = Dataset.from_dict({"question": [query], "contexts": [chunks], "answer": [answer]})
result = evaluate(test_dataset, metrics=[faithfulness, answer_relevancy, context_utilization])
return result
def evaluate_trace(question, topk, client, database_name, table_name):
trace_id, answer = client.query(
f"SELECT TraceId, SpanAttributes['output'] as Answer FROM {database_name}.{table_name} WHERE SpanAttributes['question'] = '{question}' AND ParentSpanId = ''"
).result_rows[0]
span_dict = client.query(
f"SELECT SpanAttributes FROM {database_name}.{table_name} WHERE TraceId = '{trace_id}' AND SpanKind = 'retriever'"
).result_rows[0][0]
contexts = [span_dict.get(f"documents.{i}.content") for i in range(topk)]
print(score_with_ragas(question, contexts, answer))
test_question = "¿Dónde trabajó Harrison?"
client = get_client(
host=os.getenv("MYSCALE_HOST"),
port=int(os.getenv("MYSCALE_PORT")),
username=os.getenv("MYSCALE_USERNAME"),
password=os.getenv("MYSCALE_PASSWORD"),
)
evaluate_trace(test_question, 4, client, "otel", "otel_traces")
Después de ejecutar el ejemplo, podrás evaluar el rendimiento de tu canalización RAG utilizando las puntuaciones proporcionadas por Ragas.
# Conclusión
MyScale Telemetry ofrece una solución sólida y de código abierto para mejorar la observabilidad y la evaluación de las solicitudes de LLM. Al integrarse perfectamente con LangChain Callbacks, captura datos de rastreo detallados y los almacena en MyScaleDB, lo que facilita el diagnóstico de problemas, la optimización del rendimiento y la comprensión del comportamiento de la aplicación.
El Tablero de Rastreo de MyScale en Grafana proporciona visualizaciones claras de estos datos de rastreo, lo que te ayuda a monitorear y depurar tus solicitudes de LLM de manera efectiva. Los conocimientos clave incluyen los tiempos de ejecución de las funciones, el seguimiento de la entrada y salida, los retornos del recuperador de la base de datos, la información de la solicitud, las salidas de ChatOpenAI y el uso de tokens.
Además, la integración de RAGAS con MyScale Telemetry permite una evaluación completa de las canalizaciones RAG. Utilizando los datos de rastreo almacenados en MyScaleDB, RAGAS puede evaluar métricas como la fidelidad, la relevancia de la respuesta y la utilización del contexto, asegurando resultados de alta calidad y mejora continua.
Te animamos a probar MyScale Telemetry y el Tablero de Grafana para aprovechar al máximo estas herramientas poderosas. Si tienes alguna pregunta o necesitas ayuda adicional, no dudes en comunicarte con nuestro equipo de soporte.
