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

# MCP Server

> Complete installation guide for SigmaMind API MCP Server across all Agent IDEs

## Overview

SigmaMind provides a free [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that enables AI coding assistants to browse and search complete API documentation. This comprehensive guide covers installation instructions for all major coding assistants and best practices for integrating the MCP server into your development workflow.

The server is available at the following URL:

```
https://api.sigmamind.ai/mcp
```

## Key Features

The SigmaMind API MCP server provides the following capabilities:

* **API Documentation Access** - Browse and search complete SigmaMind API documentation in real-time
* **Endpoint Reference** - Quick access to all available endpoints and their parameters
* **Code Examples** - View practical examples for common API use cases
* **Authentication Guidance** - Reference authentication methods and token management
* **Error Handling** - Access troubleshooting guides and error code documentation
* **Real-time Updates** - Always access the most current API documentation

## Installation Guide

Follow the instructions below for your preferred coding assistant or IDE.

### Cursor

Click the button below to install the MCP server in [Cursor](https://www.cursor.com/):

[Install MCP Server in Cursor](https://cursor.com/docs/context/mcp)

Or add it manually to your Cursor settings with the following JSON in `~/.cursor/mcp.json`:

```json theme={null}
{
  "mcpServers": {
    "sigmamind-api": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.sigmamind.ai/mcp",
        "--header",
        "X-API-KEY:${SIGMAMIND_API_KEY}"
      ],
      "env": {
        "SIGMAMIND_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### Claude Code

Add the MCP server to your [Claude Code](https://claude.com/product/claude-code) configuration. Create or edit `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json theme={null}
{
  "mcpServers": {
    "sigmamind-api": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.sigmamind.ai/mcp",
        "--header", "X-API-KEY:${SIGMAMIND_API_KEY}"
      ],
      "env": {
        "SIGMAMIND_API_KEY": "your-api-key-here"
      }      
    }
  }
}
```

Verify the installation by running:

```bash theme={null}
claude mcp list
```

### VS Code

Add the MCP server to your [VS Code](https://code.visualstudio.com/) workspace by creating or editing `.vscode/mcp.json`:

```json theme={null}
{
  "servers": {
    "sigmamind-api": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.sigmamind.ai/mcp",
        "--header",
        "X-API-KEY:${SIGMAMIND_API_KEY}"
      ],
      "env": {
        "SIGMAMIND_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

Alternatively, install it using the VS Code CLI:

```bash theme={null}
code --add-mcp '{"name":"sigmamind-api","type":"http","url":"https://api.sigmamind.ai/mcp"}'
```

### GitHub Copilot

[Copilot CLI](https://docs.github.com/en/copilot/concepts/agents/copilot-cli/about-copilot-cli) supports MCP servers via an interactive setup flow or by editing its config file directly.

To add the server interactively, start Copilot CLI and run `/mcp add`. When prompted, set the server URL to `https://api.sigmamind.ai/mcp`.

To configure it manually, create or edit `~/.copilot/mcp-config.json`:

```json theme={null}
{
  "mcpServers": {
    "sigmamind-api": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.sigmamind.ai/mcp",
        "--header", "X-API-KEY:${SIGMAMIND_API_KEY}"
      ],
      "env": {
        "SIGMAMIND_API_KEY": "your-api-key-here"
      }      
    }
  }
}
```

### Codex

Run the following command in your terminal to install the server in [OpenAI Codex](https://openai.com/codex/):

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

### Gemini CLI

Run the following command in your terminal to install the server in [Gemini CLI](https://geminicli.com):

set your API key in an environment variable:

```bash theme={null}
export SIGMAMIND_API_KEY="your-api-key-here"
```

then add the MCP server:

```bash theme={null}
gemini mcp add \
  --transport http \
  --header "X-API-KEY:$SIGMAMIND_API_KEY" \
  sigmamind-api \
  https://api.sigmamind.ai/mcp
```

### Windsurf

[Windsurf](https://codeium.com/windsurf) is built on VS Code, so use the file-based configuration approach. Create or edit `.codeium/windsurf/mcp_config.json`:

```json theme={null}
{
  "mcpServers": {
    "sigmamind-api": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.sigmamind.ai/mcp",
        "--header",
        "X-API-KEY:${SIGMAMIND_API_KEY}"
      ],
      "env": {
        "SIGMAMIND_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

Restart Windsurf after making changes.

### Antigravity

[Antigravity](https://antigravity.ai/) provides MCP server support through its configuration settings.

Create or edit `.gemini/antigravity/mcp_config.json` in your project:

```json theme={null}
{
  "mcpServers": {
    "sigmamind-api": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.sigmamind.ai/mcp",
        "--header",
        "X-API-KEY:${SIGMAMIND_API_KEY}"
      ],
      "env": {
        "SIGMAMIND_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

Restart Antigravity after configuration changes.

### Kiro

[Kiro](https://kiro.ai/) is a code assistant that supports MCP servers. Configure it by creating or editing `.kiro/mcp-config.json`:

```json theme={null}
{
  "mcpServers": {
    "sigmamind-api": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.sigmamind.ai/mcp",
        "--header",
        "X-API-KEY:${SIGMAMIND_API_KEY}"
      ],
      "env": {
        "SIGMAMIND_API_KEY": "your-api-key-here"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}
```

Restart Kiro after making changes.

### Manual Installation

The MCP server is available at the following URL. Add this server to your MCP client of choice. If prompted, set the transport to `http` or `Streamable HTTP`.

```
https://api.sigmamind.ai/mcp
```

## Quick Start

After installing the MCP server, you can:

1. **Ask your AI assistant about the SigmaMind API** - It will automatically reference the latest documentation
2. **Get code examples** - Request implementation examples for specific use cases
3. **Troubleshoot integration issues** - Reference error codes and resolution steps
4. **Stay up-to-date** - Always access the most current API documentation
5. **Access endpoint reference** - View all available endpoints and their parameters

## Authentication

When using the SigmaMind API MCP server, keep the following in mind:

* Store your API key securely using environment variables.
* Never commit API keys to version control.
* The MCP server authenticates requests using the X-API-KEY HTTP header.
* Configure your MCP client to send the header, for example:

```bash theme={null}
--header "X-API-KEY:${SIGMAMIND_API_KEY}"
```

* Use separate API keys for development, staging, and production.
* Rotate API keys regularly for security

## Security Best Practices

### Environment Variables

Store your SigmaMind API key in an environment variable:

```bash theme={null}
export SIGMAMIND_API_KEY="your-api-key-here"
```

For local development, use a `.env` file (ensure it's added to `.gitignore`):

```
SIGMAMIND_API_KEY=your-api-key-here
```

### Repository Configuration

Never commit the following to version control:

* API keys or authentication tokens
* `.env` files with sensitive information
* Configuration files with credentials

## Common Use Cases

### Creating Outbound Calls

Use the MCP server to access the `/v1/calls` endpoint documentation for creating and managing outbound phone calls. Ask your AI assistant for examples of call creation and status tracking.

### Managing Campaigns

Reference the `/v1/campaigns` endpoint to learn how to create, update, delete, and manage campaigns. The MCP server provides real-time documentation and code examples.

### Phone Number Management

The `/v1/phone-numbers` endpoint documentation covers purchasing, managing, and configuring phone numbers. Access provisioning guides and best practices through the MCP server.

### Chat Completions

Access examples and best practices for using the `/v1/chats` endpoint for conversational AI. The MCP server provides authentication guidance and integration examples.

### Webhook Management

Learn how to register and manage webhooks using the `/v1/webhooks` endpoint. Reference real-time update patterns and event handling through the MCP server.

## Troubleshooting

### MCP Server Connection Issues

If the MCP server is not connecting:

* Verify the exact URL: `https://api.sigmamind.ai/mcp`
* Check your network connectivity and firewall settings
* Ensure your IDE or CLI tool has MCP support enabled
* Restart your IDE or CLI tool after configuration
* Check the IDE or tool logs for specific error messages
* Ensure the transport type matches your IDE’s MCP configuration

### Documentation Not Appearing

If API documentation is not appearing in your IDE:

* Confirm the MCP server is properly configured in your settings
* Verify the server URL is correct
* Restart your IDE or CLI tool
* Try a simple query to confirm the connection
* Check the MCP configuration file for syntax errors

### Authentication Failures

If you’re experiencing authentication issues:

* Ensure your API key is set in an environment variable
* Verify the MCP client sends the X-API-KEY header
* Confirm the .env file is loaded by your IDE or CLI
* Verify your API key has the required permissions
* Ensure the API key has not expired or been revoked

## Next Steps

* [Install the MCP server](#installation-guide) in your preferred coding environment
* Set up [Authentication](#authentication) with your API key
* Review the [API Reference](/api-reference) for complete endpoint documentation

{/* - Read [Best Practices](/guides/best-practices) for API integration guidance */}