Model Context Protocol is to AI models what USB is to computers: a single standard interface so that any model can plug into any tool without writing custom integration code for every combination. Anthropic released MCP as an open standard in November 2024. Before MCP, connecting an AI model to an external tool required custom integration code for every model-tool pair. With MCP, any MCP-compatible model can use any MCP server.

This article covers how MCP works, its three primitives, how it compares to function calling, how to build a basic MCP server, popular MCP servers in use today, and the interview questions engineers are encountering as agentic AI becomes a standard system design topic.

Key Takeaways

What Is the Model Context Protocol?

What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open standard created by Anthropic and released in November 2024. It provides a universal interface for connecting AI language models to external tools, resources, and data sources. Think of it the way you think of USB: before USB, every device needed a custom cable and custom driver. After USB, any device can connect to any computer with the same connector. MCP does the same for AI models and external tools: any MCP-compatible model can use any MCP server without custom integration code for the specific model-tool pair.

Why was MCP created?

Before MCP, connecting N AI models to M external tools required N x M custom integrations. Every model-tool combination needed its own bespoke code. MCP reduces this to N + M: each AI model implements the MCP client once, each tool implements the MCP server once, and they automatically work together. For a team maintaining integrations across multiple models and data sources, this is the difference between maintaining dozens of one-off connectors and maintaining a single standard interface.

How MCP Works: The Three Primitives

What are the three MCP primitives?

MCP exposes three types of capabilities that a server can offer to a connected AI model. In practice, adoption is uneven across the three.

How does an MCP server communicate with an AI model?

MCP uses JSON-RPC over either HTTP or stdin/stdout (standard input/output). The MCP client, which is the AI application, sends a tools/list request to discover what tools are available on a connected server, then sends a tools/call request to invoke a specific tool with arguments. This same request-response pattern works regardless of which AI model and which external tool are being connected, which is what makes the protocol reusable.

MCP vs Function Calling

What is the difference between MCP and function calling?

These two are complementary, not competing. Function calling is a capability built into specific AI model APIs. MCP is a transport protocol layer above function calling. Understanding the distinction is important for anyone designing agentic AI systems.

MCP Architecture: Hosts, Clients, and Servers

What are MCP hosts, clients, and servers?

MCP has three architectural roles. Every MCP deployment involves all three, though in simple local setups, they may run on the same machine.

How to Build Your First MCP Server

How do you build a basic MCP server in Python?

Building a minimal MCP server in Python requires the MCP SDK and about 15 lines of code. The example below exposes a single tool that returns the current time. This is the simplest possible MCP server and a good starting point for understanding the structure.

1. Install the MCP SDK using this command “pip install mcp”
2. Create a server instance and register tools using the @server.tool() decorator.
3. Implement the tool function with type-annotated return values.
4. Configure the transport. stdio is the simplest for local development.
5. Test locally by adding the server to Claude Desktop’s config or another MCP host.

from mcp.server import Server
from mcp.server.stdio import stdio_server

server = Server('my-first-mcp-server')

@server.tool()
async def get_current_time() -> str:
    """Return the current ISO timestamp."""
    from datetime import datetime
    return datetime.now().isoformat()

if __name__ == '__main__':
    import asyncio
    asyncio.run(stdio_server(server))

Popular MCP Servers and Use Cases

What are the most popular MCP servers and what do they do?

The MCP ecosystem has grown rapidly since the November 2024 release. These are the most widely adopted servers as of 2026.

MCP in Agentic AI Systems

How does MCP fit into agentic AI system design?

In agentic AI systems, a language model needs to interact with external tools, APIs, databases, and services autonomously over multiple steps. MCP provides the standardised interface layer that allows the agent to discover and invoke these tools without hardcoded integrations for each one. An agentic system built on MCP can add new capabilities by simply connecting a new MCP server rather than rewriting the agent’s tool integration code. This makes the system extensible by default: the agent discovers available tools at runtime via tools/list rather than having them hardcoded at build time.

MCP Interview Questions for Engineers

What MCP questions come up in agentic AI and system design interviews?

The following questions are appearing with increasing frequency in senior engineering and AI system design interviews as MCP becomes an industry standard. Each is followed by a model answer.

Q1. What is the Model Context Protocol and why was it created?

MCP is an open standard created by Anthropic (released November 2024) that provides a universal interface for connecting AI models to external tools, resources, and data sources. It was created to solve the N x M integration problem: before MCP, connecting N AI models to M tools required N x M custom integrations. MCP reduces this to N + M by having each model and each tool implement the protocol once.

Q2. How does MCP differ from function calling in OpenAI or Claude APIs?

Function calling is a capability within a specific model’s API for invoking predefined functions. MCP is a transport-agnostic protocol layer above function calling: an MCP server exposes tools that any MCP-compatible model can use via its function calling capability. MCP adds portability and reusability across models; function calling provides the execution mechanism within a specific model.

Q3. Design an AI agent that needs to query a database, send a Slack message, and search the web. How would you architect the tool integrations?

Use MCP to provide a standardised interface layer. Deploy a Postgres MCP server, a Slack MCP server, and a Brave Search MCP server. The agent connects to all three via its MCP client and discovers available tools dynamically via tools/list at startup. This approach avoids hardcoding tool schemas into the agent and makes the system extensible: adding a new capability means deploying a new MCP server, not modifying the agent code.

Q4. What are the three MCP primitives and which is most commonly used in practice?

Tools (callable functions), Resources (data pointers), and Prompts (prompt templates). Tools are by far the most commonly used in practice. Most real-world MCP servers are tools-only. Resources and Prompts have low adoption as of 2026 because most MCP hosts have not built strong UX around them.

Q5. What are the security risks of using MCP in a production AI system?

Key security risks of using MCP in a production AI system are:

• Tool permission scope: MCP servers should expose the minimum required capabilities, not broad access to all functions of an underlying service.
• Input validation: MCP servers must validate all inputs from the AI model since the model can be prompted to call tools with malicious or unexpected inputs.
• Credential management: MCP servers often need API keys or database credentials which must be stored in environment variables or secrets managers, never hardcoded.

Q6. When would you NOT use MCP? When is direct function calling a better choice?

Direct function calling is preferable when:

• You are building a single-model integration with no portability requirement.
• Startup latency matters, and you want to avoid the MCP server process overhead; and
• Your tool set is small, stable, and unlikely to be reused across models or teams. MCP overhead is worth paying when portability, ecosystem reuse, or dynamic tool discovery are priorities.

Conclusion

MCP is the standard interface that makes AI agents extensible without custom integration code for every model-tool pair. As agentic AI systems become a standard part of software architecture, understanding MCP is moving from optional knowledge to a practical engineering expectation. This shift is closely tied to areas like Agentic AI for Software Engineers, where building and orchestrating intelligent systems is becoming a core skill. Candidates who can discuss MCP’s architecture, its trade-offs against direct function calling, and its role in production systems are signalling exactly the kind of current awareness that agentic system design interviews reward.

FAQs: Model Context Protocol

Q1. Who created the Model Context Protocol?

Anthropic created and released MCP as an open standard in November 2024.

Q2. What problem does MCP solve?

It eliminates the need for custom integration code every time an AI model connects to a new external tool.

Q3. Is MCP the same as function calling?

No, MCP is a portability layer that sits above function calling and works across multiple AI models.

Q4. Do I need to implement all three MCP primitives to build an MCP server?

No, most production MCP servers only implement Tools, which is the only primitive with widespread real-world adoption.

Q5. Is MCP relevant to system design interviews?

Yes, as agentic AI becomes a standard topic in architecture, MCP knowledge is increasingly expected in senior engineering interviews.

Recommended Reads:

• What is MCP in Agentic AI?
• Understanding Why We Use RAG and its Practical Use Cases
• Agentic AI Security Is Now Every Tech Professional’s Problem