The Universal Plug for AI Agents.
For years, connecting AI models to real-world tools meant writing custom integration code for every combination of model and capability. The Model Context Protocol changes that. MCP is the USB-C of AI — a single, open standard that lets any agent connect to any tool, any data source, any service. I think it's one of the most important infrastructure developments in AI right now, and I'm building on top of it.
What Is MCP?
"MCP is to AI agents what REST APIs were to web services — a common language that makes everything composable."
The Model Context Protocol (MCP) is an open standard developed by Anthropic that defines how AI models communicate with external tools and data sources. Instead of every AI application building its own bespoke integrations, MCP provides a universal interface: a server exposes capabilities, a client (the AI model or agent) connects to it, and they communicate through a standardized protocol.
An MCP server is a lightweight service that wraps a capability — a database, an API, a file system, a code executor, a web browser — and exposes it to any MCP-compatible AI client. Build the server once, and any agent that speaks MCP can use it.
This is a fundamental shift. Before MCP, tool integration was a bespoke, fragile, per-model problem. With MCP, it becomes infrastructure — composable, reusable, and model-agnostic.
Why MCP Matters for Agent Systems
The real power of MCP isn't any single server — it's what becomes possible when agents can dynamically discover and compose capabilities at runtime.
Model Agnosticism
An MCP server works with Claude, GPT-4, Gemini, local LLMs — any model that implements the client protocol. You build the integration once and it works everywhere. No more rewriting tool integrations every time you switch models.
Dynamic Tool Discovery
Agents can query an MCP server at runtime to discover what tools are available, what parameters they take, and what they return. The agent doesn't need to know the tools in advance — it can adapt to whatever capabilities are present.
Composable Architecture
Multiple MCP servers can be combined. An agent can simultaneously connect to a database server, a web search server, a code execution server, and a file system server — composing capabilities on the fly to solve complex tasks.
Clean Separation of Concerns
MCP separates the AI reasoning layer from the tool implementation layer. The agent focuses on what to do; the MCP server handles how to do it. This makes both layers easier to build, test, and maintain independently.
Security Boundary
MCP servers act as a controlled gateway. You define exactly what capabilities are exposed, with what permissions, under what constraints. The agent never has direct access to your systems — it goes through the server.
Ecosystem Momentum
The MCP ecosystem is growing fast. Hundreds of servers are already available for common services. Building on MCP means your agents can immediately leverage a growing library of pre-built integrations.
Servers I'm Building
Active MCP server projects in the lab — each one solving a real integration problem for agent systems.
Infrastructure Ops Server
An MCP server that exposes infrastructure management capabilities to AI agents — querying server health, reading logs, executing runbooks, and triggering alerts. Built to power the Enterprise Ops Swarm, it gives agents safe, audited access to production systems without direct shell access.
Capabilities
Stack
TypeScript · Node.js · SSH · Prometheus API
Knowledge Base Server
An MCP server that wraps a pgvector-backed RAG pipeline and exposes it as a tool. Agents can search the knowledge base with natural language, retrieve relevant documents with citations, and ask follow-up questions — all through a clean MCP interface.
Capabilities
Stack
TypeScript · pgvector · PostgreSQL · OpenAI Embeddings
Code Execution Server
A sandboxed MCP server that lets agents write and execute code in isolated Docker containers. Supports Python, TypeScript, and shell. Returns stdout, stderr, exit codes, and generated files. Built with hard resource limits and no network access by default.
Capabilities
Stack
TypeScript · Docker · Node.js
Web Intelligence Server
An MCP server that gives agents structured web access — search, scrape, extract, and summarize web content. Uses a headless browser for JavaScript-heavy sites and returns clean, structured data rather than raw HTML.
Capabilities
Stack
TypeScript · Playwright · Cheerio · Brave Search API
How I Structure MCP Servers
Every MCP server I build follows the same architectural principles — regardless of what capability it wraps.
Single Responsibility
Each server does one thing well. An infrastructure server doesn't also do web search. Focused servers are easier to secure, test, version, and reason about.
Explicit Tool Schemas
Every tool exposed by the server has a precise JSON Schema definition — parameter names, types, descriptions, and constraints. Good schemas are what allow agents to use tools correctly without trial and error.
Structured Error Responses
Errors are first-class citizens. Every tool returns structured error information that an agent can reason about — not just a stack trace. The agent needs to know what went wrong and whether it can retry.
Audit Logging
Every tool invocation is logged with the caller identity, parameters, result, and timestamp. When an agent does something unexpected, you need to know exactly what it called and what it got back.
Transport Flexibility
I build servers to support both stdio (for local/embedded use) and HTTP+SSE (for remote/multi-client use). The capability layer is transport-agnostic — switching transports doesn't require rewriting tools.
Tool Categories I Expose
Across my MCP servers, these are the categories of capabilities I expose to agents.
Data & Knowledge
Execution & Compute
Infrastructure & Ops
Web & External
Challenges & Lessons Learned
MCP is powerful, but building production-grade servers has taught me things the documentation doesn't cover.
Schema Quality Is Everything
The quality of your tool schemas directly determines how well agents use your server. Vague parameter descriptions lead to incorrect calls. I now treat schema writing as a first-class engineering task — as important as the implementation itself.
Agents Will Find Edge Cases You Didn't
Agents explore the parameter space in ways humans don't. They'll pass empty strings, null values, extremely long inputs, and combinations you never tested. Defensive input validation isn't optional — it's the first line of reliability.
Idempotency Matters More Than You Think
Agents retry failed tool calls. If your tools have side effects and aren't idempotent, retries cause duplicate actions — duplicate database writes, duplicate API calls, duplicate alerts. Design for idempotency from the start.
Timeouts Need to Be Explicit
Agents have their own context window and reasoning budgets. A tool that takes 30 seconds to respond can derail an entire agent run. Every tool needs an explicit timeout, a fast failure path, and a clear error message when it times out.
The Permission Model Is Your Security Model
What you expose through MCP is what agents can do. I treat every tool as a potential attack surface and apply least-privilege principles — agents get exactly the access they need for their role, nothing more.
Tech Stack
The tools and frameworks I use to build and run MCP servers.
Core
Transport & Communication
Infrastructure
Explore More of the Lab
MCP servers are the tool layer that powers agent swarms and RAG systems. See how they fit into the bigger picture.