MCP ExplorerExplorer

Gamecode Mcp2

@navicoreon 14 days ago
1 MIT
FreeCommunity
AI Systems
mcp in rust both client and server

Overview

What is Gamecode Mcp2

gamecode-mcp2 is a clean implementation of the Model Context Protocol (MCP) developed in Rust, designed for tool integration with minimal dependencies and a focus on auditability.

Use cases

Use cases include integrating with desktop applications like Claude, creating automated workflows, and developing custom tools that interact with the MCP server.

How to use

To use gamecode-mcp2, build the server using Cargo, create a ‘tools.yaml’ configuration file, and run the server. You can also integrate it with applications like Claude Desktop or gamecode-cli by specifying the server command in their configurations.

Key features

Key features include direct tool exposure via MCP, a clean JSON-RPC 2.0 implementation without external dependencies, dynamic tool loading through YAML configuration, and support for both built-in and external tools.

Where to use

gamecode-mcp2 can be used in various fields that require tool integration, such as software development, automation, and any application needing a reliable communication protocol for tools.

Content

Dependabot Updates
Rust CI

GameCode MCP2

A clean (and possibly naive) implementation of the Model Context Protocol (MCP)
for tool integration.

Motivation - as few dependencies as possible, as simple and auditable a
configuration as possible.

⚠️ Security Notice

MCP is early technology. Allowing LLMs to execute system commands is inherently risky.
This implementation prioritizes auditability over features - you can read every line
that processes LLM requests. Even so, proceed with caution. Only time will tell if
MCP’s approach is sound.

Key Features

  • Direct tool exposure - Tools defined in tools.yaml are exposed directly via MCP, not through meta-tools
  • Clean protocol implementation - Pure JSON-RPC 2.0 over stdio without external dependencies
  • Dynamic tool loading - Configure tools via YAML without recompiling
  • Built-in and external tools - Support for both internal handlers and external commands

Architecture

This workspace contains two crates:

  • mcp-server - The MCP server that loads tools from tools.yaml and exposes them via the protocol
  • mcp-client - A client library for testing and integration

Usage

Running the Server

# Build the server
cargo build --release --bin gamecode-mcp2

# Create a tools.yaml file (see examples/tools.yaml)
cp examples/tools.yaml .

# Run the server (it communicates via stdio)
./target/release/gamecode-mcp2

Using with Claude Desktop

Add to your Claude Desktop configuration:

{
  "mcpServers": {
    "gamecode": {
      "command": "/path/to/gamecode-mcp2"
    }
  }
}

Using with gamecode-cli

The mcp-client crate can be used as a dependency in gamecode-cli for MCP integration.

Tool Configuration

Tools are defined in tools.yaml:

tools:
  - name: my_tool
    description: Description for the LLM
    command: /path/to/command  # or "internal" for built-in
    args:
      - name: param1
        description: Parameter description
        required: true
        type: string
        cli_flag: --param  # null for positional
    internal_handler: handler_name  # for internal tools

Protocol

This implementation follows the MCP specification:

  • initialize - Handshake with client
  • tools/list - Returns all available tools
  • tools/call - Execute a specific tool

Tools are exposed directly, not through meta-tools like “run”.

Tools

No tools

Comments