Core Concepts
This page digs into the different concepts of evaluations, and what’s available in Langfuse.
Ready to start?
- Create a dataset to measure your LLM application’s performance consistently
- Run an experiment to get an overview of how your application is doing
- Set up LLM-as-a-Judge to evaluate your live traces
The Evaluation Loop
LLM applications often have a constant loop of testing and monitoring.
Offline evaluation lets you test your application against a fixed dataset before you deploy. You run your new prompt or model against test cases, review the scores, iterate until the results look good, then deploy your changes. In Langfuse, you can do that by running Experiments.
Online evaluation scores live traces to catch issues in real traffic. When you find edge cases your dataset didn’t cover, you add them back to your dataset so future experiments will catch them.
Here’s an example workflow for building a customer support chatbot
- You update your prompt to make responses less formal.
- Before deploying, you run an experiment: test the new prompt against your dataset of customer questions (offline evaluation).
- You review the scores and outputs. The tone improved, but responses are longer and some miss important links.
- You refine the prompt and run the experiment again.
- The results look good now. You deploy the new prompt to production.
- You monitor with online evaluation to catch any new edge cases.
- You notice that a customer asked a question in French, but the bot responded in English.
- You add this French query to your dataset so future experiments will catch this issue.
- You update your prompt to support French responses and run another experiment.
Over time, your dataset grows from a couple of examples to a diverse, representative set of real-world test cases.
Evaluation Methods
Evaluation methods are the functions that score traces, observations, sessions, or dataset runs. You can use a variety of evaluation methods to add scores.
| Method | What | Use when |
|---|---|---|
| LLM-as-a-Judge | Use an LLM to evaluate outputs based on custom criteria | Subjective assessments at scale (tone, accuracy, helpfulness) |
| Scores via UI | Manually add scores to traces directly in the Langfuse UI | Quick quality spot checks, reviewing individual traces |
| Annotation Queues | Structured human review workflows with customizable queues | Building ground truth, systematic labeling, team collaboration |
| Scores via API/SDK | Programmatically add scores using the Langfuse API or SDK | Custom evaluation pipelines, deterministic checks, automated workflows |
When setting up new evaluation methods, you can use Score Analytics to analyze or sense-check the scores you produce.
Experiments
An experiment runs your application against a dataset and evaluates the outputs. This is how you test changes before deploying to production.
Definitions
Before diving into experiments, it’s helpful to understand the building blocks in Langfuse: datasets, dataset items, tasks, scores, and experiments.
| Object | Definition |
|---|---|
| Dataset | A collection of test cases (dataset items). You can run experiments on a dataset. |
| Dataset item | One item in a dataset. Each dataset item contains an input (the scenario to test) and optionally an expected output. |
| Task | The application code that you want to test in an experiment. This will be performed on each dataset item, and you will score the output. |
| Evaluation Method | A function that scores experiment results. In the context of a Langfuse experiment, this can be a deterministic check, or LLM-as-a-Judge. |
| Score | The output of an evaluation. This can be numeric, categorical, or boolean. See Scores for more details. |
| Experiment Run | A single execution of your task against all items in a dataset, producing outputs (and scores). |
You can find the data model for these objects here.
How these work together
This is what happens conceptually:
When you run an experiment on a given dataset, each of the dataset items will be passed to the task function you defined. The task function is generally an LLM call that happens in your application, that you want to test. The task function produces an output for each dataset item. This process is called an experiment run. The resulting collection of outputs linked to the dataset items are the experiment results.
Often, you want to score these experiment results. You can use various evaluation methods that take in the dataset item and the output produced by the task function, and produce a score based on criteria you define. Based on these scores, you can then get a complete picture of how your application performs across all test cases.
You can compare experiment runs to see if a new prompt version improves scores, or identify specific inputs where your application struggles. Based on these experiment results, you can decide whether the change is ready to be deployed to production.
You can find more details on how these objects link together under the hood on the data model page.
Two ways to run experiments
You can run experiments programmatically using the Langfuse SDK. This gives you full control over the task, evaluation logic, and more. Learn more about running experiments via SDK.
Another way is to run experiments directly from the Langfuse interface by selecting a dataset and prompt version. This is useful for quick iterations on prompts without writing code. Learn more about running experiments via UI.
Langfuse Execution
Local/CI Execution
Langfuse Dataset
Local Dataset
Not supported
While it’s optional, we recommend managing the underlying Datasets in Langfuse as it allows for [1] In-UI comparison tables of different experiments on the same data and [2] Iteratively improve dataset based on production/staging traces.
Online Evaluation
For online evaluation, you can configure evaluation methods to automatically score production traces. This helps you catch issues immediately.
Langfuse currently supports LLM-as-a-Judge and human annotation checks for online evaluation. Deterministic checks are on the roadmap.
Monitoring with dashboards
Langfuse offers dashboards to monitor your application performance in real-time. You can also monitor scores in dashboards. You can find more details on how to use dashboards here.