Python MCP Server: Connect LLMs to Real-World Data (Step-by-Step Guide)

Want to extend your Large Language Models (LLMs) beyond basic text generation? Discover how to build a Python MCP server and seamlessly integrate it with tools like Cursor and Claude Desktop! This guide provides a hands-on approach to connecting your LLMs to external data sources, unlocking a world of new possibilities.

Why You Need a Model Context Protocol (MCP) Server

LLMs like GPT and Claude are powerful, but they can't inherently access external data or trigger actions in the real world. Think of it this way: they can write a great email, but they can't send it without help. That's where the Model Context Protocol (MCP) comes in. MCP acts as a universal adapter, allowing LLMs to interact with:

• Databases
• APIs
• Other external tools

An MCP server is the key component that handles these interactions, bridging the gap between the LLM's language capabilities and the world outside.

What You'll Achieve: Building a Simple SQLite Query Tool

In this tutorial, you'll build a functional MCP server that queries a SQLite database and returns results to your LLM client. Specifically, you'll create a server that retrieves the top chatters from a community database. You'll learn how to:

• Set up a Python MCP server.
• Connect this server to both Cursor and Claude Desktop.
• Write a simple SQLite query tool to fetch data.
• Test your setup end-to-end.

Prerequisites: Getting Ready to Code

Before diving in, ensure you have the following:

• Python 3.7+ installed.
• SQLite (with a community.db file — we'll provide a sample).
• Cursor Pro and Claude Desktop installed.
• A terminal (macOS/Linux) or PowerShell/CMD (Windows).

Understanding the MCP Architecture

The MCP architecture consists of three key components:

• Host: The application you interact with (e.g., Cursor, Claude Desktop).
• Client: The agent within the host that speaks the MCP protocol and forwards requests.
• Server: Your custom server that performs the actual data retrieval or action.

Here's how the process works step by step:

1. You send a request to the LLM in your chosen host application.
2. The LLM client analyzes the request and verifies whether an MCP tool exists for the task.
3. If a fitting tool exists (like our SQLite query tool), the client forwards the request to your Python MCP server via the MCP protocol.
4. The MCP server then performs the requested task, such as querying your local SQLite database.
5. The server sends the results back to the client who hands it back to the LLM.
6. Finally, the LLM formats the results and presents them to you in a readable format within the host application.

Step 1: Setting Up Your Python Environment

1. Create a Virtual Environment:

   python -m venv mcp-env
   source mcp-env/bin/activate  # For Windows: mcp-env\Scripts\activate
   

   Copy

2. Install the MCP Python SDK:

   pip install mcp
   

   Copy

Step 2: Obtaining the Sample Database

Download the community.db file, containing a chatters table with sample data. This will serve as your data source for the MCP server.

Step 3: Crafting Your Python MCP Server (sqlite-server.py)

Create a new file named sqlite-server.py and paste the following code:

from mcp.server.fastmcp import FastMCP
import sqlite3

# Initialize the MCP server with a friendly name
mcp = FastMCP("Community Chatters")

# Define a tool to fetch the top chatters from the SQLite database
@mcp.tool()
def get_top_chatters():
    """Retrieve the top chatters sorted by number of messages."""
    # Connect to the SQLite database
    conn = sqlite3.connect('community.db')
    cursor = conn.cursor()
    # Execute the query to fetch chatters sorted by messages
    cursor.execute("SELECT name, messages FROM chatters ORDER BY messages DESC")
    results = cursor.fetchall()
    conn.close()
    # Format the results as a list of dictionaries
    chatters = [{"name": name, "messages": messages} for name, messages in results]
    return chatters

# Run the MCP server locally
if __name__ == '__main__':
    mcp.run()

This code defines a single tool, get_top_chatters, which connects to your SQLite database, retrieves the data, and returns it in a structured format. This is a simple example of a SQLite query tool that can be triggered by Cursor and Claude.

Adding Your MCP Server to Cursor (Pro Required)

1. Open Cursor → Settings → MCP (requires Cursor Pro).

2. Click "Add a New Global MCP Server." This opens the MCP server configuration file (~/.cursor/mcp.json).

3. Update the file with your server details:

   {
     "mcpServers": {
       "sqlite-server": {
         "command": "/path/to/your/project/venv/bin/python",
         "args": [
           "/path/to/your/project/sqlite-server.py"
         ],
         "description": "A simple MCP server to query top chatters from a community database"
       }
     }
   }
   

   Copy

   Replace /path/to/your/project/ with the actual path to your project directory.

4. Save the file and return to MCP Settings. You should see your server listed with a green dot indicating it's active.

Testing Your MCP Server in Cursor

1. Open a chat in Cursor and ask: "How many chatters are in the database?".
2. Cursor will recognize that it needs an external tool.
3. Grant permission when prompted to run the tool.
4. The MCP server will query the database and the AI will present the information in the chat, including the number of chatters, names and message counts.

Integrating with Claude Desktop

1. Open Claude Desktop → Settings → Developer → Edit Config.

2. Add the same server block to claude_desktop_config.json:

   {
     "servers": [
       {
         "name": "Community Chatters Server",
         "command": "python",
         "args": ["server.py"],
         "description": "A simple MCP server to query top chatters from a community database"
       }
     ]
   }
   

   Copy

3. Save, close, and reopen Claude Desktop to apply the changes.

4. Verify the MCP server is listed in Claude Desktop's settings. A tool icon in the chat window indicates external tools are connected.

Testing Your MCP Server in Claude Desktop

1. Open a chat in Claude Desktop and ask "Show me the list of top chatters".
2. Claude Desktop will recognize the need for an external tool.
3. Approve the prompt to run the MCP tool.
4. You will receive an output that includes the names and number of chatters in the community database.

Now you’ve successfully connected Claude Desktop and Cursor to your MCP server enabling both GPT and Claude to leverage external data for responses.

Frequently Asked Questions

• What does this MCP server do? The MCP server queries a SQLite database to find statistics about community members and reports it the client application.
• How do I integrate my MCP Server with Claude Desktop? You can integrate the MCP server by adding the server block to claude_desktop_config.json and re-opening Claude Desktop.
• Can I expand this tutorial to build bigger things? Absolutely, you can expand this basic application to email or SMS capabilities.

Conclusion: Your First Step into the MCP Ecosystem

You've successfully built a basic Python MCP server and integrated it with leading LLM platforms. This opens the door to a world of possibilities, enabling your LLMs to:

• Access and analyze real-world data.
• Trigger actions and automate tasks.
• Become more intelligent and versatile.

Continue exploring the MCP ecosystem and build even more advanced applications!