Zig MCP Server

View original on GitHub

A Model Context Protocol (MCP) server that provides Zig language tooling, code analysis, and documentation access. This server enhances AI capabilities with Zig-specific functionality including code optimization, compute unit estimation, code generation, and best practices recommendations.

Features

Tools

1. Code Optimization (`optimize_code`)

Analyzes and optimizes Zig code with support for different optimization levels:

Debug
ReleaseSafe
ReleaseFast
ReleaseSmall


// Example usage
{
  "code": "const std = @import(\"std\");\n...",
  "optimizationLevel": "ReleaseFast"
}

2. Compute Units Estimation (`estimate_compute_units`)

Estimates computational complexity and resource usage of Zig code:

Memory usage analysis
Time complexity estimation
Allocation patterns detection


// Example usage
{
  "code": "const std = @import(\"std\");\n..."
}

3. Code Generation (`generate_code`)

Generates Zig code from natural language descriptions with support for:

Error handling
Testing
Performance optimizations
Documentation


// Example usage
{
  "prompt": "Create a function that sorts an array of integers",
  "context": "Should handle empty arrays and use comptime when possible"
}

4. Code Recommendations (`get_recommendations`)

Provides code improvement recommendations and best practices:

Style and conventions
Design patterns
Safety considerations
Performance insights


// Example usage
{
  "code": "const std = @import(\"std\");\n...",
  "prompt": "Improve performance and safety"
}

Resources

Language Reference (zig://docs/language-reference)
- Official Zig language documentation
- Syntax and features guide
- Best practices
Standard Library Documentation (zig://docs/std-lib)
- Complete std library reference
- Function signatures and usage
- Examples and notes
Popular Repositories (zig://repos/popular)
- Top Zig projects on GitHub
- Community examples and patterns
- Real-world implementations

Installation

Clone the repository:


git clone [repository-url]
cd zig-mcp-server

Install dependencies:


npm install

Build the server:


npm run build

Configure environment variables:


# Create a GitHub token for better API rate limits
# https://github.com/settings/tokens
# Required scope: public_repo
GITHUB_TOKEN=your_token_here

Add to MCP settings:


{
  "mcpServers": {
    "zig": {
      "command": "node",
      "args": ["/path/to/zig-mcp-server/build/index.js"],
      "env": {
        "GITHUB_TOKEN": "your_token_here",
        "NODE_OPTIONS": "--experimental-vm-modules"
      },
      "restart": true
    }
  }
}

Usage Examples

1. Optimize Code


const result = await useMcpTool("zig", "optimize_code", {
  code: `
    pub fn fibonacci(n: u64) u64 {
        if (n <= 1) return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
  `,
  optimizationLevel: "ReleaseFast"
});

2. Estimate Compute Units


const result = await useMcpTool("zig", "estimate_compute_units", {
  code: `
    pub fn bubbleSort(arr: []i32) void {
        var i: usize = 0;
        while (i < arr.len) : (i += 1) {
            var j: usize = 0;
            while (j < arr.len - 1) : (j += 1) {
                if (arr[j] > arr[j + 1]) {
                    const temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
  `
});

3. Generate Code


const result = await useMcpTool("zig", "generate_code", {
  prompt: "Create a thread-safe counter struct",
  context: "Should use atomic operations and handle overflow"
});

4. Get Recommendations


const result = await useMcpTool("zig", "get_recommendations", {
  code: `
    pub fn main() !void {
        var list = std.ArrayList(u8).init(allocator);
        var i: u32 = 0;
        while (true) {
            if (i >= 100) break;
            try list.append(@intCast(u8, i));
            i += 1;
        }
    }
  `,
  prompt: "performance"
});

Development

Project Structure


zig-mcp-server/
├── src/
│   └── index.ts    # Main server implementation
├── build/          # Compiled JavaScript
├── package.json    # Dependencies and scripts
└── tsconfig.json   # TypeScript configuration

Building


# Development build with watch mode
npm run watch
 
# Production build
npm run build

Testing


npm test

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

MIT License - see the LICENSE file for details.