Search tools, AI agents, MCP servers
Submit a tool

Search iThub

Search tools, categories and collections. Type at least two characters.

Explore all tools
↑ ↓ to explore resultsEnter to open · Esc to close

Langfuse

Open-source LLM engineering platform for tracing, prompt management, evaluations and datasets

MLOps & LLMOpsFreemiumv4.82.0

Langfuse at a glance

Pricing
Freemium
Deployment
Self-hosted
License
Open source
Version
v4.82.0November 17, 2026
Platforms
Web
Language
TypeScript
Data location
Self-hosted: operator infrastructure, VPC or on premises. Langfuse Cloud runs on AWS and ClickHouse Cloud in a US (Oregon, also HIPAA), EU (Ireland) or Japan region chosen per organization.
Maker
langfuse
Founded
2022

What is Langfuse?

Langfuse is an open-source AI engineering platform for tracing, evaluating and improving LLM applications and AI agents. It records model calls, retrievals, tool calls and agent steps as observations, and adds prompt management, evaluations, datasets and experiments, an LLM playground, dashboards and a public API on top of that data. The GitHub repository describes it as one platform for every AI call a company makes, built on OpenTelemetry, and offered both as the managed Langfuse Cloud service and as software for self-hosting.

The project started in 2022, went through Y Combinator in the Winter 2023 batch and launched publicly in the summer of 2023, according to the Langfuse handbook. On January 16, 2026, ClickHouse acquired Langfuse. The announcement states that Langfuse stays open source and self-hostable, that no licensing changes are planned, that Langfuse Cloud keeps running with the same endpoints and that the whole team joined ClickHouse. The repository license is now issued in the name of ClickHouse, Inc., the Langfuse imprint redirects to the ClickHouse imprint, and the README lists offices in Berlin, San Francisco, Amsterdam and New York.

The code base is TypeScript and ships as two Docker images, langfuse/langfuse for the web UI and APIs and langfuse/worker for asynchronous processing. A self-hosted deployment also needs PostgreSQL for transactional data, ClickHouse for traces, observations and scores, Redis or Valkey as cache and queue, and S3-compatible blob storage for raw events and attachments, as listed in the self-hosting documentation. Licensing is split: everything outside the ee folders is under the MIT (Expat) license, while code in ee/, web/src/ee/, worker/src/ee/ and packages/shared/src/server/ee/ falls under a separate enterprise license and needs a license key to run. The open-source chapter of the handbook states that tracing, evaluations, prompt management, experiments, annotation and the playground are MIT licensed without usage limits.

Langfuse v4 became generally available on August 17, 2026. The v4 changelog describes a new data model in which each completed observation is written once to a wide, append-only ClickHouse table instead of joining traces and observations at read time. It also added full-text search over inputs, outputs and metadata, monitors for cost, quality and latency thresholds, code evaluators, the Halo assistant, Observations API v2 and Metrics API v2. The v4 features require Python SDK 4.7.0 or later and JS/TS SDK 5.4.0 or later, and the versioning page lists security patches for open-source v3 through January 31, 2027.

The latest GitHub release at the time of writing is v4.82.0, published November 17, 2026. It gates legacy v3 surfaces on Langfuse Cloud behind cutoff switches, adds a Developer preset for API keys and renames the Ingestion preset to Application, reads audit logs from ClickHouse, fixes a server-side request forgery issue in the GitHub Enterprise SSO configuration and pauses an evaluation LLM connection after a provider returns HTTP 429. All releases and their notes are listed on the GitHub releases page and summarized in the Langfuse changelog.

Key capabilities

  • Tracing and observability Applications send traces made of nested observations such as generations, spans, retrievals, embeddings, tool calls and agent steps, each with latency, token usage and cost. The trace view shows the tree of steps next to the input, output and metadata of the selected observation, and traces can be grouped into sessions and filtered by user or environment. The observability docs describe the data model and SDK instrumentation.
  • OpenTelemetry ingestion Langfuse exposes an OTLP endpoint, so any OpenTelemetry-instrumented application, framework or OpenTelemetry Collector can send traces without a Langfuse SDK. On v4, sending the x-langfuse-ingestion-version: 4 header gives real-time data; without it, data can be delayed by up to 15 minutes, according to the versioning page.
  • Python and JS/TS SDKs The Python package langfuse and the npm packages under @langfuse provide manual instrumentation, an @observe() decorator in Python and access to the public API through the client api property. According to the public API docs, Python SDK v5 and JS/TS SDK v6 changed some resource names.
  • Framework and provider integrations The README lists a drop-in wrapper for the OpenAI SDK, callback handlers for LangChain and LangGraph, LlamaIndex, Haystack, the LiteLLM proxy, the Vercel AI SDK and Mastra. Further integrations cover the OpenAI Agents SDK, Claude Agent SDK, Pydantic AI, Google ADK, Strands Agents, Spring AI, CrewAI, AutoGen, smolagents, DSPy, Instructor, Ollama, Amazon Bedrock and no-code tools such as Flowise, Langflow, Dify and Open WebUI. The integrations overview lists more than 100 entries.
  • Prompt management Prompts are stored centrally with numbered versions and labels such as production and latest, so an application fetches the labeled version instead of shipping prompt text in code. Server-side and client-side caching keep prompt retrieval out of the request path, and generations can be linked to the prompt version that produced them. See the prompt management docs.
  • LLM Playground The playground runs a prompt against a configured model with adjustable parameters, and a failing generation can be opened in the playground directly from a trace. It uses an LLM API connection configured in the project; on self-hosted instances this is the optional LLM API component of the architecture.
  • Skill management (beta) Agent skills, a SKILL.md file with optional supporting files, can be versioned and labeled in the same way as prompts. Versions can be promoted or rolled back without changing application code, and skill versions are linked to the traces they produced.
  • Evaluations The evaluation docs list LLM-as-a-judge evaluators, code evaluators that run Python or TypeScript checks, annotation queues for human review, end-user feedback, text scores and scores sent through the API or SDK. Evaluators can run online on production observations or offline on datasets, and score analytics compare LLM judges with human labels.
  • Datasets and experiments Datasets hold items with input, expected output and metadata; items can be created in the UI, uploaded as CSV, added from production traces or created through the SDK. Experiments run an application version against a dataset and compare scores, cost and latency across runs in the UI, SDK or via OpenTelemetry. For CI, the langfuse/experiment-action GitHub Action fails a pull request job when a script raises RegressionError on a score threshold.
  • Metrics, dashboards and monitors Custom dashboards chart latency, cost, token usage and scores across models, users, prompts and other dimensions, and the Metrics API v2 returns the same aggregates for external tools. Since v4, monitors raise alerts on cost, quality or latency thresholds, and Pulse adds a chart above the observations table that highlights spikes. The Cloud plans include 2 to 100 alerts depending on tier, per the pricing page.
  • AI Gateway (beta) The Langfuse AI Gateway gives an organization one endpoint for OpenAI and Anthropic API calls. Provider credentials stay in the gateway, users and services receive their own gateway keys, admins approve models centrally, spend is tracked per user, key and model, and every call is recorded as a Langfuse trace. Self-hosted, it runs as the separate langfuse/ai-gateway image and needs Langfuse v4.75.0 or newer.
  • Public API and OpenAPI spec The project-level API uses HTTP Basic authentication with a public key and secret key. The API reference and an OpenAPI spec are published, and self-hosted instances from v4.36.0 serve the spec at /api/openapi.yaml and an interactive reference at /api/docs. Langfuse Cloud applies per-organization rate limits; self-hosted instances enforce none.
  • Agent tooling For coding agents, Langfuse publishes an Agent Skill in the langfuse/skills repository, a Langfuse CLI, a Cursor plugin and a Docs MCP server at https://langfuse.com/api/mcp that needs no authentication. The README suggests installing the skill and asking the agent to add tracing to an application.
  • Halo assistant Halo is an in-app agent for asking plain-language questions about project data, introduced with v4. It is available on all Cloud plans with usage limits described as low on Hobby, medium on Core and high on Pro and Enterprise.
  • Self-hosting with Docker Compose The Docker Compose guide starts the web and worker containers, PostgreSQL, ClickHouse, Redis and MinIO on one machine; the UI listens on port 3000. For a VM the guide suggests at least 4 cores, 16 GiB of memory and about 100 GiB of storage. The setup has no high availability, no horizontal scaling and no backups, and is meant for local use and testing.
  • Kubernetes, Helm and cloud templates The Helm chart is the documented production deployment, with Terraform-based guides for AWS, Azure and GCP; Render and Railway templates are community maintained with best-effort support. Langfuse can run inside a VPC or on premises, and internet access is optional.
  • Telemetry in self-hosted instances By default, self-hosted instances report basic usage statistics to a PostHog server. The README states that raw traces, prompts, observations, scores and dataset contents are not included, and the telemetry docs list the collected fields. Setting TELEMETRY_ENABLED=false disables it.
  • Langfuse Cloud plans Checked on November 17, 2026: Hobby is free with 50,000 units per month, 30 days of data access and 2 users. Core costs $29 per month and Pro $199 per month, each with 100,000 included units, unlimited users and 90 days or 3 years of data access; Enterprise costs $2,499 per month. Additional units are billed per 100,000 at $8 up to 1 million, $7 up to 10 million, $6.50 up to 50 million and $6 above that, and a Teams add-on for Pro (Enterprise SSO, fine-grained RBAC) costs $300 per month. A unit is any tracing data point: a trace, an observation or a score.
  • Self-hosted editions The open-source edition is free and covers all core features without usage limits. According to the self-hosting pricing page, Self-Hosted Enterprise adds project-level RBAC, data retention policies, audit logs, SCIM and management APIs at custom pricing that is added to a ClickHouse Cloud, BYOC or Private plan, and a Government edition adds FIPS 140-3 validated cryptography, Iron Bank hardened UBI 9 images and air-gapped deployment.

Where Langfuse fits

Debugging an agent in production

An application instrumented with the SDK, an integration or OpenTelemetry sends each request as a trace. In the trace view, each tool call, retrieval and generation appears with its input, output, latency and cost, so a slow or failing step can be located within a run of hundreds of observations. Since v4, full-text search over inputs, outputs and metadata finds traces that contain a given error or user query. The interactive demo shows a public example project.

Versioning prompts outside the code base

Prompt text and model configuration move into Langfuse, where each change creates a new version. The application fetches the version carrying a label such as production, and the SDK cache serves it locally. Promoting a new version means moving the label, and linked generations show which version produced which outputs and scores.

Running evaluations on live traffic

Online evaluators score production observations automatically: an LLM-as-a-judge template rates aspects such as correctness or tone, and code evaluators run deterministic checks in Python or TypeScript. Annotation queues route selected observations to human reviewers, and user feedback from the application can be stored as scores through the API. Score analytics then show how far LLM judges agree with human labels.

Testing changes against a dataset before release

Production traces or curated examples become dataset items with expected outputs. An experiment runs a new prompt, model or code version against the dataset and compares scores, cost and latency with a baseline run. The datasets documentation covers the SDK and UI flows, and the langfuse/experiment-action GitHub Action runs the same experiment in a pull request workflow.

Tracking AI cost and usage across teams

Token usage and cost are recorded per observation and can be aggregated by model, user, session, prompt version or custom metadata in dashboards and through the Metrics API v2. Monitors alert on cost or latency thresholds. With the AI Gateway in beta, an organization routes OpenAI and Anthropic calls through one endpoint and attributes spend to individual gateway keys.

Self-hosting inside a private network

Teams that keep trace data on their own infrastructure deploy the web and worker containers with PostgreSQL, ClickHouse, Redis or Valkey and S3-compatible storage, typically with the Helm chart on Kubernetes. Similar tools listed on iThub include OpenObserve, an observability platform with LLM monitoring, and Weights & Biases for experiment tracking and LLM evaluation. Langfuse traces applications built with LangChain or routed through LiteLLM.

Install

git clone --depth=1 https://github.com/langfuse/langfuse.git && cd langfuse && docker compose up

Reviews of Langfuse

No reviews yet

Be the first to share your experience with Langfuse.

Loading review form…

Found Langfuse useful? Upvote it todayYour vote helps other IT teams find it in the daily ranking.

Similar to Langfuse

Compare:Langfuse vs Weights & BiasesLangfuse vs OpenObserveLangfuse vs Scale AI

  1. Weights & BiasesExperiment tracking, model registry and LLM evaluation for ML teamsMLOps & LLMOps23 views
  2. OpenObserveRust observability platform for logs, metrics, traces, RUM and LLM monitoring on Parquet and object storageMonitoring & Observability51 views
  3. Scale AITraining data, RLHF, model evaluations and an enterprise agent platform from Scale AIMLOps & LLMOps60 views
  4. SSkillOptSkillOpt optimizes reusable natural-language skills for LLM agents without changing model weights.MLOps & LLMOps2 views
  5. NVIDIA SkillEvaluatorNVIDIA tool that validates AI agent skills and measures their effect with sandboxed with/without-skill agent runsMLOps & LLMOps0 views