Dynamic MCP Server

A dynamic Model Context Protocol (MCP) server implementation in Go that reads tool configurations from JSON files and provides both WebSocket and HTTP interfaces for tool execution.

Features

• Dynamic Tool Loading: Load tool configurations from JSON files at runtime
• Session Management: Automatic session creation, refresh, and cleanup
• Authentication: Support for session tokens and API keys
• WebSocket Support: Full MCP protocol implementation over WebSocket
• HTTP API: RESTful endpoints for tool listing and execution
• Redis Integration: Session storage and management
• Graceful Shutdown: Proper cleanup of resources and connections

Project Structure

.
├── cmd/
│   └── mcp-server/
│       └── main.go              # Main entry point
├── internal/
│   ├── auth/
│   │   ├── client.go            # Authentication client
│   │   ├── errors.go            # Authentication errors
│   │   └── manager.go           # Session manager
│   ├── config/
│   │   ├── loader.go            # Configuration loader
│   │   └── types.go             # Configuration types
│   └── server/
│       ├── executor.go          # API execution logic
│       ├── server.go            # Core MCP server
│       └── types.go             # Server types
├── go.mod                       # Go module file
├── go.sum                       # Go dependencies
├── config.json                    # Clean configuration file
├── mcp_tool.json                  # Original file with examples (can be removed)
└── README.md                   # This file

Configuration

The server reads tool configurations from JSON files. The main configuration file is config.json which contains:

• Session Management: Authentication service configuration
• Tool Definitions: API endpoints, parameters, and authentication requirements
• Server Settings: Port, timeouts, and other server options

Configuration Structure

{
  "session_management": {
    "auth_service_url": "https://api.yourstore.com/v1/auth",
    "session_endpoint": "/session",
    "refresh_endpoint": "/refresh",
    "validate_endpoint": "/validate",
    "logout_endpoint": "/logout"
  },
  "mcp_server_session_config": {
    "settings": {
      "session_cache_type": "memory",
      "session_cache_ttl": 3600,
      "refresh_before_expiry_seconds": 300,
      "cleanup_interval_seconds": 60,
      "max_sessions_per_apikey": 5
    }
  },
  "tools": {}
}

Adding Tools

To add tools, update the tools section in your configuration file:

{
  "tools": {
    "product_search": {
      "config": {
        "name": "product_search",
        "description": "Search for products in the catalog",
        "method": "GET",
        "url": "https://api.example.com/products/search",
        "auth_required": true,
        "auth_type": "session_token",
        "timeout": 30
      },
      "params_schema": {
        "query": {
          "type": "string",
          "description": "Search query",
          "required": true
        },
        "category": {
          "type": "string",
          "description": "Product category filter"
        }
      }
    }
  }
}

Installation

1. Clone the repository:

git clone <repository-url>
cd dms

2. Install dependencies:

go mod tidy

3. Set up Redis (required for session management):

# Using Docker
docker run -d -p 6379:6379 redis:alpine

# Or install locally
brew install redis  # macOS
sudo apt-get install redis-server  # Ubuntu

Usage

Running the Server

# Run with default configuration (config.json)
go run cmd/mcp-server/main.go

# Run with custom configuration file
go run cmd/mcp-server/main.go -config /path/to/config.json

Environment Variables

• MCP_CONFIG_FILE: Path to configuration file (default: ./config.json)
• MCP_PORT: Server port (default: 8080)
• REDIS_URL: Redis connection URL (default: redis://localhost:6379)

WebSocket Connection

Connect to the MCP server via WebSocket:

ws://localhost:8080/mcp

The server implements the full MCP protocol for tool discovery and execution.

HTTP API

List Available Tools

curl http://localhost:8080/tools

Execute a Tool

curl -X POST http://localhost:8080/tools/product_search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <session_token>" \
  -d '{"query": "laptop", "category": "electronics"}'

Development

Building

# Build for current platform
go build -o bin/mcp-server cmd/mcp-server/main.go

# Build for Linux
GOOS=linux GOARCH=amd64 go build -o bin/mcp-server-linux cmd/mcp-server/main.go

Testing

# Run tests
go test ./...

# Run tests with coverage
go test -cover ./...

Adding New Tools

1. Add tool configuration to your JSON file:

{
  "tools": {
    "new_tool": {
      "config": {
        "name": "new_tool",
        "description": "Description of the new tool",
        "method": "POST",
        "url": "https://api.example.com/new-endpoint",
        "auth_required": true,
        "timeout": 30
      },
      "params_schema": {
        "param1": {
          "type": "string",
          "description": "Parameter description",
          "required": true
        }
      }
    }
  }
}

2. Restart the server to load the new configuration

Authentication

The server supports multiple authentication methods:

• Session Token: Bearer token authentication
• API Key: X-API-Key header authentication

Sessions are automatically managed with refresh and cleanup capabilities.

Logging

The server uses structured logging with different levels:

• INFO: General information
• WARN: Warning messages
• ERROR: Error conditions
• DEBUG: Debug information (when enabled)

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

License

This project is licensed under the MIT License - see the LICENSE file for details.