Skip to main content
Everyone’s talking about MCPs — but what exactly are they? This is a concise introduction to Model Context Protocols (MCPs) for absolute beginners. No prior knowledge required.
A dark presentation slide showing a pink icon labeled "AI Agents" connected by a double-headed arrow to a white MCP logo. A left-side checklist notes features like "Crisp" and "For the Absolute Beginners" alongside crossed-out items such as "No-Nonsense" and "No-BS."
In this article we’ll cover:
  • Why MCPs are needed
  • What MCPs are
  • The MCP architecture
  • How to use an existing MCP server
  • How to build a simple MCP server and client
Example MCP server response (JSON-RPC listing available prompts):
You’ll also get links to hands-on labs, exercises, and resources to follow along with this lesson. Now, let’s start by understanding why MCPs are needed. Start with something familiar: ChatGPT. The basic flow is a request → response loop — you send a message to an LLM and it returns generated text (or other supported formats such as images or audio).
A dark-themed diagram showing the ChatGPT chat interface on the left connected by green dashed arrows to a large "LLM (GPT)" label on the right. The arrows are labeled "request" and "response," illustrating the request-response loop.
Why this isn’t enough for real-world automation
  • LLMs are excellent at reasoning, summarizing, and extracting structure from text.
  • LLMs cannot directly call third-party APIs, maintain durable state, or perform actions on external systems by themselves.
  • For practical applications (e.g., “Book a flight to New London”), you need components that can call APIs, fetch and store preferences, and execute transactions.
This is where AI agents and tools fit in. What are AI agents and tools?
  • AI agents are software components that orchestrate actions: they call LLMs to interpret intent, choose steps, interact with tools/APIs, and iterate until a goal is reached.
  • Tools are adapters or connectors that translate the agent’s requests into service-specific API calls (normalizing different vendor APIs into a consistent schema).
High-level agent process (example: flight booking)
  1. User sends a natural-language request.
  2. Agent calls the LLM to extract structured details (origin, destination, dates).
  3. Agent decides which third-party tools/APIs to call (often with LLM assistance).
  4. Agent calls those APIs (airlines, hotels, cars).
  5. Agent retrieves user preferences from memory or DB.
  6. Agent asks the LLM to evaluate options and choose.
  7. Agent performs booking and returns results to the user.
At many steps the agent consults the LLM to parse input, pick tools, and decide whether the goal is complete.
A colorful flowchart titled "LLM (GPT)" showing a process flow with labeled boxes like "Process Input" and many "Script" nodes, decision diamonds ("If", "Which", "Loop"), and branches out to several "Third Party" endpoints. It maps conditional steps and external integrations for handling inputs.
Example: LLM helps pick a flight
  • The LLM can be asked to choose between candidate flights (e.g., “Pick JA123 based on user preference: cheap, aisle seat”).
  • The agent enforces booking once the LLM chooses an option.
A dark infographic showing an LLM (GPT) helping an agent choose flights, with a table of options (JA123, DR345, AR332) and the recommendation "It's JA123!". Airline logos (Joyair, DracAir, AeroGo) and user preferences are also shown.
Consolidated pseudocode: a simplified agent orchestration
The code below is illustrative pseudocode. It omits production concerns (authentication, retries, error handling, streaming responses, secret management). Treat it as conceptual guidance, not a drop-in implementation.
Frameworks and tools that help build these agent workflows include LangChain, LangGraph, and many emerging libraries. See: What exactly are MCPs?
  • MCP (Model Context Protocol) is a protocol/specification that describes how a service exposes:
    • Which APIs and integrations are available
    • API endpoints, parameters, and authentication
    • Response schemas and example payloads
    • Prompts and helper instructions the model should use
MCPs make tool discovery and usage easier for agents by providing a standardized, machine-readable description of a service’s capabilities. Instead of hard-coding dozens of vendor APIs, agents query an MCP server to discover integrations, prompts, and schemas at runtime. What MCPs provide (quick reference) How MCP client-server architecture works
  • MCP Server: hosted by a service owner or community contributor; publishes tools, prompts, schemas, and examples.
  • MCP Client: embedded in agents, IDE assistants, or developer tools; queries the MCP server to discover how to call a service and which prompts to use.
  • Agents combine MCP metadata with LLM outputs to choose and call the right tool adapter.
Real-world use cases
  • Frontend development: an MCP server can expose browser console logs, DOM structure, and runtime context so an agent can diagnose UI issues and suggest fixes quickly.
A presentation slide titled "Use Cases – Frontend Development" showing a pink "Agent" avatar on the left. Dotted green arrows lead from the agent to boxes labeled "Develop Frontend APIs" and "MCP Server Browser" and onward to an orange app icon.
  • Data engineering: read-only MCP access to SQLite, BigQuery, or dbt Studio lets agents combine datasets, reason about missing data, and surface root causes.
Who builds MCP servers?
  • Anyone who owns a service can publish an MCP server for that service.
  • Vendors are publishing official MCP servers for their platforms; community contributors publish unofficial integrations.
Screenshot of a "Community Servers" README page showing a bulleted list of MCP server projects and links (e.g., 1Panel, A2A, Ableton Live, Ahrefs). The page has a globe icon header and a GitHub URL at the bottom.
Community MCP servers can be extremely helpful for prototyping, but treat untrusted servers with caution. Verify sources, inspect schemas and endpoints before calling production systems, and never send secrets to an untrusted MCP server.
Summary
  • MCPs provide a structured, discoverable layer that tells agents how to interact with services, tools, and APIs.
  • By combining MCP metadata with LLM reasoning, agents can discover integrations at runtime, normalize vendor APIs, and safely orchestrate complex workflows (booking, debugging, data exploration).
  • Next: we’ll dive into the MCP specification, architecture details, and step-by-step examples for using and building simple MCP servers and clients.
Before moving on, make sure you’re comfortable with the agent workflow described above — it’s the foundation for understanding MCP-driven integrations.

Watch Video