# Netmind Code Interpreter
The Code Interpreter AI service, built and customized by the [NetMind](https://netmind.ai) team, is a high-quality, robust,
and cost-efficient solution for executing code in 14+ programming languages through a secure cloud environment.
It is fully MCP server–ready, allowing seamless integration with AI agents.
## Components
### Tools
- execute_code: Execute code in the specified programming language with secure cloud execution.
- language: required: Programming language identifier (string). Supported values: 'python', 'javascript', 'typescript', 'java', 'cpp', 'c', 'go', 'rust', 'php', 'ruby', 'swift', 'kotlin', 'scala', 'r'
- files: required: List of code files to execute. Each file must have 'name' (filename with extension) and 'content' (complete source code as string)
- stdin: optional: Standard input to provide to the program during execution (default: empty string)
- args: optional: Command line arguments to pass to the program (default: empty list)
- Returns execution results with stdout, stderr, and data outputs on success, or error description on failure.
## Installation
### Requires [UV](https://github.com/astral-sh/uv) (Fast Python package and project manager)
If uv isn't installed.
```bash
# Using Homebrew on macOS
brew install uv
```
or
```bash
# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install.sh | sh
# On Windows.
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```
### Environment Variables
You can obtain an API key from [Netmind](https://www.netmind.ai/user/apiToken)
- `NETMIND_API_TOKEN`: Your Netmind API key
### Cursor & Claude Desktop && Windsurf Installation
Add this tool as a mcp server by editing the Cursor/Claude/Windsurf config file.
```json
{
"mcpServers": {
"code-interpreter": {
"env": {
"NETMIND_API_TOKEN": "XXXXXXXXXXXXXXXXXXXX"
},
"command": "uvx",
"args": [
"netmind-code-interpreter-mcp"
]
}
}
}
```
## Features
Core Features of the NetMind Code Interpreter API
We provide a robust feature set that handles the complexity of code execution, so you can focus on building what matters.
- Unified Multi-Language Support: Execute code in the language you need, without configuration changes. Our environment provides native support for Python, JavaScript, Java, Go, C++, Rust, Ruby, PHP, and more, each running in an optimized and consistent runtime.
- Seamless File Management & I/O: Effortlessly integrate your data. Upload your scripts, CSVs, and other text-based files directly to the runtime. Your code can read, write, and process these files in a fully sandboxed filesystem for complete security and data integrity.
- Automatic Image & Artifact Generation: Turn data into visuals, automatically. Code that generates plots, charts, or diagrams will have the output automatically captured and delivered to you as a secure link. Get your PNGs, JPEGs, and other results without any extra steps.
- Enterprise-Grade Security and Performance: Execute any code with complete peace of mind. Every execution runs in a disposable, fully isolated container with reasonable resource limits on memory, CPU, and time. With rapid container startup and massive concurrency support, our platform is built for production-scale performance and security.
## Supported Languages
- Python
- JavaScript/TypeScript
- Java
- C/C++
- Go
- Rust
- PHP
- Ruby
- Swift
- Kotlin
- Scala
## Configuration
Set your Netmind API token as an environment variable:
```bash
export NETMIND_API_TOKEN="your-api-token-here"
```
## Usage
### Starting the Server
```bash
# using Python module
python -m netmind_code_interpreter.server
```
### Testing the Server
Run the test client to verify everything is working:
```bash
python tests/test_client.py
```
### MCP Client Integration
The server can be used with any MCP-compatible client. Here's how to configure it:
1. Start the server on your desired port (default: 8000)
2. Configure your MCP client to connect to `http://localhost:8000/sse`
3. Use the `execute_code` tool to run code
## API Reference
### execute_code Tool
Execute code in the specified programming language.
**Parameters:**
- `language` (str): Programming language identifier
- `files` (List[Dict]): List of code files to execute
- `name` (str): Filename with appropriate extension
- `content` (str): Complete source code as a string
- `stdin` (str, optional): Standard input content
- `args` (List[str], optional): Command line arguments
**Returns:**
- Success: `{"run": {"stdout": "...", "stderr": "...", "data": [...]}}`
- Error: `{"error": "error description", "run": {"stdout": "", "stderr": "..."}}`
**Example:**
```python
result = await client.call_tool("execute_code", {
"language": "python",
"files": [
{
"name": "hello.py",
"content": "print('Hello, World!')"
}
]
})
```
## License
MIT License - see LICENSE file for details.
