Why Adding an MCP Server to Claude Code Isn’t Just a Simple Plug‑In (Interview Answer Scores 60)

1. What is MCP?

MCP (Model Context Protocol) is an open standard that lets Claude Code connect to external tools, data sources, and APIs through a unified interface, turning the assistant from a code‑only tool into one that can query databases, Jira, Sentry, GitHub, Slack, and more.

Without MCP, users must manually retrieve data, copy it, and paste it into the conversation. MCP automates this data‑fetching step, enabling Claude to pull information from multiple systems in a single turn.

Compared with built‑in tools (always available, no configuration) and skills (project‑specific reusable code), MCP is the third layer that bridges third‑party systems via external servers.

2. How to Add a Server: Commands, Configuration, and Scopes

Servers can be added via the CLI or a JSON configuration file.

CLI examples:

claude mcp add --transport http <name> <url>

for a cloud HTTP server, or

claude mcp add <name> -- <start‑command>

The latter uses stdio communication, suitable for accessing local files or databases.

MCP supports three transport types:

stdio : local process via standard input/output.

HTTP (streamable HTTP): recommended for cloud‑hosted servers, supports OAuth.

SSE : server‑sent events, deprecated – use HTTP instead.

Authentication is handled automatically: an unauthenticated server returns a 401, Claude marks it as “needs authentication”, and the /mcp command opens an OAuth flow. Static tokens can be supplied with the --header option.

Configuration file example ( .mcp.json):

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.example.com/mcp"
    },
    "algomooc-db": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@some/postgres-mcp-server"],
      "env": { "DATABASE_URL": "${DATABASE_URL}" }
    }
  }
}

Three scopes determine visibility:

local : stored in the user’s config, visible only to the current project.

project : stored in .mcp.json at the repo root, shared via Git.

user : stored in the global config, available to all of the user’s projects.

Choosing the correct scope is both a convenience and a security decision because project‑level configuration is committed to version control.

3. What a Server Provides: Tools, Resources, and Prompts

After a server is added, it exposes three kinds of objects:

Tools : executable actions such as "list all issues" or "run a SQL query". They are referenced as mcp__<server>__<tool>, e.g., mcp__github__list_issues.

Resources : structured data like files, database records, or API docs, referenced with @<server>:<protocol>://<path>, e.g., @github:issue://123.

Prompts : predefined command templates invoked as slash commands, e.g., /mcp__jira__create_issue.

In practice, tools are used most often; resources and prompts are optional extras.

Example from the author’s AlgoMooc project: instead of manually running a SQL query to find problems without animation, the author simply asks Claude to run mcp__algomooc-db__query, which returns the list and lets Claude prioritize fixes without any manual copy‑paste.

4. Why Hundreds of Tools Don’t Exhaust the Context Budget

Claude Code uses a "tool search" mechanism that lazily loads tool definitions. At session start only the server name and a short description are loaded; the full schema of a tool is fetched only when Claude decides it may need that tool.

This lazy‑loading is enabled by default. Users can adjust the strategy via an environment variable to switch between always‑load, auto‑load (based on a percentage threshold), or disable lazy loading for a specific server.

Models that do not support the tool‑reference capability (e.g., Haiku) fall back to eager loading, which can quickly consume the context budget if many tools are attached. The author experienced this when three servers contributed ~20 tools that were all loaded at once.

To keep the budget low, remove unused servers with claude mcp remove <name> and only keep servers that are truly needed for the project.

5. The Often‑Overlooked Security Layer

Each MCP server runs external code that can read or modify your data. Anthropic does not audit or endorse any server, so the security responsibility lies entirely with the user.

Three main risks are identified:

Prompt injection : malicious content returned by a server can contain hidden instructions that Claude may execute.

Data leakage : a server can silently store or forward the data you send to it.

Tool poisoning : a seemingly harmless tool (e.g., a formatter) may perform unwanted actions such as uploading source code.

Claude Code requires explicit approval before executing a tool; sensitive operations trigger a permission prompt. Users can whitelist trusted tools in the permissions block:

{
  "permissions": {
    "allow": ["mcp__github__*", "mcp__algomooc-db__query"]
  }
}

Best practices: never connect to untrusted community servers, audit any server added to .mcp.json as you would review code, and keep high‑risk tools behind confirmation dialogs.

6. How to Answer an MCP Interview Question

Four‑step answer template (≈2 minutes total):

Positioning (20 s) : Explain that MCP is a protocol for connecting Claude Code to external tools and data sources, distinct from built‑in tools and skills.

How to add and scope (30 s) : Mention the claude mcp add command or .mcp.json file, and describe the three scopes (local, project, user) with the security note about not committing raw secrets.

Tool loading (30 s) : Describe the default tool‑search lazy‑loading, the special case for models like Haiku, and how to control the loading strategy.

Security awareness (20 s) : Cite Anthropic’s disclaimer, list the three risks, and stress never using unknown community servers and always reviewing shared server configurations.

Follow‑up questions often probe the choice between built‑in tools, skills, and MCP, or ask when to use stdio vs. HTTP. Answer by emphasizing external‑system access as the deciding factor and noting that SSE is deprecated.

Conclusion

MCP turns Claude Code from a closed‑loop code assistant into a full‑stack workflow assistant. Its value lies in the standardised bridge to external systems, the lazy‑loading tool‑search that prevents context bloat, and the security model that puts trust management entirely in the user’s hands.