Langfuse et OpenLLMetry : l’observabilité LLM de vos applications avec OpenTelemetry

Observabilité LLM avec Langfuse et OpenLLMetry : tracez vos applications, puis envoyez les mêmes spans OpenTelemetry vers Langfuse et votre backend.
Langfuse et OpenLLMetry : l'observabilité LLM de vos applications avec OpenTelemetry

Langfuse et OpenLLMetry sont deux projets open source qui répondent à la même question : que se passe-t-il vraiment à l’intérieur d’une application LLM ? Quel prompt a été envoyé, quels documents ont été récupérés, combien de tokens ont été consommés, quelle étape a pris trois secondes ? Sans traces ni observabilité LLM, une application RAG ou un agent reste une boîte noire, et chaque réponse étrange devient une enquête à l’aveugle.

Les deux projets ont une particularité qui intéresse directement les équipes SRE : ils parlent OpenTelemetry. OpenLLMetry est un ensemble d’instrumentations qui produisent des spans OpenTelemetry pour les appels aux LLM, aux bases vectorielles et aux frameworks. Langfuse est une plateforme d’ingénierie LLM (traces, gestion de prompts, évaluations, jeux de données) capable de recevoir ces traces via OTLP.

Cet article montre comment les combiner pour tracer une application LLM, et comment envoyer les mêmes traces vers un backend d’observabilité généraliste. Il complète notre article pilier sur l’observabilité de l’IA.

Langfuse et OpenLLMetry : qui fait quoi en observabilité LLM ?

OpenLLMetry : l’instrumentation

OpenLLMetry, maintenu par Traceloop sous licence Apache 2.0, fournit des instrumentations OpenTelemetry pour de nombreux fournisseurs de modèles (dont Ollama et les API compatibles OpenAI), des bases vectorielles (Chroma, Qdrant, Milvus…) et des frameworks (LangChain, LangGraph, LlamaIndex, CrewAI…). Le SDK traceloop-sdk les active d’un coup ; chaque instrumentation existe aussi sous forme de paquet séparé si l’on préfère configurer OpenTelemetry soi-même.

Les spans portent des attributs inspirés des conventions sémantiques OpenTelemetry pour l’IA générative (gen_ai.* : modèle demandé, tokens d’entrée et de sortie, etc.). Ces conventions sont encore en cours de stabilisation : les noms exacts peuvent varier selon les versions.

Langfuse : l’analyse spécifique aux LLM

Langfuse stocke les traces et les présente sous un angle LLM : arbre des appels, prompts et réponses complets, coûts estimés, sessions utilisateur, scores d’évaluation et retours utilisateurs. Il s’auto-héberge (la documentation décrit des déploiements Docker Compose et Kubernetes) ou s’utilise en version cloud. Son point d’entrée OpenTelemetry est /api/public/otel, en OTLP sur HTTP (JSON ou protobuf) ; selon la documentation, gRPC n’est pas pris en charge à ce jour.

Et le backend d’observabilité ?

Langfuse est excellent pour l’équipe qui construit l’application. L’équipe d’exploitation, elle, veut voir les appels LLM dans le contexte du reste : service appelant, base de données, infrastructure, déploiements. C’est le rôle d’un backend généraliste compatible OTLP, comme Dynatrace. OpenTelemetry permet d’alimenter les deux à partir d’une seule instrumentation.

Architecture : une instrumentation, deux destinations

  1. L’application est instrumentée avec OpenLLMetry.
  2. Les spans partent en OTLP vers un OpenTelemetry Collector.
  3. Le Collector les envoie à la fois vers Langfuse (analyse LLM) et vers le backend d’observabilité (vue de bout en bout).

Le Collector centralise les secrets, permet de filtrer ou masquer des attributs sensibles (les prompts peuvent contenir des données personnelles) et évite de coupler l’application à un fournisseur.

En pratique : tracer une application LLM avec OpenTelemetry

Étape 1 — Instrumenter l’application

pip install traceloop-sdk
from traceloop.sdk import Traceloop
from traceloop.sdk.decorators import workflow

Traceloop.init(app_name="assistant-runbooks")

@workflow(name="repondre_question")
def repondre(question: str) -> str:
    # appels au LLM, au retriever, etc. : instrumentés automatiquement
    ...

Les décorateurs (workflow, task, agent, tool) regroupent les spans automatiques sous des étapes nommées. En développement, l’option disable_batch=True envoie les spans immédiatement.

Étape 2 — Pointer vers le Collector

Le SDK lit sa destination dans des variables d’environnement. Pour un Collector local en OTLP/HTTP :

export TRACELOOP_BASE_URL="http://otel-collector:4318"
# ne pas collecter le contenu des prompts et réponses :
export TRACELOOP_TRACE_CONTENT=false

Vérifiez dans la documentation d’OpenLLMetry le comportement exact de cette variable et de TRACELOOP_HEADERS, ainsi que les options de confidentialité.

Étape 3 — Configurer le Collector pour deux destinations

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch: {}

exporters:
  otlphttp/langfuse:
    endpoint: "https://langfuse.interne/api/public/otel"
    headers:
      Authorization: "Basic ${env:LANGFUSE_AUTH}"
  otlphttp/dynatrace:
    endpoint: "https://${env:DT_ENV_ID}.live.dynatrace.com/api/v2/otlp"
    headers:
      Authorization: "Api-Token ${env:DT_API_TOKEN}"

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/langfuse, otlphttp/dynatrace]

LANGFUSE_AUTH est l’encodage base64 de clé_publique:clé_secrète du projet Langfuse. Le jeton Dynatrace doit porter le droit d’ingestion des traces OpenTelemetry. Langfuse peut demander des en-têtes supplémentaires selon sa version : la documentation de Langfuse fait foi.

Étape 4 — Vérifier dans les deux outils

Dans Langfuse, chaque requête apparaît comme une trace avec ses générations, son coût estimé et le contenu des prompts. Dans le backend d’observabilité, les mêmes spans s’insèrent dans la trace distribuée du service appelant. Pour relier proprement le clic utilisateur, le service et l’appel LLM, voir OpenTelemetry de bout en bout.

Étape 5 — Définir les indicateurs à suivre

  • latence par étape (récupération, génération, outils) et au total ;
  • tokens d’entrée et de sortie par requête, par modèle et par fonctionnalité ;
  • taux d’erreurs et de dépassements de délai des appels au modèle ;
  • scores de qualité (évaluations, retours utilisateurs) suivis dans Langfuse.

Pour les agents qui appellent des outils via MCP, la même approche s’applique : voir observer des agents MCP avec OpenTelemetry.

Observabilité LLM avec Langfuse : que révèle une trace bien instrumentée ?

Quelques diagnostics deviennent possibles dès que les traces sont en place :

  • La réponse est fausse : la trace montre si le retriever a ramené les bons documents. Si oui, le problème est dans le prompt ou le modèle ; sinon, dans l’indexation.
  • La latence a doublé : on voit immédiatement si c’est la génération (prompt plus long, modèle plus lent), un outil externe ou la base vectorielle.
  • Les coûts dérivent : le nombre de tokens par requête révèle un contexte qui grossit, une boucle d’agent ou un historique de conversation jamais tronqué.
  • Un agent tourne en rond : la répétition des mêmes appels d’outils saute aux yeux dans l’arbre des spans.

Bonnes pratiques

  • Décidez explicitement si le contenu des prompts et des réponses est collecté ; masquez-le au Collector si nécessaire.
  • Renseignez service.name et l’environnement pour distinguer production et tests.
  • Ajoutez un identifiant de session ou d’utilisateur (pseudonymisé) pour regrouper les traces.
  • Échantillonnez les traces à fort volume, mais conservez les erreurs.
  • Fixez les versions des instrumentations : les attributs gen_ai.* évoluent encore.
  • Surveillez le Collector lui-même : s’il tombe, vous perdez la visibilité sur les deux destinations.

Questions fréquentes

Faut-il utiliser le SDK Langfuse ou OpenLLMetry ?

Le SDK Langfuse est le chemin le plus direct si Langfuse est la seule destination. OpenLLMetry, ou toute instrumentation OpenTelemetry standard, est préférable si les traces doivent aussi alimenter d’autres backends.

Langfuse remplace-t-il un outil d’observabilité ?

Non. Langfuse se concentre sur l’application LLM (prompts, coûts, évaluations). L’infrastructure, les autres services et les SLO restent du ressort d’un backend généraliste.

Peut-on tracer un modèle servi localement ?

Oui. OpenLLMetry instrumente notamment le client Ollama et les API compatibles OpenAI ; côté serveur, voir superviser Ollama pour les métriques d’inférence.

Conclusion

Langfuse et OpenLLMetry forment un duo cohérent : une instrumentation standard d’un côté, une analyse spécialisée de l’autre, reliées par OpenTelemetry. En ajoutant un Collector au milieu, la même trace sert à la fois l’équipe qui améliore les prompts et l’équipe qui garantit la fiabilité du service.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC ni aux projets cités. Les marques citées appartiennent à leurs propriétaires. Les outils évoluent vite : vérifiez les commandes et options dans leur documentation officielle.

Total
0
Shares
6 comments
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Dify et n8n : orchestrer des workflows IA open source, cas d'usage ops

Dify et n8n : orchestrer des workflows IA open source, cas d’usage ops

Next Post
CrewAI/AutoGen : construire des systèmes multi-agents, et l'observabilité CrewAI avec OpenTelemetry

CrewAI/AutoGen : construire des systèmes multi-agents, et l’observabilité CrewAI avec OpenTelemetry

Related Posts