Multi-Agent Monitoring LangFuse MCP Server

from hardikloglogn

A Model Context Protocol (MCP) server for comprehensive monitoring and observability of multi-agent systems using Langfuse.

🔥🔥🔥✓ VerifiedAccount requiredAdvanced setup

#automation #analytics #devops #git #security #monitoring

Monitoring and observability MCP Server

A Model Context Protocol (MCP) server for comprehensive monitoring and observability of systems using Langfuse.

🎯 What This Does

This MCP server allows you to:

Monitor all your agents in real-time
Track performance metrics (latency, cost, token usage)
Debug failed executions with detailed traces
Analyze agent performance across time periods
Compare different agent versions via metadata filters
Manage costs and set budget alerts
Visualize agent workflows

Project Structure

src/langfuse_mcp_python/server.py CLI entrypoint and stdio transport
src/langfuse_mcp_python/http_server.py Streamable HTTP and SSE transport
src/langfuse_mcp_python/utils/tool_registry.py Tool setup and registration
src/langfuse_mcp_python/tools/ Tool implementations and specs
src/langfuse_mcp_python/integrations/langfuse_client.py Langfuse API client
src/langfuse_mcp_python/core/base_tool.py Shared cache and metrics

Available Tools

Monitoring and Analytics

watch_agents Monitor active agents
get_trace Fetch a trace by ID
analyze_performance Aggregate performance over time
get_metrics Aggregate metrics (latency, cost, tokens)

Scores and Evaluation

get_scores Fetch scores
submit_score Create a score
get_score_configs List score configurations

Prompts

get_prompts List prompts
create_prompt Create a prompt
delete_prompt Delete a prompt

Sessions

get_sessions List sessions

Datasets

get_datasets List datasets
create_dataset Create a dataset
create_dataset_item Add an item to a dataset

Models

get_models List models
create_model Create a model
delete_model Delete a model

Comments

get_comments List comments
add_comment Add a comment

Traces

delete_trace Delete a trace

Annotation Queues

get_annotation_queues List annotation queues
create_annotation_queue Create a queue
get_queue_items List queue items
resolve_queue_item Resolve a queue item

Blob Storage Integrations

get_blob_storage_integrations List integrations
upsert_blob_storage_integration Create or update an integration
get_blob_storage_integration_status Fetch integration status
delete_blob_storage_integration Delete an integration

LLM Connections

get_llm_connections List connections
upsert_llm_connection Create or update a connection

Projects

get_projects List projects
create_project Create a project
update_project Update a project
delete_project Delete a project

Example: `watch_agents`

Monitor all active agents in real-time.

Example:

Show me all active agents from the last hour

Response:

Active Agent Monitoring (last_1h)

Total Traces Found: 15
Showing: Top 10 traces

1. research_agent (Trace: trace-abc12...)
   - Status: completed
   - Session: session-xyz
   - Started: 2026-03-19T10:25:00Z
   - Latency: 1250ms
   - Tokens: 3420
   - Cost: $0.0234

Architecture

MCP Client (Claude, Cursor, etc.)
  -> Langfuse MCP Server (stdio/HTTP)
  -> Langfuse API
  -> Langfuse Platform
  -> Your Langfuse Agents

Security Best Practices

Never commit credentials - Use environment variables
Rotate API keys regularly
Use read-only keys where possible
Enable rate limiting in production
Mask sensitive data in traces

Example Monitoring Workflow

Daily Agent Health Check

Check active agents: watch_agents
Review performance: analyze_performance
Check costs: get_metrics
Investigate failures: get_trace

Agent Optimization Cycle

Establish baseline: analyze_performance for current version metadata
Deploy new version with different metadata
Compare versions by running analyze_performance with version filters
Make data-driven deployment decisions

Cost Control

Track costs: get_metrics grouped by agent
Identify expensive agents
Optimize high-cost operations
Track savings over time

Contributing

Contributions welcome! Please:

Fork the repository
Create a feature branch
Add tests for new functionality
Submit a pull request

License

MIT License - see LICENSE file for details

Acknowledgments

Langfuse - Open-source LLM observability
LangGraph - Agent framework
Model Context Protocol - MCP specification

Roadmap

Version: 1.0.0
Last Updated: March 23, 2026
Status: Production Ready

Copy & paste — that's it

# Install via pip
pip install -r requirements.txt

# Or install from source
git clone https://github.com/yourusername/langfuse-mcp-python.git
cd langfuse-mcp-python
pip install -e .

Before it works, you'll need: LANGFUSE_PUBLIC_KEYLANGFUSE_SECRET_KEYLANGFUSE_HOST

Quick Start

1. Prerequisites

Python 3.11 or higher
A Langfuse account (sign up here)
agents instrumented with Langfuse

2. Installation

# Install via pip
pip install -r requirements.txt

# Or install from source
git clone https://github.com/yourusername/langfuse-mcp-python.git
cd langfuse-mcp-python
pip install -e .

3. Configuration

Create a .env file with your Langfuse credentials:

cp .env.example .env
# Edit .env and add your credentials

Your .env should look like:

LANGFUSE_PUBLIC_KEY=pk-lf-xxxxx
LANGFUSE_SECRET_KEY=sk-lf-xxxxx
LANGFUSE_HOST=https://cloud.langfuse.com

4. Run As Streamable HTTP (URL)

If you want a Streamable HTTP URL that works across all tools, run the server with the Streamable HTTP transport:

python -m langfuse_mcp_python --transport streamable-http --host 127.0.0.1 --port 8000 --path /mcp

python -m langfuse_mcp_python --transport sse --host 127.0.0.1 --port 8000

You can then connect any Streamable HTTP-compatible MCP client to:

http://127.0.0.1:8000/mcp

If you are using Claude Desktop or Cursor, keep the default stdio transport in their configs.

4b. Set Up MCP Client

For Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "langfuse-monitor": {
      "command": "uvx",
      "args": ["--python", "3.11", "langfuse-mcp-python"],
      "env": {
        "LANGFUSE_PUBLIC_KEY": "pk-lf-xxxxx",
        "LANGFUSE_SECRET_KEY": "sk-lf-xxxxx",
        "LANGFUSE_HOST": "https://cloud.langfuse.com"
      }
    }
  }
}

For Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "langfuse-monitor": {
      "command": "python",
      "args": ["-m", "langfuse_mcp_python"],
      "env": {
        "LANGFUSE_PUBLIC_KEY": "pk-lf-xxxxx",
        "LANGFUSE_SECRET_KEY": "sk-lf-xxxxx"
      }
    }
  }
}

5. Instrument Your Agents

Make sure your agents send traces to Langfuse:

from langfuse.langchain import CallbackHandler
from langgraph.graph import StateGraph

# Create Langfuse callback handler
langfuse_handler = CallbackHandler(
    public_key="pk-lf-xxxxx",
    secret_key="sk-lf-xxxxx",
    host="https://cloud.langfuse.com"
)

# Create your agent
workflow = StateGraph(AgentState)
workflow.add_node("planner", planner_node)
workflow.add_node("executor", executor_node)
app = workflow.compile()

# Run with Langfuse monitoring
result = app.invoke(
    {"input": "user query"},
    config={
        "callbacks": [langfuse_handler],
        "metadata": {
            "agent_name": "my_planner_agent",
            "version": "v1.0"
        }
    }
)

Advanced Usage

Filtering Agents

Watch only my research_agent and planner_agent from the last 24 hours

Performance Analysis

Analyze performance of my planner_agent over the last 24 hours

Cost Monitoring

Show cost breakdown by agent for the last week

Deep Debugging

Show trace details for trace-abc123