Información general

El SDK de LLM Observability para Python proporciona integraciones que automáticamente rastreen y anoten llamadas a marcos de LLM y bibliotecas. Sin cambiar tu código, puedes obtener trazas y la observabilidad de las llamadas que tu aplicación de LLM hace a los siguientes marcos:

Puedes habilitar mediante programación el rastreo automático de llamadas de LLM a un modelo LLM compatible como OpenAI o un marco como LangChain configurando integrations_enabled en true en la función LLMOBs.enable(). Además de capturar la latencia y los errores, las integraciones capturan los parámetros de entrada, los mensajes de entrada y salida y el uso de tokens (si está disponible) de cada llamada rastreada.

Nota: Cuando se utilizan los marcos o bibliotecas compatibles de LLM Observability, no se requiere ninguna instrumentación manual adicional (como los decoradores de función) para capturar estas llamadas. Para llamadas personalizadas o adicionales dentro de tu aplicación de LLM que no se rastrean automáticamente (como llamadas a la API, consultas a bases de datos o funciones internas), puedes usar decoradores de función para rastrear manualmente estas operaciones y capturar tramos (spans) detallados para cualquier parte de tu aplicación que no esté cubierta por la instrumentación automática.

Activar y desactivar integraciones

Todas las integraciones están activadas por defecto.

Para desactivar todas las integraciones, utiliza la configuración del SDK en el código y especifica integrations_enabled=False.

Para activar sólo determinadas integraciones:

1. Utiliza la configuración del SDK en el código, especificando integrations_enabled=False.
2. Habilita manualmente la integración con ddtrace.patch() en la parte superior del archivo de entrada de tu aplicación de LLM:

from ddtrace import patch
from ddtrace.llmobs import LLMObs

LLMObs.enable(integrations_enabled=False, ...)
patch(openai=True)
patch(langchain=True)
patch(anthropic=True)
patch(gemini=True)
patch(botocore=True)

Nota: Utiliza botocore como nombre de la integración de Amazon Bedrock al habilitarla manualmente.

OpenAI

La integración de OpenAI proporciona un rastreo automático para los endpoints de finalización del SDK de OpenAI Python y finalización del chat a OpenAI y Azure OpenAI.

Métodos rastreados

La integración de OpenAI instrumenta los siguientes métodos, incluidas las llamadas trasmitidas:

• Finalizaciones:
  • OpenAI().completions.create(), AzureOpenAI().completions.create()
  • AsyncOpenAI().completions.create(), AsyncAzureOpenAI().completions.create()
• Finalizaciones del chat:
  • OpenAI().chat.completions.create(), AzureOpenAI().chat.completions.create()
  • AsyncOpenAI().chat.completions.create(), AsyncAzureOpenAI().chat.completions.create()

LangChain

La integración de LangChain proporciona un rastreo automático para el LLM del SDK de LangChain Python, el modelo de chat y las llamadas a cadenas.

Métodos rastreados

La integración de LangChain instrumenta los siguientes métodos:

• LLMs:
  • llm.invoke(), llm.ainvoke()
  • llm.stream(), llm.astream()
• Modelos de chat
  • chat_model.invoke(), chat_model.ainvoke()
  • chat_model.stream(), chat_model.astream()
• Cadenas/LCEL
  • chain.invoke(), chain.ainvoke()
  • chain.batch(), chain.abatch()
  • chain.stream(), chain.astream()
• Incrustaciones
  • OpenAI : OpenAIEmbeddings.embed_documents(), OpenAIEmbeddings.embed_query()
• Herramientas
  • BaseTool.invoke(), BaseTool.ainvoke()
• Recuperación
  • langchain_community.<vectorstore>.similarity_search()
  • langchain_pinecone.similarity_search()

Amazon Bedrock

La integración de Amazon Bedrock proporciona rastreo automático para las llamadas al modelo de chat del SDK de Amazon Bedrock Runtime Python (utilizando Boto3/Botocore).

Métodos rastreados

La integración de Amazon Bedrock instrumenta los siguientes métodos:

• Mensajes de chat:
  • InvokeModel
• Mensajes de chat transmitidos:
  • InvokeModelWithResponseStream

Nota: La integración de Amazon Bedrock aún no admite el rastreo de llamadas de incrustación.

Anthropic

La integración de Anthropic proporciona rastreo automático para las llamadas de mensajes de chat del SDK de Anthropic Python.

Métodos rastreados

La integración de Anthropic instrumenta los siguientes métodos:

• Mensajes de chat (incluidas las llamadas trasmitidas):
  • Anthropic().messages.create(), AsyncAnthropic().messages.create()
• Mensajes de chat transmitidos:
  • Anthropic().messages.stream(), AsyncAnthropic().messages.stream()

Google Gemini

La integración de Google Gemini proporciona un rastreo automático para las llamadas de generación de contenido del SDK de Google AI Python.

Métodos rastreados

La integración de Google Gemini instrumenta los siguientes métodos:

• Generación de contenido (incluidas las llamadas trasmitidas):
  • model.generate_content() (También captura chat.send_message())
  • model.generate_content_async() (También captura chat.send_message_async())

Vertex AI

La integración de Vertex AI rastrea automáticamente la generación de contenido y las llamadas de mensajes de chat realizadas a través del SDK DE Vertex AI Python de Google.

Métodos rastreados

La integración de Vertex AI instrumenta los siguientes métodos:

• Generación de contenido (incluidas las llamadas trasmitidas):

  • model.generate_content()
  • model.generate_content_async()

• Mensajes de chat (incluidas las llamadas trasmitidas):

  • chat.send_message()
  • chat.send_message_async()

Información general

El SDK de LLM Observability Node.js de Datadog proporciona integraciones que rastrean automáticamente y anotan llamadas a marcos y bibliotecas de LLM. Sin cambiar tu código, puedes obtener trazas y la observabilidad de las llamadas que tu aplicación de LLM hace a los siguientes marcos:

Además de capturar la latencia y los errores, las integraciones capturan los parámetros de entrada, los mensajes de entrada y salida y el uso de tokens (cuando está disponible) de cada llamada rastreada.

Activar y desactivar integraciones

Todas las integraciones están activadas por defecto.

Para desactivar todas las integraciones, utiliza la configuración del SDK en el código y especifica plugins: false en la configuración del rastreador general.

const tracer = require('dd-trace').init({
  llmobs: { ... },
  plugins: false
});
const { llmobs } = tracer;

Para activar sólo determinadas integraciones:

1. Utiliza la configuración del SDK en el código, especificando plugins: false.
2. Habilita manualmente la integración con tracer.use() en la parte superior del archivo de entrada de tu aplicación de LLM:

const tracer = require('dd-trace').init({
  llmobs: { ... },
  plugins: false
});

const { llmobs } = tracer;
tracer.use('openai', true);

Además, puedes configurar las siguientes variables de entorno para tener un control más específico sobre la aplicación de parches en la biblioteca y la integración que inicia el tramo:

DD_TRACE_DISABLED_PLUGINS

Ejemplo: DD_TRACE_DISABLED_PLUGINS=openai,http
Una cadena separada por comas de nombres de integración desactivados automáticamente cuando se inicializa el rastreador.

DD_TRACE_DISABLED_INSTRUMENTATIONS

Ejemplo: DD_TRACE_DISABLED_INSTRUMENTATIONS=openai,http
Una cadena separada por comas de nombres de biblioteca que no se parchean cuando se inicializa el rastreador.

OpenAI

La integración de OpenAI proporciona el rastreo automático para los endpoints de finalización del SDK de OpenAI Node.js, finalización del chat e incrustaciones.

Métodos rastreados

La integración de OpenAI instrumenta los siguientes métodos, incluidas las llamadas trasmitidas:

• Finalizaciones:
  • openai.completions.create()
• Finalizaciones del chat:
  • openai.chat.completions.create()
• Incrustaciones:
  • openai.embeddings.create()

Soporte de ESM

La integración de OpenAI para el rastreador de Node.js no es compatible en ESM. Para utilizar OpenAI junto con dd-trace en tus proyectos de ESM sin errores, crea el siguiente script:

// register.mjs

import { register } from 'node:module';

register("import-in-the-middle/hook.mjs", import.meta.url, {
  parentURL: import.meta.url,
  data: { include: ["openai"]}, // this is the important bit here
});

Y empieza tu aplicación con:

DD_SITE=<YOUR_DATADOG_SITE> node --import ./register.js --require dd-trace/init script.js

Esto evita cualquier problema de compatibilidad con OpenAI y dd-trace en los proyectos de ESM.

En este caso, el rastreo no se utiliza para las llamadas de OpenAI. Para añadir este rastreo para LLM Observability, puedes instrumentar tus llamadas a OpenAI con el método llmobs.trace().

const tracer = require('dd-trace').init({
  llmobs: { ... }
});

// user application code

function makeOpenAICall (input) {
  // user code
  const response = await llmobs.trace({ kind: 'llm', name: 'openai.createChatCompletion', modelName: 'gpt-4', modelProvider: 'openai' }, async () => {
    const res = await openai.chat.completions.create({ ... });
    llmobs.annotate({
      inputData: input,
      outputData: res.choices[0].message.content
    })

    return res;
  });

  // user code to do something with `response`
}

Compatibilidad con la agrupación

Para utilizar las integraciones de LLM Observability en aplicaciones empaquetadas (esbuild, Webpack, Next.js), debes excluir los módulos de esas integraciones del empaquetado.

Si estás utilizando esbuild, o para obtener información más específica sobre por qué el rastreo no funciona directamente con los agrupadores, consulta Agrupación con el rastreador de Node.js.

Para la agrupación de Webpack o Next.js, especifica la integración correspondiente en la sección externals de la configuración de webpack:

// next.config.js
module.exports = {
  webpack: (config) => {
    // this may be a necessary inclusion
    config.resolve.fallback = {
      ...config.resolve.fallback,
      graphql: false,
    }

    // exclude OpenAI from bundling
    config.externals.push('openai')

    return config
  }
}

// webpack.config.js
module.exports = {
  resolve: {
    fallback: {
      graphql: false,
    }
  },
  externals: {
    openai: 'openai'
  }
}