MCP (Model Context Protocol) is an open standard that lets AI apps (e.g., Claude Desktop, IDEs, custom agents) safely connect to tools and data through servers that expose resources, tools, and prompts. Think of it like a universal “USB-C port” for AI apps—plug in a server and your AI gains new skills without bespoke integrations. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/?utm_source=chatgpt.com">Model Context Protocol</a>)In this tutorial you’ll:<ul><li>Understand core MCP concepts (client ↔ server, tools/resources/prompts).</li><li>Spin up a minimal Python MCP server and a Node.js MCP server.</li><li>Connect locally from Claude Desktop via JSON config.</li><li>Run everything in Docker (plus a Compose file for multi-server dev).</li><li>Try practical tasks (filesystem, HTTP call, Docker control).</li><li>Lock down permissions and debug common issues.</li></ul><blockquote>If you’re new to MCP, skim the official overview first to see how the parts fit together. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/docs/concepts/architecture?utm_source=chatgpt.com">Model Context Protocol</a>)</blockquote><hr><h2>1) Prerequisites</h2><ul><li>Python 3.10+ and/or Node 18+</li><li>Claude Desktop (optional but convenient client)</li><li>Docker + Docker Compose (optional, for containerized workflows)</li><li>A terminal and a code editor</li></ul>Official SDKs and docs: Python SDK, Node SDK, quickstarts, and Claude configuration. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/modelcontextprotocol/python-sdk?utm_source=chatgpt.com">GitHub</a>)<hr><h2>2) MCP in 3 minutes (Concepts)</h2><ul><li>Server: A process you control that exposes:<ul><li>Tools — callable functions (e.g., “search_web”, “create_repo”).</li><li>Resources — read-only items (e.g., files, DB rows, API responses).</li><li>Prompts — reusable prompt templates.</li></ul></li><li>Client: The AI app (Claude Desktop, your own chatbot) that connects to servers via transports like stdio or HTTP/SSE. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/docs/concepts/architecture?utm_source=chatgpt.com">Model Context Protocol</a>)</li></ul><hr><h2>3) Quick Start: Python MCP Server</h2>Create a tiny server with one tool (<code>say_hello</code>) and one resource (<code>/time</code>).<pre><code class="language-bash">mkdir mcp-python-hello &amp;&amp; cd mcp-python-hello
python -m venv .venv &amp;&amp; source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install mcp</code></pre><code>server.py</code><pre><code class="language-python">import asyncio, json, datetime
from mcp.server import Server
from mcp.types import Tool, TextContent
from mcp.server.stdio import stdio_server

server = Server("python-hello")

# ---- Tools ----
@server.tool()
async def say_hello(name: str) -&gt; str:
 """Return a friendly greeting."""
 return f"Hello, {name}! 👋"

# ---- Resources ----
@server.resource("local://time")
async def local_time():
 now = datetime.datetime.now().isoformat()
 return TextContent(type="text", text=f"Local time is {now}")

async def main():
 tools = [Tool(name="say_hello", description="Greet by name", inputSchema={"type":"object","properties":{"name":{"type":"string"}},"required":["name"]})]
 async with stdio_server(server, tools=tools):
 await asyncio.Event().wait()

if __name__ == "__main__":
 asyncio.run(main())</code></pre>Run it:<pre><code class="language-bash">python server.py</code></pre>This launches a stdio MCP server named <code>python-hello</code>. You’ll connect a client next. (The Python SDK handles protocol messaging/handshakes for you.) (<a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/modelcontextprotocol/python-sdk?utm_source=chatgpt.com">GitHub</a>)<hr><h2>4) Quick Start: Node.js MCP Server</h2><pre><code class="language-bash">mkdir mcp-node-hello &amp;&amp; cd mcp-node-hello
npm init -y
npm install @modelcontextprotocol/sdk</code></pre><code>server.mjs</code><pre><code class="language-js">import { StdioServer, Tool } from "@modelcontextprotocol/sdk/server";

const server = new StdioServer({
 name: "node-hello",
});

server.tool(
 new Tool({
 name: "echo",
 description: "Echo a message back.",
 inputSchema: {
 type: "object",
 properties: { message: { type: "string" } },
 required: ["message"],
 },
 handler: async ({ message }) =&gt; `You said: ${message}`,
 })
);

// Minimal resource example:
server.resource({
 uri: "local://info",
 get: async () =&gt; ({
 type: "text",
 text: "Node MCP server up and running.",
 }),
});

await server.start();</code></pre>Run it:<pre><code class="language-bash">node server.mjs</code></pre>This exposes a tool (<code>echo</code>) and a resource (<code>local://info</code>) over stdio using the official Node SDK. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/quickstart/server?utm_source=chatgpt.com">Model Context Protocol</a>)<hr><h2>5) Connect from Claude Desktop (Local)</h2>Claude Desktop can auto-start and connect to your local MCP servers via a simple JSON config. Create the config file per the docs, pointing to your server binaries and arguments. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/docs/develop/connect-local-servers?utm_source=chatgpt.com">Model Context Protocol</a>)macOS<pre><code>~/Library/Application Support/Claude/claude_desktop_config.json</code></pre>Windows<pre><code>%AppData%\Claude\claude_desktop_config.json</code></pre>Linux<pre><code>~/.config/Claude/claude_desktop_config.json</code></pre>Example config (both Python and Node servers):<pre><code class="language-json">{
 "mcpServers": {
 "python-hello": {
 "command": "python",
 "args": ["server.py"],
 "cwd": "/absolute/path/to/mcp-python-hello"
 },
 "node-hello": {
 "command": "node",
 "args": ["server.mjs"],
 "cwd": "/absolute/path/to/mcp-node-hello"
 }
 }
}</code></pre>Restart Claude Desktop. In a new chat, try:<blockquote>“Use the <code>python-hello</code> server’s <code>say_hello</code> tool with name ‘Abhigyan’.” “Read the <code>local://info</code> resource from the <code>node-hello</code> server.”</blockquote>(Claude Desktop’s integration with MCP servers and configuration is described in the official docs.) (<a target="_blank" rel="noopener noreferrer nofollow" href="https://docs.anthropic.com/en/docs/claude-code/sdk/sdk-mcp?utm_source=chatgpt.com">Claude Docs</a>)<hr><h2>6) Add Real Tasks</h2>Here are three practical tools you can add to any server:<h3>A) Filesystem read (resource)</h3>Expose a safe directory and allow read-only access (never expose secrets):Python<pre><code class="language-python">import pathlib
base = pathlib.Path.home() / "mcp-safe"

@server.resource("fs://readme")
async def readme():
 p = base / "README.txt"
 text = p.read_text()
 return TextContent(type="text", text=text)</code></pre><h3>B) HTTP fetch (tool)</h3><pre><code class="language-python">import httpx
@server.tool()
async def fetch_url(url: str) -&gt; str:
 """Fetch URL (GET) and return first 500 chars."""
 async with httpx.AsyncClient(timeout=10) as client:
 r = await client.get(url, follow_redirects=True)
 return r.text[:500]</code></pre><h3>C) Docker control (tool) — via a dedicated Docker MCP server</h3>Instead of granting shell, point your client to a Docker MCP server which exposes safe operations like listing containers, starting/stopping, composing stacks. Community examples exist and Docker’s blog covers production patterns. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/QuantGeekDev/docker-mcp?utm_source=chatgpt.com">GitHub</a>)<hr><h2>7) Run MCP Servers in Docker</h2>Containerizing servers keeps environments consistent and portable. Docker has showcased MCP usage patterns, and you can package your own with a minimal image. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://www.docker.com/blog/the-model-context-protocol-simplifying-building-ai-apps-with-anthropic-claude-desktop-and-docker/?utm_source=chatgpt.com">Docker</a>)<code>Dockerfile</code> (Python server)<pre><code class="language-dockerfile">FROM python:3.12-slim

WORKDIR /app
COPY server.py /app/server.py

# Optional: httpx for the fetch tool
RUN pip install --no-cache-dir mcp httpx

# Run as non-root for safety
RUN useradd -m appuser
USER appuser

ENTRYPOINT ["python", "server.py"]</code></pre>Build &amp; run:<pre><code class="language-bash">docker build -t mcp-python-hello:latest .
docker run --rm -it mcp-python-hello:latest</code></pre>Tip: If your server needs files, mount a volume:<pre><code class="language-bash">docker run --rm -it -v "$PWD/data:/app/data:ro" mcp-python-hello:latest</code></pre><h3>Docker Compose (Python + Node together)</h3><code>docker-compose.yml</code><pre><code class="language-yaml">services:
 mcp-python-hello:
 build:
 context: ./mcp-python-hello
 tty: true

 mcp-node-hello:
 build:
 context: ./mcp-node-hello
 tty: true</code></pre>Start both:<pre><code class="language-bash">docker compose up --build</code></pre>Then point Claude Desktop to run these via <code>docker exec</code> (advanced), or more simply run them on your host and let Claude Desktop manage startup via stdio as shown earlier. For production pipelines and catalogs of MCP servers, see community write-ups on running MCP servers from Docker Desktop. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://techwithibrahim.medium.com/run-any-mcp-server-locally-with-dockers-mcp-catalog-and-toolkit-f8ecbe0c6a79?utm_source=chatgpt.com">Medium</a>)<hr><h2>8) Using an MCP Client (DIY)</h2>You don’t have to use Claude Desktop—you can write your own client that connects to any MCP server. The official quickstart shows how to build an LLM chatbot client that speaks MCP (Python/Node/Java/Kotlin/C#). (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/quickstart/client?utm_source=chatgpt.com">Model Context Protocol</a>)<ul><li>Parse server capabilities.</li><li>List tools/resources/prompts.</li><li>Call tools with structured input and stream responses.</li><li>Route model messages ↔ MCP messages.</li></ul><hr><h2>9) Security &amp; Permissions</h2><ul><li>Least privilege: expose only the minimal directory, DB, or API scopes your use case needs.</li><li>User confirmation: MCP clients typically surface tool calls for approval before execution.</li><li>Network egress: if you allow HTTP, restrict destinations or filter content.</li><li>Auditability: log tool invocations and inputs/outputs (sans secrets).</li><li>Desktop Extensions: for Claude, packaging servers as “Desktop Extensions” provides one-click installation and a permissioned UX. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://www.anthropic.com/engineering/desktop-extensions?utm_source=chatgpt.com">Anthropic</a>)</li></ul><hr><h2>10) Troubleshooting</h2><ul><li>Server never appears in client Double-check your <code>claude_desktop_config.json</code> path and JSON syntax; ensure commands are resolvable (absolute <code>cwd</code>, correct <code>python</code>/<code>node</code>). (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/docs/develop/connect-local-servers?utm_source=chatgpt.com">Model Context Protocol</a>)</li><li>Transport errors Start with stdio (simplest). If using HTTP/SSE, confirm ports and CORS per SDK docs. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/modelcontextprotocol/python-sdk?utm_source=chatgpt.com">GitHub</a>)</li><li>Tool schema mismatch Ensure your <code>inputSchema</code> matches what the client sends. Use simple types first (string, number) and add objects incrementally. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/quickstart/server?utm_source=chatgpt.com">Model Context Protocol</a>)</li><li>Docker container exits immediately Your entrypoint likely finished. Run servers in the foreground (no daemons), or add <code>tty: true</code> in Compose while developing. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://www.docker.com/blog/the-model-context-protocol-simplifying-building-ai-apps-with-anthropic-claude-desktop-and-docker/?utm_source=chatgpt.com">Docker</a>)</li></ul><hr><h2>11) Where to Go Next</h2><ul><li>Official site &amp; spec — concepts, examples, and reference. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/?utm_source=chatgpt.com">Model Context Protocol</a>)</li><li>SDKs &amp; templates — Python/Node repos and quickstarts. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/modelcontextprotocol/python-sdk?utm_source=chatgpt.com">GitHub</a>)</li><li>Claude Desktop config — connecting local servers, Desktop Extensions. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://modelcontextprotocol.io/docs/develop/connect-local-servers?utm_source=chatgpt.com">Model Context Protocol</a>)</li><li>Docker + MCP — blog posts and examples for packaging &amp; production. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://www.docker.com/blog/the-model-context-protocol-simplifying-building-ai-apps-with-anthropic-claude-desktop-and-docker/?utm_source=chatgpt.com">Docker</a>)</li><li>Ecosystem news &amp; case studies — launch posts and coverage. (<a target="_blank" rel="noopener noreferrer nofollow" href="https://www.anthropic.com/news/model-context-protocol?utm_source=chatgpt.com">Anthropic</a>)</li></ul>

Model Context Protocol (MCP) — A Practical End-to-End Guide

The rapid rise of AI in 2023–2025 has created a new challenge: how do we let AI models safely and consistently talk to tools, APIs, and data sources?Every company is building AI assistants, copilots, or automation workflows. But each integration tends to be custom, inconsistent, and often insecure. That’s where Model Context Protocol (MCP) comes in.<h2>What is MCP?</h2>MCP (Model Context Protocol) is an open standard that defines how AI models interact with external tools, APIs, and data sources.It provides a common language and contract between:<ul><li>Models → LLMs (like GPT, Claude, Gemini, LLaMA)</li><li>Tools → Databases, SaaS APIs, developer utilities</li><li>Clients → IDEs, CLIs, or custom apps where users interact</li></ul>Think of MCP as the “Kubernetes for AI tool integration” — it standardizes communication so every model doesn’t need a bespoke connector.<h2>Why MCP Matters</h2><ol><li>Interoperability Instead of writing one-off connectors for each LLM, MCP lets you write once and run everywhere.</li><li>Security MCP defines explicit permissions for tools, so models can only use what’s granted.</li><li>Transparency Tools declare their capabilities (endpoints, functions, parameters), which the model can read before using.</li><li>Extensibility New tools can be plugged into an MCP ecosystem without changing the model.</li><li>Developer Productivity IDEs like VS Code can expose tools (e.g., Git, Docker, Jira) to models consistently, improving workflows.</li></ol><h2>MCP Architecture</h2>MCP follows a client–server model:<ul><li>Client → The environment where the user interacts (e.g., VS Code extension).</li><li>Server → A tool or data source exposed via MCP (e.g., a database, API, or custom script).</li><li>Model → The LLM that interprets user intent and invokes the right tools via MCP.</li></ul><pre><code class="language-text">[User] → [Client (IDE/CLI)] ↔ [Model] ↔ [MCP Servers (Tools/APIs)]
</code></pre><h3>Example Workflow</h3><ol><li>User asks: “Deploy my Docker container to staging.”</li><li>Model queries MCP for available tools.</li><li>Finds <code>docker</code> and <code>kubernetes</code> servers.</li><li>Invokes the right server with structured parameters.</li><li>Returns result to the user.</li></ol><h2>Core Concepts in MCP</h2><ul><li>Tool Definitions → Tools describe their inputs/outputs (like OpenAPI specs).</li><li>Schema Validation → Ensures the model’s requests match the tool’s contract.</li><li>Context Windows → Models can query MCP for metadata (like project configs) to improve grounding.</li><li>Execution Layer → Actual tool calls run on the server side, keeping the model sandboxed.</li></ul><h2>Example: Exposing a CLI Tool with MCP</h2>Imagine you want to expose <code>kubectl</code> to your AI model via MCP.<pre><code class="language-json">{
 "name": "kubernetes",
 "description": "Manage Kubernetes clusters",
 "commands": [
 {
 "name": "get_pods",
 "description": "List pods in a namespace",
 "parameters": {
 "namespace": { "type": "string", "default": "default" }
 }
 },
 {
 "name": "apply_yaml",
 "description": "Apply a YAML manifest",
 "parameters": {
 "file": { "type": "string" }
 }
 }
 ]
}
</code></pre>🔹 With this spec, any MCP-compliant model can now list pods or apply manifests safely.<h2>Benefits for DevOps &amp; AI Engineers</h2><ul><li>Safe Automation → Expose only controlled commands (no raw <code>rm -rf /</code>).</li><li>Consistency → Whether you use GPT or Claude, the tool contract looks the same.</li><li>Composable Systems → Chain multiple tools (Git → Terraform → Kubernetes) in a single workflow.</li><li>Easier Maintenance → Update one MCP server, all models benefit.</li></ul><h2>Real-World Use Cases</h2><ul><li>AI in IDEs → VS Code exposing Git, Docker, and testing tools via MCP.</li><li>ChatOps → Slack bots using MCP to interact with Jenkins or AWS.</li><li>Data Analysis → LLMs querying databases with explicit schemas.</li><li>Multi-agent Systems → Agents sharing tools using the same protocol.</li></ul><h2>Getting Started with MCP</h2><ol><li>Define a Tool Spec → JSON/YAML describing functions &amp; parameters.</li><li>Run an MCP Server → Expose tool commands over HTTP/WebSocket.</li><li>Connect a Model → Use an MCP-compatible client (OpenAI, Anthropic, etc.).</li><li>Grant Permissions → Explicitly approve which tools a model can use.</li></ol><h2>Final Thoughts</h2>The Model Context Protocol (MCP) is emerging as a key enabler of safe, standardized AI integrations.Just like Kubernetes standardized container orchestration, MCP is doing the same for AI–tool interactions.For DevOps and platform engineers, this means:<ul><li>You can expose infrastructure tools safely to LLMs.</li><li>You reduce custom glue code between AI models and APIs.</li><li>You gain security and consistency across multi-LLM environments.</li></ul>As AI adoption accelerates, MCP is poised to become the backbone of enterprise AI-tooling. If you’re building AI-driven DevOps assistants or copilots, MCP should be on your radar.

MCP

Model Context Protocol (MCP) — A Practical End-to-End Guide

Model Context Protocol (MCP): Standardizing How AI Models Connect with Tools and Data