Switch from Langfuse V4 to Confident AI

Overview

Langfuse SDK v4 (Python) and v5 (TypeScript) already run on OpenTelemetry. confident-trace speaks the same protocol, so the switch is an exporter swap: replace the Langfuse client wrapper with init(), rename the decorator, and keep every span you emit today.

In this guide, you will:

• Pick a migration method: one copyable prompt for your coding agent, manual, or by adding a Confident AI exporter to the OpenTelemetry setup Langfuse already runs.
• Install confident-trace and replace the Langfuse keys with one CONFIDENT_API_KEY.
• Replace the client setup with init() so auto instrumentation emits the spans.
• Rename @observe to @span so every trace carries a name, an input and an output.
• See what changes once the traces land in Confident AI: evals on every trace, datasets curated from production, alerts when quality drops.

Prerequisites

• A Project API Key, CONFIDENT_API_KEY (for example confident_us_proj_...). Retrieve yours here.
• Python 3.10+ for the Python SDK, or Node.js 22+ for the TypeScript SDK.
• Your existing Langfuse setup on Python SDK v4 (langfuse>=4, run pip show langfuse) or TypeScript SDK v4 or v5 (@langfuse/tracing, run npm ls @langfuse/tracing). The before snippets below follow the Langfuse quickstart as of September 2026.

Choose a Migration Method

Switch in One Prompt

Give the prompt below to your coding assistant, such as Claude Code, Cursor or Codex, from the root of your repository. It finds your Langfuse integration, confirms the SDK version, makes the changes from this guide, and tells you what still needs your hands. Review the diff before you merge it.

Migrate this codebase from Langfuse to Confident AI using confident-trace.

1. Find every Langfuse integration: imports of langfuse and @langfuse/*, @observe and observe(), get_client(), start_as_current_observation() and startActiveObservation(), langfuse.openai and observeOpenAI, LangfuseSpanProcessor, the Langfuse CallbackHandler, and LANGFUSE_* environment variables.
2. Confirm the installed Langfuse SDK version with pip show langfuse or npm ls @langfuse/tracing. This migration is for Langfuse Python SDK v4 and TypeScript SDK v4 or v5. If the major version is different, stop and tell me which version you found.
3. Make the changes from https://www.confident-ai.com/docs/guides/migrate-to-langfuse-alternative-v4:
   - install confident-trace and call init() once at startup, replacing the Langfuse client and LangfuseSpanProcessor setup
   - replace langfuse.openai and observeOpenAI with the plain OpenAI client
   - rename @observe and observe() to span, and start_as_current_observation() / startActiveObservation() to span(...) / withSpan()
   - move trace updates onto update_trace() (updateTrace() in TypeScript), with session_id as thread_id (threadId)
   - move span and generation updates onto update_span() (updateSpan())
   - keep generations for model calls auto instrumentation does not cover as LLM spans with update_span()
   - remove the Langfuse CallbackHandler from LangChain callbacks
   - replace the LANGFUSE_* variables with CONFIDENT_API_KEY, and the Langfuse flush calls with flush() / shutdown()
4. Preserve existing tracing behavior where possible: the same span names, nesting, inputs, outputs, users, sessions, tags and metadata.
5. Do not delete Langfuse prompt, dataset or score calls. List them for me instead.
6. When you are done, summarize every change and list anything that needs manual configuration, such as setting CONFIDENT_API_KEY, the EU endpoint, or model calls you could not map.

Switch Manually

1. Install confident-trace

   One package. Provider SDKs stay optional peers. CONFIDENT_API_KEY replaces LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_BASE_URL. For the EU region, also set CONFIDENT_OTEL_ENDPOINT=https://eu.otel.confident-ai.com/v1/traces.

   pip install confident-trace
   export CONFIDENT_API_KEY=...
   # replaces LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_BASE_URL

2. Replace the client wrapper with init()

   Drop the Langfuse import of OpenAI. Auto instrumentation emits the spans from the plain client.

   PythonTypeScript (alpha)

   from langfuse.openai import openai
   
   response = openai.chat.completions.create(
       model="gpt-4.1-mini",
       messages=[{"role": "user", "content": "Hello"}],
   )

3. Rename @observe to @span

   Same shape. Return values and exceptions pass through.

   PythonTypeScript (alpha)

   from langfuse import observe
   
   @observe()
   def answer(question: str) -> str:
       return openai.chat.completions.create(
           model="gpt-4.1-mini",
           messages=[{"role": "user", "content": question}],
       ).choices[0].message.content

Run your app once. The trace appears in your project's Observatory within seconds. If it does not, check that CONFIDENT_API_KEY is set in the same process and that the app flushes before it exits.

Switch Using OpenTelemetry

Langfuse SDK v4 (Python) and v4 or v5 (TypeScript) create OpenTelemetry spans. Add a Confident AI exporter next to the Langfuse one and every span reaches Confident AI as well. Your observe decorators, OpenAI wrappers and trace updates stay as they are.

1. Add the Confident AI exporter

   PythonTypeScript

   The OTLP exporter already ships with Langfuse v4, so there is nothing to install. Keep LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY set: without them, the Langfuse SDK creates no spans at all.

   import os
   
   from langfuse import get_client
   from opentelemetry import trace
   from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
   from opentelemetry.sdk.trace.export import BatchSpanProcessor
   
   langfuse = get_client()
   
   trace.get_tracer_provider().add_span_processor(
       BatchSpanProcessor(
           OTLPSpanExporter(
               endpoint="https://otel.confident-ai.com/v1/traces",
               headers={"x-confident-api-key": os.environ["CONFIDENT_API_KEY"]},
           )
       )
   )

   If you pass your own tracer_provider to Langfuse(), add the processor to that provider instead.

   For the EU region, use https://eu.otel.confident-ai.com/v1/traces.

2. Stop sending to Langfuse when you cut over

   While you compare, both platforms receive every trace. When you are ready, stop the Langfuse export. Spans are still created and still reach Confident AI.

   from langfuse import Langfuse
   
   langfuse = Langfuse(should_export_span=lambda span: False)

Run your app once. The trace appears in your project's Observatory within seconds.

What Carries Over

Every span on the provider is exported, including spans from other instrumentations such as HTTP clients. The Langfuse SDK stays in your app. To replace it with confident-trace and its auto instrumentation later, switch manually or with a coding agent.

What Changes

Tracing is where you start. Evals are where it pays off. Every trace gets a score. Low scores become dataset rows. Dataset rows become regression tests. Your next release ships against real production failures.

Migration Questions

Related

Last updated on October 5, 2026