mcp

# MCP — Model Context Protocol for Haskell [](https://hackage.haskell.org/package/mcp) [](https://hackage.haskell.org/package/mcp-types) A complete implementation of the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) for Haskell, split into two packages: - **`mcp-types`** — Pure protocol types with minimal dependencies (aeson, base, containers, text) - **`mcp`** — Servant-based HTTP server with JWT authentication ## Overview This repository provides a type-safe implementation of the Model Context Protocol in Haskell. MCP is an open protocol that standardizes how applications provide context to Large Language Models (LLMs), enabling AI models to securely connect to data sources and tools. ## Features - **Latest Protocol Support**: Implements MCP protocol version 2025-06-18 - **Complete MCP Protocol Implementation**: All MCP message types, requests, responses, and notifications - **Type-Safe Design**: Full Haskell type system integration with automatic JSON serialization via Aeson - **HTTP Transport**: Servant-based HTTP server with streaming SSE responses - **JWT Authentication**: Secure authentication via `servant-auth-server` - **Extensible Server Interface**: Configurable handler framework for implementing custom MCP servers - **Tool Framework**: Helper functions for defining tools with input validation and structured results ## Architecture The implementation is organized into two packages: ### `mcp-types` Core protocol types with minimal dependencies — suitable for building clients or alternative server implementations. - **`MCP.Types`**: Core MCP data types (Content, Resource, Tool, Prompt, Capability, etc.) - **`MCP.Protocol`**: JSON-RPC 2.0 message wrappers, all client/server request/response types, notification types - **`MCP.Aeson`**: Custom Aeson parsing options ### `mcp` Servant-based server implementation. Re-exports `MCP.Protocol` and `MCP.Types` for convenience. - **`MCP.Server`**: Core server infrastructure with `MCPServerT` monad transformer, `ProcessHandlers` record, `ToolHandler` framework, JWT-authenticated Servant API, server state management and request routing For OAuth 2.0 authorization in MCP clients, see [`oauth2-server`](https://hackage.haskell.org/package/oauth2-server). ## MCP Protocol Support | Operation | Description | Status | |-----------|-------------|--------| | `initialize` | Start session and negotiate capabilities | Supported | | `ping` | Health check | Supported | | `resources/list` | List available resources | Supported | | `resources/templates/list` | List available resource templates | Supported | | `resources/read` | Read resource contents | Supported | | `resources/subscribe` | Subscribe to resource updates | Supported | | `resources/unsubscribe` | Unsubscribe from resource updates | Supported | | `prompts/list` | List available prompts | Supported | | `prompts/get` | Get prompt with arguments | Supported | | `tools/list` | List available tools | Supported | | `tools/call` | Execute a tool | Supported | | `completion/complete` | Auto-completion with context | Supported | | `logging/setLevel` | Set logging level | Supported | | `sampling/createMessage` | Request LLM sampling | Supported | | `roots/list` | List client root directories | Supported | | `elicitation/create` | Request user input via forms | Supported | ## Install For a server implementation, add `mcp` to your `build-depends`: ```cabal build-depends: base , servant , servant-server , servant-auth-server , aeson , mcp ``` If you only need the protocol types (e.g. for a client), depend on `mcp-types` instead: ```cabal build-depends: base , aeson , mcp-types ``` This project targets GHC 9.12 (see `cabal.project`). ## Quick Start ```haskell {-# LANGUAGE DataKinds #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TypeFamilies #-} import Control.Concurrent.MVar (newMVar) import MCP.Server -- Define your handler state and user types type instance MCPHandlerState = () type instance MCPHandlerUser = MyUser -- Create server state with capabilities mkServerState :: IO (MVar MCPServerState) mkServerState = do let impl = Implementation "my-server" "1.0.0" Nothing caps = ServerCapabilities { logging = Nothing , prompts = Nothing , resources = Nothing , tools = Just (ToolsCapability { listChanged = Just True }) , completions = Nothing , experimental = Nothing } handlers = withToolHandlers myTools defaultProcessHandlers newMVar $ initMCPServerState () Nothing Nothing caps impl Nothing handlers -- Define tools using the ToolHandler framework myTools :: [ToolHandler] myTools = [ toolHandler "greet" (Just "Say hello") greetSchema $ \_args -> return $ ProcessSuccess $ toolTextResult ["Hello!"] ] ``` ## Example Server A fully documented example server lives in `mcp-server/example/`. It demonstrates every major feature: tools, resources, resource templates, prompts, completions, logging, lifecycle hooks, and JWT authentication. ### Run the example ```bash cabal run mcp-example ``` The server starts on `http://localhost:8080/mcp` and prints a JWT bearer token to stdout. Use it in the `Authorization` header for all requests: ```bash # Initialize the session (replace $TOKEN with the printed token) curl -s -X POST http://localhost:8080/mcp \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $TOKEN" \ -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}' # Send initialized notification curl -s -X POST http://localhost:8080/mcp \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $TOKEN" \ -d '{"jsonrpc":"2.0","method":"notifications/initialized","params":null}' # List available tools curl -s -X POST http://localhost:8080/mcp \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $TOKEN" \ -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' # Call the add tool curl -s -X POST http://localhost:8080/mcp \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer $TOKEN" \ -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"add","arguments":{"a":17,"b":25}}}' ``` See `mcp-server/example/SKILL.md` for curl examples covering all 15 endpoints. ## Project Structure ``` mcp-types/ # Core protocol types package ├── src/MCP/ │ ├── Aeson.hs # Custom Aeson parsing options │ ├── Protocol.hs # JSON-RPC protocol messages │ └── Types.hs # Core MCP data types └── mcp-types.cabal mcp-server/ # Server implementation package ├── src/MCP/ │ ├── Server.hs # Re-exports Common, HTTP, and Stdio │ └── Server/ │ ├── Common.hs # Types, state, request routing, tool helpers │ ├── HTTP.hs # Servant-based HTTP transport with JWT auth │ └── Stdio.hs # Stdio transport ├── test/ │ ├── Main.hs # Test entry point │ └── MCP/ │ ├── Integration.hs # HTTP integration tests (hspec-wai) │ ├── StdioIntegration.hs # Stdio integration tests │ ├── TestServer.hs # Test server configuration │ └── TestUtils.hs # Test utilities and request builders ├── example/ │ ├── Main.hs # Example server (tools, resources, prompts, etc.) │ ├── mcp-example.cabal # Standalone cabal project │ ├── mcp-config.json # Claude Desktop MCP configuration template │ └── SKILL.md # Build, run, and test instructions └── mcp.cabal ``` ## Development ```bash cabal build all cabal test all ``` ## License MPL-2.0 — see `LICENSE` in this repository. ## References - [Model Context Protocol Specification](https://modelcontextprotocol.io/) - [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk) - [Official MCP Documentation](https://modelcontextprotocol.io/introduction)