---
updatedAt: 2026-10-03T12:42:45.000Z
agentTools:
projectIndex: https://docs.getmontecarlo.com/llms.txt
---
# MCP Server
How AI agents interact with Monte Carlo
## Overview
The Monte Carlo MCP Server connects your AI agent or assistant directly to Monte Carlo through the Model Context Protocol (MCP). Once connected, your agent can investigate alerts, explore assets and lineage, create and manage monitors, and evaluate AI agent performance โ all without leaving the tools you already work in, like Claude, Cursor, or VS Code.
**Want to see what's possible?** Jump to [What you can do](#what-you-can-do) for copy-paste prompts that get you to value in seconds. The server also publishes ready-to-run **prompts** for common workflows โ see [Guided prompts](#guided-prompts).
An Editor role or above is required.
**Recommended model: Claude Opus 5.5 or later.** Workflows that chain many tool calls, such as onboarding a warehouse or investigating an incident, are where model capability matters most. If your client lets you choose the model, as Claude Code, Claude Desktop and Cursor do, select Claude Opus 5.5 or later.
**Want smarter agents, not just connected ones?** The MCP Server gives your AI agent access to Monte Carlo's tools. The [Agent Toolkit](https://github.com/monte-carlo-data/mc-agent-toolkit) goes further โ it teaches your agent how to use those tools effectively, with pre-built skills for monitoring, code change validations and more. [Get started with the Agent Toolkit](https://docs.getmontecarlo.com/docs/agent-toolkit) โ
## Get connected
Pick the path that matches how you work. Most Claude users should start with the **Claude connector** (option 1) โ it's the fastest and requires no setup. For other AI agents, use **OAuth** (option 2). For automations and service accounts, **API keys** are supported (option 3).
## Option 1: Claude connector (recommended for Claude users)
Monte Carlo is available as an Anthropic-verified connector in the **Claude Connectors Directory**, so there are no keys to manage and nothing to configure.
1. Open the [Monte Carlo connector](https://claude.com/connectors/monte-carlo) in the directory, or in Claude go to **Settings โ Connectors** and find Monte Carlo.
2. Click **Connect**. Your browser opens the Monte Carlo login page.
3. Sign in and click **Allow access** on the consent screen.
That's it โ Claude can now interact with your Monte Carlo account. This works on both Claude (claude.ai) and Claude Desktop.
***
## Option 2: OAuth (recommended for all other agents)
Any MCP client that supports [HTTP transport with OAuth 2.1](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) can connect to Monte Carlo with no API keys.
Monte Carlo registers OAuth clients through Dynamic Client Registration, so there is no OAuth app to create and no client ID or secret to copy. Your client registers itself on first connection. If your client asks for a client ID and secret, use its DCR option instead.
Point your client at the endpoint below using HTTP transport; on first connection it opens your browser to sign in and authorize access.
```
https://mcp.getmontecarlo.com/mcp
```
Most clients just need the URL. A few common examples:
**Command-line clients** (e.g. Claude Code) โ add the server in one line:
```bash
claude mcp add --transport http monte-carlo-mcp https://mcp.getmontecarlo.com/mcp
```
**Config-file clients** (e.g. Cursor, VS Code) โ add the URL to your MCP config:
```json
{
"mcpServers": {
"monte-carlo": {
"url": "https://mcp.getmontecarlo.com/mcp"
}
}
}
```
> VS Code uses a `"servers"` key instead of `"mcpServers"`; otherwise the entry is identical. When the client connects, your browser opens to complete authentication. To confirm it's working, ask your agent: *"Test the Monte Carlo MCP connection."*
### Connect from a Snowflake Cortex Agent
Cortex Agents connect through an [MCP connector](https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-agents-mcp-connectors):
an API integration holding the OAuth config, plus an external MCP server pointing at Monte Carlo.
Steps 1 and 2 are a one-time setup, run once per Snowflake account. Steps 3 and 4 apply to each user and agent.
Requires `CREATE INTEGRATION` on the account and `CREATE EXTERNAL MCP SERVER` on the schema, both
held by `ACCOUNTADMIN` by default.
**Step 1. Create the API integration and MCP server.**
In Snowsight, open a SQL worksheet and set your role to ACCOUNTADMIN, or to a role with CREATE INTEGRATION on the account and CREATE EXTERNAL MCP SERVER on your target schema. Replace . with the schema that will hold the server.
```sql
CREATE API INTEGRATION monte_carlo_mcp_integration
API_PROVIDER = external_mcp
API_ALLOWED_PREFIXES = ('https://mcp.getmontecarlo.com/mcp')
API_USER_AUTHENTICATION = (
TYPE = OAUTH_DYNAMIC_CLIENT
OAUTH_RESOURCE_URL = 'https://mcp.getmontecarlo.com/mcp'
)
ENABLED = TRUE;
CREATE EXTERNAL MCP SERVER ..monte_carlo_mcp_server
WITH DISPLAY_NAME = 'Monte Carlo'
URL = 'https://mcp.getmontecarlo.com/mcp'
API_INTEGRATION = monte_carlo_mcp_integration;
```
Use `OAUTH_DYNAMIC_CLIENT`, not `TYPE = OAUTH2`. The latter requires a static client ID and secret,
which Monte Carlo does not issue.
**Step 2. Attach it to your agent, and grant access.**
You can also add the server from Snowsight under **AI & ML** > **Agents** > **MCP Connectors**.
```sql
ALTER AGENT ADD MCP_SERVER = '..monte_carlo_mcp_server';
GRANT USAGE ON EXTERNAL MCP SERVER monte_carlo_mcp_server TO ROLE ;
GRANT USAGE ON INTEGRATION monte_carlo_mcp_integration TO ROLE ;
```
**Step 3. Authenticate.** Each user authorizes Monte Carlo with an Editor role or above. In Snowflake CoWork, open the sources panel and select **Connectors**, then **Connect**. From the Agent:run API, run
`SYSTEM$START_USER_OAUTH_FLOW('MONTE_CARLO_MCP_INTEGRATION')`, open the returned URL, then pass the query string from the redirect to `SYSTEM$FINISH_OAUTH_FLOW` in the same session:
```sql
SELECT SYSTEM$FINISH_OAUTH_FLOW('state=&authz_code=');
```
**Step 4. Tell the agent when to call Monte Carlo.** Cortex selects tools from your agent's
instructions, so state the check explicitly:
```text
Before presenting any query result, extract the base tables from the FROM and JOIN
clauses and use the Monte Carlo tools to check each one for active alerts, monitoring
coverage, and upstream issues. Report what you find with the results, and lead with a
warning if a table feeding the headline metric has an active incident.
```
See [How to make Claude a trusted analyst](https://montecarlo.ai/blog-how-to-make-claude-a-trusted-analyst-for-your-whole-company#step-3-validate-data-trust-with-live-health-checks)
for the full pattern.
***
## Option 3: API keys (advanced)
Use MCP Server keys when you're running a **service account, CI/automation, or a client that doesn't support HTTP transport or OAuth**. For individual, interactive use, prefer the connector or OAuth above.
MCP Server keys are **scoped credentials** that work only with the MCP Server โ they are not standard API keys, and standard API keys will not work with the MCP Server. Treat the key secret like any other credential and store it securely; if it's exposed, create a new key and revoke the old one.
**Step 1 โ Create MCP Server keys.** Create keys via the UI, CLI, or GraphQL โ flip between the tabs below (the CLI method requires MC CLI v0.141.4+):
```text Via UI
Settings โ API Keys โ Add
Choose "MCP server" as the key type, add a description, then click Add.
Copy the Key id and Key secret.
```
```bash Via CLI
montecarlo mcp create-key --description "Automation key"
```
```graphql Via GraphQL
mutation CreateMcpIntegrationKey($description: String) {
createMcpIntegrationKey(description: $description) {
key {
id
secret
}
}
}
```
**Step 2 โ Add the server to your client.** Key-based clients connect through `mcp-remote` (requires Node.js LTS + npm/npx โ see [Reference & operations](https://docs.getmontecarlo.com/docs/mcp-server-reference-and-operations)). Add the entry to your MCP config, replacing `` and ``:
```json
{
"mcpServers": {
"monte-carlo": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://mcp.getmontecarlo.com/mcp",
"--header",
"Authorization: Bearer :"
]
}
}
}
```
If your client has trouble with the `Authorization` header, use custom headers instead:
```json
"--header", "x-mcd-id: ",
"--header", "x-mcd-token: "
```
> To confirm it's working, ask your agent: *"Test the Monte Carlo MCP connection."*
## What you can do
The MCP Server exposes Monte Carlo as a set of tools your agent can chain together. You don't need to know the tool names โ just describe what you want. Here are some of the most popular workflows, each with a prompt you can try and the kinds of tools the agent reaches for.
### **Example: Triage alerts**
Find what needs attention and act on it:
> *What Monte Carlo alerts do we have in the past 3 days? Triage them and let me know what I need to review first.*
Tools the agent may use: `get_alerts`, `alert_assessment`, `update_alert`.
If your client supports MCP prompts, try `/mcp__monte-carlo__mc-triage past 3 days`
### **Example: Investigate an asset**
Understand a table's health and how data flows into it:
> *Check the health of table X, including its upstream dependencies."* / *"What are the lineage dependencies of table X?*
Tools the agent may use: `search`, `get_table`, `get_asset_lineage`.
If your client supports MCP prompts, try `/mcp__monte-carlo__mc-asset-health table X`
### **Example: Close coverage gaps**
Find unmonitored critical tables and propose monitors:
> *Which critical tables in *`