Skip to main content
Agentic AI Hub
Get the app

MCP & the Tool/Context Ecosystem

Table of Contents
Link copied!

Models are only half the story. The other half is the plumbing that gives models hands: how an assistant reaches your files, databases, SaaS tools, and the web. That layer is becoming standardized fast.

What MCP is

The Model Context Protocol (MCP) is an open standard, introduced by Anthropic in late 2024 and since adopted across the industry, for connecting AI applications to external tools and data. The tagline that stuck: "a USB-C port for AI." Instead of every app hand-coding a bespoke integration for every tool, an app speaks MCP once and can talk to any MCP server. → modelcontextprotocol.io

The architecture is a simple client/server split:

  • MCP host / client is the AI app (Claude Code, ChatGPT, Cursor, an IDE, your own agent) that wants capabilities.
  • MCP server is a small program exposing three kinds of things to the client:
    • Tools are actions the model can call (query a DB, send a Slack message, open a PR).
    • Resources are data the model can read (files, records, docs).
    • Prompts are reusable templated instructions/workflows the server offers.
  • Transport is local (stdio) or remote (HTTP/SSE, with an auth story via OAuth for hosted servers).

Why it matters

  • Write once, connect everywhere, vendor-neutrally. Before MCP it was an N×M problem: every AI app times every tool. Now you build one server for your tool and every MCP-speaking client can use it, whether that's Claude, a Cursor agent, or your own app on the OpenAI Agents SDK.
  • Auth is part of the standard, but authorization is on you. Remote MCP servers authenticate via OAuth. Exposing a tool still means deciding what the agent may do with it, so scope credentials tightly and treat tool access as a security boundary (see Safety, Alignment & Governance and Browser & Computer-Use Agents).
  • Broad adoption. What started at Anthropic is now supported across major agent runtimes and IDEs, with OpenAI, Google, and Microsoft tooling interoperating with it. That cross-vendor buy-in is what turned MCP from a nice idea into the default integration layer.

The ecosystem around it

  • Server registries & directories. Official and community registries catalog thousands of MCP servers (databases, SaaS apps, dev tools, browsers, search). Reference servers exist for the common cases (filesystem, git, fetch, Postgres, etc.).
  • First-party servers. Many vendors now ship their own MCP server (GitHub, Linear, Stripe, Sentry, Notion, Cloudflare, and more), so you get maintained, authenticated access rather than a scraped hack.
  • Hosted/remote servers + connectors. The "connectors" you toggle inside Claude, ChatGPT, and others are frequently MCP servers under the hood, with OAuth so a user grants scoped access to their accounts.
  • Skills & plugins. Layered on top: packaged instructions/workflows (e.g., Claude Skills, plugins) that use MCP tools but add domain know-how and multi-step procedure. MCP gives the hands. Skills give the playbook.

How this composes with function calling

Under the hood, MCP tools surface to the model through the same function-/tool-calling mechanism every frontier API already exposes: the model emits a structured call, the host executes it (here, by routing to an MCP server), and the result returns to the model. So MCP doesn't replace function calling. It standardizes where the functions come from and how they're described, so the same tool works across providers instead of being re-declared per app. Provider tool-calling formats still differ slightly (OpenAI, Anthropic, Google each have their own JSON shape), but MCP sits above that, and adapters/SDKs bridge the gaps.

Practical guidance for builders

  • Consuming tools? Prefer an existing, maintained MCP server over hand-rolling an API client, so you inherit auth, schemas, and updates.
  • Exposing your product to AI? Ship an MCP server. It's becoming the expected way to be "AI-accessible," the way a public API became table stakes a decade ago.
  • Security is on you. MCP servers can read data and take actions, so the same cautions as agents apply: scope credentials, review tool permissions, be wary of prompt injection via tool outputs (a malicious record can carry instructions), and don't auto-approve destructive tools. Only install servers you trust.
  • Keep tool surfaces lean. Exposing 200 tools to a model degrades tool selection. Curate the set per task (many hosts let you enable/disable servers or tools per session).

Bottom line: MCP is the connective tissue of the agent era, the standard that lets any model, in any app, use any tool. Build agents and you'll produce and consume MCP servers constantly.

Link copied!