---
title: Overview
seoTitle: Open Source AI Engineering Platform
description: Langfuse is an open-source AI engineering platform (GitHub) that helps teams collaboratively debug, analyze, and iterate on their AI agent applications. All platform features are natively integrated to accelerate the development workflow.
---

# Langfuse Overview

Langfuse is an open-source AI engineering platform ([GitHub](https://github.com/langfuse/langfuse)) that helps teams collaboratively debug, analyze, and iterate on their AI agent applications. All platform features are natively integrated to accelerate the development workflow. Langfuse is open, self-hostable, and extensible ([_why Langfuse?_](/why)).

**Start with Langfuse** [Sign up](/cloud)

## Observability [#observability]

[Observability](/docs/observability/overview) is essential for understanding and debugging AI agent applications. Unlike traditional software, AI agent applications involve complex, non-deterministic interactions that can be challenging to monitor and debug. Langfuse provides comprehensive tracing capabilities that help you understand exactly what's happening in your application.

- Traces include all LLM and non-LLM calls, including retrieval, embedding, API calls, and more
- Support for tracking multi-turn conversations as sessions and user tracking
- Agents can be represented as graphs
- Capture traces via our native SDKs for Python/JS, 100+ library/framework integrations, OpenTelemetry, or via an LLM Gateway such as LiteLLM
- Based on OpenTelemetry to increase compatibility and reduce vendor lock-in

Want to see an example? Play with the [interactive demo](/docs/demo).

[Watch end-to-end walkthrough](/watch-demo) of Langfuse Observability and how to integrate it with your application.

**Trace Details**

Traces allow you to track every LLM call and other relevant logic in your app.

_[Video: Inspect a trace](https://static.langfuse.com/docs-videos/trace-new-ui.mp4): Trace detail of a RAG answer with the generation selected. Hover the cost and token values in the generation header to see the cost and usage breakdowns, expand the collapsed chat history, then select the retrieval span in the tree to see the context it returned._

**Sessions**

Sessions allow you to track multi-step conversations or agentic workflows.

_[Video: Follow a conversation as a session](https://static.langfuse.com/docs-videos/overview-sessions.mp4): Trace detail of one support-chat turn. Click the “session” badge in the trace header to open the session: every turn of the conversation in one view, with the user and assistant messages in order. Click the last turn in the list on the left to jump to it._

**Timeline**

Debug latency issues by inspecting the timeline view.

_[Video: Find slow steps in the timeline](https://static.langfuse.com/docs-videos/overview-timeline.mp4): Trace detail of an agent trace. Switch from “Tree” to “Timeline” to see each step as a bar on a time axis with its duration and cost, so the slowest steps stand out. Click one of the llm.chat calls to open it, then switch back to “Tree”._

**Users**

Add your own `userId` to monitor costs and usage for each user. Optionally, create a deep link to this view in your systems.

_[Video: See traces and scores per user](https://static.langfuse.com/docs-videos/overview-users.mp4): Users list with each user's first and last event, trace count, tokens and cost. Click a user to open their page with total observations, tokens and cost, their traces, and the “Scores” tab with every score on their traces._

**Agent Graphs**

LLM agents can be visualized as a graph to illustrate the flow of complex agentic workflows.

_[Video: Switch the agent graph between aggregated and expanded](https://static.langfuse.com/changelog-videos/2026-07-13-graph-view-modes.mp4): Trace detail of an agent trace, “Graph” tab next to Tree and Timeline. In the default Aggregated mode, repeated steps collapse into one node such as “llm.chat (3/3)”; select it to see its observations. Switch the toggle to Expanded to see the run as it happened, click a tool call node, then switch back to Aggregated._

**Dashboard**

See quality, cost, and latency metrics in the dashboard to monitor your LLM application.

_[Video: Monitor traces, costs and scores on the dashboard](https://static.langfuse.com/docs-videos/overview-dashboard.mp4): Home dashboard with traces by name, model costs and scores. Change the time range from “Past 1 day” to “Past 7 days”, then scroll through observations by level, model usage and cost, user consumption, score trends and latency percentiles._

**Alerts**

Get notified over Slack, GitHub Actions, or Webhooks when a metric crosses a threshold with [alerts](/docs/observability/features/alerts).

  ![Alerts list showing severity, name, and tags for each alert](/images/docs/monitors-list.png)

## Prompt and Skill Management [#prompts]

[Prompt Management](/docs/prompt-management/overview) lets you manage and version model-call templates. [Skill Management](/docs/skill-management/overview), currently in beta, brings versioning and labels to agent instructions and supporting files. Use both to connect the instructions your application receives to its behavior in traces.

- [Get started](/docs/prompt-management/get-started) with prompt management
- [Create and load a skill](/docs/skill-management/get-started) for your agent
- Manage, version, and optimize your prompts throughout the development lifecycle
- Test prompts interactively in the [LLM Playground](/docs/prompt-management/features/playground)
- Run [Experiments](/docs/evaluation/features/prompt-experiments) against datasets to test new prompt versions directly within Langfuse

Want to learn more? [**Watch end-to-end walkthrough**](/watch-demo) of Langfuse Prompt Management and how to integrate it with your application.

**Create**

Create a new prompt via UI, SDKs, or API.

_[Video: Create a prompt](https://static.langfuse.com/docs-videos/prompt-create.mp4): Prompts > “New prompt”. Enter the name order-status-reply and a text prompt with the variables {{customer_name}} and {{order_id}}; Langfuse lists the detected variables below the editor. Keep “Set the production label” checked and click “Create prompt”: version 1 opens with the production and latest labels._

**Version Control**

Collaboratively version and edit prompts via UI, API, or SDKs.

_[Video: Save a new prompt version](https://static.langfuse.com/docs-videos/prompt-new-version.mp4): Prompts > support-reply > “New version”. Edit the system message, add the commit message “Confirm order numbers” and click “Save new prompt version”. The new version appears on top of the version list with its commit message and the latest label._

**Deploy**

Deploy prompts to production or any environment via labels - without any code changes.

_[Video: Promote a prompt version to production](https://static.langfuse.com/docs-videos/deploy-prompt.mp4): Prompts > qa-answer-with-context-chat with the latest version (#12) selected. Click “Add label”, tick production under “Promote to production?” and click “Save and promote to production”; the production label moves to #12. The video then selects #9 and promotes it back to production._

**Metrics**

Compare latency, cost, and evaluation metrics across different versions of your prompts.

_[Video: Compare prompt versions by metrics](https://static.langfuse.com/docs-videos/prompt-metrics.mp4): Prompts > qa-answer-with-context-chat > “Metrics” tab: one row per version with median latency, input and output tokens, cost, generation count and score columns such as accuracy and helpfulness. Switch back with the “Versions” tab._

**Test in Playground**

Instantly test your prompts in the playground.

_[Video: Open a prompt in the playground](https://static.langfuse.com/docs-videos/playground-open-prompt.mp4): Prompts > movie-critic, version 3. Click “Playground” > “Fresh playground”, fill the variables criticlevel (expert) and movie (Dune: Part Two) in the Variables panel and click “Submit” to get the model's answer in Output._

**Link with Traces**

Link prompts with traces to understand how they perform in the context of your LLM application.

_[Video: See which prompt version a generation used](https://static.langfuse.com/docs-videos/prompt-linking.mp4): Trace detail with a generation that used movie-critic v3. Click the prompt badge “movie-critic - v3” in the generation header to open the prompt, then open its “Linked Generations” tab and the “Metrics” tab with latency, cost and scores per version._

**Track Changes**

Track changes to your prompts to understand how they evolve over time.

_[Video: Compare two prompt versions](https://static.langfuse.com/docs-videos/prompt-changes.mp4): Prompts > support-reply with the latest version (#5) selected. Hover an older version in the version list and click its compare icon; the “Changes v2 → v5” dialog shows the content and config diff. Close it._

## Evaluation [#evaluation]

[Evaluation](/docs/evaluation/overview) is crucial for ensuring the quality and reliability of your LLM applications. Langfuse provides flexible evaluation tools that adapt to your specific needs, whether you're testing in development or monitoring production performance.

- [Evaluate Production Traffic](/docs/evaluation/get-started/online) to score live production traces
- Get started with different [evaluation methods](/docs/evaluation/overview): LLM-as-a-judge, code evaluators, user feedback, manual labeling, or custom pipelines
- Identify issues early by running evaluations on production traces
- Create and manage [Datasets](/docs/evaluation/features/datasets) for systematic testing in development that ensure your application performs reliably across different scenarios
- Run [Experiments](/docs/evaluation/core-concepts#experiments) to systematically test your LLM application

Want to learn more? [**Watch end-to-end walkthrough**](/watch-demo) of Langfuse Evaluation and how to use it to improve your LLM application.

**Analytics**

Plot evaluation results in the Langfuse Dashboard.

_[Video: Analyze scores](https://static.langfuse.com/docs-videos/score-analytics.mp4): Scores > “Analytics”. Pick helpfulness as the first score to see its statistics, trend over time and distribution, then pick faithfulness as the second score to compare both: means, matched pairs, correlation and a side-by-side distribution._

**User Feedback**

Collect feedback from your users. Can be captured in the frontend via our Browser SDK, server-side via the SDKs or API.

_[Video: Review user feedback scores](https://static.langfuse.com/docs-videos/user-feedback-scores.mp4): Scores page. Search name:user-feedback value:<0.5 to list the thumbs-down feedback the chat widget sent through the API, with the customer's comment such as “Still charged twice.” Click a row's trace to open the conversation in a side panel._

**LLM-as-a-Judge**

Run fully managed LLM-as-a-judge evaluations on production or development traces. Can be applied to any step within your application for step-wise evaluations.

_[Video: Set up an LLM-as-a-judge evaluator](https://static.langfuse.com/docs-videos/2026-08-21-evaluator-llmaaj-setup.mp4): Evaluators > “New evaluator” > template “Classify Input Topic” (LLM-as-a-judge). Filter the sample observations to the support chatbot, map the {{input}} variable to payload.message under “Map variables to data”, run the judge on one sample to see its score and reasoning, then click “Create evaluator” and confirm the rule in the “Evaluator saved” dialog._

**Experiments**

Evaluate prompts and models on datasets directly in the user interface. No custom code is needed.

_[Video: Run a prompt experiment from the UI](https://static.langfuse.com/docs-videos/prompt-experiments.mp4): Datasets > capital-cities > “Run experiment” > “via User Interface” > Configure. Select prompt answer-question, version 3, and model gpt-4.1, keep the dataset capital-cities, skip evaluators, name the run and click “Run Experiment”. A toast confirms the experiment was triggered._

**Annotation Queue**

Baseline your evaluation workflow with human annotations via Annotation Queues.

_[Video: Create and work an annotation queue](https://static.langfuse.com/docs-videos/2025-12-19-annotation-queues.mp4): Human Annotation > “New queue”: name it “Error Analysis”, add the “First Pass” score config and click “Create queue”. In Tracing, select three traces, choose “Add to Annotation Queue” in the selection bar and pick “Error Analysis”. Open the queue with “Process queue” and annotate the first item in the Annotate panel._

**Custom Evals**

Add custom evaluation results, supports numeric, boolean and categorical values.

```bash
POST /api/public/scores
```

Add scores via Python or JS SDK.

```python filename="Example (Python)"
from langfuse import get_client

langfuse = get_client()

langfuse.create_score(
  trace_id="123",
  name="my_custom_evaluator",
  value=0.5,
)
```

## Where to start?

Setting up the full process of online tracing, prompt management, production evaluations to identify issues, and offline evaluations on datasets requires some time. Most teams eventually end up with a process that looks like this:

The AI Engineering Loop:

- [Trace](/academy/tracing): traces, sessions, agents, prompts
- [Monitor](/academy/monitoring): dashboards, LLM-as-judge, feedback
- [Build datasets](/academy/datasets): datasets, features-as-tests
- [Experiment](/academy/experiments): prompts, models, code variants
- [Evaluate](/academy/evaluate): judges, custom evals, annotation

If you're new to AI engineering, take a look at the [Academy](/academy), where you'll find conceptual guidance on how to approach AI engineering, trade-offs, and best practices. If you already know what you want, [the getting-started guides below](#quickstarts) will get you going.

Tip: let your coding agent do the setup and work with Langfuse through the [Agent Skill](/docs/api-and-data-platform/features/agent-skill), [CLI](/docs/api-and-data-platform/features/cli), or [MCP server](/docs/api-and-data-platform/features/mcp-server). On Langfuse Cloud, you can also ask [Halo](/docs/api-and-data-platform/features/halo), the Langfuse assistant, about your project data from inside the app.

## Quickstarts [#quickstarts]

Get up and running with Langfuse in minutes. Choose the path that best fits your current needs:

- [Integrate LLM Application/Agent Tracing](/docs/observability/get-started)
- [Integrate Prompt Management](/docs/prompt-management/get-started)
- [Setup Evaluations](/docs/evaluation/get-started/online)

## Why Langfuse?

- **Open source:** Fully open source with public API for custom integrations
- **Production optimized:** Designed with minimal performance overhead
- **Best-in-class SDKs:** Native SDKs for Python and JavaScript
- **Framework support:** Integrated with popular frameworks like OpenAI SDK, LangChain, and LlamaIndex
- **Multi-modal:** Support for tracing text, images and other modalities
- **Full platform:** Suite of tools for the complete LLM application development lifecycle

## Community & Contact

We actively develop Langfuse in [open source](/open-source) together with our community:

- Contribute and vote on the Langfuse [roadmap](/docs/roadmap).
- Ask questions on [GitHub Discussions](/gh-support) or private [support channels](/support).
- Report bugs via [GitHub Issues](/issue).
- Chat with the community on [Discord](/discord).
- Join a [community hour](/events) to talk to the team and ask questions live.
- [Why people choose Langfuse?](/why)

Langfuse evolves quickly, check out the [changelog](/changelog) for the latest updates. Subscribe to the **mailing list** to get notified about new major features:

Subscribe to the Langfuse product update newsletter at https://langfuse.com/changelog.

<!-- agent-instructions -->

---

## Agent Instructions

This page is part of the [Langfuse](https://langfuse.com) documentation, published as plain Markdown for AI agents. Every page is available as Markdown by appending `.md` to its URL, or by sending an `Accept: text/markdown` header. This page: `https://langfuse.com/docs.md`.

### Querying these docs

If the answer is not on this page, query the documentation instead of guessing:

- **Semantic search** across all Langfuse docs, returning an answer with the relevant pages and excerpts. Ask a specific, self-contained question:

  ```bash
  curl -sG "https://langfuse.com/api/search-docs" --data-urlencode "query=How do I trace a LangGraph agent?"
  ```

- **Index of every page**: <https://langfuse.com/llms.txt>, with per-section indexes [llms-docs.txt](https://langfuse.com/llms-docs.txt), [llms-integrations.txt](https://langfuse.com/llms-integrations.txt), and [llms-self-hosting.txt](https://langfuse.com/llms-self-hosting.txt).

### Before writing Langfuse code

- **Install the [Langfuse Agent Skill](https://langfuse.com/docs/api-and-data-platform/features/agent-skill).** It encodes Langfuse's own best practices for instrumentation, prompt management, and evaluation, and materially improves results.
- **Read [What does a good trace look like?](https://langfuse.com/docs/observability/best-practices.md)** before instrumenting an application.
- **Verify endpoints, parameters, and response fields** against the [API reference](https://api.reference.langfuse.com) instead of inferring them from code examples.
- **Use the [Langfuse CLI](https://langfuse.com/docs/api-and-data-platform/features/cli)** (`npx @langfuse/cli api <resource> <action>`) to read or write traces, prompts, datasets, and scores from the terminal.

Found an error in these docs? Please open an issue at <https://github.com/langfuse/langfuse-docs/issues>.
