Model Context Protocol (MCP)

{
  "servers": {
    "filesystem": {
      "type": "stdio",
      "command": "npx -y @modelcontextprotocol/server-filesystem /path/to/your/project",
      "enabled": true,
      "description": "File system access"
    },
    "github": {
      "type": "stdio",
      "command": "npx -y @modelcontextprotocol/server-github",
      "enabled": true,
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

# Event types available for hooks
MCP_SERVER_DISCOVER      # Discovery started
MCP_SERVER_DISCOVERED    # Servers found in config
MCP_SERVER_CONNECT       # Connection attempt
MCP_SERVER_CONNECTED     # Successfully connected
MCP_SERVER_DISCONNECT    # Server disconnected
MCP_SERVER_ERROR         # Connection/execution error
MCP_TOOL_REGISTER        # Tool registered
MCP_TOOL_UNREGISTER      # Tool unregistered
MCP_TOOL_CALL_PRE        # Before tool execution
MCP_TOOL_CALL_POST       # After tool execution

#!/usr/bin/env python3
import json
import sys
from typing import Any, Dict

class CustomMCPServer:
    def __init__(self):
        self.tools = [
            {
                "name": "my_custom_tool",
                "description": "Does something amazing",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "input": {"type": "string", "description": "Input text"}
                    },
                    "required": ["input"]
                }
            }
        ]

    def handle_initialize(self, params: Dict) -> Dict:
        return {
            "protocolVersion": "2024-11-05",
            "capabilities": {"tools": {}},
            "serverInfo": {"name": "custom-server", "version": "1.0.0"}
        }

    def handle_tools_list(self, params: Dict) -> Dict:
        return {"tools": self.tools}

    def handle_tools_call(self, params: Dict) -> Dict:
        tool_name = params.get("name")
        arguments = params.get("arguments", {})

        if tool_name == "my_custom_tool":
            result = f"Processed: {arguments.get('input', '')}"
            return {"content": [{"type": "text", "text": result}]}

        return {"error": "Tool not found"}

    def run(self):
        for line in sys.stdin:
            try:
                request = json.loads(line)
                method = request.get("method")
                params = request.get("params", {})
                request_id = request.get("id")

                # Route to handler
                if method == "initialize":
                    result = self.handle_initialize(params)
                elif method == "tools/list":
                    result = self.handle_tools_list(params)
                elif method == "tools/call":
                    result = self.handle_tools_call(params)
                else:
                    result = {"error": f"Unknown method: {method}"}

                # Send response
                response = {
                    "jsonrpc": "2.0",
                    "id": request_id,
                    "result": result
                }
                print(json.dumps(response), flush=True)

            except Exception as e:
                error_response = {
                    "jsonrpc": "2.0",
                    "id": request.get("id"),
                    "error": {"code": -32603, "message": str(e)}
                }
                print(json.dumps(error_response), flush=True)

if __name__ == "__main__":
    server = CustomMCPServer()
    server.run()

{
  "servers": {
    "my-custom-server": {
      "type": "stdio",
      "command": "python3 /path/to/custom_server.py",
      "enabled": true,
      "description": "My custom MCP server"
    }
  }
}