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

# MCP integration

> Connect your own tools to the agent with the Model Context Protocol — databases, internal APIs, ticket systems, anything.

The **Model Context Protocol** (MCP) is an open spec for letting AI agents talk to external tools and data sources. Rumus speaks MCP, so any MCP server — yours or third-party — can plug in and the agent gets new tools to work with.

Use it to give the agent access to:

* Internal databases ("query users where signup\_date > 2026-01-01").
* Ticket / issue systems (open, comment, close tickets from chat).
* Documentation systems (search internal wikis).
* Anything your team has wrapped in an MCP server.

## How MCP works in Rumus

When you add an MCP server, Rumus connects to it on startup, asks it for the list of tools it offers, and registers each tool as something the agent can invoke. From then on, those tools appear alongside Rumus's built-in ones — the agent doesn't treat them differently.

You manage MCP servers at **Settings → AI → MCP**.

## Add a server

<Steps>
  <Step title="Open the MCP tab">
    **Settings → AI → MCP**.
  </Step>

  <Step title="Click Add server">
    A JSON editor opens. Rumus accepts standard MCP server config — either the wrapped-in-`mcpServers` form or a flat object.
  </Step>

  <Step title="Paste your config">
    Two transport types are supported:

    * **`command`** (stdio) — Rumus spawns the process and talks over stdin/stdout.
    * **`url`** (HTTP / SSE) — Rumus connects to a remote MCP endpoint over HTTP.

    See the [Examples](#examples) below.
  </Step>

  <Step title="Save">
    Rumus connects to the server. The status pill flips to **Connected** when the handshake succeeds, or **Disconnected** with the error if it doesn't. Tool counts update as soon as the server lists its tools.
  </Step>
</Steps>

## Examples

### stdio (command) transport

Most local MCP servers — including the ones you write yourself or grab from npm — run via stdio:

```json theme={null}
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    }
  }
}
```

Rumus spawns the process when the server starts and reuses it for every tool call.

### HTTP / SSE (url) transport

For remote servers (your team's internal MCP gateway, a hosted MCP service):

```json theme={null}
{
  "mcpServers": {
    "internal-tools": {
      "url": "https://mcp.example.internal/v1/sse",
      "headers": {
        "Authorization": "Bearer ${INTERNAL_TOKEN}"
      }
    }
  }
}
```

The HTTP/SSE transport is appropriate when the server isn't on your local machine, or when multiple users share it.

### Multiple servers

You can configure as many servers as you want — just add more entries under `mcpServers`. Each one is connected independently and contributes its own tools to the pool.

## Connection status

Each server in the list shows a status badge:

* **Connected** — handshake succeeded, tools are loaded and available to the agent.
* **Disconnected** — connection failed or dropped. Hover for the error; click **Retry** to reconnect.

If a server you're using disappears mid-conversation, the agent reports the failure on the next call to one of its tools and proceeds without it.

## How the agent picks MCP tools

MCP tools are listed in the agent's system prompt with their descriptions. The agent picks tools the same way it picks built-in ones — by matching the tool description against what your prompt is asking for.

That means **good descriptions matter**. An MCP tool exposed as "query the database" gets used a lot; the same tool exposed as "exec\_sql\_v2" gets used much less.

## Approval and MCP tools

By default, MCP tool calls go through the same approval flow as Rumus's built-in tools — see [Command approval](/docs/ai/command-approval). That's deliberately conservative for new servers.

If you trust a particular MCP server, you can mark its tools as auto-approve in the server's settings. Read-mostly tools (search, read, query) are usually safe to auto-approve; mutating tools (create, delete, post) are safer with the prompt left on.

## Pre-configured servers

Rumus does **not** ship pre-configured MCP servers — the page starts empty. You add the ones your team uses.

If you're new to MCP and just want to try it, the [official MCP servers](https://github.com/modelcontextprotocol/servers) list has reference implementations for common things (filesystem access, fetch, sqlite).

## Tips

* **Wrap a single concern per server.** A filesystem server, a database server, and a ticketing server are easier to debug than one big "tools" server.
* **Version your config.** The JSON config can be checked into a dotfiles repo; pasting it into a new install gets you back to your full toolset in seconds.
* **Restart the server after upgrading it.** Rumus reads the tool list at connection time. If the server adds new tools, reconnect (toggle off and on) to pick them up.

<Note>
  MCP setup question we didn't cover? Ask in the [Rumus community](https://www.rumus.ai/community) — server config snippets and debugging tips welcome.
</Note>

## Next steps

<CardGroup cols={2}>
  <Card title="Agentic execution" icon="robot" href="/docs/ai/agentic">
    How tool calls flow once MCP is hooked up.
  </Card>

  <Card title="Command approval" icon="shield" href="/docs/ai/command-approval">
    The same approval gate applies to MCP tool calls.
  </Card>
</CardGroup>