MCP — Kết nối Claude Code với thế giới bên ngoài

MCP là gì?

Model Context Protocol (MCP) là open standard cho phép Claude Code kết nối với external tools và data sources. "Open standard" nghĩa là Anthropic không độc quyền — bất kỳ service nào cũng có thể build MCP server, và Claude Code (cũng như các AI agent khác) có thể connect tới.

Khái niệm cốt lõi: Tools

Trước khi hiểu MCP, cần hiểu khái niệm tools trong agentic AI.

Tools cho phép agent như Claude Code thực hiện hành động — không chỉ trả về text. Khi Claude Code chạy grep, đọc file, gọi bash, hay tìm kiếm web — đó là tools. MCP mở rộng khả năng này ra ngoài máy tính của bạn: Claude có thể gọi Linear API, query Postgres, post Slack message — tất cả thông qua tool call.

Đây là điểm khác biệt căn bản với AI "bình thường": thay vì chỉ generate text, Claude Code có thể làm việc trong hệ thống thực của bạn.

ASCII diagram: Kiến trúc MCP

Claude Code nói chuyện với MCP server qua MCP Protocol (một JSON-RPC protocol chuẩn). MCP server sau đó nói chuyện với service thực (Linear API, database, v.v.). Bạn không cần biết chi tiết protocol — chỉ cần biết: Claude gọi tool, MCP server thực thi, kết quả trả về cho Claude.

┌─────────────────────────────────────────────────────────────────┐
│                         BẠN (developer)                         │
│              "review PR theo requirements MEN-12"               │
└─────────────────────────┬───────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────────────┐
│                      CLAUDE CODE                                │
│                                                                 │
│   Reasoning engine ──► Tool selection ──► Tool call            │
│                              │                                  │
│                    "Cần fetch MEN-12                            │
│                     → gọi linear.get_issue(MEN-12)"            │
└──────────────────────────────┬──────────────────────────────────┘
                               │
                    MCP Protocol (JSON-RPC)
                               │
        ┌──────────────────────┼──────────────────────┐
        │                      │                      │
        ▼                      ▼                      ▼
┌──────────────┐    ┌─────────────────┐    ┌──────────────────┐
│ Linear MCP   │    │  Context7 MCP   │    │  Postgres MCP    │
│ (HTTP server)│    │  (HTTP server)  │    │  (stdio server)  │
│              │    │                 │    │                  │
│ • get_issue  │    │ • get_docs      │    │ • query          │
│ • comment    │    │ • search_pkg    │    │ • list_tables    │
│ • transition │    │ • list_versions │    │ • describe       │
└──────┬───────┘    └────────┬────────┘    └────────┬─────────┘
       │                     │                      │
       ▼                     ▼                      ▼
  Linear API           CDN / npm registry      Local Postgres
  (cloud)              (internet)              (localhost:5432)

2 loại MCP server

HTTP servers — Remote, hosted by service provider

HTTP servers chạy trên cloud của service provider (Linear, Slack, Notion...). Bạn connect tới chúng qua network. Thường yêu cầu auth (OAuth2 hoặc API key).

Ví dụ: Linear MCP, Slack MCP, Notion MCP, GitHub MCP, Context7 MCP.

Stdio servers — Local processes trên máy bạn

Stdio servers là các process chạy trực tiếp trên máy bạn. Claude Code spawn process đó, giao tiếp qua stdin/stdout. Không có network call, không cần expose port.

Ví dụ: MCP server cho local Postgres, MCP server cho nội bộ công ty (CRM, internal DB), MCP server bạn tự viết.

Bảng so sánh HTTP vs Stdio

Add MCP Server

Cú pháp cơ bản

Sau khi chạy lệnh, Claude Code wizard sẽ hướng dẫn auth:

# HTTP server
claude mcp add linear https://mcp.linear.app/sse

# Stdio server (command + args)
claude mcp add postgres -- npx @modelcontextprotocol/server-postgres postgresql://localhost/mydb

# Với scope cụ thể
claude mcp add --scope project linear https://mcp.linear.app/sse

Cú pháp cơ bản

Quản lý servers với /mcp

Trong session Claude Code, gõ /mcp để xem trạng thái:

Adding Linear MCP server...

Authentication required:
  → OAuth2 flow (recommended): Open browser to authenticate
  → API key: Enter your Linear API key manually

Select method [1/2]: 1

Opening browser for OAuth2...
✓ Authenticated as: Khoa Đỗ (khoa@company.com)
✓ Linear MCP server added (scope: local)

Tools available:
  • linear.get_issue       — Fetch issue details
  • linear.create_issue    — Create new issue
  • linear.update_issue    — Update status, assignee, labels
  • linear.comment         — Add comment to issue
  • linear.list_issues     — Query issues by filter
  (12 tools total, ~8k tokens in context)

Quản lý servers với /mcp

> /mcp

Connected MCP Servers:
  ✓ linear       12 tools  ~8k tokens   HTTP    [active]
  ✓ context7      3 tools  ~2k tokens   HTTP    [active]
  ✓ slack         6 tools  ~4k tokens   HTTP    [idle 2h]
  ✓ postgres      8 tools  ~5k tokens   stdio   [active]
  ✗ figma        15 tools  ~12k tokens  HTTP    [disabled]

Total MCP overhead: ~19k tokens (9.5% context)

Commands: /mcp disable <name> | /mcp enable <name> | /mcp reconnect <name>

3 Scope của MCP server

Scope quyết định MCP server được lưu ở đâu và ai có thể dùng.

Typical use case

.mcp.json example (project scope)

API key đặt trong env vars (.env gitignored) — không bao giờ hardcode vào .mcp.json.

• Local scope: MCP server cho database dev local (chỉ bạn dùng, chỉ project này). Test API key cá nhân.
• User scope: Linear MCP, Slack MCP bạn dùng across mọi project. Personal preference.
• Project scope: Team shared servers — Linear (cả team đều cần xem ticket), Context7 (docs cho stack chung), GitHub MCP. Commit .mcp.json vào repo, mọi người clone về là có ngay.

{
  "mcpServers": {
    "linear": {
      "type": "http",
      "url": "https://mcp.linear.app/sse",
      "env": {
        "LINEAR_API_KEY": "${LINEAR_API_KEY}"
      }
    },
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/sse"
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
    }
  }
}

CRITICAL: Context Cost của MCP

Đây là phần quan trọng nhất bài này. Hiểu sai điểm này dẫn đến lãng phí context window rất lớn.

MCP servers add tool definitions — kể cả khi bạn không dùng

Khi Claude Code start, nó load toàn bộ tool definitions của tất cả MCP server đang enabled. Tool definition là JSON schema mô tả mỗi tool có tham số gì, làm gì. Mỗi definition này tốn token.

5 server không dùng → 30k token lãng phí — tương đương 15% context window mất trước khi bạn gõ prompt đầu tiên.

Tính toán thực tế

Nếu bạn chỉ làm backend dev hôm nay: Linear + Context7 là đủ (~10k). Figma và Jira là 19k wasted. Hơn 57% MCP overhead là không cần thiết.

Audit và clean up với /mcp

Auto tool search mode (unstable)

Khi MCP tools vượt 10% context window, Claude Code tự động switch sang tool search mode — thay vì load toàn bộ definitions, nó search on-demand khi cần tool nào mới load tool đó.

Nghe hay, nhưng feature này chưa stable. Tool search đôi khi miss tool phù hợp, dẫn đến Claude không biết tool đó tồn tại. Không nên dựa vào auto tool search. Chủ động /mcp disable vẫn là cách tốt hơn.

Context window khi có MCP servers:

┌────────────────────────────────────────────────────────────┐
│  CONTEXT WINDOW (200k tokens)                              │
├────────────────────────────────────────────────────────────┤
│  System prompt                                   ~5k       │
│  CLAUDE.md                                      ~3-8k      │
├────────────────────────────────────────────────────────────┤
│  MCP tool definitions (luôn ở đây, dù không dùng):        │
│    linear (12 tools)                            ~8k        │
│    slack (6 tools)                              ~4k        │
│    context7 (3 tools)                           ~2k        │
│    figma (15 tools)  ← bạn không design hôm nay ~12k      │
│    jira (10 tools)   ← team không dùng nữa      ~7k       │
│    ─────────────────────────────────────────              │
│    MCP overhead tổng:                           ~33k (16%) │
├────────────────────────────────────────────────────────────┤
│  Conversation + tool calls + file reads          ...       │
│            ↓ bị squeeze bởi 33k overhead ↓                │
└────────────────────────────────────────────────────────────┘

> /mcp

⚠️  MCP overhead: 33k tokens (16.5% context)
    Recommend: disable unused servers

> /mcp disable figma
✓ figma disabled. Restart session for effect.

> /mcp disable jira
✓ jira disabled. Restart session for effect.

> /mcp
MCP overhead: 14k tokens (7% context)  ← giảm được 19k tokens

CRITICAL: MCP vs CLI vs Skill — Decision tree

Đây là quyết định quan trọng. Không phải mọi integration đều nên là MCP server.

Decision tree

Bảng so sánh CLI vs MCP vs Skill

Anthropic internal example: cu tool

Anthropic sử dụng một internal CLI tool tên cu cho các workflows nội bộ. Thay vì tạo MCP server riêng cho cu, Anthropic chỉ cần ghi vào CLAUDE.md:

Claude tự biết khi nào cần gọi cu, không cần MCP server, không tốn token cho tool definitions. Đây là triết lý CLI > MCP khi CLI đã đủ tốt.

Bạn cần Claude tương tác với external service/tool?
│
├─► Service có CLI tool tốt, documented?
│     (gh, aws, gcloud, kubectl, heroku...)
│     │
│     └─► DÙNG CLI — ưu tiên hàng đầu
│           Lý do: không tốn context, docs tốt,
│           bạn đã biết dùng, Claude hiểu rõ
│
├─► Service không có CLI nhưng có official MCP server?
│     (Linear, Figma, Notion, Datadog...)
│     │
│     ├─► Bạn dùng service này thường xuyên?
│     │     └─► Có → ADD MCP (project hoặc user scope)
│     │     └─► Không → Dùng Skill hoặc manual API call
│     │
│     └─► Đây là one-off task?
│           └─► Dùng Skill hoặc viết script nhỏ
│
└─► Service không có CLI cũng không có MCP?
      │
      ├─► Có pattern lặp lại nhiều lần?
      │     └─► Viết Skill với API call template
      │
      └─► One-off → Prompt Claude viết curl / script tạm

## Internal Tools

We use `cu` for internal task management. Key commands:
- `cu task list` — list your open tasks
- `cu task create "title" --project X` — create task
- `cu deploy --env staging` — deploy to staging

Ví dụ thực chiến: Setup Linear + Context7 + Slack cho dev team

Bối cảnh

Team 5 người, stack: Next.js + Postgres + Linear + Slack. Bạn muốn Claude Code có thể:

Bước 1: Add Linear MCP (HTTP, OAuth)

Wizard mở browser → Authenticate với Linear account → Done.

Claude giờ có thể:

Bước 2: Add Context7 MCP (HTTP)

• Fetch ticket details từ Linear
• Tra cứu docs thư viện up-to-date
• Post notification khi PR merge
• Fetch ticket chi tiết, acceptance criteria, comments
• Transition status (In Progress → In Review)
• Comment trực tiếp lên ticket

claude mcp add --scope project linear https://mcp.linear.app/sse

Bước 2: Add Context7 MCP (HTTP)

Không cần auth (public service). Claude giờ có thể fetch docs Next.js, React, Postgres, bất kỳ npm package nào — luôn up-to-date, không hallucinate API cũ.

Bước 3: Add Slack MCP (HTTP)

claude mcp add --scope project context7 https://mcp.context7.com/sse

Bước 3: Add Slack MCP (HTTP)

Scope user (không phải project) vì Slack token là cá nhân. Wizard → OAuth → Done.

Bước 4: Save vào .mcp.json project, commit

Linear và Context7 đã ở scope project nên tự động vào .mcp.json. Kiểm tra:

claude mcp add --scope user slack https://mcp.slack.com/sse

Bước 4: Save vào .mcp.json project, commit

cat .mcp.json

Ví dụ thực chiến: Setup Linear + Context7 + Slack cho dev team (tiếp)

Commit file này:

{
  "mcpServers": {
    "linear": {
      "type": "http",
      "url": "https://mcp.linear.app/sse",
      "env": { "LINEAR_API_KEY": "${LINEAR_API_KEY}" }
    },
    "context7": {
      "type": "http",
      "url": "https://mcp.context7.com/sse"
    }
  }
}

Ví dụ thực chiến: Setup Linear + Context7 + Slack cho dev team (tiếp)

Slack không vào .mcp.json vì scope user — mỗi người tự auth bằng account của mình.

Bước 5: Team clone repo → auto get MCP servers

Teammate mới clone repo:

git add .mcp.json
git commit -m "chore: add Linear + Context7 MCP servers for team"

Bước 5: Team clone repo → auto get MCP servers

Claude Code tự đọc .mcp.json, prompt:

git clone https://github.com/company/project
cd project
claude

Ví dụ thực chiến: Setup Linear + Context7 + Slack cho dev team (tiếp)

Teammate authenticate Linear một lần → xong. Không cần hướng dẫn manual setup.

Bước 6: /mcp audit context cost — disable khi không cần

Cuối sprint, bạn đang focus code, không cần Slack notifications:

Found .mcp.json with 2 servers:
  • linear — requires auth (click to authenticate)
  • context7 — no auth required

Set up now? [Y/n]: Y

Bước 6: /mcp audit context cost — disable khi không cần

> /mcp

Connected:
  ✓ linear   12 tools  ~8k tokens   [active]
  ✓ context7  3 tools  ~2k tokens   [active]
  ✓ slack     6 tools  ~4k tokens   [user scope, idle]

Total overhead: ~14k tokens (7% context)

> /mcp disable slack
✓ slack disabled for this session.
  Context freed: ~4k tokens

Case studies theo role

Backend Engineer: Postgres MCP + Plan Mode

Tình huống: Cần optimize query đang slow, nhưng không nhớ chính xác schema các bảng.

Claude switch Plan Mode, dùng postgres.describe_table() để xem schema thực, postgres.list_indexes() để xem indexes hiện tại, sau đó đề xuất plan thêm index composite cụ thể. Không cần bạn copy-paste schema.

MCP dùng: Stdio Postgres server (local DB), scope local.

DevOps/SRE: Incident Response với Datadog + PagerDuty

Tình huống: Alert 2h sáng, service down.

> Trong Plan Mode: analyze query này trong src/reports/monthly.ts
  và đề xuất optimization. Dùng Postgres MCP để check actual indexes.

DevOps/SRE: Incident Response với Datadog + PagerDuty

Claude fetch metrics từ Datadog, check incident history từ PagerDuty, cross-reference. Trả về "p99 tăng đột biến lúc 01:43 UTC, trùng với deploy v2.3.1, khả năng connection pool exhaustion" — trong 2 phút, không cần mở 3 tab browser.

MCP dùng: Datadog MCP + PagerDuty MCP, scope user.

Frontend Engineer: Figma MCP fetch design specs

Tình huống: Implement component mới từ Figma design.

> Check Datadog MCP: service payments-api — error rate và p99 latency
  30 phút qua. Sau đó check PagerDuty MCP: incidents liên quan.
  Tóm tắt root cause hypothesis.

Frontend Engineer: Figma MCP fetch design specs

Claude dùng Figma MCP lấy design tokens trực tiếp — không cần bạn đo pixel hay copy hex code thủ công. Implementation khớp 100% với design.

MCP dùng: Figma MCP, scope user.

Product Manager: Sprint Summary

Tình huống: Viết sprint summary hàng tuần.

> Fetch Figma frame "Button variants" từ file Design System v3.
  Implement theo exact specs: colors, padding, border-radius, hover state.

Product Manager: Sprint Summary

Claude fetch từ cả hai nguồn, generate summary có đầy đủ: features shipped, bugs fixed, blocked items, metrics. PM chỉ cần review và publish.

MCP dùng: Linear MCP + Notion MCP, scope project.

Marketing: weekly metrics digest

Tình huống: Báo cáo metrics hàng tuần cho team.

> Dùng Linear MCP: fetch tất cả issues completed sprint MEN-Sprint-14.
  Dùng Notion MCP: lấy template sprint summary.
  Generate summary hoàn chỉnh theo template.

Marketing: weekly metrics digest

MCP dùng: Google Analytics MCP + Slack MCP, scope user.

> Google Analytics MCP: fetch sessions, conversion rate, top pages tuần này.
  So sánh với tuần trước. Format theo template và post lên #marketing-metrics Slack.

Anti-patterns

Anti-pattern 1: Bật mọi MCP server "phòng khi cần"

Triệu chứng: /mcp show 12 server connected. Tổng overhead 60k tokens. Bạn thực sự dùng 2 server mỗi ngày.

Tại sao tệ: 60k token = 30% context window mất trước khi làm việc. Performance giảm, cost tăng, Claude bị "loãng" attention.

Cách đúng: Enable MCP server theo project (.mcp.json chỉ có những gì cả team cần), disable cá nhân những gì bạn không dùng session đó.

Anti-pattern 2: Dùng MCP khi CLI đã đủ tốt

Ví dụ sai: Add github-mcp trong khi gh CLI đã có sẵn, documented tốt, và bạn dùng thành thạo.

Tại sao tệ: gh tốn 0 token overhead. github-mcp tốn ~10k token definitions. Với gh, bạn kiểm soát chính xác command nào chạy. Với MCP, Claude tự quyết — đôi khi gọi tool không cần thiết.

Cách đúng: GitHub → dùng gh. AWS → dùng aws. Kubernetes → dùng kubectl. Chỉ dùng MCP khi không có CLI tốt hoặc khi cần real-time data phức tạp hơn CLI cho phép.

Anti-pattern 3: Hardcode API key trong .mcp.json

Ví dụ sai:

File này checked vào repo → API key lộ cho toàn team, lộ vào git history.

Cách đúng: Dùng env vars:

{
  "mcpServers": {
    "linear": {
      "env": { "LINEAR_API_KEY": "lin_api_abc123xyz..." }
    }
  }
}

Anti-pattern 3: Hardcode API key trong .mcp.json

Key thực nằm trong .env (gitignored) hoặc CI/CD secrets.

Anti-pattern 4: Không refresh OAuth token định kỳ

Triệu chứng: Đang làm việc giữa session, Claude báo "Linear MCP error: 401 Unauthorized". Mất đà, phải interrupt để re-auth.

Cách đúng: /mcp reconnect linear để refresh token trước khi bắt đầu session dài. Set calendar reminder re-auth OAuth monthly (token thường expire 30-90 ngày).

Anti-pattern 5: Skip /mcp audit — MCP zombie

Triệu chứng: 6 tháng sau bạn nhận ra Jira MCP vẫn connected dù team chuyển sang Linear từ tháng 2. 7k token mất mỗi session từ tháng 2.

Cách đúng: Mỗi tháng gõ /mcp một lần, check usage. Disable server không còn relevant. 5 phút/tháng tiết kiệm hàng nghìn token.

Anti-pattern 6: Dùng MCP cho one-off task

Tình huống: Bạn cần một lần duy nhất query Notion để lấy meeting notes hôm qua.

Sai: Add Notion MCP (setup, auth, tốn ~5k token overhead mãi mãi sau đó).

Đúng: Viết Skill nhỏ với curl gọi Notion API một lần, hoặc copy-paste thủ công nếu thực sự chỉ 1 lần.

{ "LINEAR_API_KEY": "${LINEAR_API_KEY}" }

Mẹo nâng cao

Mẹo 1: Local MCP server cho internal tools

Nếu công ty có internal CRM, legacy system không expose public API — bạn vẫn có thể build MCP server local (stdio):

Script Python gọi internal REST API của công ty, serve MCP protocol qua stdio. Không cần firewall rules, không expose mạng.

Mẹo 2: .mcp.json template cho organization

Tạo template repo có sẵn .mcp.json với cấu hình chuẩn cho stack của team:

Mỗi project mới fork từ template → có sẵn MCP config chuẩn của org.

Mẹo 3: Multiple environment — dev vs prod MCP

organization-templates/
├── nextjs-starter/
│   └── .mcp.json  # linear + context7 + postgres
├── python-api/
│   └── .mcp.json  # linear + context7 + datadog
└── mobile-react-native/
    └── .mcp.json  # linear + figma + context7

# Build simple stdio MCP server
# chạy trên máy bạn, không expose ra internet
claude mcp add --scope project internal-crm -- python3 ./scripts/crm-mcp-server.py

Mẹo 3: Multiple environment — dev vs prod MCP

Dev và prod database tách biệt trong .mcp.json. Switch bằng env vars — không nhầm lẫn.

Mẹo 4: Combine MCP + Skill cho workflows phức tạp

Skill /sprint-review (xem Bài 2.9: Skills) có thể orchestrate nhiều MCP servers:

{
  "mcpServers": {
    "postgres-dev": {
      "type": "stdio",
      "command": "npx",
      "args": ["@mcp/postgres", "${DEV_DATABASE_URL}"]
    },
    "postgres-prod": {
      "type": "stdio",
      "command": "npx",
      "args": ["@mcp/postgres", "${PROD_DATABASE_URL}"]
    }
  }
}

Mẹo 4: Combine MCP + Skill cho workflows phức tạp

Bạn gõ /sprint-review, Claude orchestrate 3 MCP servers, tổng hợp, post kết quả. 10 phút thủ công → 30 giây.

Mẹo 5: Delegate MCP-heavy task sang subagent

Nếu task cần fetch nhiều data từ nhiều MCP servers (ví dụ: generate quarterly report từ Linear + GitHub + Datadog + Slack + Google Analytics), đừng để main context phình:

# /sprint-review

Workflow:
1. Linear MCP: fetch all completed issues sprint hiện tại
2. GitHub MCP: fetch PRs merged tuần này, link với issues
3. Slack MCP: fetch messages #bugs channel 7 ngày qua
4. Generate sprint review document:
   - Features shipped (link PR + ticket)
   - Bugs fixed vs reported
   - Velocity metrics
   - Blockers next sprint
5. Post summary vào Slack #engineering channel

Mẹo 5: Delegate MCP-heavy task sang subagent

Subagent chạy với context window riêng (xem Bài 2.8: Subagents), gọi các MCP tools, trả về summary. Main context của bạn nhận 1 trang kết quả thay vì hàng chục nghìn token raw data.

Mẹo 6: Audit monthly

Lịch đơn giản để không có MCP zombie:

Spawn subagent để generate quarterly report Q1:
- Fetch từ Linear: 3 sprints completed
- Fetch từ GitHub: PRs, contributors
- Fetch từ Datadog: uptime, incident count
- Trả về summary 1 trang, không cần raw data

Mẹo 6: Audit monthly

5 phút/tháng, context luôn clean.

Mỗi đầu tháng:
1. /mcp → review list
2. Có server nào không dùng tháng trước? → disable
3. Có workflow mới cần MCP server? → add
4. OAuth token nào gần expire? → renew
5. .mcp.json có outdated server? → remove + commit

Áp dụng ngay

Bài tập 1: Khám phá MCP ecosystem (15 phút)

Bước 1: Mở trình duyệt, vào claude.com/connectors.

Bước 2: Browse theo category. Identify 2-3 MCP servers relevant với stack/workflow của bạn.

Gợi ý theo stack:

Bước 3: Add 1 server thử:

Bước 4: Trong session Claude Code, thử dùng tool của server đó. Ví dụ với Context7:

• Web dev: Context7 (docs) + Linear/Jira (tickets) + GitHub (PRs)
• Backend/Data: Postgres/MySQL MCP + any analytics MCP
• DevOps: Datadog/Grafana MCP + PagerDuty MCP
• Mobile: Figma MCP + Linear MCP

claude mcp add --scope local <name> <url>

Bài tập 1: Khám phá MCP ecosystem (15 phút)

Ghi lại: Server add mất bao lâu? Tool hoạt động như kỳ vọng?

Bài tập 2: Audit context cost (10 phút)

Bước 1: Mở project bạn đang làm, start Claude Code.

Bước 2: Gõ /mcp.

Bước 3: Điền vào bảng audit:

Bước 4: Disable 1+ server không cần thiết:

Server name    | Tools | Token est | Dùng lần cuối | Giữ?
──────────────────────────────────────────────────────────
               |       |           |               | Y/N
               |       |           |               | Y/N
               |       |           |               | Y/N

Total overhead: ___ tokens (___ % context)
Overhead sau khi clean: ___ tokens (___ % context)

> Tìm latest API của React Hook useCallback, dùng context7

Bài tập 2: Audit context cost (10 phút)

Bước 5: Gõ lại /mcp, so sánh overhead trước và sau.

> /mcp disable <name>

Tóm tắt

🎯 MCP là open standard — cho phép Claude Code thực hiện actions trong external services (Linear, Slack, Postgres, Figma...) thay vì chỉ trả về text. Tools là cơ chế core của agentic AI.

🎯 2 loại server: HTTP server (remote, provider-hosted, cần auth) và Stdio server (local process, không cần network, an toàn cho internal tools).

🎯 3 scope: Local (chỉ bạn, project này), User (bạn, mọi project), Project (cả team, qua .mcp.json checked in repo). API key luôn qua env vars, không hardcode.

🎯 MCP tốn context kể cả khi không dùng — mỗi server 2-15k token definitions. Dùng /mcp audit định kỳ, disable server không essential. Tránh MCP zombie.

🎯 CLI > MCP khi CLI đã tốt. gh cho GitHub, aws cho AWS — zero context overhead. MCP tốt nhất khi service không có CLI và bạn dùng hàng ngày.