Quick MCP Example

🚀 Standardizing Server Communication for Interactions with LLMs Using the MCP Protocol

Model Context Protocol (MCP) is an open protocol that unifies the way applications provide context to Large Language Models (LLMs). In other words, it offers a unified framework for LLM-based applications to connect to data sources, retrieve context information, utilize tools, and execute standard prompts.

The MCP ecosystem defines three key components:

• MCP Server: Handles tool availability (publicly available functions), tool execution (running these functions on demand), static content as resources (providing referenceable data), and preset prompts (standardized templates for common tasks).
• Client: Manages the connection to the server, LLM integration, and message passing between components.
• Host: Provides the user interface, showcases MCP functionality to users, and serves as an integration point with other ecosystems.

This architecture creates a modular system that allows different components to be developed independently while maintaining interoperability. This enables users to build MCP servers for different LLM-related functions and use them plug-and-play in various supported applications. MCP is commonly used to integrate functional APIs and tools or connect to local data sources.

✨ Features

MCP Server Components

The MCP server forms the basis of the protocol by exposing standardized functions through well-defined interfaces. Hosts and clients can connect to these servers via the protocol standard, but how these functions are presented to users remains flexible and is entirely up to the developers. That is, the actual implementation and user experience can be designed according to the developers' wishes - whether it's a command-line interface, a graphical application, or embedded in a larger system.

In this guide, we'll focus on building an example MCP server with core functions, along with a simple client implementation to demonstrate the interaction pattern. First, let's outline the main components of the MCP server:

Tools

Tools are functions that an LLM can call to perform operations or retrieve information. Each tool is defined as follows:

{
  name: string;          // Unique identifier for the tool
  description?: string;  // Human-readable description
  inputSchema: {         // JSON schema for tool parameters
    type: "object",
    properties: { ... }  // Tool-specific parameters
  }
}

Tools allow the LLM to interact with external systems, execute code, query databases, or perform calculations. They represent operations that have an effect or generate new information.

Resources

Resources represent data sources that can be accessed by client applications. They are identified by a unique identifier and include:

{
  uri: string;           // Unique identifier for the resource
  name: string;          // Human-readable name
  description?: string;  // Optional description
  mimeType?: string;     // Optional MIME type
}

Resources can be static content or dynamically generated content. MCP supports multiple data formats, including text files, PDF documents, and JSON data.

Prompts

Prompts define the behavior pattern of the LLM. They allow clients to specify how to interact with the LLM, such as:

• Specifying how to process the input
• Defining the output format
• Configuring context information

Through MCP, clients can flexibly configure the behavior of the LLM to meet the requirements of specific application scenarios.

📦 Installation

Clone the Repository

git clone https://github.com/ALucek/quick-mcp-example.git
cd quick-mcp-example

Create a ChromaDB Database

Follow the instructions in MCP_setup.ipynb to create a vector database and embed a PDF document.

Create a Virtual Environment and Install Dependencies

# Use uv (recommended)
uv venv
source .venv/bin/activate  # macOS/Linux
# Or
.venv\Scripts\activate     # Windows

# Install dependencies
uv sync

Run the Client and Server

python client.py mcp_server.py

🚀 Quick Start

By following the above steps, you can quickly set up an LLM interaction system based on the MCP protocol. For more detailed information, please refer to the relevant documentation and example code.