Model Context Protocol (MCP) is an open standard that defines how AI agents connect to tools, databases, and APIs. It standardises the interface between a large language model and external systems, making it possible to build AI agents that read your database, call your APIs, and take actions inside your infrastructure — without writing custom integration code for every combination.

What problem does MCP solve?

Before MCP, connecting an LLM to your internal tools was a bespoke engineering problem. Every AI tool had its own way of defining functions, passing context, and handling errors. You wrote custom glue code for every integration. A Slack bot, a code analyser, and a database agent each had completely different internal architectures — nothing was reusable.

Anthropic released MCP as an open standard in late 2024, and it has been adopted rapidly by Claude, GitHub Copilot, Cursor, Zed, and many other AI tools. The protocol defines a common language for three things:

  1. Resources — data the AI can read (files, database records, API responses)
  2. Tools — actions the AI can take (write a file, create a ticket, run a query)
  3. Prompts — pre-built instructions the AI can be given by the host application

This separation matters. Resources are read-only. Tools have side effects. Keeping them distinct is how you reason about what an agent can and cannot do.

How does MCP work, technically?

MCP is a client-server protocol running over JSON-RPC. An MCP server exposes your tools and resources. An MCP client (typically the AI application or agent framework) connects to one or more servers and asks them what they can do.

When an AI agent needs to take an action, it sends a structured request to the appropriate MCP server. The server executes the action and returns a structured response. The agent reasons about the response and decides its next step.

The transport is flexible: local servers communicate over stdio (the process’s standard input/output), while remote servers use HTTP with Server-Sent Events. This means you can run an MCP server locally for development and deploy the same server remotely for production agents with no protocol changes.

A minimal MCP server has three responsibilities:

  • Declare what tools and resources it exposes (the schema)
  • Handle incoming tool call requests
  • Return results in the defined response format

Official SDKs exist for TypeScript, Python, and Kotlin. The surface area is small — a basic server is 50–100 lines of code.

Which tools support MCP today?

As of mid-2025, MCP is supported natively in:

  • Claude Desktop and the Claude API (Anthropic)
  • GitHub Copilot Workspace
  • Cursor and Zed (code editors)
  • LangChain, LlamaIndex, and AutoGen (agent frameworks)
  • A growing ecosystem of community MCP servers for Postgres, Slack, Notion, GitHub, Jira, and dozens of other tools

The community ecosystem is the key value. Instead of building a “connect our AI to Postgres” integration from scratch, you install an existing MCP server for Postgres in minutes. Your agent immediately gains the ability to query your database through a standardised, auditable interface.

How should engineering leaders evaluate MCP for their team?

Three questions to answer before adopting MCP:

Is your team already building AI integrations? If yes, MCP is likely cheaper than maintaining bespoke integration code. Standardised servers are easier to test, secure, and hand off between team members.

Do you need to compose tools from multiple sources? MCP’s real power is that a single agent can connect to multiple servers simultaneously. A code-review agent can call your GitHub server, your Jira server, and your internal deployment API in the same session.

Are you concerned about security and auditability? MCP’s explicit tool schema means you can review exactly what capabilities an agent has before it runs. Every tool call is a discrete, loggable event. This is a meaningful improvement over agents that execute arbitrary code.

The practical recommendation for most engineering teams: start by deploying one community MCP server (Postgres or GitHub are good choices) and integrating it into a low-stakes internal agent. Understand the observability story before expanding.

MCP is not magic — it is an interface contract. Its value grows as more of your infrastructure exposes MCP servers. Start narrow, instrument everything, and build from there.

Karthikeyan VK speaks on Agentic AI and Model Context Protocol at conferences and CTO events across India. Get in touch to book a session.