Langfuse — The Open-Source LLM Observability Platform

Every LLM application ships with a question the developer cannot answer: what is actually happening inside my production agents? Which prompt variant performs better? Where does quality degrade across a 12-step chain? Why did that user session fail? Langfuse is the open-source answer to those questions — a full observability and experimentation stack built specifically for LLM applications.

Part of our Developer Tools category.

At a Glance

The Problem Langfuse Solves

LLM applications are opaque in ways traditional software is not. A REST API either returns 200 or it doesn’t. An LLM chain might return technically valid text that is subtly wrong — the wrong prompt version was deployed, a retrieval step returned stale context, a tool call was made with bad parameters, or a model cost 10× what was budgeted without anyone noticing.

Langfuse instruments LLM applications the way APM tools instrument microservices — but with LLM-specific concepts: traces that capture multi-step chains as hierarchical spans, eval pipelines that score output quality automatically, prompt registries that track versions in production, and experiment frameworks that let you compare prompt variants on real data before deploying.

The question Langfuse is positioned to answer is not did it crash? but is it good?

The ClickHouse Acquisition

In January 2026, ClickHouse acquired Langfuse following ClickHouse’s $400M Series D round at a $15B valuation. This is relevant context for evaluation: Langfuse is no longer an independent startup but a product line inside one of the largest open-source database companies in the world.

What changed: the storage architecture. Langfuse’s self-hosted deployment previously used PostgreSQL alone. The current architecture uses a dual-storage design — PostgreSQL for structured metadata and ClickHouse for high-volume telemetry ingestion. This gives Langfuse the ability to handle hundreds of thousands of traces per day without the write contention that plagued earlier versions. It also represents a meaningful infrastructure dependency for self-hosters who did not previously run ClickHouse.

What did not change: the MIT license on the core product, the open-source development model, and the public roadmap.

Core Features

Tracing

The primary interface for production observability is Langfuse’s hierarchical trace model. Each user interaction or workflow execution becomes a trace. Inside a trace, every LLM call, tool invocation, retrieval step, and custom span becomes a nested observation. The resulting visualization shows the entire execution tree: inputs, outputs, latency, token counts, and cost at each step.

The SDK supports two instrumentation styles. The decorator approach wraps existing functions with minimal code changes:

from langfuse.decorators import observe, langfuse_context

@observe()
def run_chain(user_input: str) -> str:
    # your LLM logic here
    return result

The low-level approach provides explicit span management for cases where you need fine-grained control over what gets recorded and how.

A drop-in OpenAI wrapper is available that requires no changes beyond swapping the import — all OpenAI API calls are automatically traced:

from langfuse.openai import openai  # drop-in replacement

Integrations exist for LangChain (callback handler), LlamaIndex (instrumentation), Haystack (component-level tracing), PydanticAI, and 20+ other frameworks.

Evaluations

Tracing tells you what happened. Evaluations tell you whether it was good.

Langfuse supports three evaluation modes:

LLM-as-a-judge: Configure an evaluation prompt that scores a trace output on a dimension (accuracy, tone, groundedness, etc.) using any supported LLM model. Evals run automatically on incoming traces in production. Results appear as scores attached to individual observations.

Heuristic evals: Code-based functions that compute deterministic scores — regex matches, JSON schema validation, word count checks, exact match, etc.

Human review: The Langfuse UI includes a scoring interface for human annotators. Review queues can be assigned to team members or external reviewers.

All three score types aggregate in the same data model, making it straightforward to correlate automated evals with human ratings.

Prompt Management

Langfuse provides a centralized prompt registry that decouples prompts from application code. Prompts are versioned, tagged, and deployable through the UI without code deploys. Applications fetch the latest production prompt at runtime:

from langfuse import Langfuse

lf = Langfuse()
prompt = lf.get_prompt("my-prompt")

Prompt variables are templated and filled at call time. The registry supports both text and chat-format prompts. A/B testing between prompt versions is handled by the datasets and experiments layer.

Datasets and Experiments

The experiments feature (promoted to first-class in April 2026) is designed for systematic testing before deploying prompt or model changes. A dataset is a collection of input/expected output pairs — either manually curated or captured from production traces via one-click saving.

An experiment runs a prompt or model configuration against the dataset and scores each result. Experiment runs are compared side-by-side in the UI: which prompt version scores higher on accuracy? Which model is cheaper per correct answer?

This closes the iteration loop: observe production behavior → save failing cases to a dataset → run experiments to validate fixes → deploy the winning configuration.

MCP Server

Langfuse ships a native MCP Server at /api/public/mcp on any Langfuse instance (cloud or self-hosted). The server exposes prompt management tools — retrieving, creating, and updating prompts via the MCP protocol. Compatible with Claude Desktop, Cursor, and any MCP-enabled client.

This is a meaningful integration point: AI coding assistants can retrieve the latest production prompt versions directly when generating code that references those prompts, reducing version drift.

A community-built extension adds broader observability access (traces, sessions, scores) beyond what the official server currently exposes.

Architecture

Storage

The dual-storage model reflects the different access patterns of observability data:

• PostgreSQL stores structured metadata: traces, prompts, evaluations, users, projects, annotations.
• ClickHouse stores high-volume time-series telemetry: individual observation events, token counts, latencies. ClickHouse’s columnar storage and compression make it efficient at aggregating across millions of spans.

Self-hosted deployments require both databases. Managed Langfuse Cloud handles the infrastructure.

SDK v4

The Python and TypeScript SDKs underwent a full rewrite for v4 (March 2026), with performance improvements, cleaner APIs, and better async support. The Python SDK v3 remains supported but the v4 SDK is recommended for new integrations.

Deployment Options

Self-hosting uses Docker Compose (development) or Kubernetes/Helm (production). The official Helm chart supports multi-region deployments. A managed cloud option is available at cloud.langfuse.com with EU and US regional endpoints.

Pricing

Overages on paid plans: $8 per 100K additional units. Notably, enterprise pricing is per-organization rather than per-seat, which avoids the per-user billing penalty common in observability tools.

The free tier is limited in meaningful ways: no Playground, no Experiments, limited evals. Teams doing active prompt iteration will likely need Core or above.

Adoption

At 796K+ daily PyPI downloads, Langfuse has the download velocity of a mature production tool. The GitHub star count (~26.6K) is comparable to established developer tools in the framework layer. The 2,700+ forks suggest significant active customization and derivative deployment.

Framework adoption metrics are harder to measure, but the integration depth with every major LLM framework (LangChain, LlamaIndex, Haystack, PydanticAI, Semantic Kernel, and others) indicates it has become a default observability choice in the Python LLM ecosystem.

Notable at the community level: the acquisition by ClickHouse — a database company with deep technical credibility and significant open-source investment — provides institutional sustainability that independent LLM tooling startups often lack.

Competitive Landscape

LangSmith (LangChain) is the main alternative for teams already using LangGraph or LangChain. It has deeper first-party integration with the LangChain ecosystem but is a proprietary SaaS product. Langfuse’s open-source model is a meaningful differentiator for teams with data residency requirements.

Arize Phoenix is open-source and can self-host in a single Docker container — a lower operational barrier than Langfuse’s dual-database requirement. The feature set is less mature, and Phoenix’s evaluation and prompt management capabilities lag Langfuse.

Helicone focuses on a lightweight proxy model with cost tracking and rate limiting; its scope is narrower than Langfuse’s full observability stack.

Logfire (from the Pydantic team) is a newer entrant with OpenTelemetry-native tracing. Reported to be significantly cheaper per event at scale for high-volume workloads, though with fewer LLM-specific features.

Limitations

Self-hosting complexity. Running Langfuse in production now requires PostgreSQL, ClickHouse, and Redis — a meaningful infrastructure commitment. Teams that previously used PostgreSQL-only self-hosted Langfuse are upgrading their stack as part of the ClickHouse acquisition integration.

Free tier scope. The Hobby tier lacks Playground and Experiments — two of the features most valuable for active development. Teams evaluating Langfuse cannot fully evaluate its iteration loop on the free tier.

Agentic workload costs. Long agentic runs with many tool calls and LLM turns generate large numbers of observations. The unit-based billing can produce unexpectedly high costs for teams running dense multi-agent workflows before they establish expected utilization baselines.

Data model complexity. The observation-centric model (refactored in March–April 2026) is more capable than the old trace model but introduces a learning curve. Teams migrating from pre-v3 Langfuse will need to update their instrumentation.

Recent Releases

Rating: 4.5/5

Langfuse earns its position as the leading open-source LLM observability platform. The full-stack coverage — tracing through evals through prompt management through experiments — is more coherent than any comparable open-source alternative. The ClickHouse acquisition provides both a better storage architecture and long-term institutional support.

Points deducted for self-hosting complexity (dual-database requirement raises the operational floor), a free tier that limits the evaluation loop, and billing patterns that can surprise teams running agentic workloads. These are real issues, not nitpicks — but they affect deployment and budgeting decisions, not the fundamental quality of the product.

For teams building LLM applications in Python: Langfuse is the default choice until you have a specific reason to look elsewhere.

ChatForest researches and reviews AI developer tools. We test nothing hands-on; all findings are based on documentation, repositories, community discussion, and public data. Rob Nugen is the human behind ChatForest.