Mezmo MCP

Mezmo's remote MCP server connects AI assistants to Mezmo's Observability platform so you can run advanced root-cause analysis, discover pipelines, and export logs without hosting anything yourself.

GitHub

Mezmo MCP Server (Model Context Protocol)

Mezmo MCP is a remote Model Context Protocol (MCP) server that lets AI assistants and IDE chat agents interact with the Mezmo observability platform via the Model Context Protocol. Use it for streamlined observability, log analysis, and root-cause analysis in your favorite tools.

Add Mezmo MCP and you can:

🕵️ Run advanced Root-cause analysis over recent logs
📦 List and describe Pipelines
📤 Export and filter Logs with powerful query syntax

Mezmo MCP Server (Model Context Protocol)

Overview

Mezmo MCP is a remote MCP server that connects AI assistants and IDE chat to Mezmo so you can run advanced root-cause analysis, discover pipelines, and export logs without hosting anything yourself. It’s built for observability use cases and works across many popular MCP clients.

Available Tools & Examples

analyze_logs_for_root_cause_relative_time: analyze logs over a relative window
- Example: analyze my logs from the last 30 minutes and determine root cause for any issues that you find
analyze_logs_for_root_cause_time_range: analyze logs between specific timestamps
- Example: analyze errors between 2025-01-01T10:00:00Z and 2025-01-01T11:00:00Z
deduplicate_logs_relative_time: deduplicate similar logs over a relative window
- Example: deduplicate error logs from the last hour for app "checkout-service"
deduplicate_logs_time_range: deduplicate similar logs between specific timestamps
- Example: deduplicate logs from 2025-01-01T10:00:00Z to 2025-01-01T11:00:00Z
export_logs_relative_time: export raw logs over a relative window
- Example: export error logs from the last 30 minutes for app "my-app-frontend"
export_logs_time_range: export raw logs between specific timestamps
- Example: export logs from 2025-01-01T10:00:00Z to 2025-01-01T11:00:00Z with level error
list_pipelines: list all pipelines
- Example: list all my pipelines
get_pipeline: get details for a pipeline by ID
- Example: show me details for pipeline <pipeline id>

Best Practices

Start broad for root-cause analysis
- If the query is too narrow, our RCA can't do its thing. Cast a wide net, and if needed, specify app/service/level in subsequent queries.
Prefer analyze_logs_for_root_cause or deduplicate_log tools for insights
- These tools deduplicate and groups similar logs for better summaries, allowing the results to fit into finite LLM context windows.
Use relative time ranges
- Prefer values like last_15_minutes, last_hour when supported.
Keep prompts simple; add filters gradually
- Add app, host, level, and query filters step by step.
Use export_logs for raw data only
- For dashboards or offline analysis, use export_logs; otherwise prefer RCA.

Installation

Requirements

A Mezmo Service Key (generate one in your Mezmo dashboard under Settings > API Keys; see Mezmo docs for details)
Node.js ≥ 18 (only needed for clients that use the mcp-remote bridge)
One of the supported MCP clients below

For every client we follow a simple rule:

Supports remote URL? → configure it with a url that points to https://mcp.mezmo.com/mcp and include the Authorization header.
StdIO-only client? → use the mcp-remote bridge:

AUTH_HEADER="Bearer <SERVICE KEY>" npx mcp-remote https://mcp.mezmo.com/mcp \
  --header "Authorization:${AUTH_HEADER}"

Client Configurations

Expand a section below to see setup instructions for your preferred editor or tool.

Cursor natively supports remote MCP servers, so you only need a remote configuration.

Clicking the Install MCP Server badge opens Cursor and automatically adds the mezmo entry to your ~/.cursor/mcp.json with a placeholder for the Service Key. After it’s created, edit the file and replace <SERVICE KEY> with your actual Mezmo service key. Restart Cursor for changes to take effect. The final configuration should look like the example below.

{
  "mcpServers": {
    "mezmo": {
      "url": "https://mcp.mezmo.com/mcp",
      "headers": {
        "Authorization": "Bearer <SERVICE KEY>"
      }
    }
  }
}

Windsurf also supports remote servers via the serverUrl field.

{
  "mcpServers": {
    "mezmo": {
      "serverUrl": "https://mcp.mezmo.com/mcp",
      "headers": {
        "Authorization": "Bearer <SERVICE KEY>"
      }
    }
  }
}

{
  "mcpServers": {
    "mezmo": {
      "url": "https://mcp.mezmo.com/mcp",
      "headers": {
        "Authorization": "Bearer <SERVICE KEY>"
      }
    }
  }
}

VS Code’s Copilot Chat supports remote MCP servers with HTTP transport.

"mcp": {
  "servers": {
    "mezmo": {
      "type": "http",
      "url": "https://mcp.mezmo.com/mcp",
      "headers": {
        "Authorization": "Bearer <SERVICE KEY>"
      }
    }
  }
}

{
  "mcp": {
    "servers": {
      "mezmo": {
        "type": "http",
        "url": "https://mcp.mezmo.com/mcp",
        "headers": {
          "Authorization": "Bearer <SERVICE KEY>"
        }
      }
    }
  }
}

Zed does not support remote URLs yet, so use the mcp-remote bridge.

{
  "context_servers": {
    "Mezmo": {
      "command": {
        "path": "npx",
        "args": [
          "mcp-remote",
          "https://mcp.mezmo.com/mcp",
          "--header",
          "Authorization:${AUTH_HEADER}"
        ],
        "env": {
          "AUTH_HEADER": "Bearer <SERVICE KEY>"
        }
      },
      "settings": {}
    }
  }
}

{
  "mcpServers": {
    "mezmo": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.mezmo.com/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <SERVICE KEY>"
      }
    }
  }
}

Claude Code supports remote URLs:

claude mcp add --transport http mezmo https://mcp.mezmo.com/mcp \
  --header "Authorization: Bearer <SERVICE KEY>"

{
  "mcpServers": {
    "Mezmo": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.mezmo.com/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <SERVICE KEY>"
      }
    }
  }
}

{
  "mcpServers": {
    "mezmo": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.mezmo.com/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <SERVICE KEY>"
      }
    }
  }
}

{
  "mcpServers": {
    "mezmo": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "mcp-remote",
        "https://mcp.mezmo.com/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <SERVICE KEY>"
      }
    }
  }
}

Add a new MCP and enter:

AUTH_HEADER="Bearer <SERVICE KEY>" npx mcp-remote https://mcp.mezmo.com/mcp \
  --header "Authorization:${AUTH_HEADER}"

Roo Code supports remote URLs:

{
  "mcpServers": {
    "mezmo": {
      "type": "streamable-http",
      "url": "https://mcp.mezmo.com/mcp",
      "headers": {
        "Authorization": "Bearer <SERVICE KEY>"
      }
    }
  }
}

{
  "command": "npx",
  "args": [
    "mcp-remote",
    "https://mcp.mezmo.com/mcp",
    "--header",
    "Authorization:${AUTH_HEADER}"
  ],
  "env": {
    "AUTH_HEADER": "Bearer <SERVICE KEY>"
  }
}

{
  "mcpServers": {
    "mezmo": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.mezmo.com/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <SERVICE KEY>"
      }
    }
  }
}

Qodo Gen supports remote URLs:

{
  "mcpServers": {
    "mezmo": {
      "url": "https://mcp.mezmo.com/mcp",
      "headers": {
        "Authorization": "Bearer <SERVICE KEY>"
      }
    }
  }
}

{
  "mcpServers": {
    "mezmo": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.mezmo.com/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <SERVICE KEY>"
      }
    }
  }
}

{
  "Mezmo": {
    "command": "npx",
    "args": [
      "mcp-remote",
      "https://mcp.mezmo.com/mcp",
      "--header",
      "Authorization:${AUTH_HEADER}"
    ],
    "env": {
      "AUTH_HEADER": "Bearer <SERVICE KEY>"
    },
    "working_directory": null,
    "start_on_launch": true
  }
}

Opencode supports remote URLs:

"mcp": {
  "mezmo": {
    "type": "remote",
    "url": "https://mcp.mezmo.com/mcp",
    "headers": {
      "Authorization": "Bearer <SERVICE KEY>"
    },
    "enabled": true
  }
}

Add to ~/.codex/config.toml:

[mcp_servers.mezmo]
command = "npx"
args = [
  "mcp-remote",
  "https://mcp.mezmo.com/mcp",
  "--header",
  "Authorization:${AUTH_HEADER}",
]
env = { AUTH_HEADER = "Bearer <SERVICE KEY>" }

Codex defaults to being sandboxed, so you'll also need to give it network access. If you want to run in a sandbox mode of workspace-write for example, add this:

[sandbox_workspace_write]
network_access = true

You can either start with a flag like codex --sandbox workspace-write or set a default mode with:

sandbox_mode = "workspace-write"

Troubleshooting

1. `npx` argument-escaping bug

Some clients pass command-line arguments to npx without quoting spaces. This can split the Authorization header (e.g. Bearer and the token become separate arguments) and cause authentication failures.

Work-around: store the header in an environment variable and pass it without spaces:

{
  "command": "npx",
  "args": [
    "mcp-remote",
    "https://mcp.mezmo.com/mcp",
    "--header",
    "Authorization:${AUTH_HEADER}"
  ],
  "env": {
    "AUTH_HEADER": "Bearer <SERVICE KEY>"
  }
}

2. Lost connection to the Mezmo MCP server

If your client shows an error such as “server disconnected” or stops responding to MCP commands:

Disable or remove the Mezmo MCP entry in your client settings.
Re-enable (or re-add) the same entry, or simply restart the client.

This forces the client to establish a fresh connection to the Mezmo MCP backend.

3. 401/403 authentication errors

Verify the Authorization header is present and formatted as Bearer <SERVICE KEY>.
If using npx mcp-remote, prefer the environment variable approach to avoid splitting the header.
Regenerate your Service Key in Mezmo and try again if issues persist.

Next Steps

Once your client is configured you can immediately run natural-language commands such as

analyze my logs from the last 30 minutes and determine root cause for any issues that you find
list all my pipelines
show me details for pipeline <pipeline title>
export error logs from the last 30 minutes for app "my-app-frontend"

Enjoy streamlined observability with Mezmo + AI! 🎉

Related Servers

Claude Code Exporter

Export and organize Claude Code conversations with powerful filtering. Supports CLI and MCP server integration for Claude Desktop.

MicroShift Test Analyzer

Analyzes MicroShift test failures from Google Sheets to correlate them with specific MicroShift versions.

WinCC Unified MCP XT

An MCP server for interfacing with SIEMENS WinCC Unified SCADA systems via their GraphQL API.

EVM MCP Server

Provides blockchain services for over 30 EVM-compatible networks through a unified interface.

Kontxt

Indexes local code repositories to provide codebase context to AI clients.

Universal MCP Server

A universal MCP server with a modular plugin architecture.

MCP API Bridge

A server that bridges Google Sheets, Azure AI, and MQTT APIs.

Projet MCP Server-Client

An implementation of the Model Context Protocol (MCP) for communication between AI models and external tools, featuring server and client examples in Python and Spring Boot.

MediaWiki MCP Server

Enables LLM clients to interact with any MediaWiki wiki using the Model Context Protocol.

Code Runner MCP

Execute JavaScript and Python code in a secure sandbox. Supports Deno for JS/TS and Pyodide for Python, with configurable permissions.