mcp

This MCP server provides a Rust-implemented Model Context Protocol (MCP) server with HTTP and STDIO transports. It supports complete MCP protocol features, including JSON-RPC 2.0 messaging, server capability negotiation, authentication/authorization, and a modular feature set (resources, tools, prompts, logging, completion, sampling, and roots). The HTTP transport exposes a streamable endpoint suitable for single requests, batches, and SSE streams, while the STDIO transport enables subprocess-based communication via standard input/output. Use the Docker image provided (jeetulsamaiya/mcp-server) to run the server in a container, or build from source to run directly on a Rust toolchain.

To get started, run the server using the Docker command (as configured in mcp_config). The server exposes the /mcp endpoint by default for HTTP transport. You can initialize a connection, query available tools, and interact with features such as prompts, resources, and tools via JSON-RPC messages. The server also supports session management, logging configuration, and authentication hooks if you enable them in the TOML configuration. When using the HTTP transport, you can initialize a session, list tools, and stream events using SSE, or use the STDIO transport for subprocess workflows by launching the binary and piping JSON-RPC messages to its stdin.

Prerequisites:

• Docker (recommended for quick setup) or Rust toolchain (stable) if building from source
• Internet access to pull the MCP server image or crates from crates.io

Option A: Run via Docker (recommended)

1. Install Docker from https://docs.docker.com/get-dimer
2. Pull and run the MCP server image (adjust image name if needed): docker run -i jeetulsamaiya/mcp-server
3. If you need to customize, mount a configuration file and set environment variables accordingly: docker run -i
   -e MCP_BIND=0.0.0.0
   -e MCP_PORT=8080
   -e MCP_TRANSPORT=http
   -v /path/to/mcp-server.toml:/etc/mcp/mcp-server.toml
   jeetulsamaiya/mcp-server

Option B: Build from source (Rust)

1. Install Rust and Cargo from https://www.rust-lang.org/tools/install
2. Clone the repository and navigate to the project root
3. Build in release mode: cargo build --release
4. Run the server (example for HTTP transport): ./target/release/mcp-server start --bind 127.0.0.1 --port 8080 --transport http

Prerequisites for compilation may include additional system dependencies listed in the repository's docs (e.g., OpenSSL, Zstd, or SRTP-related crates).

Tips and common considerations:

• If you enable authentication, configure API keys or JWT tokens via the TOML configuration and environment vars as documented in the project docs.
• For production, consider tweaking max_connections, request_timeout, and session_timeout in the config to match workload and security requirements.
• If using the HTTP transport with SSE streaming, ensure your client handles long-lived connections and reconnects properly.
• The server supports dynamic capability negotiation; ensure your clients query capabilities after initialization to adapt to available features.
• When running in Docker, map volumes for persistent configuration and data as needed, and prefer the release binary for production deployments to maximize performance.