Listen to this Post
Introduction:
Every AI engineer who has built agentic systems knows the pain: you write a filesystem wrapper for one agent, a database connector for another, and an API integration for a third. Each time, you’re solving the same problem from scratch, writing bespoke glue code that locks your tools to a single agent implementation. The Model Context Protocol (MCP) fundamentally changes this dynamic by establishing a standardized, JSON-RPC based protocol that turns tools from agent-specific functions into reusable infrastructure that any MCP-compatible host can plug into【1†L9-L13】.
Learning Objectives:
- Understand the architectural shift MCP introduces and why it replaces custom integration code with a standardized protocol
- Learn to implement MCP servers that expose Tools, Resources, and Prompts as reusable capabilities
- Master practical deployment patterns for MCP servers across Linux and Windows environments
- Apply security hardening techniques to MCP implementations in production
You Should Know:
- Understanding The MCP Architecture: Hosts, Clients, And Servers
MCP defines a clear three-layer architecture that separates concerns and enables true reusability. The MCP Host is the AI application itself—think Claude Desktop, a custom LangGraph agent, or any LLM-powered application. The Host communicates with MCP Clients, which in turn talk to MCP Servers—lightweight services that expose specific capabilities like file system access, database queries, or API integrations【1†L9-L11】.
The protocol operates over JSON-RPC, making it language-agnostic and easily implementable. This means you can build an MCP server in Python, Node.js, Rust, or any language that speaks JSON, and any MCP-compliant host can consume it.
Three Core Primitives:
→ Tools: Functions the model can invoke—”search_files”, “query_database”, “send_email”—each with defined input schemas【1†L13-L14】
→ Resources: Data the model can read—files, database schemas, configuration objects—exposed as URI-addressable entities【1†L14】
→ Prompts: Reusable prompt templates that the server exposes, allowing standardized interaction patterns across agents【1†L14-L15】
Step‑by‑step: Building Your First MCP Server
- Choose your implementation language—Python with the official MCP SDK, Node.js, or a custom JSON-RPC implementation
- Define your server capabilities—decide whether you’re exposing Tools, Resources, or Prompts
- Implement the protocol handlers—
tools/list,tools/call,resources/list,resources/read,prompts/list, `prompts/get`
4. Configure transport—stdio for local development, SSE for remote deployments - Register with your MCP Host—configure Claude Desktop or your custom agent to connect
Linux Implementation Example:
Install the Python MCP SDK
pip install mcp
Create a basic filesystem MCP server
cat > filesystem_server.py << 'EOF'
import asyncio
from mcp.server import Server, stdio_server
from mcp.types import Tool, TextContent
app = Server("filesystem-server")
@app.list_tools()
async def list_tools():
return [
Tool(
name="read_file",
description="Read contents of a file",
inputSchema={
"type": "object",
"properties": {
"path": {"type": "string", "description": "File path"}
},
"required": ["path"]
}
)
]
@app.call_tool()
async def call_tool(name: str, arguments: dict):
if name == "read_file":
with open(arguments["path"], "r") as f:
return TextContent(type="text", text=f.read())
if <strong>name</strong> == "<strong>main</strong>":
asyncio.run(stdio_server.run(app))
EOF
Run the server
python filesystem_server.py
Windows Implementation:
Using Python on Windows python -m pip install mcp Your server code remains the same; transport handles the differences Configure your MCP host to connect via stdio with the appropriate Python path
2. Replacing Custom Wrappers With MCP Servers
The fundamental shift MCP enables is moving tool logic from inside your agent’s code to standalone servers. Before MCP, your agent code might look like this:
BEFORE: Agent-specific, tightly coupled class MyAgent: def search_files(self, query): Custom implementation pass def query_database(self, sql): Custom implementation pass
After MCP, your agent becomes a thin client that delegates to MCP servers:
AFTER: Protocol-based, loosely coupled
class MCPAwareAgent:
def <strong>init</strong>(self, mcp_client):
self.client = mcp_client
def search_files(self, query):
return self.client.call_tool("filesystem", "search", {"query": query})
Step‑by‑step: Migrating Custom Tools To MCP
- Inventory your existing tools—list every function your agent currently calls
- Group by capability domain—filesystem operations, database queries, API calls
- Design your MCP server interfaces—define tool names, descriptions, and JSON schemas
- Implement each tool as an MCP handler—keeping business logic separate from protocol concerns
- Test with multiple hosts—verify your server works with Claude Desktop, custom agents, and other MCP clients
- Deploy as infrastructure—treat your MCP servers as independent services with their own lifecycle
3. Security Hardening For MCP Servers In Production
When exposing MCP servers to LLM agents, security becomes paramount. An agent with filesystem access can read sensitive files, and a database-connected agent can execute arbitrary queries.
Critical Security Controls:
- Input validation—validate all tool arguments against strict schemas
- Path sanitization—prevent directory traversal attacks in filesystem tools
- Query parameterization—use parameterized queries to prevent SQL injection
- Rate limiting—prevent abuse through excessive tool calls
- Authentication and authorization—implement API keys or OAuth for remote MCP servers
Linux Security Hardening Commands:
Run MCP server as a dedicated non-root user sudo useradd -r -s /bin/false mcpserver sudo chown -R mcpserver:mcpserver /opt/mcp-server Set restrictive file permissions sudo chmod 750 /opt/mcp-server sudo chmod 640 /opt/mcp-server/config.json Use systemd to manage the service with security restrictions cat > /etc/systemd/system/mcp-server.service << 'EOF' [bash] Description=MCP Server After=network.target [bash] User=mcpserver Group=mcpserver WorkingDirectory=/opt/mcp-server ExecStart=/usr/bin/python3 /opt/mcp-server/server.py Restart=always ProtectSystem=strict ProtectHome=true PrivateTmp=true NoNewPrivileges=true [bash] WantedBy=multi-user.target EOF sudo systemctl daemon-reload sudo systemctl enable mcp-server sudo systemctl start mcp-server
Windows Security Considerations:
- Run MCP servers under least-privilege service accounts
- Use Windows Defender Application Control to restrict executable paths
- Implement proper ACLs on directories the server accesses
- Consider using Windows Sandbox for testing untrusted MCP servers
4. Deploying MCP Servers With LangChain And LangGraph
LangChain and LangGraph provide natural integration points for MCP. The MCP protocol’s tool definition maps cleanly to LangChain’s tool interface.
Integration Example:
from langchain.tools import StructuredTool
from mcp.client import MCPClient
class MCPToolAdapter:
def <strong>init</strong>(self, server_name: str, mcp_client: MCPClient):
self.server = server_name
self.client = mcp_client
self._tools = self._load_tools()
def _load_tools(self):
tools = self.client.list_tools(self.server)
return [
StructuredTool.from_function(
func=lambda kwargs: self.client.call_tool(
self.server, tool.name, kwargs
),
name=tool.name,
description=tool.description,
args_schema=tool.inputSchema
)
for tool in tools
]
Use with LangGraph agent
adapter = MCPToolAdapter("filesystem", mcp_client)
tools = adapter._tools
agent = create_react_agent(llm, tools)
Step‑by‑step: Production Deployment
- Containerize your MCP servers—use Docker for consistent deployment
- Implement health checks—ensure your MCP server responds to `initialize` requests
- Set up logging and monitoring—log all tool calls and errors
- Configure retry and timeout policies—prevent LLM agents from hanging
5. Version your MCP servers—support multiple versions simultaneously
- Document your tool schemas—use OpenAPI or similar for discoverability
Docker Deployment:
FROM python:3.11-slim WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY server.py . EXPOSE 8000 CMD ["python", "server.py"]
5. Advanced MCP Patterns: Resources And Prompts
Beyond tools, MCP’s Resources and Prompts capabilities open powerful patterns. Resources allow agents to read configuration, schemas, or documentation dynamically. Prompts enable standardized interaction templates that evolve independently of agent code.
Resource Example—Exposing Database Schemas:
@app.list_resources() async def list_resources(): return [ Resource( uri="postgres://schema/public", name="Public Schema", description="Database schema for public tables", mimeType="application/json" ) ] @app.read_resource() async def read_resource(uri: str): if uri == "postgres://schema/public": Query database for schema schemas = get_schema() return TextResourceContents( uri=uri, text=json.dumps(schemas), mimeType="application/json" )
Prompt Example—Reusable Analysis Template:
@app.list_prompts()
async def list_prompts():
return [
Prompt(
name="analyze_logs",
description="Analyze system logs for anomalies",
arguments=[
PromptArgument(
name="time_range",
description="Time range to analyze",
required=True
)
]
)
]
@app.get_prompt()
async def get_prompt(name: str, arguments: dict):
if name == "analyze_logs":
return GetPromptResult(
messages=[
PromptMessage(
role="user",
content=f"Analyze logs from {arguments['time_range']} for security anomalies"
)
]
)
What Undercode Say:
- MCP transforms tools from agent-specific functions into reusable infrastructure, eliminating the “rewrite everything” problem that plagues agentic system development【1†L12-L13】
-
The protocol’s three primitives—Tools, Resources, and Prompts—provide a complete framework for agent-tool interaction that scales from simple filesystem access to complex enterprise integrations【1†L13-L15】
-
Security cannot be an afterthought with MCP; exposing tools to LLM agents introduces new attack surfaces that require careful input validation, least-privilege design, and comprehensive monitoring【1†L7-L11】
-
The true value of MCP emerges when organizations build libraries of MCP servers that become shared infrastructure, similar to how microservices transformed backend development
-
MCP’s JSON-RPC foundation makes it accessible across programming languages, lowering the barrier to adoption and enabling polyglot tool development
Prediction:
+1 The Model Context Protocol will become the de facto standard for agent-tool interaction within 18 months, similar to how OpenAPI standardized REST APIs【1†L7-L9】
+1 MCP server marketplaces will emerge, enabling organizations to purchase and deploy pre-built capabilities rather than building from scratch【1†L12-L13】
-1 Security incidents involving MCP servers will increase as adoption grows, particularly around improperly validated filesystem and database tools【1†L7-L11】
+1 LangChain and LangGraph will deepen MCP integration, making it the default tool interface for their agent frameworks【1†L17-L18】
+1 The distinction between “tool building” and “infrastructure building” will blur, with MCP servers becoming first-class citizens in cloud deployment pipelines【1†L15-L17】
▶️ Related Video (66% Match):
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Mtayyabzunair Mcp – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
