# Connecting to the Wolfram Cloud MCP

Server URL: [https://agenttools.wolfram.com/mcp](https://agenttools.wolfram.com/mcp)

This guide covers how to connect various LLM applications and IDEs to the [Wolfram Cloud MCP](https://wolfr.am/Cloud-MCP) using the Streamable HTTP transport (the current recommended standard). SSE (server-sent events) transport is deprecated in the MCP specification but noted where still relevant.

For information on how to connect to the Wolfram Local MCP instead, go [here](https://wolfr.am/LocalMCP-Docs).

------------------------------------------------------------------------

## Table of Contents

-   [ChatGPT (Web)](#chatgpt-web-)
-   [Claude.ai (Web / Desktop / Mobile)](#claude-ai-web-desktop-mobile-)
-   [Claude Desktop—Local Config Method](#claude-desktop-local-config-method)
-   [Claude Code (CLI)](#claude-code-cli-)
-   [Anthropic API (Direct Integration)](#anthropic-api-direct-integration-)
-   [Cursor IDE](#cursor-ide)
-   [VS Code with GitHub Copilot](#vs-code-with-github-copilot)
-   [GitHub Copilot CLI](#github-copilot-cli)
-   [Other Available Registries](#other-available-registries)
-   [Troubleshooting](#troubleshooting)

------------------------------------------------------------------------

## ChatGPT (Web)
Wolfram is available as an app in the [ChatGPT App Directory](https://chatgpt.com/apps). 

### Steps using official app: ###

1. Open the [Wolfram app](https://chatgpt.com/apps/wolfram/asdk_app_69fe0bf66c8481919c513d799406436e) page.
2. If prompted, sign in to your ChatGPT account.
3. Review the app information, capabilities and permissions.
4. Click **Connect**.
5. Once connected, the app should appear in your available apps list. 

### Verify the connection: ###

1. Open a new ChatGPT conversation.
2. Click the **+** button (or use the Apps menu, depending on your interface).
3. Locate and select **Wolfram** from your available apps.
4. Alternatively, if your ChatGPT interface supports app mentions, invoke the app directly in a prompt.

#### Example prompts:

```text
Use Wolfram to solve and graph x^2 - 5x + 6 = 0.
```

```text
Use Wolfram to calculate the orbital period of a satellite 400 km above Earth.
```

### Managing the connection:

1. Open **Settings** in ChatGPT.
2. Navigate to **Apps**.
3. Locate **Wolfram** in your connected apps list.
4. From there you can:
   - Review permissions
   - Reconnect the app
   - Disconnect the app


------------------------------------------------------------------------

## Claude.ai (Web / Desktop / Mobile)

Wolfram Cloud MCP is available as a [connector](https://claude.com/connectors/wolfram), or remote MCP servers can be configured as **custom connectors** brokered through your Anthropic account. The connection originates from Anthropic's cloud infrastructure, so the server must be publicly reachable. 

### Steps using official connector: ###

1. Visit the Wolfram official [Claude connector](https://claude.com/connectors/wolfram) OR navigate to **[claude.ai/customize/connectors](https://claude.ai/customize/connectors)** and search for **Wolfram** in the connector directory. 
2. Click the link under "Used in" to add to Claude.
3. Click **Connect**.
4. Once connected, the Wolfram connector will appear in your connector list.
5. If you'd like to modify the tool's permissions, click the **+** button at the lower left of the chat interface, select **Connectors**, then **Manage connectors**. We recommend always allowing Wolfram|Alpha and Wolfram Context tools, with a "Needs Approval" setting on the Wolfram Language Evaluator. Without modifying permissions, you may need to approve requests more frequently. 

### Enabling the connector in a conversation

After connecting, enable Wolfram for a specific conversation:

1. Click the **+** button at the lower left of the chat interface.
2. Select **Connectors**.
3. Toggle **Wolfram** on.

### Steps using custom connector: ###

1. Open [claude.ai](https://claude.ai) and click your account menu in the lower-left corner.
2. Go to **Settings → Connectors**.
3. Click **Add custom connector**.
4. In the dialog, enter:
   - **Name:** `Wolfram`
   - **URL:** `https://agenttools.wolfram.com/mcp`
5. Click **Add**. 
6. Once connected, the connector will appear in your Connectors list and be available in conversations.

-   **Note:** Remote connectors in Claude.ai are brokered through Anthropic's servers, not your local machine. Local MCP servers configured via `claude_desktop_config.json` are a separate mechanism. Learn more about Wolfram Local MCP [here](https://wolfr.am/MCP-Server-Learn). 

------------------------------------------------------------------------

## Claude Desktop—Local Config Method

For servers not yet in the Extensions directory, you can manually configure Claude Desktop via its JSON config file.

**Config file locations:**
-   **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
-   **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`

**Option A—Direct URL (Streamable HTTP, recommended):**

Open Settings → Developer → Edit Config and add the following:

```json
{
  "mcpServers": {
    "wolfram": {
      "url": "https://agenttools.wolfram.com/mcp"
    }
  }
}
```

**Option B—Via `mcp-remote` proxy (for older Claude Desktop versions):**

If your version of Claude Desktop doesn't support direct URL connections, use the `mcp-remote` npm package as a proxy. Requires Node.js.

```json
{
  "mcpServers": {
    "wolfram": {
      "command": "npx",
      "args": ["mcp-remote", "https://agenttools.wolfram.com/mcp"]
    }
  }
}
```

After editing the config, restart Claude Desktop. The Wolfram tools will appear in your conversations.


#### Organization-level tool control (Team and Enterprise only)

Owners can disable specific Wolfram tools across the organization:

1. Navigate to **[Organization settings > Connectors](https://claude.ai/admin-settings/connectors)**.
2. Locate the **Wolfram** connector.
3. Click the connector to expand its settings.
4. Disable any tool calls you do not want members to invoke—for example, tools that write data or take external actions.

-   **Note:** When using Claude's **Research** (Advanced Research) feature with Wolfram connected, Claude may invoke Wolfram tools automatically without per-call approval. Disable write-capable tools before using Research if you want to restrict this behavior.

------------------------------------------------------------------------

## Claude Code (CLI)

Claude Code supports remote MCP servers natively via its `claude mcp add` command. HTTP transport is the recommended option for remote servers.

**Add the server (Streamable HTTP):**

```bash
claude mcp add --transport http wolfram https://agenttools.wolfram.com/mcp
```

**Verify the connection:**

```bash
claude mcp list
# or inside a session:
/mcp
```

**Scoping options:**

| Scope | Flag | Description |
|---|---|---|
| Local (default) | _(none)_ | Available only in the current project |
| Global | `--scope global` | Available across all projects |
| Project (shared) | `--scope project` | Stored in `.mcp.json`, committable to version control |


**Manual `.mcp.json` configuration** (for sharing with a team):

Create or edit `.mcp.json` in your project root:

```json
{
  "mcpServers": {
    "wolfram": {
      "type": "streamable-http",
      "url": "https://agenttools.wolfram.com/mcp"
    }
  }
}
```

-   **Note:** `streamable-http` is accepted as an alias for `http` in JSON configs, for compatibility with server documentation that uses the MCP spec name.

If the server disconnects mid-session, Claude Code will automatically attempt to reconnect with exponential backoff (up to 5 attempts).

#### Allowlisting specific tools (HTTP server)

In `.mcp.json` or `~/.claude.json`, use the `tool_configuration` field to restrict which tools are available:

```json
{
  "mcpServers": {
    "wolfram": {
      "type": "http",
      "url": "https://agenttools.wolfram.com/mcp",
      "tool_configuration": {
        "enabled": true,
        "allowed_tools": ["WolframAlpha", "WolframLanguageEvaluator", "WolframContext"]
      }
    }
  }
}
```

#### Denylisting specific tools

To allow all tools *except* specific ones, use `denied_tools`:

```json
{
  "mcpServers": {
    "wolfram": {
      "type": "http",
      "url": "https://agenttools.wolfram.com/mcp",
        "tool_configuration": {
        "enabled": true,
        "denied_tools": ["WriteNotebook", "SubmitPaclet"]
      }
    }
  }
}
```

#### Global permission deny via settings

To prevent Claude Code from ever calling a specific tool from any MCP server—including Wolfram—add it to the `deny` list in `.claude/settings.json` or `~/.claude/settings.json`:

```json
{
  "permissions": {
    "deny": ["mcp__wolfram__WriteNotebook", "mcp__wolfram__SubmitPaclet"]
  }
}
```

#### Disabling tool search for Wolfram (always-load mode)

By default, Claude Code defers loading MCP tool schemas until needed. To force Wolfram tools to always be available at session start:

```json
{
  "mcpServers": {
    "wolfram": {
      "type": "http",
      "url": "https://agenttools.wolfram.com/mcp",
      "alwaysLoad": true
    }
  }
}
```

------------------------------------------------------------------------

## Anthropic API (Direct Integration)

You can connect to the Wolfram MCP server directly from the Anthropic Messages API using the `mcp_servers` parameter. This requires the beta header `mcp-client-2025-11-20`.

-   **Note:** Only MCP tool calls are supported via this method. MCP prompts and resources require a client-side SDK connection.

**Python example:**

```python
import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1000,
    messages=[
        {"role": "user", "content": "What is the integral of x^2 from 0 to 5?"}
    ],
    mcp_servers=[
        {
            "type": "url",
            "url": "https://agenttools.wolfram.com/mcp",
            "name": "wolfram",
        }
    ],
    tools=[
        {
            "type": "mcp_toolset",
            "mcp_server_name": "wolfram"
        }
    ],
    betas=["mcp-client-2025-11-20"],
)

print(response)
```

**JavaScript/TypeScript example:**

```javascript
const Anthropic = require("@anthropic-ai/sdk");

const client = new Anthropic.Anthropic();

const response = await client.beta.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1000,
  messages: [
    { role: "user", content: "What is the integral of x^2 from 0 to 5?" }
  ],
  mcp_servers: [
    {
      type: "url",
      url: "https://agenttools.wolfram.com/mcp",
      name: "wolfram",
    }
  ],
  tools: [
    {
      type: "mcp_toolset",
      mcp_server_name: "wolfram"
    }
  ],
  betas: ["mcp-client-2025-11-20"],
});

console.log(response);
```

**Restricting which tools are available:**

```json
{
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "wolfram",
      "default_config": { "enabled": false },
      "configs": {
        "WolframAlpha": { "enabled": true },
        "WolframLanguageEvaluator": { "enabled": true }
      }
    }
  ]
}
```

------------------------------------------------------------------------

## Cursor IDE

Cursor supports remote MCP servers via Streamable HTTP. Configuration can be project level or global.

**Option A—Settings UI (recommended):**

1. Open **Cursor Settings → Tools & MCP → New MCP Server**.
2. Choose **HTTP** transport.
3. Enter:
   - **Name:** `wolfram`
   - **URL:** `https://agenttools.wolfram.com/mcp`
4. Click **Install**. 

**Option B—Manual JSON config:**

-   **Project-level:** `.cursor/mcp.json` in your project root (commit to share with team)
-   **Global:** `~/.cursor/mcp.json`

```json
{
  "mcpServers": {
    "wolfram": {
      "url": "https://agenttools.wolfram.com/mcp"
    }
  }
}
```


**Option C—Via `mcp-remote` proxy (for older Cursor versions):**

```json
{
  "mcpServers": {
    "wolfram": {
      "command": "npx",
      "args": ["mcp-remote", "https://agenttools.wolfram.com/mcp"]
    }
  }
}
```

After saving, reload the Cursor window or restart the IDE. Wolfram tools will appear in the agent's tool list.

-   **Tip:** Cursor reads the root key as `"mcpServers"`. Do not use `"servers"`—that is VS Code's key.

------------------------------------------------------------------------

## VS Code with GitHub Copilot

VS Code uses a different config key from Cursor (`"servers"` instead of `"mcpServers"`). MCP tools only work in **Agent mode** in Copilot Chat.

**Prerequisites:**
-   VS Code 1.99 or later
-   GitHub Copilot extension installed
-   Copilot Chat open in **Agent mode** (select "Agent" from the mode drop-down)

**Option A—Command Palette (recommended):**

1. Open the Command Palette (`Cmd/Ctrl+Shift+P`).
2. Run **MCP: Add Server…**.
3. Select **HTTP** as the server type.
4. Paste `https://agenttools.wolfram.com/mcp` and press Enter.
5. Give it the name `wolfram` and choose **Global** (all workspaces) or **Workspace** (current project only).

**Option B—Manual `mcp.json` config:**

-   **Global:** Run `MCP: Open User Configuration` from the Command Palette.
-   **Workspace:** Create `.vscode/mcp.json` in your project root.

```json
{
  "servers": {
    "wolfram": {
      "type": "http",
      "url": "https://agenttools.wolfram.com/mcp"
    }
  }
}
```

A **Start** button will appear in the `mcp.json` file. Click it to activate the server and discover its tools.

-   **Important:** VS Code uses `"servers"` as the root key, not `"mcpServers"`. Copying a Cursor or Claude Desktop config without changing this key is the most common setup mistake.

------------------------------------------------------------------------

## GitHub Copilot CLI

**Option A—Interactive `/mcp add`:**

In a Copilot CLI session, run:

```
/mcp add
```

When prompted:
-   Choose **HTTP** as the server type.
-   Enter the URL: `https://agenttools.wolfram.com/mcp`
-   Enter the name: `wolfram`

**Option B—Edit config file directly:**

-   **Global:** `~/.copilot/mcp-config.json`
-   **Project:** `.mcp/copilot/mcp.json`

```json
{
  "mcpServers": {
    "wolfram": {
      "type": "http",
      "url": "https://agenttools.wolfram.com/mcp"
    }
  }
}
```

Save the file and restart Copilot CLI for changes to take effect.

**Managing servers:**

```
/mcp show              # list all configured servers
/mcp show wolfram      # details + available tools
/mcp disable wolfram   # disable without removing
/mcp enable wolfram    # re-enable
/mcp delete wolfram    # remove
```
------------------------------------------------------------------------

## Other Available Registries 
The Wolfram Cloud MCP is available through many other registries: 
-   [Smithery.ai](https://smithery.ai/servers/wolframmcp/Wolfram)
-   [MCP Install](https://www.mcpinstall.com/mcp-server/10040-mcpserver)
-   [MCP Repository](https://mcprepository.com/wolframresearch/agenttools)


------------------------------------------------------------------------

## Troubleshooting

**Server not connecting**
-   Confirm the URL is reachable: `curl https://agenttools.wolfram.com/mcp`
-   Ensure your network allows outbound HTTPS on port 443.
-   For Claude.ai custom connectors, remember the connection comes from Anthropic's servers, so the MCP server must be publicly accessible—private/VPN-only hosts won't work.

**Tools not appearing**
-   Make sure you're using **Agent mode** in VS Code Copilot Chat (tools are invisible in Ask or Edit modes).
-   In Claude Code, run `/mcp` inside a session to see server status.
-   Validate your JSON config with a linter—a single misplaced comma will silently break the file.

**Wrong config key**
-   Claude Desktop and Cursor use `"mcpServers"` as the root key.
-   VS Code uses `"servers"` as the root key.
-   Mixing these up is the most common cross-client copy-paste mistake.

**SSE vs. HTTP transport**
-   SSE (server-sent events) transport is deprecated in the MCP specification. Prefer `http`/`streamable-http` for all new configurations.
-   If a client requires SSE, use the URL as is; many servers accept both transports at the same endpoint.

**Authentication errors**
-   If the server requires a token, add it as a header (`Authorization: Bearer YOUR_TOKEN`) in your client's config.
-   For OAuth-based servers, follow the browser login flow when prompted—credentials are stored securely in your system keychain.

**Connecting to local Wolfram Desktop**
-   For users wanting to connect to their **local** Wolfram Desktop, Mathematica or Wolfram Engine application, learn more about Wolfram Local MCP (Wolfram MCP Server for Local Wolfram Applications) [here](https://wolfr.am/MCP-Server-Learn).


------------------------------------------------------------------------

*Source: [Wolfram Cloud MCP](https://wolfr.am/Cloud-MCP) — © 2026 Wolfram Research*