Building an MCP Server in Java: Simple Request Extraction and Response

Introduction

The Model Context Protocol (MCP) server needs to handle different types of requests. In this blog post, we’ll focus on the simplest approach – how to extract the method from the request body and handle basic operations like initialization, listing tools, etc.

Basic Request Structure

1. Request Body Format

{
  "method": "listTools",
  "params": {
    "name": "toolName",
    "arguments": {...}
  }
}

Simple Request Handler

1. Extract Method and Handle Request

public class McpServer {
    public Object handleRequest(Map<String, Object> requestBody) {
        // Extract method from request
        String method = (String) requestBody.get("method");

        // Extract parameters
        Map<String, Object> params = (Map<String, Object>) requestBody.get("params");

        // Route to appropriate handler
        switch (method) {
            case "initialize":
                return handleInitialize();
            case "listTools":
                return handleListTools();
            case "callTool":
                return handleCallTool(params);
            case "listPrompts":
                return handleListPrompts();
            case "getPrompt":
                return handleGetPrompt(params);
            case "listResources":
                return handleListResources();
            case "readResource":
                return handleReadResource(params);
            default:
                return createErrorResponse("Unknown method: " + method);
        }
    }
}

2. Simple Handler Methods

public class McpServer {
    private Object handleInitialize() {
        Map<String, Object> response = new HashMap<>();
        response.put("serverName", "MyMcpServer");
        response.put("serverVersion", "1.0.0");
        response.put("capabilities", getCapabilities());
        return response;
    }

    private Object handleListTools() {
        List<Map<String, Object>> tools = new ArrayList<>();

        // Add your tools here
        Map<String, Object> tool1 = new HashMap<>();
        tool1.put("name", "getWeather");
        tool1.put("description", "Get weather for a city");
        tools.add(tool1);

        Map<String, Object> response = new HashMap<>();
        response.put("tools", tools);
        return response;
    }

    private Object handleCallTool(Map<String, Object> params) {
        String toolName = (String) params.get("name");
        Map<String, Object> arguments = (Map<String, Object>) params.get("arguments");

        // Execute the tool
        Object result = executeTool(toolName, arguments);

        Map<String, Object> response = new HashMap<>();
        response.put("result", result);
        return response;
    }

    private Object handleListPrompts() {
        List<Map<String, Object>> prompts = new ArrayList<>();

        // Add your prompts here
        Map<String, Object> prompt1 = new HashMap<>();
        prompt1.put("name", "greeting");
        prompt1.put("description", "Generate a greeting");
        prompts.add(prompt1);

        Map<String, Object> response = new HashMap<>();
        response.put("prompts", prompts);
        return response;
    }

    private Object handleGetPrompt(Map<String, Object> params) {
        String promptName = (String) params.get("name");

        // Generate prompt content
        String content = generatePrompt(promptName);

        Map<String, Object> response = new HashMap<>();
        response.put("content", content);
        return response;
    }

    private Object handleListResources() {
        List<Map<String, Object>> resources = new ArrayList<>();

        // Add your resources here
        Map<String, Object> resource1 = new HashMap<>();
        resource1.put("uri", "file:///data/config.json");
        resource1.put("name", "Configuration");
        resources.add(resource1);

        Map<String, Object> response = new HashMap<>();
        response.put("resources", resources);
        return response;
    }

    private Object handleReadResource(Map<String, Object> params) {
        String uri = (String) params.get("uri");

        // Read the resource
        String content = readResourceContent(uri);

        Map<String, Object> response = new HashMap<>();
        response.put("content", content);
        return response;
    }
}

3. Helper Methods

public class McpServer {
    private Map<String, Object> getCapabilities() {
        Map<String, Object> caps = new HashMap<>();
        caps.put("tools", true);
        caps.put("prompts", true);
        caps.put("resources", true);
        return caps;
    }

    private Object executeTool(String toolName, Map<String, Object> arguments) {
        switch (toolName) {
            case "getWeather":
                String city = (String) arguments.get("city");
                return "Weather in " + city + ": Sunny, 25°C";
            case "calculate":
                int a = (Integer) arguments.get("a");
                int b = (Integer) arguments.get("b");
                return a + b;
            default:
                return "Tool not found: " + toolName;
        }
    }

    private String generatePrompt(String promptName) {
        switch (promptName) {
            case "greeting":
                return "Hello! How can I help you today?";
            default:
                return "Prompt not found: " + promptName;
        }
    }

    private String readResourceContent(String uri) {
        // Simple file reading example
        if (uri.startsWith("file://")) {
            String path = uri.substring(7);
            return "Content of " + path;
        }
        return "Resource not found: " + uri;
    }

    private Object createErrorResponse(String message) {
        Map<String, Object> error = new HashMap<>();
        error.put("error", message);
        return error;
    }
}

Complete Example

public class SimpleMcpServer {
    public static void main(String[] args) {
        McpServer server = new McpServer();

        // Example request
        Map<String, Object> request = new HashMap<>();
        request.put("method", "listTools");
        request.put("params", new HashMap<>());

        Object response = server.handleRequest(request);
        System.out.println("Response: " + response);
    }
}

Key Points

1. Extract Method: Get the method name from requestBody.get("method")
2. Extract Params: Get parameters from requestBody.get("params")
3. Switch Statement: Route to appropriate handler based on method
4. Simple Response: Return HashMap with response data
5. No Complex Classes: Use basic Java collections for simplicity

Request Examples

// Initialize
{"method": "initialize", "params": {}}

// List Tools
{"method": "listTools", "params": {}}

// Call Tool
{"method": "callTool", "params": {"name": "getWeather", "arguments": {"city": "London"}}}

// List Prompts
{"method": "listPrompts", "params": {}}

// Get Prompt
{"method": "getPrompt", "params": {"name": "greeting"}}

// List Resources
{"method": "listResources", "params": {}}

// Read Resource
{"method": "readResource", "params": {"uri": "file:///data/config.json"}}

This approach is simple, easy to understand, and can be extended with more complex functionality as needed.

---