Technical Tutorials

The Model Context Protocol (MCP) has rapidly emerged as the standard for connecting Large Language Models (LLMs) to external tools and data sources. As developers move beyond static prompting and into dynamic, agentic workflows, understanding how to build efficient MCP Servers is no longer optional—it is essential. An MCP Server acts as the bridge between the AI’s reasoning engine and the real world, allowing it to fetch live data, execute code, or interact with proprietary APIs in a structured, secure manner.

What is an MCP Server?

At its core, an MCP Server is a lightweight application that exposes specific capabilities (tools) to MCP Clients. The Client, typically an LLM interface or an AI agent, discovers these tools and invokes them when appropriate. Unlike traditional REST APIs, which are designed for human-readable JSON payloads, MCP uses a standardized JSON-RPC 2.0 protocol to handle request/response cycles, subscriptions, and error handling specifically optimized for AI interaction.

The key value proposition of MCP lies in its context-awareness. It allows the LLM to not only call a function but also to understand the schema of the input it expects and the format of the output it will receive, all without human intervention in the loop.

Architecture and Protocol

The MCP specification defines three primary types of interactions:

Tools: Executable functions (e.g., "calculate_sum", "query_database").
Resources: Read-only data sources (e.g., "get_file_contents", "fetch_news_headlines").
Prompts: Pre-defined prompt templates that the client can invoke.

Communication occurs via stdio (standard input/output) or Server-Sent Events (SSE). For local development, stdio is the default and simplest approach, making it ideal for testing and desktop applications.

Building Your First MCP Server with Python

While you can build MCP Servers from scratch using any language, the fastmcp library provides a streamlined developer experience. Below is a practical example of an MCP Server that exposes a simple calculator tool and a static resource.


from fastmcp import FastMCP

mcp = FastMCP("Math Server")

@mcp.tool()
def add(a: float, b: float) -> float:
    """
    Adds two numbers together.
    
    Args:
        a: The first number.
        b: The second number.
    Returns:
        The sum of a and b.
    """
    return a + b

@mcp.resource("config://server_settings")
def get_server_settings() -> dict:
    """
    Returns the current configuration settings for the server.
    """
    return {
        "version": "1.0.0",
        "environment": "production",
        "features": ["addition", "subtraction"]
    }

if __name__ == "__main__":
    mcp.run(transport="stdio")

In this example, the @mcp.tool() decorator defines a function that the LLM can call. The docstring is critical here; MCP clients use these descriptions to determine *when* to use the tool. Similarly, the @mcp.resource() decorator exposes data. The URI scheme (config://) helps categorize the resource for the client.

Best Practices for Development

When building production-grade MCP Servers, consider the following:

Clear Tool Descriptions: LLMs rely heavily on documentation. Be explicit about input types, constraints, and expected outputs. Avoid ambiguity.
Statelessness: Ideally, MCP Servers should be stateless. If state is required (e.g., session management), handle it internally via a database or cache, not by relying on the client to maintain context across calls.
Error Handling: Return meaningful error messages. If a tool fails, the LLM needs to know *why* so it can adjust its strategy (e.g., retry with different parameters or choose a different tool).
Security: Never expose sensitive credentials in tool definitions. Use environment variables or secure key stores. Validate all inputs to prevent injection attacks, especially when tools interact with databases or shell commands.
Testing: Use the MCP Inspector (available in the MCP GitHub repo) to debug your server. It provides a UI to list tools, view schemas, and test invocations manually.

Deployment Considerations

For local development, running via stdio is sufficient. However, for remote access (e.g., from a cloud-based AI agent), you must expose the server via HTTP/SSE. Libraries like fastmcp support this out of the box:


if __name__ == "__main__":
    # For remote access
    mcp.run(transport="sse", host="0.0.0.0", port=8000)

Note that SSE endpoints require proper CORS configuration and authentication (e.g., API keys, OAuth) to prevent unauthorized access. Always deploy behind a reverse proxy (like Nginx or Caddy) for TLS termination and rate limiting.

Conclusion

MCP Servers represent a paradigm shift in how we integrate AI with enterprise systems. By standardizing the interface, MCP reduces the boilerplate code required to connect LLMs to new tools, enabling faster iteration and more robust agentic applications. As the ecosystem matures, expect to see more advanced features like streaming tool outputs, multi-step workflows, and tighter integration with major AI providers. Start small with a single tool, validate it with the Inspector, and scale up as your needs grow. The future of AI is connected, and MCP is the protocol that makes it happen.