A Beginner’s Guide to MCP (Made Simple)

After spending a few days exploring the Model Context Protocol (MCP) and even writing some code around it .. ( https://github.com/rilov/mcp )

I wanted to share a simplified perspective based on my understanding so far..

What is MCP?

Model Context Protocol (MCP) is a standard way to connect Large Language Models (LLMs) to external tools, APIs, and data sources by passing structured context.

Think of MCP like this

LLM = brain, but to do anything useful (send email, call an API, fetch data), it needs hands and eyes.

MCP gives the LLM details about the external tools available in the host, and tells it what tools are available and how to use them … just like an app store manifest.

What Exactly Happens in MCP

Step1 — Tool is Exposed via MCP Server

• Each tool (API, script, service) is wrapped with a MCP server interface.
• The MCP server describes what it does using metadata like Function name Description Parameters and types (JSON Schema)
• These tools can be called via HTTP, Docker, Python, etc.

Step 2 — MCP Host Loads the Tools

• The MCP host (an agent or app) loads this metadata from all registered MCP servers.
• This becomes a registry of available tools.
• The MCP host prepares this info in a format the LLM can understand (OpenAI-style function descriptions or JSON schemas).

Step 3. LLM Receives Tool Context

When the user asks a question (e.g., “Book me a flight”), the MCP host.. Sends the user query + tool metadata to the LLM. The LLM uses that context to reason which tool to call. The model returns a structured call as ouput.

output from llm(simplified to understand)

{“tool”: “book_flight”,
“args”: {
“destination”: “New York”,
“date”: “2025–05–01”}}

Step 4. MCP Host Executes the Call

• The MCP host reads this response from the LLM.
• It routes the call to the right MCP server/tool (via HTTP, Python, Docker, etc).
• Gets back the result.

Step 5 . LLM Continues the Conversation

• The result is given back to the LLM (or directly to the user).
• If needed, the LLM uses the new info to take the next step (like a follow-up call or message).

Role of Each Component Involved.

MCP Server — Wraps a tool (api call , custom code and functionality like email sending) and describes what it can do

Get RILOV’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

MCP Host — Aggregates tools, sends tool info to LLM, handles execution

LLM — Reads tool context, decides what tool to call, returns function call

User Starts the whole process with a natural-language prompt

MCP feels very much like OpenAI’s function calling mechanism. But the key difference is

Function calling is a capability of an LLM and introduced by openAi.

MCP is a standardized protocol for plugging in tools that the LLM can call across different models, platforms, and hosting setups.

Side-by-Side Comparison

Think of it like this..

Why MCP matters (even if function calling exists)

• You don’t want to manually define tools every time for every model.
• You want plug-and-play tools to work across: OpenAI, Anthropic, Mistral, local LLMs, etc. Local Docker tools, HTTP services, CLI tools, Python modules.
• You want secure, maintainable, shareable, and discoverable tool ecosystems.

Function Calling means the AI chooses a specific tool or function to use, and provides the name of the tool along with the required input (arguments) to run it. But you still have to manage how the tool is actually executed.

Model Context Protocol (MCP) takes that idea further. It builds a full ecosystem around those tools — with a registry that lists available tools, standardized descriptions (like what each tool does and what inputs it needs), and a system to automatically run them. This way, the AI can not only choose the right tool but also trigger it seamlessly, making everything more automated and coordinated.

The Model Context Protocol (MCP) introduces a powerful new way to integrate AI into automation workflows by turning APIs, scripts, and services into callable “tools” with clear metadata. By bridging the gap between tool registries and LLMs, MCP enables intelligent agents to reason about which action to take .. without hardcoding logic or manual orchestration.

This approach marks a major shift in how infrastructure automation is designed. Instead of relying on brittle pipelines or static workflows, AI agents can dynamically decide which tool to use based on user intent and system context. This makes automation more adaptive, context-aware, and reusable across teams and environments.

In practical terms, it means infrastructure platforms can evolve from passive dashboards and runbooks into intelligent systems that self-operate, troubleshoot, and collaborate with engineers. MCP lowers the barrier to integrating AI into infrastructure, and as adoption grows, it has the potential to transform everything from DevOps to incident management, provisioning, and beyond.

We’re no longer just automating commands ..we’re enabling conversations with infrastructure.