Langfuse

Building an application with a large language model is only part of the work. Developers also need to understand what happens after a user sends a request. Which prompt was used? How many model calls were made? Where did the application slow down? Did a retrieval step return useful information? And is a new prompt actually producing better answers?

These questions become harder to answer when an application moves beyond a simple chatbot and starts using multiple models, tools, retrieval systems, and autonomous agent workflows.

Langfuse addresses this problem by providing a platform for tracing, monitoring, evaluating, and improving LLM applications. It also includes prompt management, datasets, experiments, and integrations with popular AI development frameworks.

The platform is open source, can be self-hosted, and offers a managed Cloud service. It became part of ClickHouse in January 2026, while continuing to develop its AI engineering product. Langfuse+1

What Langfuse Brings to an LLM Development Environment

Langfuse is designed to help teams understand how their AI applications behave during development and after deployment.

Traditional application logs are useful for finding errors, but they do not always provide enough context to understand an LLM interaction. A language model can produce an unexpected response even when an application does not encounter a conventional software error.

For example, imagine a customer-support assistant that receives a question, searches a knowledge base, retrieves several documents, sends information to an LLM, and generates an answer.

A poor response could originate from several places. The retrieval system might return irrelevant information. The prompt might not explain the task clearly. The model could misunderstand the supplied context, or an external tool could fail.

Langfuse provides a structured view of these operations through application tracing. Developers can inspect requests, model generations, observations, inputs, outputs, token usage, timing, and connected operations.

This makes it easier to understand the complete path of an AI interaction rather than examining isolated log entries.

The platform is particularly relevant to applications where multiple operations contribute to one user-facing answer. It supports both straightforward LLM integrations and more involved agent workflows. Langfuse+1

Following an AI Request Through Its Entire Workflow

Tracing is one of Langfuse’s central functions.

A trace represents an application interaction. Individual operations can appear as observations within that trace, including model generations, spans, events, and other application steps.

This structure matters when debugging systems that use more than one model call.

Consider a retrieval-augmented generation application. Its workflow might involve a user query, embedding generation, vector database retrieval, document filtering, prompt construction, and an LLM response.

Without connected tracing, developers may need to inspect logs from several services to understand what happened. Langfuse brings the captured operations together so that the sequence can be investigated.

The resulting information can help developers identify:

• Slow model calls and other latency problems.
• Unexpected model inputs or outputs.
• Expensive interactions and token consumption.
• Failed application steps.
• Problems involving retrieval or external tools.
• Differences between individual sessions and users.

Langfuse also supports session tracking, which is useful for examining multiple interactions belonging to the same conversation.

Its integration with OpenTelemetry provides another important advantage. Teams can use the platform’s Python and JavaScript/TypeScript SDKs or send compatible telemetry through its OpenTelemetry endpoint.

This makes Langfuse relevant to teams that want LLM-specific observability without abandoning established instrumentation practices. Langfuse+1

Prompt Management Makes Changes Easier to Control

Prompts are often treated as ordinary strings inside an application’s codebase. That approach works for small experiments, but it becomes inconvenient when prompts change frequently or multiple people need to maintain them.

Langfuse offers centralized prompt management to address this problem.

Developers can store prompt templates, create new versions, assign labels, and retrieve the required version through the SDK. Labels can represent environments such as staging and production, allowing an application to reference a deployment label instead of a hardcoded prompt version.

This separation makes collaboration easier.

For example, a product specialist might improve a customer-support prompt while an engineer maintains the application code. Rather than requiring every prompt adjustment to go through a full software deployment, the team can manage prompt changes through Langfuse.

Prompt versioning also gives developers a history of previous configurations. If a new prompt behaves poorly, the team can restore an earlier version by changing its deployment label.

More importantly, prompt management connects with tracing and evaluation. Teams can analyze how different prompt versions perform instead of making decisions based on personal impressions.

That relationship makes the platform useful for applications that need a repeatable prompt development process. Langfuse+2

Evaluations Turn Production Data Into Improvement Opportunities

A functioning AI application is not necessarily a reliable AI application.

A chatbot might generate fluent responses while providing incorrect information. An agent might complete a task but use unnecessary tools, create excessive delays, or produce inconsistent results.

Langfuse provides evaluation features to help teams measure these behaviors.

It supports online evaluation of incoming production traces and offline evaluation using predefined datasets. Developers can use custom evaluation functions, model-based judges, scores, and human annotation workflows.

This allows evaluation to become part of the development cycle.

For example, a developer changing an LLM or prompt can run an experiment against a known dataset. The results can then be compared with a previous version to identify improvements or regressions.

Langfuse also supports dataset versioning, helping teams reproduce experiments against a specific dataset state.

For automated development workflows, its evaluation tools can connect with CI processes. The official documentation describes using the Langfuse experiment GitHub Action to fail a workflow when evaluation scores fall below a defined threshold.

This gives teams a more systematic way to check application changes before releasing them. Langfuse+1

Integrations Without Being Locked Into One AI Framework

Langfuse is not limited to one model provider or development framework.

Its integration ecosystem includes LangChain, LangGraph, OpenAI, Google ADK, LlamaIndex, CrewAI, DSPy, Pydantic AI, Microsoft Agent Framework, Vercel AI SDK, and several other tools.

It also supports model providers such as Anthropic, Google Gemini, Amazon Bedrock, Mistral, DeepSeek, and OpenAI.

The platform provides native Python and JavaScript/TypeScript SDKs, along with API access and OpenTelemetry support.

This flexibility is useful when an application combines technologies from different providers. A team can build around its existing framework and use Langfuse to collect and analyze the resulting telemetry.

There is, however, an important boundary.

Langfuse is an observability and AI engineering platform, not a managed environment that executes stateful AI agents. It can inspect their traces, evaluate their behavior, and help developers improve their workflows, but the application still needs its own execution environment.

That distinction is worth understanding before selecting it as part of an AI infrastructure stack. Langfuse+1

Self-Hosting, Cloud Deployment, and Infrastructure Trade-Offs

One of Langfuse’s strongest differences from many commercial observability platforms is its self-hosted open-source edition.

The self-hosted core is available under the MIT license without a Langfuse usage-based subscription fee. Teams can deploy it locally, on cloud infrastructure, or within their own environment.

That does not mean operating it has no cost.

A production deployment requires services such as PostgreSQL, ClickHouse, Redis or Valkey, application containers, background workers, and blob storage. Langfuse provides Docker Compose, Kubernetes Helm, and cloud deployment guidance.

These requirements introduce operational responsibilities. Teams must consider storage, backups, capacity, upgrades, security, and infrastructure availability.

The Cloud edition removes much of this operational work by providing managed hosting. Users can concentrate more on their applications instead of maintaining the complete observability stack.

There is also a meaningful difference between data access and data retention. A Cloud plan’s historical access window determines how far back users can inspect information. Data retention is a separate feature that controls when stored data is deleted.

Organizations handling sensitive production information should evaluate these settings alongside their security and compliance requirements. Langfuse+3

What Is Changing in Langfuse in November 2026?

Langfuse has continued adding features beyond traditional LLM tracing.

Its Halo assistant, launched in October 2026, can investigate traces, inspect observations, help create datasets, and build dashboards. It can also process large groups of observations using a sandboxed workflow. Proposed changes to data or configuration require user approval. Langfuse+1

Another recent development is the introduction of beta skill management, which extends version control to agent skills and their supporting files. Langfuse+1

Most notably, on November 4, 2026, Langfuse announced its AI Gateway public beta.

The gateway allows applications and coding agents to route supported OpenAI and Anthropic requests through Langfuse. Organizations can issue gateway keys, inspect usage, attribute costs to users or keys, and record model calls as traces.

Its initial release is a beta, so supported providers and behavior may change. It should be evaluated as an additional capability rather than assumed to be a mature replacement for every API gateway. Langfuse+2

For teams building serious LLM products, these developments make Langfuse an increasingly broad engineering platform. Its strongest appeal remains the connection between observability, prompt management, evaluation, and an open deployment model.