Scaling Agentic Workflows: Building and Integrating MCP Servers in Python

Introduction

In the current era of Agentic AI, the biggest hurdle isn't the model's intelligence—it's the integration tax. Writing bespoke connectors for every database, API, or local tool is inefficient and hard to maintain.

The Model Context Protocol (MCP) is a game-changing open standard that decouples "intelligence" (the LLM) from "context" (the tools and data). By providing a universal interface, MCP allows you to build a toolset once and expose it to any compliant agent. LangChain serves as the perfect orchestrator here, acting as the bridge between high-level reasoning and standardized tool execution.

---

High-Level Architecture

The architecture follows a clean, decoupled client-server pattern:

1. AI Agent (LangChain): The "brain" that determines which tool to call based on intent.

2. MCP Client: A thin layer within LangChain that translates agent requests into MCP-standard JSON.

3. MCP Server (Custom): A standalone service (running via Stdio or HTTP) hosting specific tools.

4. Resource Execution: The server executes the code and returns a standardized response.

---

Technical Implementation (Python)

1. The Custom MCP Server

We’ll build a "System Inspector" server using the mcp SDK to expose local system metrics to our agent.

Python

# server.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("SystemInspector")

@mcp.tool()
def get_system_status(category: str) -> str:
    """Provides status updates for specific system categories (memory, cpu, disk)."""
    stats = {
        "memory": "85% utilized",
        "cpu": "12% load",
        "disk": "Ok"
    }
    return f"System {category} status: {stats.get(category, 'Unknown category')}"

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

2. The LangChain Agent Integration

Using the LangChain MCP adapter, we connect the agent to our local server via Stdio.

Python

# agent.py
import asyncio
from langchain_anthropic import ChatAnthropic
from langchain_mcp_adapters.tools import load_mcp_tools
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from mcp import StdioServerParameters

server_params = StdioServerParameters(command="python", args=["server.py"])

async def run_agent():
    mcp_tools = await load_mcp_tools(server_params)
    llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful system administrator."),
        ("human", "{input}"),
        ("placeholder", "{agent_scratchpad}"),
    ])
    
    agent = create_tool_calling_agent(llm, mcp_tools, prompt)
    executor = AgentExecutor(agent=agent, tools=mcp_tools, verbose=True)
    await executor.ainvoke({"input": "What is the current CPU status?"})

if __name__ == "__main__":
    asyncio.run(run_agent())

---

Security & Production Hardening

Moving from a local script to production requires Defense in Depth.

Stdio vs. HTTP/SSE

• Stdio: Best for local IDE tools; inherently secure as it doesn't open network ports.

• HTTP/SSE: Required for enterprise-grade remote tools. Use OAuth 2.1 and Scope-based access to ensure the agent only touches what it should.

Sandboxing with Docker

To prevent "runaway" agent calls from affecting your host, run the MCP server in an air-gapped container.

YAML

# docker-compose.yml (Excerpt)
services:
  mcp-server:
    build: .
    security_opt: ["no-new-privileges:true"]
    networks:
      - mcp_internal
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
networks:
  mcp_internal:
    internal: true # No internet egress

---

Real-World Value

• Scalability: Maintain a library of "micro-tools" that can be plugged into any agent.

• Security: Isolate tool execution from the core LLM logic.

• Maintainability: Update tool logic in one place (the MCP server) without redeploying the agent.

Conclusion

The shift toward MCP marks a transition from bespoke automation to standardized intelligence. As we move toward complex, multi-agent ecosystems, the ability to build, secure, and scale these decoupled architectures will be the hallmark of a modern Technology Architect.