MCP Python Server — API Wrapper

Overview: What is MCP Python Server?

The MCP Python Server project is an API wrapper designed to expose tools through the Model Context Protocol (MCP). This protocol provides a standardized way for AI applications like Claude Desktop or ChatGPT Desktop, equipped with support for MCP, to interact with specific data sources or tools via an external API. The server allows developers to create and serve custom tools that integrate directly into these AI platforms, enhancing their functionality.

🔧 Core Features & MCP Capabilities

The core features of the MCP Python Server include:

• Tool Exposure: It exposes a tool (or methods) for users through the MCP interface.
• External API Integration: It supports querying an external HTTP API, allowing complex operations and data retrieval capabilities.
• Direct Integration with MCP Clients: The server can be easily integrated into platforms like Claude/Desktop by using predefined configurations such as claude.json.

Key benefits of this setup include:

• Enhanced AI Application Functionality: Tools developed on this server can extend the capabilities available in AI applications, enabling more personalized and powerful interactions.
• Flexibility: Developers can leverage existing external APIs to perform a wide range of tasks directly within their chosen AI application.

⚙️ MCP Architecture & Protocol Implementation

The architecture of the MCP Python Server leverages the following components:

• MCP Framework: It uses mcp[cli], which is available via pip or uv, to handle interactions between the server and the client.
• Tool Definition: Tools are defined using asynchronous functions with clear descriptions, making it easy to understand their purpose and usage.

For example, a typical tool could be defined as follows:

from mcp.server.fastmcp import FastMCP

tool = FastMCP("API Wrapper")

@tool.tool(description="A tool for consulting external APIs.")
async def consultar_api(param: str) -> str:
    """This function asynchronously consults an external API with the provided parameter."""

This implementation ensures that tools are both functional and understandable, adhering closely to MCP standards.

🚀 Getting Started with Installation

Prerequisites

• Python 3.9+
• mcp[cli]: Installable via pip or using uv init.
• MCP Clients: Ensure that your chosen AI application supports the Model Context Protocol (compatible with Claude/Desktop).

Setup Steps

Using pip:

pip install "mcp[cli]"

Using uv:

uv init mcp-api-server
cd mcp-api-server
uv add "mcp[cli]"

Tool Installation:

mcp install mi_script.py

You can extend this with environment variables if necessary:

mcp install mi_script.py -f .env

Ensure that all dependencies are installed as well:

pip install -r requirements.txt

Create a .env file for optional environment variable setup:

API_KEY=your-api-key-here
API_URL=https://api.yourdomain.com

💡 Key Use Cases in AI Workflows

Case 1: Data Retrieval and Analysis

Assume you want to build a tool that fetches real-time financial data from an external API. You could define such a function within the server.py file as follows:

async def obtener_precios_acciones(param: str) -> str:
    async with httpx.AsyncClient() as client:
        response = await client.get(f"https://api.stockmarket.com/prices?symbol={param}")
        return response.json()

This example demonstrates fetching stock prices, which can then be displayed or used within the AI application to inform financial decision-making.

Case 2: Translation and Localization

Creating a translation tool for generating translations in multiple languages would also benefit from using this server. The following function defines how such a tool might look:

async def traducir(texto: str, lang: str) -> str:
    return f"Translated: {texto} → {lang}"

This allows the AI to seamlessly integrate language translation capabilities into its workflow.

🔌 Integration with MCP Clients

To enable seamless integration with various AI clients such as Claude/Desktop and ChatGPT/Desktop, ensure that appropriate configurations are set up. For example:

Example claude.json Configuration:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"],
      "env": {"API_KEY": "MI_API_KEY"}
    },
    "myServer": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp[cli]",
        "mcp run server.py"
      ],
      "env": {"API_KEY": "SECRETEXAMPLE"}
    }
  }
}

Place this file in the respective application's configuration directory:

• Windows: %APPDATA%\Claude\claude.json
• Linux/macOS: ~/.claude/claude.json

This setup allows your custom tools to be directly invoked by the AI application, enhancing its capabilities.

📊 Performance & Compatibility Matrix

The following table outlines compatibility with different MCP clients and their features:

MCP Client	Resources	Tools	Prompts	Status
Claude Desktop	✔️	✔️	✔️	Full Support
Continue	✔️	✔️	❌	Partial Support
Cursor	❌ (No MCP)	✔️	❌	Tool Only

This compatibility matrix ensures that you can choose the appropriate setup for each client, optimizing both resource usage and functionality.

🛠️ Advanced Configuration & Security

Environment Variables

Creating an .env file to hold sensitive information like API keys is crucial for security. This file contains settings such as:

API_KEY=your-secret-key-here

Running in Development Mode

You can run the server in development mode to quickly test changes:

mcp dev server.py

For production, use:

mcp run server.py

Or with uv for added security and flexibility:

uv run --with mcp[cli] mcp run server.py

❓ Frequently Asked Questions (FAQ)

1. Q: How do I integrate an external API into the AI application?

   • A: Define a tool within your server.py, such as an asynchronous function that queries the API.

2. Q: What does the MCP configuration file look like for integrating my server?

   • A: Refer to the examples provided, ensuring you correctly set up commands and environments for each client.

3. Q: Can I run the server on Windows/Linux/MacOS?

   • A: Yes, but paths may vary depending on your operating system; ensure environment variables are correctly configured.

4. Q: How do I secure sensitive data during setup?

   • A: Use environment variables to store such data and keep configuration files out of version control systems.

5. Q: Are there any limitations with the integration across different MCP clients?

   • A: Consult the compatibility matrix for specific details on client support. Some clients may have fewer features or partial support.

👨‍💻 Development & Contribution Guidelines

Developing New Tools

To contribute new tools, follow these guidelines:

1. Define a new method using @tool decorator.
2. Ensure the tool is well documented with clear parameter descriptions.
3. Test the tool thoroughly to ensure reliability and compatibility across clients.

Contribution Workflow

• Fork this repository.
• Make necessary changes.
• Run tests locally before submission via pull request.

🌐 MCP Ecosystem & Resources

For deeper learning, explore these resources:

• Official Documentation: https://docs.mcp.run/
• MCP SDK for Python: GitHub Repository: https://github.com/modelcontextprotocol/mcp

Conclusion

With the MCP Python Server, developers can enhance their AI applications with custom tools and resource integrations. By following this guide, you’ll be well on your way to building powerful, extensible solutions that offer a unique blend of functionality.

---

Note: This documentation has been created using information from the provided README file and structured according to the template requirements. All content is in English, with original technical language aiming for clarity and completeness while emphasizing MCP server capabilities and AI application integration.