ATAS MCP Bridge

Model Context Protocol (MCP) server connecting ATAS Platform (7.x) and ATAS X (8.x) to AI agents and development assistants.

Leer en Espanol

Overview

ATAS MCP Bridge bridges the gap between institutional-grade order flow trading in ATAS and modern AI models. It exposes real-time market data, full order book depth (DOM), delta volume candles, account positions, open orders, trade executions, and automated order routing directly to AI assistants.

Compatible with all major AI coding agents and MCP clients:

• OpenCode

• Qwen Code

• Kiro (CLI & IDE)

• Claude Code

• OpenAI Codex / Developers Platform

• OpenClaw

• Kimi Kode

• Z Code

• Google Antigravity (AGY CLI & IDE)

• Cursor

• Claude Desktop

• Windsurf / VS Code (Cline & Roo Code)

Related MCP server: MetaTrader 5 MCP Server

Architecture

+------------------------------------+          HTTP / SSE (127.0.0.1:8787)         +----------------------+
|           ATAS Platform            | <------------------------------------------> |   MCP Server (Py)    |
|            "MCP Bridge"            |             GET  /api/*                      |      server.py       |
|    (ChartStrategy in C# / .NET)    |             POST /api/order                  |      (mcp 2.0)       |
+------------------------------------+             GET  /api/stream                 +----------------------+
                                                                                               ^
                                                                                               | MCP (stdio)
                                                                                               v
                                                                                    +----------------------+
                                                                                    |      AI Clients      |
                                                                                    |  - OpenCode          |
                                                                                    |  - Qwen Code         |
                                                                                    |  - Kiro              |
                                                                                    |  - Claude Code       |
                                                                                    |  - OpenAI Codex      |
                                                                                    |  - OpenClaw          |
                                                                                    |  - Kimi Kode         |
                                                                                    |  - Z Code            |
                                                                                    |  - Antigravity       |
                                                                                    |  - Cursor            |
                                                                                    |  - Claude Desktop    |
                                                                                    +----------------------+

Communication Flow:

1. C# Addon (ATAS.McpBridge): Runs inside the ATAS process as a native ChartStrategy. It hosts an embedded HTTP and Server-Sent Events (SSE) listener on 127.0.0.1:8787.

2. Thread Safety & Lock-Free Design: All ATAS API calls occur strictly on the main ATAS thread within OnCalculate(). Incoming HTTP execution requests are queued in a thread-safe ConcurrentQueue and processed on the next tick. Read requests are answered immediately from volatile in-memory JSON snapshots without interrupting market data processing.

3. Python MCP Server (server.py): Speaks Model Context Protocol over standard I/O (stdio), exposing 12 production-ready tools with robust structured error handling.

4. Python HTTP Client (atas_client.py): Zero-dependency client using Python standard library with automated port discovery and environment variable support.

MCP Tools (12 Tools)

HTTP REST and SSE Endpoints

The C# addon serves the following endpoints locally at http://127.0.0.1:8787:

Prerequisites

• Operating System: Windows 10 / 11 (x64)

• Platform: ATAS Platform (7.x) or ATAS X (8.x) installed

• .NET SDK: .NET 8 SDK or higher (winget install Microsoft.DotNet.SDK.8 or dotnet --version)

• Python: Python 3.10 or higher with pip

Installation and Quickstart

1. Clone the repository and install dependencies

git clone https://github.com/Ax3lsk3r3/atas-mcp.git
cd atas-mcp
pip install -r requirements.txt

Optionally install as an editable package so the atas-mcp CLI command is globally available:

pip install -e .

2. Compile and deploy the C# Addon

Run the build script:

build.bat

The script compiles the project in Release mode and copies ATAS.McpBridge.dll to both ATAS strategy folders:

• %APPDATA%\ATAS\Strategies\ (ATAS Platform 7.x)

• %APPDATA%\ATAS X\Strategies\ (ATAS X 8.x)

3. Attach the Strategy in ATAS

1. Launch ATAS (or ATAS X).

2. Open a chart for the instrument you want to trade (e.g. NQ, ES, BTCUSDT, EURUSD).

3. Right-click the chart -> select Indicators (or Add Indicator).

4. Search for MCP Bridge and add it to the chart.

5. In the strategy properties panel:

   • Check the IsActivated checkbox.

   • Select your portfolio / account (simulation or demo accounts recommended).

6. Verify in your web browser:

   • Navigate to http://127.0.0.1:8787/api/health

   • Expected output: {"ok":true,"id":"atas-mcp-bridge","version":"1.0.0"}

4. Run the Automated Smoke Test

Verify the Python client against a local mock bridge without launching ATAS:

python test_client.py

All 13 automated tests should pass.

5. Start the MCP Server

The server supports two primary modes:

Mode A: Stdio (for local desktop IDEs and CLIs):

start_mcp.bat
# or directly:
python server.py
# or if installed via pip:
atas-mcp

Mode B: Server-Sent Events (SSE) (for web applications, remote environments, cloud agents):

start_mcp_sse.bat
# or directly:
python server.py --transport sse --host 127.0.0.1 --port 8000
# or with Docker:
docker compose up -d

The SSE endpoint will be available at http://127.0.0.1:8000/sse for web chat UIs (LibreChat, Open WebUI, AnythingLLM) and remote agent runners (OpenClaw, LangChain, CrewAI, AutoGen).

Client Integration Examples

Detailed setup guides for all supported clients are provided in mcp-config-examples.md.

OpenCode

Add to ~/.config/opencode/config.json or project opencode.json:

{
  "mcp": {
    "atas": {
      "type": "stdio",
      "command": "python",
      "args": ["<PATH_TO_ATAS_MCP>/server.py"]
    }
  }
}

Qwen Code

Run via CLI:

qwen mcp add atas python "<PATH_TO_ATAS_MCP>/server.py"

Kiro (CLI & IDE)

Run via CLI:

kiro mcp add atas python "<PATH_TO_ATAS_MCP>/server.py"

Claude Code (CLI)

Run via CLI:

claude mcp add atas -- python "<PATH_TO_ATAS_MCP>/server.py"

Google Antigravity (AGY)

Add to %USERPROFILE%\.gemini\config\mcp_config.json:

{
  "mcpServers": {
    "atas": {
      "command": "python",
      "args": ["<PATH_TO_ATAS_MCP>/server.py"]
    }
  }
}

Cursor

Add to %USERPROFILE%\.cursor\mcp.json:

{
  "mcpServers": {
    "atas": {
      "command": "python",
      "args": ["<PATH_TO_ATAS_MCP>/server.py"]
    }
  }
}

Claude Desktop

Add to %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "atas": {
      "command": "python",
      "args": ["<PATH_TO_ATAS_MCP>\\server.py"],
      "cwd": "<PATH_TO_ATAS_MCP>"
    }
  }
}

Technical Details

1. ATAS 7.x and 8.x Compatibility:

   • Targets .NET 8, which runs natively on ATAS 7.x and forwards cleanly into ATAS X .NET 10 cross-platform runtime.

   • Uses IndicatorCandle for full access to volume and delta statistics.

   • Price rounding respects ShrinkPrice(price) to prevent exchange reject errors.

   • Full order book depth snapshot extracted via MarketDepthInfo.GetMarketDepthSnapshot().

2. Position Tracking:

   • In ChartStrategy, the net open volume and direction are computed from strategy-specific execution fills (MyTrades).

   • This ensures safe isolation: manual orders outside this strategy do not corrupt the algorithmic tracking of the strategy.

3. Dynamic Port Discovery:

   • If port 8787 is occupied, the C# bridge scans ports 8787 through 8807 automatically.

   • The selected port is stored in %APPDATA%\ATAS\McpBridge.port and %APPDATA%\ATAS X\McpBridge.port.

   • atas_client.py auto-discovers this file or falls back to the ATAS_MCP_PORT environment variable.

Troubleshooting

Risk Disclaimer

This software connects directly to financial trading platforms and can place binding orders on financial markets. Trading futures, equities, forex, and cryptocurrencies involves substantial risk of loss and is not suitable for every investor.

• Always test strategies, prompts, and tool calls thoroughly on simulated accounts (DEMO or Market Replay) before deploying capital.

• This software is distributed strictly for educational and technical automation purposes, without warranty of any kind.

License

MIT License. See LICENSE for details.