# CPPCon MCP Server
This project implements a Model Context Protocol (MCP) server that provides a tool to compile C++ code using the [Compiler Explorer (godbolt.org)](https://godbolt.org) API. It allows clients to request the assembly output for given C++ code and compiler options, supporting both standard tool invocation and Server-Sent Events (SSE) for streaming results.
## Features
* **MCP Compliant:** Built using `mcp-server[fastmcp]`, ensuring adherence to the Model Context Protocol.
* **`get_assembly` Tool:** Exposes a tool that compiles C++ code using MSVC (via godbolt.org) and returns the generated assembly.
* **SSE Support:** Provides a Server-Sent Events endpoint (`/sse`) for streaming compilation status and results.
* **Tool Discovery:** Exposes a `/capabilities` endpoint for clients to discover available tools and their schemas.
* **Client Messaging:** Supports a `/message` endpoint for general client-to-server communication.
## Setup
### Prerequisites
* Python 3.11 or higher
### Installation
1. **Create a virtual environment** (recommended):
```bash
python -m venv venv
source venv/bin/activate # On Windows, use `venv\Scripts\activate`
```
2. **Install dependencies:**
```bash
pip install "mcp-server[fastmcp]" uvicorn requests pydantic
```
## Running the Server
To start the MCP server, execute the `server.py` script:
```bash
python server.py
```
The server will run on `http://127.0.0.1:8000` by default.
## Usage
The server exposes several endpoints compliant with the Model Context Protocol.
### 1. Get Server Capabilities
Clients can discover the server's capabilities, including available tools, by sending a `GET` request to the `/capabilities` endpoint.
```bash
curl http://127.0.0.1:8000/capabilities
```
### 2. Invoke `get_assembly` Tool (Standard POST)
To get the assembly output for C++ code in a single request/response cycle, send a `POST` request to the `/tool/get_assembly` endpoint.
**Example Request:**
```bash
curl -X POST
-H "Content-Type: application/json"
-d '{"code": "int main() { return 0; }", "options": "/O2"}'
http://127.0.0.1:8000/tool/get_assembly
```
### 3. Stream `get_assembly` Results (Server-Sent Events)
For streaming compilation status and results, connect to the `/sse` endpoint using `GET`. The `code` and `options` for compilation are passed as URL query parameters. An optional `sessionId` can also be provided for client tracking.
**Example Request:**
```bash
curl -N "http://127.0.0.1:8000/sse?code=int%20main()%20%7B%20return%200%3B%20%7D&options=/O2&sessionId=my_compiler_session_123"
```
The server will stream events in the following format:
```
event: message
data: {"status": "starting_compilation", "sessionId": "my_compiler_session_123"}
event: result
data: {"type": "text", "text": "; Assembly output here..."}
event: message
data: {"status": "compilation_complete", "sessionId": "my_compiler_session_123"}
```
In case of an error, an `event: error` will be sent:
```
event: error
data: {"type": "server_error", "text": "Error details here...", "sessionId": "my_compiler_session_123"}
```
### 4. Send Client Messages
Clients can send general messages to the server via a `POST` request to the `/message` endpoint. These messages can be used for various client-initiated communications.
**Example Request:**
```bash
curl -X POST
-H "Content-Type: application/json"
-d '{"type": "client_ping", "sessionId": "my_compiler_session_123", "data": "Are you alive?"}'
http://127.0.0.1:8000/message
```
The server will respond with:
```json
{"status": "message_received", "sessionId": "my_compiler_session_123"}
```
### 5. Test Server Using modelcontextprotocol/inspector
```bash
npx @modelcontextprotocol/inspector
```
### 6. Configure using VSCode http MCP server command create mcp.json and start tool
```json
{
"servers": {
"my-mcp-server-4620e938": {
"url": "http://localhost:8000/sse",
"type": "http"
}
},
"inputs": []
}
```
### 7. Chat with Copilot, when context need assembly, it will invoke
