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

# MCP Server

Scout MCP is a hosted [Model Context Protocol](https://modelcontextprotocol.io/specification/latest) server that gives MCP-compatible clients access to Scout over HTTP. Clients connect directly to Scout's hosted MCP endpoint and use Scout through standard MCP tool calls — without installing or running a separate local server.

Scout MCP is designed for MCP-compatible IDEs, agents, and developer tools that support remote HTTP MCP servers.

<Frame>
  <img src="https://mintcdn.com/scout-171d217e/8AIkth7IYHyGPHoU/images/mcp-server/overview.png?fit=max&auto=format&n=8AIkth7IYHyGPHoU&q=85&s=eba308612541acfb27a3bde2f8bfd0f8" alt="A translucent Scout MCP Server card with the Scout asterisk mark" width="1536" height="1024" data-path="images/mcp-server/overview.png" />
</Frame>

## Setup

To connect a client, you'll need:

* **MCP endpoint:** `https://mcp.scoutos.com/mcp`
* **HTTP header:** `Authorization: Bearer YOUR_SCOUT_TOKEN`

Scout MCP uses **JSON-RPC 2.0 over Streamable HTTP**.

For credentials, use a Scout private key or a signed JWT in the `Authorization` header. Prefer a short-lived signed JWT when possible. Create or copy a key from [Settings → API Keys](/settings/api-keys).

If your client only supports local stdio MCP servers and not remote HTTP MCP servers, you may need a bridge or a different client.

## Connect your client

Configure your MCP client to connect to `https://mcp.scoutos.com/mcp` and include `Authorization: Bearer YOUR_SCOUT_TOKEN` with requests.

### Claude

Claude supports custom connectors using remote MCP servers. To connect Scout, configure it with:

* **Name:** `Scout`
* **Server URL:** `https://mcp.scoutos.com/mcp`
* **Header:** `Authorization: Bearer YOUR_SCOUT_TOKEN`

After saving the connector, confirm Scout's tools appear in Claude.

### Claude Code

```bash theme={null}
claude mcp add --transport http scout https://mcp.scoutos.com/mcp
```

If Claude Code supports custom auth headers in your environment, add your Scout bearer token in the MCP server configuration:

```json theme={null}
{
  "mcpServers": {
    "scout": {
      "url": "https://mcp.scoutos.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_SCOUT_TOKEN"
      }
    }
  }
}
```

After adding the server, reload MCP connections in Claude Code and verify Scout's tools are discovered.

### Codex

```bash theme={null}
codex mcp add scout --url https://mcp.scoutos.com/mcp
```

If needed, configure it directly in `~/.codex/config.toml`:

```toml theme={null}
[mcp_servers.scout]
url = "https://mcp.scoutos.com/mcp"

[mcp_servers.scout.headers]
Authorization = "Bearer YOUR_SCOUT_TOKEN"
```

If your Codex install requires remote MCP support to be enabled, make sure the relevant MCP feature flag is turned on first.

### Cursor

Add a custom MCP server in Cursor using Scout's hosted endpoint:

```json theme={null}
{
  "mcpServers": {
    "scout": {
      "url": "https://mcp.scoutos.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_SCOUT_TOKEN"
      }
    }
  }
}
```

After saving the configuration, reload Cursor's MCP tools and confirm the Scout server is active.

### Visual Studio Code

If you're using a VS Code MCP extension or MCP-compatible setup that supports remote HTTP servers, configure Scout like this:

```json theme={null}
{
  "mcpServers": {
    "scout": {
      "url": "https://mcp.scoutos.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_SCOUT_TOKEN"
      }
    }
  }
}
```

If your MCP extension only supports command-based local servers, you may need a bridge layer or a client that supports remote MCP natively.

### v0 by Vercel

If your v0 environment supports connecting a custom MCP server, use:

* **Name:** `Scout`
* **URL:** `https://mcp.scoutos.com/mcp`
* **Header:** `Authorization: Bearer YOUR_SCOUT_TOKEN`

If the interface accepts JSON configuration, use:

```json theme={null}
{
  "mcpServers": {
    "scout": {
      "url": "https://mcp.scoutos.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_SCOUT_TOKEN"
      }
    }
  }
}
```

## Verify the connection

After connecting, your client should automatically discover Scout's available MCP tools.

A quick smoke test is to ask:

```text theme={null}
List my Scout workflows.
```

```text theme={null}
Show my Scout agents.
```

If the client connects successfully but no tools appear, reload the MCP server configuration and confirm your bearer token is valid.

## Tools

Scout MCP exposes the following tool groups:

| Tool group    | What it covers                                                |
| ------------- | ------------------------------------------------------------- |
| **Agents**    | List, upsert, and interact with Scout agents.                 |
| **Databases** | Create, inspect, update, and delete databases and views.      |
| **Tables**    | Manage tables and schemas inside databases.                   |
| **Documents** | Create, list, update, delete, and batch-edit table documents. |
| **Workflows** | List, inspect, create, and run Scout workflows.               |
| **Triggers**  | List, create, update, delete, and execute Scout triggers.     |
| **Drive**     | Upload and download files in Scout Drive.                     |

## Example usage

Once Scout MCP is connected, here are practical things you can ask your client to do.

### Explore your workspace

```text theme={null}
List my Scout workflows and explain what each one does.
```

```text theme={null}
Show my databases and summarize which tables look customer-related.
```

```text theme={null}
Find the agent named "SDR Assistant" and show its current configuration.
```

### Run and debug workflows

```text theme={null}
Run workflow wf_abc123 with this sample payload and summarize the output:
{ "company": "Acme Corp", "contact_email": "hello@acme.com" }
```

```text theme={null}
Check recent Scout run logs and surface any failures from today.
Show me the error details for any failed runs.
```

### Manage data

```text theme={null}
Upload this CSV to Scout Drive and then sync it to the customers table.
```

```text theme={null}
Create a new database called "Support Tickets" with a table that has
columns: ticket_id, status, priority, and summary.
```

### Work with triggers

```text theme={null}
List all my Scout triggers. Which ones are active?
```

```text theme={null}
Update the Slack trigger on workflow wf_abc123 to only respond
in the #support channel.
```

## Per-call headers

When a Scout agent calls an MCP-backed tool, it can supply request headers for a single call through a reserved `headers` input. These headers are merged over the connection's base auth headers and aren't forwarded as normal tool arguments. Paired with [Variables](/agents/variables), header values can reference runtime data like a per-request token or a tenant ID without exposing those values to the model:

```json theme={null}
{
  "headers": {
    "Authorization": "Bearer {{env.API_KEY}}",
    "X-Tenant": "{{tenant.id}}"
  }
}
```

See [Variables](/agents/variables) for the full syntax and resolution rules.

## FAQ

<AccordionGroup>
  <Accordion title="Does Scout MCP replace the Scout API?">
    No. Scout MCP is a protocol layer on top of Scout's existing APIs. It exists to make Scout easier to use from MCP-compatible clients.
  </Accordion>

  <Accordion title="Does the MCP server store credentials?">
    The default hosted model is designed around client-provided bearer tokens that are passed upstream to Scout APIs.
  </Accordion>

  <Accordion title="Is the service publicly reachable?">
    Yes. The hosted service is exposed publicly at the network layer, while protected access is enforced through Scout authentication.
  </Accordion>

  <Accordion title="What resources can clients access through Scout MCP?">
    The current documented surface includes Agents, Tables, Databases, Documents, Workflows, Triggers, and Drive.
  </Accordion>
</AccordionGroup>

## Troubleshooting

| Issue                                        | What to check                                                               |
| -------------------------------------------- | --------------------------------------------------------------------------- |
| Client says the server is unreachable        | Confirm the endpoint is exactly `https://mcp.scoutos.com/mcp`.              |
| Authentication fails                         | Verify the `Authorization: Bearer YOUR_SCOUT_TOKEN` header is being sent.   |
| Server connects but no tools appear          | Refresh MCP discovery or reload the client.                                 |
| Client only supports OAuth connector flows   | Use the custom MCP server option instead.                                   |
| Client only supports local stdio MCP servers | Use a remote-compatible client or a bridge/proxy approach.                  |
| Tool calls fail after connecting             | Confirm the bearer token has access to the Scout resources being requested. |

## References

<CardGroup cols={2}>
  <Card title="Scout API keys" icon="key" href="/settings/api-keys">
    Create and manage the credentials you use to authenticate Scout MCP.
  </Card>

  <Card title="Scout API reference" icon="book" href="https://ref.scoutos.com">
    Full reference for the Scout HTTP API.
  </Card>

  <Card title="Variables" icon="brackets-curly" href="/agents/variables">
    Reference runtime values in tool inputs, including MCP per-call headers.
  </Card>

  <Card title="MCP specification" icon="file-code" href="https://modelcontextprotocol.io/specification/latest">
    The open standard Scout MCP implements for client-to-service communication.
  </Card>
</CardGroup>