Python MCP Server Tutorial: Integrate LLMs with Real-World Data (Cursor & Claude)

Are you struggling to move past basic text generation with Large Language Models (LLMs)? Do you want to connect your LLMs to real-world data sources such as databases and APIs? This in-depth guide will walk you through building your own MCP (Model Context Protocol) server in Python and integrating it with tools like Cursor and Claude Desktop.

What You'll Achieve

• Understand the importance of MCP for LLM development.
• Create a Python MCP server to query a SQLite database.
• Integrate your MCP server with Cursor & Claude Desktop.
• Learn how to test your setup end-to-end.

Why is Model Context Protocol (MCP) Essential?

LLMs are great at generating text, but they lack the ability to access external information or perform actions on their own. They are limited to generating text based on their training data. The Model Context Protocol (MCP) acts as a universal adapter that enables LLMs to interact with external tools and data sources, such as:

• Databases
• APIs
• Local files

Think of MCP as a USB-C port for your AI – a standardized way to connect your LLMs to the outside world! With a Python MCP server, your LLMs can do more than just chat; they can take actions and provide contextually relevant information.

How MCP Works: A Step-by-Step Overview

1. The User Request: You send a request to the LLM within a host application like Cursor or Claude Desktop (e.g., "List the top chatters").
2. LLM Processing and Tool Check: The LLM processes your text. It determines if an MCP tool is available to fulfill the request.
3. MCP Client Forwarding: If a suitable tool exists, the MCP client (part of the host application) forwards the request to your Python MCP server.
4. Server-Side Magic: The MCP server takes over:
   • It queries a local data source like your SQLite database.
   • Or, it might call remote services (e.g., email/SMS APIs).
5. Results Returned: The server sends the results back to the MCP client.
6. LLM Presentation: Finally, the LLM formats and presents the information/result to you within the host application.

Essentially, the host provides the UI, the client manages requests, and the Python MCP server handles the heavy lifting of connecting the LLM to real-world data and actions.

Prerequisites

Before diving into the code, ensure you have the following:

• Python 3.7+ installed
• SQLite (with a community.db file containing chat data)
• Cursor Pro and Claude Desktop installed
• A terminal (macOS/Linux) or PowerShell/CMD (Windows)

Step-by-Step: Building Your First Python MCP Server

Step 1: Set Up Your Development 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: Get the Sample Database

Download the community.db file (ensure it contains a chatters table with sample data).

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

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 creates a simple MCP server with one tool (get_top_chatters). It connects to your SQLite database, retrieves the top chatters, and returns the data in a usable format.

Integrating with Cursor IDE

1. Open Cursor. Go to Settings -> MCP (requires Cursor Pro).
2. Click "Add a New Global MCP Server." This opens the ~/.cursor/mcp.json file.
3. Update the file with the following configuration:

{
  "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"
    }
  }
}

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

4. Save and return to MCP Settings. A green dot should indicate successful server and tool recognition.

Test Your Integration with Cursor

1. Ask a question like, "How many chatters are in the database?" in the Cursor chat window.
2. Cursor will recognize the need for an external tool.
3. Approve the prompt to run the MCP tool.
4. The MCP server will query the database, and Cursor will display the number of chatters and details.

Integrate with Claude Desktop

1. Open Claude Desktop. Go to Settings -> Developer -> Edit Config.
2. Add the following 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"
    }
  ]
}

• Adjust the command and args based to your environment and where you saved server.py.

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

Test Your Integration with Claude Desktop

1. In Claude Desktop, ask "Show me the list of top chatters".
2. Approve the prompt to run the MCP tool.
3. Claude Desktop will display the results retrieved from your SQLite Database.

Frequently Asked Questions

• What if Claude or Cursor can't find my Python MCP server? Double check the path, activate your virtual environment and restart the host application.
• Can I extend the Python MCP server to other data source? Yes, just implement additional @mcp.tool() decorated methods to expose other functionality.
• Where can I learn more about building MCP integrations? Start by reviewing the official MCP documentation.

Congratulations! You've built a Python MCP server and integrated it with both Cursor and Claude Desktop. Now you can enhance your LLM interactions with real-world data!