Model Context Protocol (MCP) Python Implementation

This project implements a functioning Model Context Protocol (MCP) server and client in Python, following the Anthropic MCP specification. It demonstrates the key patterns of the MCP protocol through a simple, interactive example.

What is MCP?

The Model Context Protocol (MCP) is an open standard built on JSON-RPC 2.0 for connecting AI models to external data sources and tools. It defines a client-server architecture where an AI application communicates with one or more MCP servers, each exposing capabilities such as:

• Tools: Executable functions that perform actions
• Resources: Data sources that provide information
• Prompts: Predefined templates or workflows

MCP standardizes how these capabilities are discovered and invoked, serving as a "USB-C for AI" that allows models to interact with external systems in a structured way.

Project Structure

• server/: MCP server implementation
  • server.py: WebSocket server that handles MCP requests and provides sample tools/resources
• client/: MCP client implementation
  • client.py: Demo client that connects to the server and exercises all MCP capabilities

Features Demonstrated

This implementation showcases the core MCP protocol flow:

1. Capability Negotiation: Client-server handshake via initialize
2. Capability Discovery: Listing available tools and resources
3. Tool Invocation: Calling the add_numbers tool with parameters
4. Resource Access: Reading text content from a resource

Setup

1. Create a virtual environment:

   python3 -m venv .venv
   source .venv/bin/activate
   

2. Install dependencies:

   pip install -r requirements.txt
   

Usage

1. Start the MCP server (in one terminal):

   python server/server.py
   

2. Run the MCP client (in another terminal):

   python client/client.py
   

The client will connect to the server, perform the MCP handshake, discover capabilities, and demonstrate invoking tools and accessing resources with formatted output.

How It Works

MCP Server

The server:

• Accepts WebSocket connections
• Responds to JSON-RPC requests following the MCP specification
• Provides a sample tool (add_numbers)
• Provides a sample resource (example.txt)
• Supports the MCP handshake and capability discovery

MCP Client

The client:

• Connects to the server via WebSocket
• Performs the MCP handshake
• Discovers available tools and resources
• Demonstrates calling a tool and reading a resource
• Presents the results in a formatted display

Protocol Details

MCP implements these key methods:

Method	Description
initialize	Handshake to establish capabilities
tools/list	List available tools
tools/call	Call a tool with arguments
resources/list	List available resources
resources/read	Read resource content
prompts/list	List available prompts

Extending the Project

You can extend this implementation by:

• Adding more tools with different capabilities
• Adding dynamic resources that change on each read
• Implementing prompt templates for guided interactions
• Creating more interactive client applications

References

• Anthropic Model Context Protocol Spec
• JSON-RPC 2.0 Specification
• WebSockets Protocol