What is MCP (Model Context Protocol), and how does it connect AI to tools like Gmail, Drive, or Jira?

Question

Accepted Answer

**MCP (Model Context Protocol)** is an open standard, introduced by Anthropic, that lets AI apps connect to external tools and data through one uniform interface — instead of writing a bespoke integration for every app. Think of it as a universal adapter between a model and the outside world.

## Client and server

```text
MCP SERVER → exposes capabilities to the model:
  - TOOLS     → actions the model can call (send_email, create_issue, search_files)
  - RESOURCES → data the model can read (a file, a Drive doc, a DB row)
  - PROMPTS   → reusable prompt templates the server offers
MCP CLIENT → the AI app (Claude Desktop, Claude Code, an IDE) that connects to servers
TRANSPORT  → stdio (local process) or HTTP (remote), speaking JSON-RPC both ways
```

The key win: each tool provider writes **one** MCP server, and **any** MCP-compatible client can use it. You add a Gmail server, a Drive server, a Jira server — and the model can call all of their tools without you wiring up a custom integration per app.

## A tiny config and flow

```jsonc
// The client config registers servers; the model then sees their tools
{
  "mcpServers": {
    "gmail": { "command": "npx", "args": ["@org/mcp-gmail"] },   // local, stdio
    "jira":  { "url": "https://mcp.acme.com/jira" }              // remote, HTTP
  }
}
```

```text
FLOW:
1. Client starts/connects to each server, asks "what tools do you have?"
2. Server replies with tool schemas (name, description, params) via JSON-RPC
3. User: "file a Jira bug for the login crash" → model picks the jira create_issue tool
4. Client calls the tool on the server → server hits the Jira API → returns the result
5. Model uses the result in its answer
```

Because discovery and calls are standardized over JSON-RPC, the model learns each server's tools at connect time — no per-tool code in the app itself.

## Why it matters

Before MCP, every AI-to-tool integration was a one-off: custom code, custom auth, custom maintenance, repeated for each app and each AI product. MCP replaces that N×M explosion with one protocol — a tool author ships a single server, and every compatible client gains the integration for free. That standardization is what makes it practical to give an assistant real reach into Gmail, Drive, Jira, and your own internal systems without rebuilding the plumbing every time.