MCP (Model Context Protocol) is basically a tool bridge.

1. First: What MCP Actually Is (in practical terms)

MCP (Model Context Protocol) is basically a tool bridge.

Instead of Claude guessing things, it can call tools that retrieve context from systems like:

• Figma

• GitHub

• Jira

• databases

• APIs

So instead of saying:

“Claude, what does this UI look like?”

Claude can ask Figma directly through an MCP tool.

Architecture looks like this:

Claude (VS Code)

      │

      │ MCP protocol

      ▼

MCP Server

      │

      ▼

Figma API

The MCP server is just a wrapper around APIs.

2. Local Setup (VS Code + Claude + MCP + Figma)

Typical dev setup:

Step 1 — Install Claude Code in VS Code

Claude Code extension connects your editor to the Claude agent.

Claude becomes your agent runtime.

Step 2 — Run an MCP Server locally

Example:

npx @modelcontextprotocol/server-figma

or via Docker:

docker run mcp/figma-server

This server exposes tools like:

get_figma_file

get_figma_components

get_figma_design_tokens

Step 3 — Configure Claude to know the MCP server

Create or update:

.claude/mcp.json

Example:

{

  "mcpServers": {

    "figma": {

      "command": "npx",

      "args": ["@modelcontextprotocol/server-figma"],

      "env": {

        "FIGMA_TOKEN": "your-figma-api-token"

      }

    }

  }

}

Restart Claude.

Now Claude can call:

figma.get_figma_file

Step 4 — Claude uses the tool automatically

Example prompt:

Claude, inspect the Figma design for the login page

and generate a React component.

Claude will:

1. call MCP

2. retrieve Figma nodes

3. generate code

3. Now the

real architectural question you asked

Should we actually do this?

For enterprise architecture, the answer is:

Usually no.

And your instinct earlier was correct.

4. The MCP Anti-Pattern

Bad architecture:

Microservice

     │

     ▼

Claude Agent

     │

     ▼

MCP Server

     │

     ▼

External system

Now your production services depend on:

• AI runtime

• MCP protocol

• external tools

That is fragile and slow.

5. The LTM / Intent-Driven Way

Your architecture should be:

Intent

   │

   ▼

Skills

   │

   ▼

Tools

Example:

Intent:

Generate UI component

Skill:

generate_component_from_design()

Tool:

Figma API

No MCP needed.

6. When MCP

actually makes sense

MCP is best for developer productivity, not runtime systems.

Good uses:

Use Case

Good

Design → Code generation

✅

Exploring design systems

✅

Documentation generation

✅

Prototyping

✅

Bad uses:

Use Case

Bad

Microservice runtime

❌

API gateway integration

❌

Production workflow

❌

system-to-system integration

❌

7. Security Best Practices

Never let MCP become a data exfiltration channel.

1 — Use scoped tokens

For Figma:

• read-only token

• specific workspace

2 — Never commit tokens

Use environment variables:

FIGMA_TOKEN

not in repo.

3 — Run MCP locally only

Dev machine only.

Never expose:

mcp server : public internet

4 — Proxy in enterprise

Enterprise pattern:

Claude

   │

MCP server

   │

Internal proxy

   │

Figma API

Proxy controls:

• rate limiting

• auth

• audit logs

8. The Architecture I Recommend for You

For your LTM approach:

Intent

│

▼

Skill: generate_ui_from_figma

│

▼

Figma API client

│

▼

Design JSON

Claude only orchestrates.

No MCP required.

9. The Hackathon Trick (this wins)

If you’re showing intent-driven engineering:

Demo:

Intent:

"Create UI from Figma login page"

Claude:

1. pulls Figma design

2. generates React component

3. generates tests

4. generates API contract

5. generates microservice stub

One prompt.

People go:

“Holy hell.”

10. My Honest Take (for you specifically)

Given your architecture work and the Learn Teach Master model you’re building:

You should position MCP like this:

MCP is a convenience bridge for context retrieval, not a core enterprise architecture component.

That’s the architect answer.

✅ TL;DR

Use MCP for:

• developer tooling

• design/code generation

• exploration

Don’t use it for:

• runtime systems

• microservices

• enterprise integration