Jayasoruban R — AI Full Stack Engineer

Model Context Protocol (MCP) is an open standard that enables developers to build secure, two-way integrations between LLMs and their data/tools. Instead of building custom connectors for every new model, you build one MCP server that works everywhere.

In this 1,000+ word guide, we will break down the protocol from the ground up and look at how to deploy it in production.

#The MCP Architecture

MCP operates on a client-host-server model. Your application (the Host) connects to an MCP Server via a Client. The Server then exposes **Tools**, **Resources**, and **Prompts**.

Building a Simple MCP Server

typescript

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-database-server",
  version: "1.0.0",
}, {
  capabilities: { tools: {} },
});

// Expose a tool to query your database
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "query_db",
    description: "Query the internal database for customer info",
    inputSchema: {
      type: "object",
      properties: {
        query: { type: "string" }
      },
      required: ["query"]
    }
  }],
}));

#1. Transport Layers: Stdio vs. SSE vs. WebSockets

MCP is transport-agnostic. While most local examples use **Stdio** (Standard Input/Output), production systems often require remote connections.

**Stdio:** Best for local development and CLI tools. Fast and simple, but restricted to the same machine.

**SSE (Server-Sent Events):** The standard for remote MCP. It provides a lightweight, one-way stream from server to client, with a standard POST endpoint for client-to-server messages.

**WebSockets:** Used for high-frequency, bidirectional communication. Ideal for real-time monitoring tools or interactive agents.

#2. Resources vs. Tools: When to use which?

A common confusion is when to use a 'Resource' vs. a 'Tool'.

**Resources:** These are **static or read-only context**. Think of them as 'files' or 'database tables'. The model can read them but cannot execute them. Use these for providing background knowledge or documentation.

**Tools:** These are **executable functions**. They perform actions (like sending an email) or complex computations (like running a Python script). Tools always have a JSON Schema defining their input.

#3. The Lifecycle of an MCP Request

1. **Discovery:** The Host asks the Server for a list of available tools.

2. **Selection:** The LLM decides which tool it needs to solve the user's problem.

3. **Invocation:** The Host sends a request to the Server with the model's arguments.

4. **Execution:** The Server performs the action and returns the result.

5. **Context Injection:** The Host passes the result back to the LLM to complete the conversation.

#4. Security: The MCP Security Model

MCP is designed to be secure by default. Unlike older plugins, the server never has direct access to the LLM's full context or the user's prompt. It only sees the specific tool calls it is asked to execute.

Implementing Scoped Access

In production, you should never use a single 'admin' token. I recommend implementing per-user MCP sessions where the server only exposes tools and resources that the specific user has permission to access.

#5. Building an MCP Aggregator

In a complex enterprise environment, you might have 10 different MCP servers (one for GitHub, one for Jira, one for Internal DB). An **Aggregator** is a special MCP Host that connects to all of them and presents a unified interface to the LLM. This allows you to scale your toolset without overloading the model's context window.

#Conclusion

MCP is the 'USB-C for AI'. It is the first protocol that actually solves the 'isolated island' problem of LLM integrations. By building on MCP today, you are future-proofing your AI applications against the rapid evolution of model providers and orchestration frameworks.

Key Takeaway

"Moving from demo to production requires shifting focus from prompt engineering to system engineering. The magic is in the retrieval loop."

MCP in Production: The New Standard for Model-Tool Communication