# MCP Server

Use Atlas Cloud AI models directly in your IDE with the official MCP Server. Generate images, videos, audio (TTS), and 3D models, chat with LLMs, and track balance & usage. Supports Cursor, Claude Desktop, Claude Code, Codex, Gemini CLI, and more.

Source: https://atlascloud.ai/docs/en/mcp-server

## What is MCP?

[Model Context Protocol (MCP)](https://modelcontextprotocol.io/) is an open standard developed by Anthropic that enables AI assistants to interact with external tools and data sources in a standardized way. Think of MCP as a universal adapter — it allows AI-powered IDEs like Cursor, Claude Desktop, and Claude Code to seamlessly connect with third-party services, APIs, and data.

By using MCP, developers can extend their AI assistant's capabilities far beyond simple code completion: they can search documentation, generate images, videos, audio, and 3D models, interact with LLMs, and much more — all through natural language commands within their coding environment.

## Atlas Cloud MCP Server

Atlas Cloud provides an **official MCP Server** ([`atlascloud-mcp` on npm](https://www.npmjs.com/package/atlascloud-mcp)) that brings the full power of Atlas Cloud's AI API platform directly into your IDE. With 400+ AI models available — spanning image, video, 3D, audio (TTS), and large language models — you can access everything without switching between browser tabs or writing API calls manually.

GitHub Repository: [AtlasCloudAI/mcp-server](https://github.com/AtlasCloudAI/mcp-server)

## Supported Models

- 🎬 **Video** — Seedance 2.0 · Kling 3 · Sora 2 · Veo 3.1 · HappyHorse 1 · Grok Imagine 1.5 · Wan 2.7
- 🎨 **Image** — Nano Banana 2/Pro · GPT Image 2 · Flux 2 · Seedream 5
- 🧊 **3D** — Hunyuan 3D image-to-3D / text-to-3D
- 💬 **LLM** — Claude · GPT · DeepSeek · MiniMax · Kimi · GLM · Qwen
- 🔊 **Audio (TTS)** — Seed Audio · xAI/Grok TTS · ElevenLabs

Explore the full catalog on our [Models](https://www.atlascloud.ai/models) page.

## Key Features

- **Documentation Search** — Search Atlas Cloud docs, models, and API references directly from your IDE
- **Model Discovery** — List and explore 400+ available AI models with pricing and capabilities, filterable by type (Text/Image/Video/Audio)
- **Image Generation** — Generate images using models like Nano Banana, GPT Image 2, Flux 2, Seedream, etc.
- **Video Generation** — Generate videos using models like Seedance, Kling, Sora, Veo, Wan, etc.
- **3D Generation** — Turn text or photos into 3D models (GLB/OBJ/USDZ) with Hunyuan 3D
- **Audio Generation (TTS)** — Synthesize speech with Seed Audio, xAI/Grok TTS, ElevenLabs, etc.
- **Quick Generate** — One-step image/video/audio generation that auto-finds the right model by keyword and builds the parameters
- **Media Upload** — Upload local files to get a URL for image-editing or image-to-video workflows
- **LLM Chat** — Chat with LLM models (OpenAI-compatible) including Claude, GPT, DeepSeek, Qwen, Kimi, GLM, etc.
- **Balance & Usage** — Check your account balance, daily usage, and cost breakdowns via the Atlas Cloud Public API
- **Dynamic Schema** — Automatically fetches each model's parameter schema and validates parameters *before* submitting, so invalid requests fail fast without spending credits

## Prerequisites

Before setting up the Atlas Cloud MCP Server, make sure you have:

- **Node.js 18 or higher** — [Download Node.js](https://nodejs.org/)
- **Atlas Cloud API Key** — Sign up and get your key at [atlascloud.ai](https://www.atlascloud.ai)

## Configuration

### CLI Agents (one-line install)

The fastest path — these AI coding agents add the server with a single command:

```bash
# Claude Code
claude mcp add atlascloud -- npx -y atlascloud-mcp

# OpenAI Codex CLI
codex mcp add atlascloud -- npx -y atlascloud-mcp

# Gemini CLI
gemini mcp add atlascloud -- npx -y atlascloud-mcp

# Goose CLI
goose mcp add atlascloud -- npx -y atlascloud-mcp
```

Then set your API key as an environment variable:

```bash
export ATLASCLOUD_API_KEY="your-api-key-here"
```

To persist the API key across terminal sessions, add the export command to your shell profile (`~/.bashrc`, `~/.zshrc`, etc.).

### Cursor

Open or create the file `~/.cursor/mcp.json` and add the following:

```json
{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": ["-y", "atlascloud-mcp"],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

Restart Cursor to apply the changes.

### Claude Desktop

Open the configuration file:
- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

Add the MCP server configuration:

```json
{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": ["-y", "atlascloud-mcp"],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

Restart Claude Desktop to apply the changes.

### Windsurf

Add the following to your Windsurf MCP configuration:

```json
{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": ["-y", "atlascloud-mcp"],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### Codex

Prefer the one-line install above, or open/create the Codex configuration file `~/.codex/config.toml` and add:

```toml
[mcp_servers.atlascloud]
command = "npx"
args = ["-y", "atlascloud-mcp"]

[mcp_servers.atlascloud.env]
ATLASCLOUD_API_KEY = "your-api-key-here"
```

### Gemini CLI

Prefer the one-line install above, or open/create the Gemini settings file `~/.gemini/settings.json` and add:

```json
{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": ["-y", "atlascloud-mcp"],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### Kilo Code

Open or create the project-level config `.kilocode/mcp.json` and add:

```json
{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": ["-y", "atlascloud-mcp"],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### OpenCode

Open or create the OpenCode config file `opencode.json` and add:

```json
{
  "mcp": {
    "atlascloud": {
      "type": "local",
      "command": ["npx", "-y", "atlascloud-mcp"],
      "enabled": true,
      "environment": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### Other MCP Clients

The same JSON configuration works with every MCP-compatible client:

| Client | Where to add it |
| --- | --- |
| [Cline](https://github.com/cline/cline) | MCP Marketplace → Add Server |
| [Continue](https://continue.dev) | `config.yaml` → MCP |
| [VS Code (Copilot)](https://code.visualstudio.com) | `.vscode/mcp.json` or Settings → MCP |
| [Trae](https://trae.ai) | Settings → MCP → Add Server |
| [JetBrains IDEs](https://www.jetbrains.com) | Settings → Tools → AI Assistant → MCP |
| [ChatGPT Desktop](https://openai.com/chatgpt/desktop) | Settings → MCP |
| [Amazon Q Developer](https://aws.amazon.com/q/developer/) | MCP Configuration |
| [Roo Code](https://github.com/RooCodeInc/Roo-Code) | Settings → MCP → Add Server |

## Available Tools

The Atlas Cloud MCP Server provides 13 tools that your AI assistant can use:

| Tool | Description |
| --- | --- |
| `atlas_search_docs` | Search Atlas Cloud documentation and models by keyword |
| `atlas_list_models` | List all available models, optionally filtered by type (Text/Image/Video/Audio) |
| `atlas_get_model_info` | Get detailed model info including API schema, parameters, and usage examples |
| `atlas_generate_image` | Generate images and 3D models (image-to-3D / text-to-3D) with any supported Image model |
| `atlas_generate_video` | Generate videos with any supported video model |
| `atlas_generate_audio` | Generate audio / speech (TTS) with any supported audio model |
| `atlas_quick_generate` | One-step image/video/audio generation — auto-finds model by keyword, builds params, and submits |
| `atlas_upload_media` | Upload local files to get a URL for use with image-edit / image-to-video models |
| `atlas_chat` | Chat with LLM models (OpenAI-compatible format) |
| `atlas_get_prediction` | Check status and result of image/video/audio/3D generation tasks |
| `atlas_get_balance` | Get the account balance and credit summary for your API key |
| `atlas_get_model_usage` | Get daily model usage (requests, tokens, image/video counts) over a date range |
| `atlas_get_model_costs` | Get daily model cost (spend) buckets over a date range |

> **Note**: The balance, usage, and cost tools are powered by the Atlas Cloud **Public API** (`https://api.atlascloud.ai/public/v1`), so you can audit spend and quota without leaving your IDE.

## Usage Examples

Once configured, you can interact with Atlas Cloud through natural language:

### Search for Models

- *"Search Atlas Cloud for video generation models"*
- *"List all image generation models with their pricing"*
- *"Show me details about the DeepSeek V3 model"*

### Generate an Image

> "Generate an image of a cat in space using Seedream"

The assistant will:
1. Use `atlas_list_models` to find Seedream image models
2. Use `atlas_get_model_info` to get the model's parameters
3. Use `atlas_generate_image` with the correct parameters

### Generate a Video

> "Create a video of a rocket launch using Kling v3"

The assistant will:
1. Find the Kling video model
2. Get its schema to understand required parameters
3. Use `atlas_generate_video` with appropriate parameters

### Upload a Local Image for Editing or Video Generation

> "Edit this image /Users/me/photos/cat.jpg to add a hat"

The assistant will:
1. Use `atlas_upload_media` to upload the local file and get a URL
2. Find an image-editing model
3. Use `atlas_generate_image` with the uploaded URL

> **Note**: Uploaded files are for temporary use with Atlas Cloud generation tasks only. Files may be cleaned up periodically. Do not use this as permanent file hosting — abuse may result in API key suspension.

### Generate Speech (TTS)

> "Read this sentence aloud with Seed Audio: Welcome to Atlas Cloud"

The assistant will:
1. Use `atlas_list_models` with `type="Audio"` to find the TTS model
2. Use `atlas_generate_audio` with the text to synthesize
3. Use `atlas_get_prediction` to retrieve the generated audio URL

### Generate a 3D Model

> "Turn this product photo into a 3D model with Hunyuan 3D"

3D models are Image-type models, so the assistant uses `atlas_generate_image` with the `image` parameter and retrieves a GLB/OBJ/USDZ file via `atlas_get_prediction`.

### Chat with an LLM

> "Ask DeepSeek V3 to explain quantum computing"

The assistant will use `atlas_chat` with the DeepSeek model.

### Check Balance and Usage

> "How much Atlas Cloud credit do I have left, and what did I spend this month?"

The assistant will use `atlas_get_balance` for the current balance and `atlas_get_model_costs` for the spend breakdown.

## Troubleshooting

### Common Issues

**"Command not found" error when running npx**

Make sure Node.js 18+ is installed and `npx` is available in your PATH:

```bash
node --version  # Should be 18.x or higher
npx --version   # Should output a version number
```

**"Invalid API Key" error**

Verify your API key is correctly set:

```bash
echo $ATLASCLOUD_API_KEY  # Should output your key
```

If empty, set it again and make sure there are no extra spaces or quotes.

**MCP Server not showing up in IDE**

- Make sure you've restarted your IDE after adding the configuration
- Double-check the JSON syntax in your configuration file
- Verify the configuration file is in the correct location for your IDE

### Getting Help

- **GitHub Issues**: [AtlasCloudAI/mcp-server/issues](https://github.com/AtlasCloudAI/mcp-server/issues)
- **Atlas Cloud Support**: [Contact us](/contact)

## More Atlas Cloud Tools

Prefer a different integration? Atlas Cloud also ships:

- **CLI** — use Atlas Cloud from the terminal: [atlascloud-cli](https://github.com/AtlasCloudAI/cli)
- **Skills** — a Skills package for Claude Code and other skill-compatible agents: [atlas-cloud-skills](https://github.com/AtlasCloudAI/atlas-cloud-skills)
- **ComfyUI nodes** — [atlascloud_comfyui](https://github.com/AtlasCloudAI/atlascloud_comfyui)
- **n8n nodes** — [n8n-nodes-atlascloud](https://github.com/AtlasCloudAI/n8n-nodes-atlascloud)

## FAQ

### Is the MCP Server free to use?

The MCP Server itself is free and open-source (MIT license). You only pay for the Atlas Cloud API usage based on the models you use. Check our [model pricing](https://www.atlascloud.ai/models) for details.

### Which AI models can I access?

You can access all 400+ models available on Atlas Cloud, including video models (Seedance, Kling, Sora, Veo, Wan), image models (Nano Banana, GPT Image, FLUX, Seedream), 3D models (Hunyuan 3D), TTS models (Seed Audio, xAI/Grok TTS, ElevenLabs), and LLMs (Claude, GPT, DeepSeek, Qwen, Kimi, GLM, MiniMax). Visit our [Models](/models) page for a complete list.

### Do I need to install anything besides Node.js?

No. The MCP Server is distributed via npm and runs using `npx`, which downloads and executes the package automatically. No global installation is required.

### Can I use the MCP Server with other IDEs?

The MCP Server works with any IDE or application that supports the Model Context Protocol, including Cursor, Claude Desktop, Claude Code, Codex, Gemini CLI, Goose, Windsurf, Kilo Code, OpenCode, Cline, Continue, VS Code (Copilot), Trae, JetBrains IDEs, ChatGPT Desktop, Amazon Q Developer, and Roo Code.

### Is my API key secure?

Your API key is stored locally in your IDE's configuration file and is only sent to Atlas Cloud's API endpoints. The MCP Server does not collect, log, or transmit your API key to any third-party services.