Langfuse MCP server: tools, limits and setup
Langfuse offers 84 tools across traces, prompts and evaluations, but the top search result is not the real server.
Last verified 1 September 2026 · from Langfuse's documentation, repositories and pricing page
This page is one of 90 in a directory of monitoring and developer tools. Each page checks what an AI coding agent can get out of the tool through its MCP server, the connector that lets the agent query the tool directly.
Summary
The Langfuse MCP server connects your coding agent to what your own AI agents do in production: traces, prompts, evaluations and datasets. Langfuse has no infrastructure monitoring.
The first search result can mislead. A search for Langfuse MCP often surfaces a GitHub repository that exposes 4 prompt tools and has not been touched since February 2025. The real connector is Langfuse Cloud's hosted endpoint, with 79 tools.
One ownership note: ClickHouse acquired Langfuse on 16 January 2026, with published commitments that the open-source model and Cloud continue.
Connect to the hosted server. Set a read-only allowlist before you point an agent at production. Remember that objects Langfuse creates for you, including evaluation scores, are billable.
What is the Langfuse MCP server?
MCP is an open protocol that lets an AI coding agent such as Claude Code or Cursor call a tool's functions, such as listing traces, without anyone writing code against the tool's API.
The agent connects to a server and gains a set of tools it can call on its own, based on what you ask in English.
Langfuse has three MCP servers, and they are not equal:
| Server | Tools | State |
|---|---|---|
Langfuse Cloud MCP · /api/public/mcp | 84 | The real connector. Hosted, streamable HTTP, Basic auth |
langfuse/mcp-server-langfuse on GitHub | 4 | Prompt tools only. 9 commits, all February 2025. Never published to npm. Open issue titled "Abandoned?" with no reply |
Docs MCP · langfuse.com/api/mcp | 4 | Documentation search, unauthenticated. Useful for an agent writing Langfuse instrumentation |
Do not judge the project by the dormant repository. The main repository, langfuse/langfuse, has 34,031 stars and released v4.5.0 and v4.6.0 on 6 August 2026, and reached v4.26.0 on 31 August 2026. The project is active; that one repo is not.
Langfuse covers agent observability in full. It reaches part of the way into release, and part of the way into cost.
| Part of the work | What Langfuse has here | Can an agent reach it |
|---|---|---|
| Code, tests & review | None | No code-review product |
| CI & release | Prompt management: versions and labels | Partial. There is no CI product, build or test pipeline. Prompt management versions the system prompts your agents run on, and promoting a label ships that change. 6 read-write tools cover it |
| Production observability | None | No infrastructure telemetry. Teams run it alongside an infrastructure tool, not instead of one |
| Agent observability & evals | Traces, evals, prompts, datasets | Yes. Core strength, and the product's whole purpose |
| AI cost management | LLM call cost tracking | Partial. Tracks the cost of your LLM calls; there is no cloud cost product |
Langfuse answers questions about your agents, and none about the machines they run on. An agent connected here can tell you which prompt version regressed, what an evaluation scored and what a conversation cost. It cannot tell you that a slow database caused the slow call. This connector sits beside an infrastructure connector; it does not replace one.
What can an AI agent do with Langfuse?
| Task | Tools | Works | Watch out for |
|---|---|---|---|
| Review last night's agent sessions | listObservations getObservation queryMetrics | Yes | Result limits, and the plan's data access window |
| Manage and version prompts | listPrompts getPrompt createTextPrompt updatePromptLabels | Yes | Prompt writes are on by default |
| Run and score evaluations | listEvaluators createEvaluationRule createScore listScores | Yes | Scores created are billable units |
| Build datasets from production traces | upsertDataset upsertDatasetItem createDatasetRunItem listDatasetRuns | Yes | Dataset writes are on by default |
| Queue traces for human annotation | createAnnotationQueue createAnnotationQueueItem updateAnnotationQueueItem | Yes | Queue output is billable units |
| Build dashboards over agent behavior | createDashboard createDashboardWidget addDashboardPlacement | Yes | Nothing documented |
| Correlate an agent failure with infrastructure | No | No infrastructure telemetry exists here |
The distribution of the 84 tools shows what Langfuse is. Datasets, annotation queues, scores and evaluators account for 38 of them, more than all the trace and dashboard tools combined. It is an evaluation tool that stores traces, not a monitoring tool with evaluation added.
What connecting costs before the first question
A context window is the amount of text a model can hold at once, and connecting uses some of it before the agent asks anything. Every tool the server registers sends its name, description and input schema to the model when the session starts. The tool list is charged whether or not a single tool is called.
Langfuse does not publish this figure, and neither does any other vendor in this guide. Because all 84 tools are exposed by default, the second row is what a connection costs unless you restrict it.
| Tool set | Tools | Tokens (GPT-5.6, GPT-5.5) | Tokens (GPT-4, GPT-3.5) | Tokens (Claude Haiku 4.5 to Opus 5) | Share of a 200,000-token window |
|---|---|---|---|---|---|
| Read-only allowlist | 43 | 10,314 to 14,382 | 10,076 to 14,271 | 13,819 to 17,882 | 5.0% to 8.9% |
| Everything, as documented on 18 August 2026 | 79 | 17,964 to 26,238 | 17,519 to 26,062 | 24,117 to 32,038 | 8.8% to 16.0% |
Encodings: GPT-5.6, GPT-5.5 o200k_base; GPT-4, GPT-3.5 cl100k_base; Claude Haiku 4.5 to Opus 5 count_tokens. Counted 18 August 2026 from Langfuse's MCP reference, which publishes each tool's description and full input schema.
The hosted server needs project keys, so tools/list needs an account. The read-only set is every tool named list, get or query, 45 of the 84. The two models in column one share the o200k_base encoding, so they get one count. The spread is formatting, about 40%. Reasoning tokens are output. The tool list is input, charged once at connection.
The Claude figures are measured rather than encoded. Anthropic publishes no local tokenizer, so the definitions were sent to the API's count_tokens endpoint and a no-tools baseline subtracted. The range covers two tokenizer generations rather than two serializations. Haiku 4.5 and Opus 4.6 sit at the low end, Opus 5 and Sonnet 5 at the high end. The gap between them is about a third.
Can Langfuse watch your own AI agents?
Watching your own agents is the job Langfuse exists for, so these signals are the fair test. Checked against Langfuse's documentation, retrieved 13 August 2026.
| Signal | Covered | Notes |
|---|---|---|
| Eval scores on production traces | Yes | Managed and custom evaluators, LLM-as-a-judge, and a score submission API |
| Prompt versioning and correlation | Yes | Prompt management with versions is a core surface, 6 tools |
| Trace-level grouping of agent runs | Yes | Traces with observations. Deletion and retention are keyed on them |
| Datasets and experiments from production data | Yes | 12 dataset tools, plus experiments (2) |
| Human annotation loop | Yes | Annotation queues (10 tools), and the queue output is billable |
| Goal drift | No | Not documented as a signal as of 13 August 2026. Traces record each step, so you can write an evaluator for drift; Langfuse ships none |
| Loop detection | No | Not documented as a signal as of 13 August 2026. Repeated observations are visible inside a trace; nothing flags the repetition as a loop |
| Cache hit rate | No | Not documented as a named signal as of 13 August 2026. Token counts and cost are tracked per observation, and cache behavior is not reported separately from them |
| Agent trace joins the infrastructure trace | No | No infrastructure product to join with. If a slow database made your agent slow, the cause is in the rest of your stack |
Langfuse MCP server limits: where answers come back incomplete
Every limit below is documented. Only the rate limit announces itself, with a 429 and a Retry-After header. The rest arrive silently.
The agent says: “That period has no traces.” The plan's window ends at 30 days.
Each Langfuse Cloud plan includes a data access window: Hobby 30 days, Core 90 days, Pro and Enterprise 3 years. Traces outside the window are simply not returned, and nothing in the response says a window was applied. Self-hosted instances keep data indefinitely by default.
Guard: The agent states the plan's access window next to any no data conclusion about a past period.
The agent says: “That is every observation on the trace.” On API v1 the result stops at 100, silently.
The Observations API returns 50 results by default, and a single trace pages its observations through the same API, so one deep trace arrives 50 at a time. Paging is the normal case and an agent handles it. The problem is the ceiling: version 1 caps at 100 and returns no cursor. A trace with more than 100 observations ends there. The response carries no marker that separates a full result from a truncated one. Version 2 caps at 1,000 and uses cursor pagination, which does say when more remains.
Langfuse's own worked example has 20,070 traces producing 119,500 observations, close to 6 per trace on average, so most traces stay well under the ceiling. Agent runs are the exception: a long tool-using conversation is exactly the trace that passes 100.
Guard: Use API v2 so exhaustion is reported by the cursor, and have the agent state the count it retrieved against the limit it used.
The agent stops answering halfway through an investigation. The day's metrics quota is spent.
Rate limits are per organization, and the tightest one for investigation work is Metrics API v2 on the Hobby plan: 100 requests per day. It is a daily bucket, not a per-minute one, so an exploring agent can exhaust it in one session, after which every metrics call fails until the day rolls over. Core gets 100 per hour, Pro 500 per hour. Payloads cap at 5MB each way.
Guard: The agent watches for 429 responses and reports the Retry-After rather than concluding the data is missing.
The agent says: “I removed the test dataset.” Nothing brings it back.
Deletion through this connector is permanent. Langfuse states plainly that "deleted assets cannot be recovered", and there is no undo, no soft delete and no recovery window. Write tools are on by default, so a delete tool is reachable the moment an agent connects unless an allowlist stops it.
No tool here deletes a trace. The eleven delete tools cover datasets and dataset runs, dashboards and their widgets, evaluators and evaluation rules, models, score configs and annotation queues. Trace deletion is a REST API route instead, capped at 50 requests a day on the Hobby plan. Langfuse also advises against sending more than 30 to 50 trace ids in one delete request. A large cleanup therefore means many separate requests over a long period, and a wrong instruction keeps executing for all of that time. An agent asked to tidy up traces cannot do it through this connector, and may reach for a dataset delete instead.
Guard: Keep every delete tool off the allowlist, and run cleanups from a script you can review rather than from an agent conversation.
The agent says: “I turned on automated evaluation.” Each score it writes is a billed unit.
Objects Langfuse creates are billable. A unit is a trace, an observation or a score. The docs state that scores from LLM-as-a-Judge, annotation queues and experiments all count. Switching on automated evaluation therefore raises the unit count on every trace it touches, and an agent that enables it is making a billing decision.
Observations dominate the total. In Langfuse's own worked example, 20,070 traces produced 119,500 observations. A volume estimate from trace counts alone therefore understates the bill by roughly six times.
Guard: Estimate volume from observations rather than traces, and keep the tools that create evaluators and evaluation rules off the agent's allowlist.
How to configure Langfuse MCP for agents
- 1
Set a read-only allowlist first
Verbatim from the docs: "Both read and write tools are available by default. If you only want to use read-only tools, configure your MCP client with an allowlist." 79 tools are exposed, and some of them change prompts, datasets and scores. Do this before the agent touches production. Each client does this differently. In Claude Code, run
/permissionsand allow only themcp__langfuse__read tools you need, leaving the write tools unapproved. In Cursor, use the per-tool toggles under MCP settings. In Codex, approve tools one at a time as they are first called. There is no server-side read-only flag. - 2
Self-hosting needs one extra variable
Set
LANGFUSE_MCP_ALLOWED_HOSTSor every request returns 403. The endpoint otherwise looks identical to Cloud, so the missing variable is easy to overlook. - 3
Consider the Agent Skill instead
The Agent Skill is a packaged instruction set that teaches a CLI-capable agent to call Langfuse's REST API directly rather than going through MCP tools. For those environments, Langfuse's docs say, verbatim: "Langfuse recommends its Agent Skill instead of the MCP server."
Paste this into your agent’s instructions
This block makes the agent report which API version it used, how many rows came back against the limit, and the plan window it was reading inside.
When you query Langfuse, always report alongside your answer: - The API version used. Use v2; it paginates by cursor and allows 1,000 results against v1's 100. - Rows returned against the limit you set, and whether you paginated to the end. - The plan's data access window (Hobby 30 days, Core 90 days, Pro 3 years) next to any conclusion about a past period. - Any 429 received and its Retry-After. The Hobby metrics budget is 100 calls per day and resets daily. - Any write you performed: prompts, datasets, scores and deletions are live by default, and deletions are permanent. Never state that data does not exist. State that no data was returned under the constraints above. Write your answer in ASD-STE100 Simplified Technical English. Use short sentences with one idea in each.
Do you need the MCP server at all?
For CLI agents, no, and Langfuse itself points that way: its documentation recommends the Langfuse Agent Skill over MCP for CLI-capable environments. MCP keeps its place in clients without a CLI, where the hosted tools are the only interactive route.
The public REST API takes the same Basic auth keys and serves everything the tools wrap. And on the way in, ingestion is OpenTelemetry, so instrumenting an application never required MCP in the first place.
What MCP adds is three things: 84 discoverable tools with descriptions the agent can read, no glue code, and one connection covering prompts, datasets, evals and dashboards together.
Use MCP for interactive work across those surfaces, the Agent Skill for CLI environments per Langfuse's own advice, and the raw API for anything scripted.
Langfuse MCP server setup
There is no binary to run. You need your project's public and secret keys, and the endpoint for your region. The examples below use the EU endpoint, so swap in your region from the table.
If your agent runs in a CLI, remember Langfuse's advice above: the Agent Skill may serve you better than MCP. The configs below are for when you choose MCP anyway.
| Region | Endpoint |
|---|---|
| EU | cloud.langfuse.com/api/public/mcp |
| US | us.cloud.langfuse.com/api/public/mcp |
| Japan | jp.cloud.langfuse.com/api/public/mcp |
| HIPAA | hipaa.cloud.langfuse.com/api/public/mcp |
| Self-hosted | your-domain.com/api/public/mcp |
The self-hosted endpoint additionally requires LANGFUSE_MCP_ALLOWED_HOSTS, or every request returns 403.
Claude Code
The header is base64 of pk-lf-...:sk-lf-... including the colon, which is what the base64 call below produces.
claude mcp add --transport http langfuse \ https://cloud.langfuse.com/api/public/mcp \ --header "Authorization: Basic $(echo -n 'pk-lf-...:sk-lf-...' | base64)"
Cursor
In ~/.cursor/mcp.json for all projects, or .cursor/mcp.json in one.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Codex CLI
Codex reads TOML, so the JSON blocks on this page will not transfer.
[mcp_servers.langfuse]
url = "https://cloud.langfuse.com/api/public/mcp"
http_headers = { Authorization = "Basic <base64 of pk:sk>" }The key is `mcp_servers`, with an underscore. The http_headers line carries the same Basic credentials as every other client; without it Codex connects and every call returns 401.
Every other client
Each block below is the configuration for one client, with the file path and the key that client expects.
Claude Desktop
macOS ~/Library/Application Support/Claude/claude_desktop_config.json. Windows %APPDATA%\Claude\claude_desktop_config.json. There is no CLI. Edit through Settings, Developer, Edit Config, then quit and restart fully for changes to load.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Gemini CLI
~/.gemini/settings.json globally, or .gemini/settings.json per project. CLI: gemini mcp add.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}VS Code Copilot
.vscode/mcp.json per workspace, or your user profile. CLI: code --add-mcp.
{"servers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}The key is `servers`, not `mcpServers`. VS Code is the only client that uses that name; a config copied from another client fails silently.
Windsurf
~/.codeium/windsurf/mcp_config.json, which is the path Windsurf documents. Key mcpServers, the same shape as Cursor.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Zed
~/.config/zed/settings.json, carrying the same endpoint and the same Basic authorization header as the blocks above.
The key is `context_servers`. Zed does not use MCP vocabulary in config, so searching its settings for mcp finds nothing.
Google Antigravity
~/.gemini/config/mcp_config.json globally, or .agents/mcp_config.json per project. Key mcpServers. There is no CLI. Use the /mcp overlay. Supports stdio, streamable HTTP, SSE and websocket.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Amp (Sourcegraph)
~/.config/amp/settings.json or .amp/settings.json, carrying the same endpoint and Basic authorization header. The amp mcp CLI covers approve, doctor and oauth.
The key is namespaced: `amp.mcpServers`. A bare mcpServers block is ignored.
Cline
~/.cline/mcp.json per the docs. The source also reads ~/.cline/data/settings/cline_mcp_settings.json. Key mcpServers. Supports stdio, streamable HTTP and SSE.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Goose (Block)
~/.config/goose/config.yaml, carrying the same endpoint and Basic authorization header.
YAML, and servers are called `extensions`. Goose does not use the MCP vocabulary in config at all. Add one interactively with goose configure, or per session with goose session --with-extension.
Kiro (AWS)
.kiro/settings/mcp.json per workspace, or ~/.kiro/settings/mcp.json globally. Key mcpServers.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Warp
~/.warp/.mcp.json or .warp/.mcp.json. Key mcpServers. Also addable through the /agent-add-mcp skill.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}JetBrains Junie
.junie/mcp/mcp.json per project, or ~/.junie/mcp/mcp.json. Key mcpServers. Manage with /mcp in the CLI.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Roo Code
.roo/mcp.json per project, or the VS Code global storage path under RooVeterinaryInc.roo-cline/mcp_settings.json. Key mcpServers.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Continue
.continue/mcpServers/*.yaml, one file per server, carrying the endpoint and the Basic authorization header.
YAML, and `mcpServers` is a list, not an object. Every JSON client keys servers by name. Continue takes an array, so a converted config will not parse.
Trae
.trae/mcp.json per project, or paste into the UI under Raw Config (JSON). Key mcpServers.
{"mcpServers":{"langfuse":{"type":"http",
"url":"https://cloud.langfuse.com/api/public/mcp",
"headers":{"Authorization":"Basic <base64 of pk:sk>"}}}}Devin
Devin has no config file to edit. Servers are added through a web form in the settings UI, and Devin's documentation states you do not need to write or paste JSON. The same Basic authorization header goes into those fields.
The Docs MCP, separate and unauthenticated
Langfuse also runs a documentation server at https://langfuse.com/api/mcp with four tools: searchLangfuseDocs, getLangfuseDocsPage, getLangfuseOverview and submitFeedback. No auth. Useful for an agent writing Langfuse instrumentation, and unrelated to your project data.
Read-only access, permissions and security
Read-only is an allowlist in your MCP client
Both read and write tools are exposed by default, so the allowlist in your client is the only read-only control.
Auth is HTTP Basic
The server takes the project's public and secret keys, so the keys you hand the agent decide which project the agent can read.
Langfuse has four published security advisories, all first-party and fixed
They matter here because this tool holds prompt and response data. Three are rated medium: an unauthenticated Slack OAuth install path (January 2026), SSO account takeover through a cross-site request forgery (November 2025), and cross-organization member enumeration (November 2025). One is rated low: a member role able to retrieve stored LLM provider API keys (April 2026).
Troubleshooting
- 403 on a self-hosted endpoint
LANGFUSE_MCP_ALLOWED_HOSTSis not set. The self-hosted MCP requires it; Cloud does not.- 401 on connect
- The Basic auth header must be base64 of
pk-lf-...:sk-lf-...with the colon. A common failure is encoding only the secret key. - 429 on metrics calls
- The Hobby plan's Metrics API budget is 100 requests per day, a daily bucket. Wait for the
Retry-After, or upgrade the plan, or self-host, where rate limits are yours to configure. - Old traces are missing
- The cause is the plan's data access window. Hobby is 30 days. The window hides data that is still stored; a retention policy, if one is configured, actually deletes it, and retention deletion cannot be undone.
Langfuse MCP server: Reference
| Item | Value | Scope |
|---|---|---|
| Hosted endpoint | /api/public/mcp on EU, US, JP, HIPAA and self-hosted · transport streamable HTTP · HTTP Basic auth | |
| Tools | 84, recounted group by group against Langfuse's MCP reference on 1 September 2026: datasets 12, annotation queues 10, scores 8, evaluators 8, prompts 6, observations 5, evaluation rules 5, dashboards 5, widgets 5, models 4, comments 3, placements 3, metrics 2, experiments 2, alerts 2, health 1, media 1, feedback 1, migration 1 | |
| Public repo | langfuse/mcp-server-langfuse: 173 stars, 9 commits (all 15 to 16 February 2025), 2 releases, never on npm, 4 prompt tools | |
| Main project | langfuse/langfuse: 34,031 stars · v4.26.0 released 31 August 2026 · MIT license except the ee/ directories | |
| Owner | ClickHouse, which acquired Langfuse on 16 January 2026. Published commitments: the open-source, self-hostable model continues, Cloud keeps running, support unchanged. Self-hosted Enterprise is sold bundled with ClickHouse commercial plans | |
| Rate limits, per organization | Ingestion 1,000/min Hobby, 4,000 Core, 20,000 Pro · Metrics v2 100/day Hobby, 100/hr Core, 500/hr Pro · other APIs 30 to 1,000/min by plan · payloads 5MB each way | Cloud-published. Self-hosted rate limits are set locally |
| Result caps | Observations default 50, v1 max 100, v2 max 1,000 with cursors · Metrics v2 row limit default 100, max 1,000 | Not stated in Langfuse's published API limits, which cover request rates rather than result sizes |
| Data access window | Hobby 30 days · Core 90 days · Pro and Enterprise 3 years | Cloud-published. Self-hosted keeps data indefinitely by default |
| Billable unit | Traces plus observations plus scores, including objects created by Langfuse features. Overage graduated from $8 per 100k units | Cloud only |
| Plans | Hobby free with 50k units. The paid plans each include 100k units: Core $29/mo · Pro $199/mo · Enterprise $2,499/mo | Cloud only |
What engineers report
Langfuse is one of the most widely used agent-observability tools: langfuse/langfuse carries 34,031 stars, shipped v4.26.0 on 31 August 2026, and ClickHouse acquired the company on 16 January 2026. The two Hacker News comments below are what individual engineers said, not a measure of adoption. One recurring question is whether the project is still alive. It is, on every signal above. The dormant MCP repository is why people keep asking.
“Langfuse has ongoing conferences and is still used by many frameworks.”
“I used it, but only briefly to evaluate it. ... Ultimately I found the data model and UI to be both cumbersome and unintuitive.”
Should you connect an agent to Langfuse?
Yes. Best for teams that treat Langfuse as their agent-quality system of record and configure the allowlist before connecting anything autonomous.
- Strongest fit
- Teams shipping LLM features who want the agent working across traces, prompts, datasets and evals in one conversation.
- Main advantage
- 84 tools on a hosted endpoint with regional and HIPAA options, on an open-source, self-hostable product (MIT license, except the
ee/directories) that is actively developed. - Main weakness
- No infrastructure telemetry, so the cause of a slow agent often lives in a system Langfuse cannot see. The best-known GitHub repository,
langfuse/mcp-server-langfuse, is not the connector, so teams lose time finding the real one. - Operational risk
- Write tools are on by default across prompts, datasets and scores, and automated evaluation adds billable units. Deletion is permanent.
From Oodle
One platform for agent traces and infrastructure
Agent traces usually sit in a different product from the rest of your telemetry, so when a slow database makes an agent slow the symptom is in one tool and the cause is in another. Oodle keeps both in one query surface, from $10 per million spans.
See agent observabilityFrequently asked questions
Which MCP server should I use?
The hosted endpoint at /api/public/mcp, 84 tools. Ignore langfuse/mcp-server-langfuse on GitHub: 4 prompt tools, untouched since February 2025. The third surface, the docs server at langfuse.com/api/mcp, answers documentation questions only. For CLI environments, Langfuse recommends its Agent Skill over MCP.
Is it read-only?
No. Both read and write tools are on by default; read-only requires an allowlist in your client.
Why does my agent say older traces do not exist?
Check the plan's data access window: Hobby 30 days, Core 90 days, Pro 3 years. The response does not say a window was applied.
Does Langfuse monitor infrastructure?
No. LLM and agent traces only. Teams run it alongside an infrastructure tool, not instead of one.
Do evaluations increase the bill?
Yes. Scores from LLM-as-a-judge, annotation queues and experiments are billable units like any other object.
