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:

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