Quick Example

🚀 Server for Standardizing Interactions with Large Language Models (LLMs) using the MCP Protocol

The Model Context Protocol (MCP) is an open protocol designed to unify the way applications provide context to large language models. In other words, it offers a unified framework for LLM-based applications to connect to data sources, utilize tools, and execute standard prompts.

The MCP ecosystem defines three specific components:

• MCP Server: It is responsible for tool availability (publicly available functions), tool execution (running requested functions), serving static content as resources (providing referenceable data), and preset prompts (standard templates for common tasks).

• Client: It manages the connection to the server, LLM integration, and message passing between components.

• Host: It provides a front-end interface to showcase MCP functions to users and serves as an integration point for the entire ecosystem.

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

📦 MCP Server Components

The MCP server forms the foundation of the protocol by exposing standardized capabilities through well-defined interfaces. Hosts and clients can connect to these servers via this protocol standard, but how these functions are presented to users remains flexible and is entirely up to the developers. This means that the actual implementation and user experience can be fully designed by the developers - whether through a command-line interface, a graphical application, or embedded within a larger system.

In this guide, we will focus on building an example MCP server with core capabilities, 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 LLMs 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 LLMs to interact with external systems, execute code, query databases, or perform calculations. They represent actions that can have an effect or generate new information.

📄 Resources

Resources represent data sources accessible to client applications. They are identified by URIs and include:

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

💡 Prompts

Prompts are predefined instructions used to guide LLMs to perform specific tasks. They can include context information, input parameters, etc.

💻 Usage Examples

Basic Usage

To set up and run the example project, follow these steps:

1. Clone the repository:

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

2. Create a ChromaDB database: Follow the instructions in MCP_setup.ipynb to create a vector database and embed a PDF file.

3. Create a virtual environment and install dependencies:

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

# Install dependencies
uv sync

4. Run the client and server:

python client.py mcp_server.py