Langfuse

Visit Website

Introduction

Langfuse records what an LLM application did: traces, generations, token counts, prompts, scores, and datasets. Python and JavaScript SDKs send those observations. You can also ingest through OpenTelemetry. The same project stores prompt versions and runs evals against datasets, so tracing and evaluation sit in one product instead of a log tool plus a spreadsheet.

The server is open source (MIT) at langfuse/langfuse. You can run it with Docker Compose or on Kubernetes. Langfuse Cloud is the hosted service, with a free Hobby plan and paid plans metered in units. A unit is a trace, an observation (span, event, or generation), or a score. Langfuse does not replace the tests around your non-LLM code.

Features

1. Traces: Nested observations show a request that called a retriever, a model, and a tool. Sessions group chat turns. Users can be attached to the trace.
2. SDKs and OTel: Python and JavaScript SDKs are the primary path. Java and Go can use OpenTelemetry. An HTTP API covers everything else.
3. Prompt management: Prompts are versioned, labeled, and fetched at runtime, with a playground to try a version against a model.
4. Evals: Datasets, experiments from the SDK or the UI, LLM-as-a-judge evaluators, and human annotation queues. Scores attach to traces.
5. Cost and token fields: Generations can store token counts and a calculated cost when the SDK is given prices or the model is known.
6. Dashboards and alerts: Custom dashboards over the stored scores and usage. Alert limits depend on the Cloud plan.
7. Self-host: Docker Compose for a local install, Kubernetes for production. Cloud and self-host speak the same SDK.
8. Regions: Cloud data regions include the US, EU, and Japan. HIPAA is an Enterprise option.

Pros

1. Trace plus eval in one store: A bad score can be opened as the trace that produced it, which is the loop prompt debugging actually needs.
2. Self-host is a real option: MIT license and published Compose and Kubernetes docs. The Hobby cloud plan is not the only way to try it.
3. OpenTelemetry ingest: Services that already emit OTel spans do not need a second proprietary agent for basic tracing.
4. Prompt versions are not a wiki: Fetching a labeled prompt from Langfuse means production and the playground can run the same text.
5. Hobby is enough to evaluate: 50,000 units a month, two users, and 30 days of data access, with no credit card.

Cons

1. Units add up: A trace with many spans and several scores is many billable units, not one. A chatty agent will leave the Hobby allowance.
2. Self-host is a stack: Production installs need the databases Langfuse documents (Postgres and ClickHouse in current architectures, plus object storage and a cache). Compose on a laptop is not that install.
3. Judge evals are model calls: LLM-as-a-judge scores cost tokens and move when the judge changes. Langfuse stores the score; it does not make it objective.
4. Plan limits are sharp: Hobby is two users and 30 days of access. Annotation queues and API rate limits step up only on paid plans.
5. Not a functional test runner: It will not notice a broken login page unless your LLM app happened to trace it.

Usage and Links (Example)

pip install langfuse

from langfuse import get_client

langfuse = get_client()
with langfuse.start_as_current_observation(as_type="span", name="answer") as span:
    span.update(input={"question": "What is Langfuse?"})
    answer = "Langfuse stores LLM traces, prompts, and scores."
    span.update(output=answer)

Set LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, and LANGFUSE_HOST (Cloud or your own URL). The SDK method names have changed across major versions; use the snippet in the docs for the version you installed, not a cached blog post. For self-host, start from the Docker Compose guide and only then point the SDK at it.

Resources:

• Langfuse website
• Documentation
• Pricing
• GitHub: langfuse/langfuse

Pricing

From langfuse.com/pricing. Cloud units are traces, observations, and scores.

1. Self-host: Free under the MIT license. You pay for machines and operations.
2. Hobby: $0. 50,000 units per month, 30 days of data access, 2 users, community support. No credit card.
3. Core: $29 per month. 100,000 units included, then graduated usage starting at $8 per 100,000 units. 90 days of data access, unlimited users.
4. Pro: $199 per month. Same included units and overage curve, 3 years of data access, higher rate limits, SOC 2 and ISO 27001 reports. A Teams add-on is $300 per month for SSO, project RBAC, and a Slack channel.
5. Enterprise: $2,499 per month, with audit logs, SCIM, an SLA, and custom rate limits. Yearly commits can change the unit price.

Graduated overage on the published card: $8 / 100k units from 100k to 1M, then $7, $6.50, and $6 at higher bands. Startup, research, and open-source discounts are separate applications.

Recommended for?

1. LLM features that need a trace of retrieval, tools, and the final generation, not only the last string.
2. Python or JavaScript apps that can add the SDK, or services that already speak OpenTelemetry.
3. Teams that may self-host for data-residency reasons and want the same product in Cloud for everyone else.
4. Eval workflows that should attach a score to a real production trace. Keep ordinary software tests in pytest, Jest, or Playwright.

Conclusion

Langfuse is the open-source LLM trace and eval store to compare against a closed vendor. Self-host if you have the operational capacity; otherwise Hobby is the no-card trial and Core at $29 is the first paid step. Count observations, not requests, before you estimate the bill. It records and scores model calls. It does not test the rest of the product.