DIY MCP Part 1: MCP Server

Key Concepts

• MCP (Meta-Config Protocol): A protocol for communication between clients and servers, enabling tools and resource access.
• Standard IO (Standard Input/Output): A set of three streams (stdin, stdout, stderr) used for communication between processes.
• JSON RPC 2.0: A lightweight remote procedure call protocol encoded in JSON.
• Tools: Functions or operations exposed by an MCP server that clients can invoke.
• Resources: Data or information exposed by an MCP server that clients can access.
• Capabilities: Features supported by an MCP server, such as tools and resources.
• JSON Schema: A vocabulary that allows you to annotate and validate JSON documents.

Interacting with MCP Servers via Standard IO

Overview

The video demonstrates how to interact with an MCP server using standard IO (stdin and stdout) directly from the terminal, without relying on specialized MCP libraries. It then proceeds to build a basic MCP server from scratch using TypeScript, highlighting the core concepts and steps involved.

Interacting with an Existing MCP Server

1. Launching the MCP Server: The video starts by launching an MCP server (fetch) using the command uvx mcp server fetch.

2. Initialization: The MCP server requires an initialization message. An example JSON RPC 2.0 message is provided:

   {
     "jsonrpc": "2.0",
     "id": 0,
     "method": "initialize",
     "params": {
       "protocolVersion": "1.0",
       "capabilities": {
         "tools": true
       },
       "clientInfo": {
         "name": "MCP Inspector",
         "version": "0.1.0"
       }
     }
   }
   

   • jsonrpc: Specifies the JSON RPC version.
   • id: A tracking ID for the request.
   • method: The method to call (e.g., "initialize").
   • params: Parameters for the method, including protocol version, capabilities, and client information.

3. Initialization Notification: After receiving the initialization response, the client sends a notification to the server indicating that it is initialized.

4. Discovering Tools: The client sends a tools/list request to discover the tools supported by the server.

5. Invoking Tools: The client sends a tools/call request to invoke a specific tool, providing the tool name and any required arguments. For example:

   {
     "jsonrpc": "2.0",
     "id": 1,
     "method": "tools/call",
     "params": {
       "tool": "fetch",
       "arguments": {
         "url": "https://jsonplaceholder.typicode.com/todos/1"
       }
     }
   }
   

   The server responds with the result of the tool execution.

6. Closing the Session: The session is closed by sending an EOF (End-of-File) signal (Ctrl+D).

Building an MCP Server from Scratch

The video then guides the viewer through building a basic MCP server using TypeScript.

1. Setting up Standard IO: The code uses the readline module to read input from stdin and write output to stdout.

   import * as readline from 'node:readline';
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
   });
   

2. Parsing JSON Input: Each line read from stdin is parsed as JSON. A try...catch block is used to handle potential parsing errors.

3. Handling the initialize Method: The server checks for the initialize method and sends back a response containing server information and capabilities.

   function sendResponse(id: number, result: any) {
     const response = JSON.stringify({
       jsonrpc: "2.0",
       id: id,
       result: result,
     });
     console.log(response);
   }
   

4. Defining Tools: The server defines two tools: getDrinkNames and getDrinkInfo. Each tool has a description, an input schema (using JSON Schema), and an execute function.

   • getDrinkNames: Returns a list of drink names.
   • getDrinkInfo: Returns information about a specific drink, given its name.

5. Handling the tools/list Method: The server responds to the tools/list method by providing a list of available tools, including their names, descriptions, and input schemas.

6. Handling the tools/call Method: The server handles the tools/call method by:

   • Identifying the requested tool.
   • Executing the tool's execute function.
   • Sending back the result.

7. Supporting Resources: The server adds support for resources by:

   • Declaring that it supports resources in its capabilities.
   • Defining a resource (e.g., "menu") with a name, URI, and a getter function.
   • Handling the resources/list method by returning a list of available resources.
   • Handling the resources/read method by retrieving the content of a specific resource.

8. Supporting the ping Method: The server implements the ping method, which simply returns an empty object as a response.

Data Structures

• Drinks Data: The server uses a simple data structure to store information about available drinks, including their names, prices, and descriptions.
• Tool Definition: Each tool is defined as an object with properties such as name, description, inputSchema, and execute.
• Resource Definition: Each resource is defined as an object with properties such as name, uri, and get.

Key Arguments and Perspectives

• Simplicity of MCP: The video emphasizes that MCP is a relatively simple protocol that can be implemented in any language with standard IO and JSON support.
• Importance of Understanding Core Concepts: The video advocates for building MCP clients and servers from scratch to gain a deeper understanding of the underlying concepts.
• Flexibility of MCP: The video highlights the flexibility of MCP in terms of defining custom tools and resources.

Conclusion

The video provides a practical guide to interacting with and building MCP servers using standard IO. It demonstrates the core concepts of the MCP protocol, including initialization, tool invocation, and resource access. By building a basic MCP server from scratch, the video empowers viewers to understand and implement MCP in their own projects. The next video will cover building an MCP client from scratch.