Home / Articles

Quick Dive — What Is MCP?

What MCP is in a few minutes: the USB-C style port for AI tools, why it was needed beyond a plain REST API, and what an MCP server exposes to ChatGPT or Claude.

Publisher: REACTAPP.TOP11 min read2438 words

This article is published in English.

Sources: ⚡ Quick Dive — What Is MCP?

This walkthrough rebuilds the path from raw materials to a working system for: Quick Dive — What Is MCP?. The focus is operable steps, explicit checks, and code that you can drop into a repo without guessing intent.

MCP is basically a USB-C port for AI

For the MCP is basically a stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Prefer small, testable units over sprawling scripts. When a step fails, the failure should point at a single responsibility rather than a tangled pipeline. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary.

ChatGPT → custom GitHub integration
Claude  → another GitHub integration
Cursor  → another GitHub integration
              MCP
               ↓
        ┌──────┼──────┐
        ↓      ↓      ↓
      GitHub  DB     Slack
ChatGPT ─┐
Claude  ─┼──→ MCP Server ─→ Your System
Cursor  ─┤
VS Code ─┘

Why Was MCP Needed?

For the Why Was MCP Needed stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary.

Read Jira tickets
Read GitHub
Query database
Search documentation
Create tasks
Send messages
ChatGPT integration
      ↓
GitHub-specific code
Claude integration
      ↓
GitHub-specific codeCursor integration
      ↓
GitHub-specific code
           GitHub MCP Server
                    ↑
          ┌─────────┼─────────┐
          ↓         ↓         ↓
       ChatGPT    Claude    Cursor

But What Exactly Is an MCP Server?

For the But What Exactly Is stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary.

GET /orders
POST /orders
GET /customers
MCP Server
   │
   ├── getCustomer()
   ├── searchOrders()
   ├── createTicket()
   └── getProjectDocumentation()

The Three Words You Should Remember

For the The Three Words You stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Keep configuration outside application code. Environment files, secret stores, and feature flags belong in one place operators can audit without reading the whole graph. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary.

Tools
Resources
Prompts

Tools

For the Tools stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary. For the Tools stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion.

createIssue()
sendEmail()
searchOrders()
deployApplication()

Resources

When working through the Resources stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments. Log tool name, args hash, latency, and outcome for every call. Debugging agent loops without that trail wastes hours.

Documentation
Files
Database records
Logs
Schemas

Prompts

When working through the Prompts stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Keep configuration outside application code. Environment files, secret stores, and feature flags belong in one place operators can audit without reading the whole graph. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn.

A Small Example

When working through the A Small Example stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish. Log tool name, args hash, latency, and outcome for every call. Debugging agent loops without that trail wastes hours. When working through the A Small Example stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion.

school-mcp

The school-mcp stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments. Expose tools with narrow schemas and explicit side-effect labels. Hosts need to know which calls mutate state before they auto-approve.

getStudentAttendance(studentId)getAssignments(classId)createAssignment(...)getFeeStatus(studentId)
getAssignments()
getStudentSubmissions()
             AI Model
                ↓
            MCP Client
                ↓
             MCP Server
                ↓
        Your Application/API
                ↓
             Database

Let’s Build a Tiny MCP Server

The Let s Build a stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Keep configuration outside application code. Environment files, secret stores, and feature flags belong in one place operators can audit without reading the whole graph. Expose tools with narrow schemas and explicit side-effect labels. Hosts need to know which calls mutate state before they auto-approve.

my-mcp/
│
├── package.json
├── tsconfig.json
└── src/
    └── index.ts
import { McpServer } from "@modelcontextprotocol/server";

const server = new McpServer({
  name: "school-mcp",
  version: "1.0.0"
});
server.registerTool(
  "get_student",
  {
    description: "Get student information"
  },
  async ({ studentId }) => {
    const student = await getStudent(studentId);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(student)
        }
      ]
    };
  }
);
REST API
GraphQL
Database
Filesystem
Internal services

This Is the Part That Usually Makes MCP Click

The This Is the Part stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish. Expose tools with narrow schemas and explicit side-effect labels. Hosts need to know which calls mutate state before they auto-approve. The This Is the Part stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion.

GET /api/students/:id
AI
 ↓
MCP Tool
 ↓
Existing REST API
 ↓
Backend
 ↓
Database
server.registerTool("get_student", ..., async ({ studentId }) => {
const response = await fetch(
    `${API_URL}/students/${studentId}`
  );
  return await response.json();
});

How Does ChatGPT Use It?

For the How Does ChatGPT Use stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary.

ChatGPT
   ↓
MCP App / Connector
   ↓
Remote MCP Server
   ↓
Your API
ChatGPT
    ↓
Custom MCP App
    ↓
https://mcp.yourcompany.com
    ↓
Company Services

How Does Claude Use MCP?

For the How Does Claude Use stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Keep configuration outside application code. Environment files, secret stores, and feature flags belong in one place operators can audit without reading the whole graph. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary.

Claude / Claude Code
        ↓
    MCP Client
        ↓
    MCP Server
        ↓
Your Tools / Data
Claude
  ↓
school-mcp
  ↓
getAssignments()
getAttendance()

Cursor Works the Same Way

For the Cursor Works the Same stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish. Authenticate at the gateway and re-authorize at the data plane. A bearer token alone is not a tenancy boundary. For the Cursor Works the Same stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion.

company-dev-mcp
   │
   ├── search_docs
   ├── get_api_schema
   ├── inspect_logs
   └── create_jira_ticket
Search internal docs
      ↓
Inspect API schema
      ↓
Check logs
      ↓
Explain issue

The Mental Model

When working through the The Mental Model stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn.

                   USER
                     ↓
               "Find my orders"
                     ↓
        ┌─────────────────────────┐
        │       AI CLIENT         │
        │ ChatGPT / Claude/Cursor │
        └────────────┬────────────┘
                     ↓
                 MCP Protocol
                     ↓
        ┌─────────────────────────┐
        │       MCP SERVER        │
        │                         │
        │  Tools                  │
        │  Resources              │
        │  Auth / Permissions     │
        └────────────┬────────────┘
                     ↓
          Existing Application
                     ↓
          REST / GraphQL / DB
                     ↓
                    DATA

Why Is MCP Powerful?

When working through the Why Is MCP Powerful stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Keep configuration outside application code. Environment files, secret stores, and feature flags belong in one place operators can audit without reading the whole graph. Log tool name, args hash, latency, and outcome for every call. Debugging agent loops without that trail wastes hours.

Tool A integration for ChatGPT
Tool A integration for Claude
Tool A integration for Cursor
Tool A integration for VS Code
            MCP Server
                 ↑
       ┌─────────┼──────────┐
       ↓         ↓          ↓
    ChatGPT    Claude     Cursor

Another Benefit: AI Doesn’t Need Everything in the Prompt

When working through the Another Benefit AI Doesn stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn. When working through the Another Benefit AI Doesn stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion.

Take:
20 documentation files
+
database schema
+
API specification
+
logs

Put everything into context
Question
   ↓
AI decides what information is needed
   ↓
Calls relevant tool/resource
   ↓
Receives small relevant result
"Why did payment 784 fail?"
             ↓
       getPayment(784)
             ↓
        inspectLogs()
             ↓
          Answer

But MCP Is Not Magic

deleteUser()
sendPayment()
deployProduction()
Authentication
Authorization
Input validation
Audit logs
Rate limits
User permissions
Confirmation for dangerous operations

MCP vs REST API

REST
 VS
MCP
              HUMAN APP
                   ↓
               REST API
                   ↓
                Backend
                 AI
                  ↓
                 MCP
                  ↓
               REST API
                  ↓
               Backend

MCP vs Function Calling

Application
    ↓
Tell model these specific functions
    ↓
Model calls function
Function calling
     =
"Model can use a function."
MCP
     =
"Standard way AI clients and external
 systems expose/discover/use capabilities."

One MCP Server, Many AI Clients

                         ┌───────────┐
                         │ ChatGPT   │
                         └─────┬─────┘
                               │
                         ┌─────▼─────┐
                         │ Claude    │
                         └─────┬─────┘
                               │
                         ┌─────▼─────┐
                         │ Cursor    │
                         └─────┬─────┘
                               │
                       MCP Protocol
                               │
                     ┌─────────▼─────────┐
                     │ COMPANY MCP       │
                     │                   │
                     │ searchDocs        │
                     │ getCustomer       │
                     │ createTicket      │
                     │ inspectLogs       │
                     └─────────┬─────────┘
                               │
                ┌──────────────┼──────────────┐
                ↓              ↓              ↓
              GitHub          Jira          Database

the Biggest Learning

AI → API
AI Application
      ↓
MCP Client
      ↓
Standard Protocol
      ↓
MCP Server
      ↓
Controlled Tools + Data
      ↓
Existing Systems

The One-Line Explanation

Operational checklist