What Is MCP? A Developer's Guide to Model Context Protocol (2026)

If you've used Claude Desktop, Cursor, or VS Code with AI extensions, you've probably seen "MCP server" in settings or docs. MCP (Model Context Protocol) is the open standard that lets AI applications talk to your data and tools in a consistent way — without every app building its own custom integration.

In this guide you'll learn what MCP is, how the architecture works, where it's used today, and how to try your first server in under 10 minutes. No prior MCP experience required.

What you'll learn

What MCP is and why it exists
Core concepts: hosts, clients, servers, tools, resources, and prompts
How a tool call flows from an AI app to your API
Where MCP fits in the 2026 AI tooling landscape (including the July 2026 spec update)
How to connect your first MCP server locally

Prerequisites

Basic familiarity with APIs and JSON
Node.js 18+ (for the quick-start example)
Optional: Claude Desktop or Cursor to test a server locally

The problem MCP solves

Before MCP, every AI product wired up external tools differently:

ChatGPT had plugins (now mostly replaced by other patterns)
Cursor had its own tool and rules system
Claude had computer use and custom connectors
Your internal API needed a separate integration for each client

That meant building the same "search GitHub issues" or "query Postgres" connector multiple times — once per AI app.

MCP standardizes this. You build one MCP server that exposes your tools and data. Any MCP-compatible client (Claude, Cursor, VS Code, and others) can connect to it using the same protocol.

Think of MCP like USB-C for AI integrations: one port, many devices.

MCP in one sentence

MCP is an open protocol that lets AI applications discover and call tools, read resources, and use prompts exposed by external servers.

The official spec and docs live at modelcontextprotocol.io.

Architecture: who is who?

MCP uses a host → client → server model:

text

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  MCP Host   │────▶│ MCP Client  │────▶│ MCP Server  │
│ (Cursor)    │     │ (in Cursor) │     │ (your code) │
└─────────────┘     └─────────────┘     └─────────────┘
                                              │
                                              ▼
                                        Your API / DB / files

You typically build servers. Hosts already include clients.

Three things a server can expose

1. Tools (actions)

Tools are functions the AI can call — with defined inputs and outputs.

Examples:

get_stock_price(symbol) → returns latest price
create_github_issue(title, body) → creates an issue
run_sql_query(query) → returns rows

This is the most common MCP feature for developers.

2. Resources (read-only context)

Resources are data the AI can read — files, database rows, API responses, config.

Examples:

file:///project/README.md
postgres://users/schema
A JSON snapshot of your dashboard metrics

Resources help the model ground answers in real data without guessing.

3. Prompts (templates)

Prompts are reusable prompt templates the server publishes — useful for standardized workflows like "code review this diff" or "summarize this CSV."

Less common in early tutorials, but useful for team workflows.

How a tool call works (simplified)

Here's what happens when you ask Claude to "check my open GitHub issues" through an MCP server:

text

User: "What issues are open in my-app?"
  → Model picks tool: list_issues
  → Server calls GitHub API
  → Server returns [{ id: 42, title: "Fix login bug" }, ...]
  → Model: "You have 3 open issues. The oldest is..."

All of this uses JSON-RPC 2.0 messages over a transport — commonly stdio (local) or HTTP (remote).

Local vs remote MCP servers

Local (stdio) is the fastest way to learn. Your host starts the server with a command like npx my-mcp-server and talks over stdin/stdout.

Remote (HTTP) is how you ship servers to production — but requires auth, HTTPS, and (as of 2026) stricter OAuth patterns for public deployments.

What's new in MCP for 2026?

The protocol is moving fast. The 2026-07-28 specification (release candidate as of mid-2026) introduces major changes:

Stateless core — the initialize handshake and session IDs are being removed in favor of self-contained requests
server/discover — clients fetch server capabilities on demand instead of at connect time
Stronger OAuth — better alignment with OAuth 2.0 / OpenID Connect for remote servers
Extensions — MCP Apps (server-rendered UI) and Tasks (long-running work)

What this means for you today:

If you're learning MCP, start with the current TypeScript/Python SDK patterns — the concepts (tools, resources, transports) stay the same.
If you're shipping a remote server to production, plan for the July 2026 migration: remove session stickiness, update auth, and follow the migration guide.

For a deep build walkthrough, see TrinityTuts' Zerodha MCP tutorial — a real-world example of tools + API integration.

Quick start: run a sample MCP server

Let's connect a published server so you can see MCP in action before writing your own.

Option A — Claude Desktop

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/YOUR_USERNAME/Documents"
      ]
    }
  }
}

If configured correctly, Claude will call the filesystem server's tools and return real filenames.

Option B — Cursor

Security note: Only grant filesystem (or any server) access to directories you're comfortable exposing to the model. Start with a sandbox folder, not your entire home directory.

MCP vs "just use the API"

Use MCP when: you want Claude, Cursor, and other clients to share the same tool layer — especially for internal APIs, dev tools, and workflows you use daily.

Skip MCP when: you're building a single app with a single model provider and don't need cross-client reuse.

Popular MCP servers to try

Browse more at the MCP servers repository.

What to build next

Once you understand the concepts, the best learning path is:

If you're in India and connecting to local services (Zerodha, Razorpay, Sarvam AI), MCP is especially valuable — you can expose APIs that global tutorials never cover.

Real-world MCP: why developers are adopting it now

MCP adoption accelerated in 2025–2026 because it solves a problem every AI power-user hits: your IDE assistant is smart, but blind to your systems.

Before MCP, you copied API responses into chat, exported CSVs manually, or built one-off scripts per AI tool. MCP replaces that friction with a standard tool layer.

Who benefits most:

At TrinityTuts, we first explored MCP by building a Zerodha Kite integration — portfolio queries and order flows through Claude. That project proved MCP isn't theoretical: you can ship a useful server in an afternoon if you know the target API.

What to expect in your first week: confusion about transports (stdio vs HTTP), then a clear win once one server works. Most developers report their first "aha" moment within 30 minutes of connecting filesystem or GitHub MCP.

Troubleshooting

Server doesn't appear in Claude Desktop

Restart the app after editing claude_desktop_config.json
Validate JSON syntax (trailing commas break config)
Check Claude logs: macOS ~/Library/Logs/Claude/

npx command fails

Ensure Node.js 18+ is installed: node -v
Try running the server command directly in a terminal first

Tools run but return empty data

Confirm API tokens / env vars are set in the server config
Check the server only has access to paths or repos you specified

Cursor doesn't use MCP tools

Use Agent mode (not basic chat) for tool execution
Verify the server shows as connected in MCP settings

FAQ

Is MCP only for Claude?

No. MCP is an open standard. Cursor, VS Code, and other clients support or are adding MCP. The ecosystem is growing beyond a single vendor.

Do I need to pay to use MCP?

The protocol is open. Costs come from the AI host (Claude Pro, Cursor subscription, API usage) and whatever APIs your server calls.

Is MCP the same as ChatGPT plugins?

Similar idea (extend the AI with tools), different standard. MCP is vendor-neutral and actively adopted by dev tools in 2025–2026.

Can I expose any API as MCP?

Yes — if you can wrap it in a server that defines tools with clear schemas. That's how integrations like Zerodha + Claude work.

Is it safe to run MCP servers locally?

Local stdio servers run with your user's permissions. Only install servers you trust, scope filesystem access tightly, and never hardcode secrets in config files — use environment variables.

Should I wait for the July 2026 spec before building?

No. Build now with current SDKs. Follow the migration guide when you deploy remote servers to production; local stdio servers are largely unaffected.

How to Build an MCP Server for Zerodha – AI-Powered Trading with Claude — real-world MCP + finance API
Boost Developer Speed with Google Cloud CLI & Claude AI — AI-assisted dev workflows
Coming soon: Build Your First MCP Server in TypeScript (TrinityTuts Week 2)

Summary

MCP standardizes how AI apps connect to tools, data, and prompts.
You build servers; hosts like Claude and Cursor include clients.
Start with local stdio servers; graduate to HTTP for production.
The 2026 spec makes remote MCP more scalable and OAuth-aligned — plan ahead if you ship publicly.
Your next step: run a sample server, then build a small custom one.

Last updated: July 2026 · Author: Aneh Thakur