> ## Documentation Index
> Fetch the complete documentation index at: https://raindrop.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Overview

> Query your Raindrop data directly from your AI coding assistant.

Raindrop's MCP server brings **Raindrop Triage** — our expert investigator for AI applications — into your coding assistant. Ask it what's happening in your app, hand off its findings to your local agent, and go from "something looks off" to a code fix without leaving your editor.

The server is hosted at `https://mcp.raindrop.ai/mcp` — there's nothing to install. Add the configuration to your editor and start asking.

## Investigate with Raindrop Triage

The Raindrop agent continuously analyzes your traces, signals, and user feedback to surface broader distribution changes and one-off unique failure modes — not just metrics, but concrete findings with root-cause hypotheses and the events that demonstrate them.

Through the MCP server, your local coding agent can pull those investigations in and collaborate on the fix:

1. **Ask Raindrop what's wrong.** "Ask Raindrop agent what issues happened today" checks both Issue Detection reports for broader distribution changes and Stumbles for individual interactions where something bad happened.
2. **Drill in.** Your local agent pulls the full trace for any flagged event: prompts, tool calls, model outputs, timings, errors.
3. **Fix it in code.** With the investigation and trace in context, your local agent can locate the relevant prompt or handler in your repo and propose a patch — you stay in your editor the whole time.

Example session:

```
You:        Ask Raindrop agent what issues happened today.
Assistant:  Raindrop flagged 3 issues. The top one is "Tool calls failing
            with malformed JSON" — 47 events, started ~9am.
You:        Pull the trace for one of those events and find the root cause.
Assistant:  The model is emitting trailing commas in the arguments object.
            It's our `search_orders` tool prompt — line 42 of tools/orders.ts.
            Want me to tighten the schema and add a repair step?
```

## Other capabilities

Beyond agent-led investigations, the MCP server exposes the rest of your Raindrop data:

* **Pull an activity overview** — event trends, recent issues, and top signals from your dashboard.
* **Check known findings directly** — pair Issue Detection reports for broader distribution changes with Stumbles for one-off unique failure modes.
* **Search events semantically** — find conversations matching a description (e.g. "users frustrated by load times").
* **Inspect traces** — full execution tree for any event, including timing, tool calls, and errors.
* **Quantify signals** — count and filter events matching a signal over a time range.
* **Create signals** — describe a behavior to track, review the examples Raindrop finds, refine the draft, and create the signal.
* **Browse user history** — list conversations for a specific user.
* **Manage Memory** — list, create, edit, and delete the customer-specific context Raindrop uses across product surfaces.
* **Triage issues** — once you've shipped a fix, resolve an issue (or ignore / reopen it, or change its priority) without leaving your editor.

More prompts to try:

* "Show me an overview from Raindrop of what's happening in my app"
* "Find Raindrop events where users are getting bad responses"
* "How many Raindrop events matched the 'tool\_failure' signal this week?"
* "Create a signal in the Support project for users reporting they were charged twice."
* "List Raindrop conversations for user \[ID]"
* "Show me what Raindrop remembers about this project"
* "Mark that Raindrop issue as resolved — I just deployed the fix"

<Note>
  Resolving, ignoring, reopening, or reprioritizing an issue; editing Memory; and creating a signal
  are write actions. These are available to **API-key** callers and to **OAuth** clients that were
  granted the matching write scope (`write:issues`, `write:memories`, or `write:signals`). Read-only
  tools need no special scope. MCP can create new signals today; refining an existing saved signal
  through MCP is coming soon.
</Note>

## Authentication

**OAuth 2.1** is the default. Supported MCP clients handle it automatically — on first connection, your editor opens a browser window to authenticate. No tokens to manage.

**API key** is the alternative for clients that don't support OAuth, or for non-interactive environments (CI, shared setups). At [app.raindrop.ai](https://app.raindrop.ai), go to **settings → API Keys → Query SDK → Manage API Keys → New API Key**, then pass it as a Bearer token:

```
Authorization: Bearer <your-api-key>
```

## Connect your editor

<Tabs>
  <Tab title="Claude Code">
    Run this command in your project directory:

    ```bash theme={null}
    claude mcp add raindrop --transport http https://mcp.raindrop.ai/mcp
    ```

    Claude Code supports OAuth natively — it will open a browser window to authenticate on first use.

    To use an API key instead:

    ```bash theme={null}
    claude mcp add raindrop --transport http https://mcp.raindrop.ai/mcp --header "Authorization: Bearer YOUR_API_KEY"
    ```
  </Tab>

  <Tab title="Codex">
    Add the server, then authenticate with OAuth:

    ```bash theme={null}
    codex mcp add raindrop --url https://mcp.raindrop.ai/mcp
    codex mcp login raindrop
    ```

    Codex [supports Streamable HTTP MCP servers and OAuth](https://developers.openai.com/codex/mcp). Current Codex versions discover Raindrop's OAuth resource automatically. Codex opens a browser window to authenticate, and the CLI and IDE extension share the same MCP configuration.

    To use an API key instead, set `RAINDROP_API_KEY` in the environment used to launch Codex, then add the server:

    ```bash theme={null}
    codex mcp add raindrop --url https://mcp.raindrop.ai/mcp --bearer-token-env-var RAINDROP_API_KEY
    ```

    Codex stores the environment variable name, not the API key. For CLI use, configure the variable in your shell profile or secret manager. For the IDE extension, ensure your editor inherits it from its launch environment. Do not commit the key.
  </Tab>

  <Tab title="Devin">
    You must be an **Admin** of your Devin account to add a custom MCP server.

    In Devin, go to **Settings → Connectors → MCP Marketplace → Add Custom MCP** and fill out the form:

    | Field                     | Value                                                |
    | ------------------------- | ---------------------------------------------------- |
    | **Name**                  | `Raindrop`                                           |
    | **Description**           | Raindrop is an observability platform for AI agents. |
    | **Transport type**        | `HTTP`                                               |
    | **Server URL**            | `https://mcp.raindrop.ai/mcp`                        |
    | **Authentication method** | `Authorization header`                               |
    | **Authorization header**  | `Authorization: Bearer YOUR_API_KEY`                 |

    Devin requires an API key — generate one at [app.raindrop.ai](https://app.raindrop.ai) under **Settings → API Keys → Query SDK → Manage API Keys → New API Key**.
  </Tab>

  <Tab title="Cursor">
    Add to your Cursor MCP settings (`.cursor/mcp.json`):

    ```json theme={null}
    {
      "mcpServers": {
        "raindrop": {
          "url": "https://mcp.raindrop.ai/mcp"
        }
      }
    }
    ```

    Cursor handles OAuth automatically. Restart Cursor to activate.

    To use an API key instead, add a `headers` field:

    ```json theme={null}
    {
      "mcpServers": {
        "raindrop": {
          "url": "https://mcp.raindrop.ai/mcp",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="VS Code">
    Add to your VS Code settings (`.vscode/mcp.json`):

    ```json theme={null}
    {
      "servers": {
        "raindrop": {
          "type": "http",
          "url": "https://mcp.raindrop.ai/mcp"
        }
      }
    }
    ```

    VS Code handles OAuth automatically.

    To use an API key instead, add a `headers` field:

    ```json theme={null}
    {
      "servers": {
        "raindrop": {
          "type": "http",
          "url": "https://mcp.raindrop.ai/mcp",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="Windsurf">
    Add to your Windsurf MCP configuration (`~/.codeium/windsurf/mcp_config.json`):

    ```json theme={null}
    {
      "mcpServers": {
        "raindrop": {
          "serverUrl": "https://mcp.raindrop.ai/mcp"
        }
      }
    }
    ```

    Windsurf handles OAuth automatically.

    To use an API key instead, add a `headers` field:

    ```json theme={null}
    {
      "mcpServers": {
        "raindrop": {
          "serverUrl": "https://mcp.raindrop.ai/mcp",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="Other">
    Any MCP-compatible client can connect using:

    * **Transport**: Streamable HTTP
    * **URL**: `https://mcp.raindrop.ai/mcp`
    * **Auth**: API key, or OAuth 2.1 for supported clients

    If you're connecting a custom hosted client that uses its own HTTPS OAuth callback, [contact us](mailto:support@raindrop.ai) with the client name and exact callback URL so we can enable OAuth for it. Otherwise, use an API key as `Authorization: Bearer <key>`.

    Consult your client's documentation for its MCP server configuration.
  </Tab>
</Tabs>

## Troubleshooting

**Tools not showing up in my editor**

Verify your MCP configuration is correct and restart your editor. Check that the server URL is exactly `https://mcp.raindrop.ai/mcp`. In Claude Code, run `claude mcp list` or `/mcp`. In Codex, run `codex mcp list`.

**Authentication failed**

If using OAuth, try disconnecting and re-authenticating — your editor will reopen the browser auth flow. If using an API key, check that the header format is exactly `Authorization: Bearer <token>` with no extra whitespace.

**Dynamic registration reports `invalid_redirect_uri`**

Raindrop only accepts OAuth callbacks configured for trusted MCP clients. [Email support](mailto:support@raindrop.ai) with the client name and exact redirect URI so we can enable OAuth for it. Otherwise, use an API key.