If you built an AI agent over the past two years, you likely ran into the MxN integration problem. Every time you wanted an agent to interact with a system—whether querying a PostgreSQL database, triggering a CI/CD workflow, or reading internal documents—you had to write bespoke adapter code.
If you switched your underlying LLM from OpenAI to Anthropic, or tried testing an open-source model running locally, you had to re-implement tool definitions, adjust JSON schemas, and rewrite client logic. Multiply $M$ models by $N$ internal tools, and your backend codebase quickly devolves into brittle glue code.
This pattern creates high maintenance overhead, weak separation of concerns, and security risks when production API credentials get scattered across disparate agent runtimes.
The Model Context Protocol (MCP) acts as an open standard between AI clients and external systems—think of it as "USB-C for AI agents."
Instead of hardcoding tool execution directly inside agent codebases, MCP introduces a client-server architecture using standard JSON-RPC 2.0 messages over transports like standard input/output (stdio) or HTTP with Server-Sent Events (SSE).
MCP exposes three core primitives:
With this separation, you write an MCP server once for your tool or service. Any MCP-compliant client can connect and utilize it without custom wiring.
Exposing backend functions to an AI agent requires defining tools and handling execution calls. Using the official mcp Python SDK with FastMCP, you can construct an MCP server in very few lines of code.
Here is an example of an MCP server that exposes host system monitoring capabilities:
import psutil
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("SystemMonitor")
@mcp.tool()
def get_system_metrics() -> dict:
"""Fetch current CPU and Memory usage of the host system."""
cpu_percent = psutil.cpu_percent(interval=1)
memory_info = psutil.virtual_memory()
return {
"cpu_usage_percent": cpu_percent,
"memory_usage_percent": memory_info.percent,
"memory_available_mb": round(memory_info.available / (1024 * 1024), 2)
}
if __name__ == "__main__":
mcp.run(transport="stdio")
When an MCP client initializes a connection, it requests available tools. The server automatically inspects the Python docstrings and type hints to generate the tool schema expected by the LLM.
On the client side, the agent interacts with the server standardizing JSON-RPC communication without needing hardcoded knowledge of how the internal service runs.
Here is how an asynchronous MCP client queries the server and invokes a tool:
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
async def run_agent():
server_params = StdioServerParameters(
command="python",
args=["server.py"]
)
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
tools = await session.list_tools()
print("Discovered tools:", [tool.name for tool in tools.tools])
result = await session.call_tool("get_system_metrics", arguments={})
print("Metrics result:", result.content)
if __name__ == "__main__":
asyncio.run(run_agent())
Adopting MCP shifts how enterprise AI architectures are designed:
Decoupling external services from model logic simplifies auditing, speeds up debugging, and makes your AI tooling future-proof.
Tanmay builds AI agents and automation for businesses and is open to freelance projects. Invite readers to connect on LinkedIn to discuss custom AI integrations or backend architecture.