?
OutilintermédiaireVérifié le 2025-05

Observabilité LLM : logs, traces, métriques

Instrumenter vos déploiements LLM avec OpenTelemetry, Langfuse ou Helicone.

Pourquoi l'observabilité LLM est différente

Les LLMs ajoutent des dimensions d'observabilité absentes des services classiques : qualité des réponses, coûts par requête, comportement non-déterministe, et chaînes d'appels complexes (RAG, agents). Les outils traditionnels ne suffisent pas.

Les trois piliers

1. Traces (chaînes d'appels)

Tracer chaque étape d'un pipeline RAG ou agent :

User Query → Embedding (50ms) → Retrieval (120ms) → Reranking (200ms) → LLM (2.1s) → Response

2. Métriques

  • Latence (TTFT, total, par étape)
  • Coût (tokens input/output, prix par requête)
  • Qualité (scores de pertinence, taux de fallback)
  • Volume (requêtes/min, tokens/min)

3. Logs (contenu)

  • Prompts envoyés et réponses reçues
  • Documents récupérés et scores
  • Erreurs et retries

Langfuse : observabilité LLM open source

from langfuse import Langfuse
from langfuse.decorators import observe

langfuse = Langfuse()

@observe()
def rag_pipeline(question: str):
    # Chaque étape est automatiquement tracée
    docs = retrieve_documents(question)
    response = generate_answer(question, docs)
    return response

@observe()
def retrieve_documents(query: str):
    # Tracé comme span enfant
    embeddings = embed(query)
    results = vector_search(embeddings)
    return results

Langfuse fournit un dashboard avec : - Vue des traces complètes - Coûts agrégés par utilisateur/feature - Latences p50/p95/p99 - Scores de qualité (via feedback ou eval)

Helicone : proxy d'observabilité

# Juste changer le base_url
import openai

client = openai.OpenAI(
    base_url="https://oai.helicone.ai/v1",
    default_headers={"Helicone-Auth": "Bearer sk-..."}
)

Helicone intercepte tous les appels LLM et fournit : - Dashboard de coûts en temps réel - Rate limiting et caching intégrés - Alertes sur les anomalies

OpenTelemetry pour LLM

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider

provider = TracerProvider()
trace.set_tracer_provider(provider)
tracer = trace.get_tracer("llm-service")

with tracer.start_as_current_span("llm_call") as span:
    span.set_attribute("llm.model", "gpt-4o")
    span.set_attribute("llm.tokens.input", token_count)
    span.set_attribute("llm.tokens.output", output_tokens)
    span.set_attribute("llm.cost", cost)
    response = call_llm(prompt)

Métriques essentielles à monitorer

  • Coût/requête : Détecter les prompts trop longs ou les boucles d'agents
  • Latence p95 : Identifier les outliers (requêtes longues)
  • Taux d'erreur : Rate limits, timeouts, modèle indisponible
  • Token utilisation : Ratio input/output, optimisation possible
  • Qualité : Taux de thumbs down, scores d'évaluation automatique

Alertes recommandées

  • Coût journalier > 2x la moyenne
  • Latence p95 > 10s
  • Taux d'erreur > 5%
  • Score qualité moyen en baisse de 10%

Sources

infraobservabilitémonitoring