Ragas vs Langfuse is usually the wrong framing, because they solve different halves of RAG evaluation. Ragas is a free Apache 2.0 Python library that computes metrics such as faithfulness, answer relevancy and context precision. Langfuse is an open source LLM observability platform (MIT core, cloud or self hosted) that stores traces, datasets and scores over time. Langfuse's own docs say the split is clean: Ragas defines and computes the metric; Langfuse stores the score next to the trace. Use Ragas alone for local scoring, Langfuse alone if managed judges or code evaluators are enough, and both when you want Ragas numbers on Langfuse experiments and production traces.

On Nov 4, 2026 we checked the wiring against current packages (Ragas 0.4.3, Langfuse Python SDK 5.1.0) without calling a paid model or a Langfuse Cloud project. The numbers and the caveats are below.

What's new (November 14, 2026): Ragas shipped 0.4.4 on November 13, its first release since January. It fixes the langchain-community import failure, patches CVE-2026-6587 in the multimodal metrics, and works again with current Claude models. We installed it in a clean Python 3.13 venv on November 14; ID based recall and precision still returned 0.667 on our toy sample, so the Langfuse wrapper code below is unchanged.

Ragas vs Langfuse at a glance

ItemRagasLangfuse
What it isPython metrics library for RAG and LLM appsTracing, datasets, experiments and scores platform
LicenseApache 2.0MIT for the open source core; Enterprise features gated
HostingLocal; you run the codeCloud (Hobby free) or self host with Docker or Kubernetes
Price (checked Nov 4, 2026)Free; you pay judge and embedding callsHobby free (50k units a month, 2 users, 30 day data); Core 29 dollars a month; Pro 199 dollars a month
What it storesScore tables you keep yourselfTraces, observations, datasets, experiment runs, scores
RAG metricsFaithfulness, response relevancy, context precision and recall, factual correctness, ID based and string metricsManaged LLM judges (including Ragas partnered catalog entries), code evaluators, and any score you push via SDK
Production monitoringNone built inTrace UI, filters, dashboards, alerts, online evaluators
Latest we checkedPyPI 0.4.4, released November 13, 2026 (0.4.3 before that, from January 13)langfuse Python package 5.2.0 on PyPI (Nov 5, 2026); Cloud pricing page Nov 4, 2026

What Ragas does well

Ragas gives you named RAG metrics with published definitions. Faithfulness splits an answer into claims and asks a judge whether each claim is supported by the retrieved context. Response relevancy checks how on topic the answer is for the question. Context precision and recall look at retrieval quality. Some metrics need no model at all: ID based context recall and precision compare retrieved document IDs with reference IDs on your CPU.

That makes Ragas strong for offline gates and for production samples where you already captured the question, contexts and answer. It does not give you a dashboard, a dataset UI, retention rules or a place to compare this week's run with last week's. Our RAG evaluation metrics guide walks through the metric names against DeepEval and TruLens. For a code first walkthrough, see RAG evaluation through Python.

What Langfuse does well

Langfuse is built to keep the evidence of what your app did. You send traces and observations (including OpenTelemetry), store datasets of inputs, run experiments that execute a task against those items, and attach scores to traces, observations, sessions or dataset runs. The experiments via SDK docs cover concurrent task runs, item level and run level evaluators, and CI friendly reruns.

For RAG specifically you have three scoring paths that all write to the same score model: Ragas metrics as SDK evaluators, managed LLM as a judge evaluators that run server side (the catalog includes evaluators built with Ragas), and code evaluators for deterministic checks. Human annotation queues sit on top for review. If you are choosing a tracing host rather than a metrics library, start with Langfuse vs LangSmith and our best LLM observability tools roundup.

How Ragas and Langfuse fit together

Langfuse publishes a dedicated integration page, Run Ragas evaluations on Langfuse experiments and traces. The recommended offline path is:

  1. Install langfuse, ragas and a judge stack (their example uses langchain-openai).
  2. Initialize Ragas metrics once, assign a wrapped LLM (and embeddings for metrics that need them), and call metric.init(RunConfig()).
  3. Put questions in a Langfuse dataset (no expected output needed for reference free metrics).
  4. Define a task that returns both answer and contexts so evaluators see the same retrieval the model saw.
  5. Wrap each metric as an async evaluator that builds a SingleTurnSample and awaits single_turn_ascore, then returns Evaluation(name=..., value=float(score)).
  6. Call dataset.run_experiment(...) with those evaluators.

Scores named after the metrics (for example faithfulness, answer_relevancy) attach to each item's trace and to the dataset run, so consecutive experiments are comparable in the UI.

For live traffic, the same page documents a batch path: fetch a sample of observations, score with Ragas, then write scores back with langfuse.create_score(name=..., value=..., trace_id=...). Ragas's own Langfuse howto describes the same idea (score each trace or score a periodic batch). Reference free metrics matter here: faithfulness and answer relevancy do not need a ground truth answer, so production traces that already store question, contexts and answer can be scored without labeling.

What we tested on Nov 4, 2026

We did not open a Langfuse Cloud project or call a judge model. We did confirm the packages and the local metric math that the integration depends on.

from ragas.metrics.collections import (
    IDBasedContextRecall,
    IDBasedContextPrecision,
)
from ragas.dataset_schema import SingleTurnSample
from langfuse import Evaluation

sample = SingleTurnSample(
    retrieved_context_ids=["a", "b", "c"],
    reference_context_ids=["a", "c", "d"],
)
print(IDBasedContextRecall().single_turn_score(sample))
print(IDBasedContextPrecision().single_turn_score(sample))
print(Evaluation(name="faithfulness", value=0.8))

Both ID metrics returned about 0.667 on that toy sample (two of three relevant IDs retrieved; two of three retrieved IDs relevant). Evaluation(name=..., value=...) constructed cleanly on langfuse 5.1.0. Importing IDBasedContextRecall from ragas.metrics still works but prints a deprecation warning pointing at ragas.metrics.collections. Older docs that say "SDK v4" for run_experiment still describe APIs present in 5.1.0 (get_client, Evaluation, run_experiment on datasets). A full cloud experiment needs Langfuse keys and a judge model; we left that for your project.

If you are comparing Ragas to a closed platform instead of to Langfuse, our Ragas vs LangSmith guide covers wrapping the same metrics inside LangSmith's evaluate().

Maintenance and risk on the Ragas side

Ragas is still the metric brand many teams search for, but the release cadence slowed sharply this year. Between 0.4.3 on January 13, 2026 and 0.4.4 on November 13, 2026 there was no release at all. Our earlier LangSmith comparison noted the last main branch commit we could verify was February 24, 2026, an unanswered maintenance question on GitHub (issue #3004), and CVE-2026-6587 (SSRF in the multimodal faithfulness path for versions 0.2.3 through 0.4.3, low severity), which the 0.4.4 notes say is now fixed. Upgrade to 0.4.4, pin the version, prefer ID based or string metrics when you can, and keep the Langfuse evaluator wrappers thin so you can swap DeepEval or a managed judge later without losing experiment history.

Langfuse, by contrast, ships frequent SDK releases: 5.2.0 followed 5.1.0 on November 5, 2026 with batch evaluation fixes (it keeps paging past empty observation pages and allows 60 seconds per page fetch). Langfuse also documents self hosting of the MIT core. For licensing nuance on commercial use of the cloud and the EE folders, see Is Langfuse free for commercial use.

What each costs

Ragas costs nothing beyond your judge and embedding calls. Faithfulness typically makes multiple judge calls per example. ID based metrics are free on CPU.

Langfuse Cloud pricing on Nov 4, 2026: Hobby is free with 50,000 units a month, 30 days of data access and 2 users. Core is 29 dollars a month with 100,000 units, 90 days of data and unlimited users. Pro is 199 dollars a month with the same included units, 3 years of data access, higher rate limits and compliance reports. Paid plans bill extra units on a graduated scale starting at 8 dollars per 100,000 units. A billable unit is a trace, an observation or a score, so every Ragas score you write back counts. Self hosting the open source stack has no licence fee; you pay the infrastructure. Details: Langfuse pricing.

Which should you pick?

  • Ragas alone when you want portable metric code, no account, and a CSV or notebook is enough history.
  • Langfuse alone when tracing, prompt versions and managed or code evaluators cover your quality bar, and you would rather not depend on Ragas's release pace.
  • Both when your team already trusts Ragas metric names and wants those exact scores on Langfuse dataset runs and sampled production traces. That is the path Langfuse documents.
  • Langfuse plus another library (DeepEval, custom judges) when you need active maintenance or different metric definitions, still using Langfuse for storage and comparison.
  • Neither as a pair if your stack is already LangSmith centered; use Ragas vs LangSmith instead of forcing Langfuse into that design.

FAQ

Is Ragas vs Langfuse a real either or choice?

Usually not. Ragas scores answers; Langfuse stores traces and scores. Langfuse's integration docs present them as complementary. You only choose one when you refuse a second dependency or when managed judges already match your rubric.

Can I run Ragas metrics inside Langfuse experiments?

Yes. Wrap each metric as an evaluator that returns a Langfuse Evaluation, pass the list to dataset.run_experiment, and keep the task output shaped with answer and contexts. Official steps live on the Langfuse Ragas integration page.

Do Ragas scores on Langfuse need ground truth answers?

Not for the reference free metrics used in the official example (faithfulness, answer relevancy). Those compare the answer with the question and retrieved contexts. Reference based Ragas metrics still need an expected output per dataset item.

Is Langfuse free if I only want Ragas scores?

Hobby Cloud is free within unit and seat limits, and self hosting the MIT core is free of licence fees. Scores count as billable units on Cloud, and judge model spend sits outside Langfuse. Read the pricing page before you sample every production trace.

Should I pick Langfuse or LangSmith to store Ragas scores?

Both can wrap Ragas evaluators. Pick Langfuse when you want open source self hosting and MIT core. Pick LangSmith when you already live in the LangChain or LangGraph tracing model. See Langfuse vs LangSmith for the platform comparison and Ragas vs LangSmith for the LangSmith wiring we tested earlier.

Is Ragas still maintained?

Yes, though the pace is slow. Version 0.4.4 arrived on November 13, 2026, ten months after 0.4.3, with an import fix and a patch for CVE-2026-6587. Upgrade and pin it, and keep your Langfuse wrappers easy to replace in case the gap between releases opens up again.