Saturday, September 19, 2026

Kiro × MCP — From Zero to Production
One-page mental model

From “Kiro is an AI IDE” to “I can configure its MCP runtime.”

Kiro is the agent host. MCP is the bridge that gives the agent external tools, prompts, and resources. Configure servers in mcp.json, control permissions, and govern them in enterprise with a registry.

Kiro = MCP client MCP server = tools + resources + prompts Local = stdio Remote = HTTP / SSE Workspace or user config autoApprove / disabledTools

The one sentence

Kiro is the agent harness.
MCP is the standardized bridge to external capabilities.
Configuration tells Kiro how to start or connect to each server.
flowchart LR U[You] --> K[Kiro Agent] K --> R[Reason / Plan] R --> M[MCP Tools] R --> B[Built-in Tools] M --> X[External systems] X --> O[Result] O --> K B --> F[Files / Shell / Git] F --> K

01 · What is MCP?

Source: kiro.dev/docs/mcp

MCP (Model Context Protocol) lets Kiro communicate with external servers that expose specialized tools, prompts, and resources.

What you can do

  • Access specialized knowledge bases and docs
  • Integrate external services and APIs
  • Add domain-specific tools
  • Use server-provided prompt/resource templates

Surfaces that support MCP

SurfaceLocalRemote
IDE✓✓
CLI✓✓
Web✓✓
Mobile——

Core roles

  1. Kiro — MCP client / agent host
  2. MCP server — process that exposes capability
  3. Transport — local stdio or remote HTTP/SSE
  4. Tool — callable action with schema
  5. Resource / Prompt — retrievable context or template
sequenceDiagram participant U as User participant K as Kiro participant M as MCP Server participant X as External API U->>K: Ask a question that needs external data K->>M: tools/call with structured arguments M->>X: Call the real system X-->>M: Raw result M-->>K: Normalized MCP result K->>U: Answer grounded in tool output

02 · Configuration — write this from memory

Sources: Configuration · CLI Configuration · MCP overview

Two main files
Workspace (project-specific): .kiro/settings/mcp.json
User (global): ~/.kiro/settings/mcp.json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "env": {
        "SOME_KEY": "${SOME_KEY}"
      },
      "disabled": false,
      "autoApprove": ["tool_name"],
      "disabledTools": ["dangerous_tool"]
    }
  }
}
{
  "mcpServers": {
    "api-server": {
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${API_TOKEN}"
      },
      "disabled": false
    }
  }
}

Remote servers can also use OAuth. See agent configuration docs for oauth / oauthScopes.

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git"],
      "env": {
        "GIT_CONFIG_GLOBAL": "/dev/null"
      }
    },
    "aws-docs": {
      "command": "npx",
      "args": ["-y", "@aws/aws-documentation-mcp-server"]
    }
  }
}
{
  "name": "myagent",
  "description": "My special agent",
  "mcpServers": {
    "fetch": {
      "command": "fetch3.1",
      "args": []
    }
  },
  "includeMcpJson": false
}

includeMcpJson controls whether the agent also loads workspace + user mcp.json servers.

# Add a server (CLI)
kiro-cli mcp add \
  --name "awslabs.aws-documentation-mcp-server" \
  --scope global \
  --command "uvx" \
  --args "awslabs.aws-documentation-mcp-server@latest" \
  --env "FASTMCP_LOG_LEVEL=ERROR"

Property cheat sheet

PropertyWhat it does
commandExecutable Kiro launches for a local (stdio) server
argsArguments passed to that command
envEnvironment variables. Use ${VAR} for secrets
urlRemote MCP endpoint (HTTP/SSE)
headersHTTP headers for remote servers
disabledTurn the server off without deleting it
autoApproveTools that skip the approval prompt (use sparingly)
disabledToolsHide/block specific tools from the agent
timeoutRequest timeout in ms (supported in several surfaces)

Loading priority

Highest → lowest:
1. Agent config (mcpServers in agent JSON)
2. Workspace (.kiro/settings/mcp.json)
3. User / global (~/.kiro/settings/mcp.json)
1
Install prerequisites
Python / Node / uvx / Docker as required by the server
2
Write mcp.json
Choose workspace or user scope
3
Save
Kiro reconnects on config changes
4
Verify
Check MCP panel or /mcp / /tools
5
Approve deliberately
Use autoApprove only for trusted, low-risk tools

03 · Server directory

Source: kiro.dev/docs/mcp/servers

Server directory = discovery + one-click install.
Browse available MCP servers and click “Add to Kiro”. Install links use the kiro:// URL scheme.

Key points from the docs:

  • MCP servers are third-party tools. Only install from trusted sources.
  • Review each server’s documentation and licensing.
  • Kiro is not responsible for third-party MCP servers.
  • After adding, servers appear in the MCP panel with connection status.
Local stdio servers run as processes in your environment with the same privileges as the agent (workspace files, env vars, credentials). Treat them like any executable you install.

04 · Tools, prompts, and resources

Source: kiro.dev/docs/mcp/usage · Tools overview

Tools

Callable actions the model can invoke. A good tool has:

  • Precise name
  • Clear description
  • Narrow input schema
  • Predictable output

Example: get_vulnerabilities(project, severity) is better than a catch-all tool.

How to use them

  • Direct questions — ask in natural language
  • # mentions — reference server prompts/resources
  • /tools — list tools and token usage (CLI)
  • MCP panel — see servers, status, and tools (IDE)

Controlling tools

  • autoApprove — skip prompts for listed tools
  • disabledTools — hide dangerous tools
  • Agent tools / allowedTools — restrict what an agent can see or run without prompt
  • Permissions layer for broader policy

06 · Examples (from official docs)

Source: kiro.dev/docs/mcp/examples

{
  "mcpServers": {
    "aws-docs": {
      "command": "uvx",
      "args": ["awslabs.aws-documentation-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Tools include search, read, and recommend documentation.

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Prefer environment variables over hard-coded tokens.

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "disabled": false
    }
  }
}

07 · Best practices & security

Source: kiro.dev/docs/mcp/security

Important: Local stdio MCP servers execute as processes in your environment with the agent’s privileges — workspace files, environment variables, and available credentials. Treat an MCP server like executable code you install.

Secrets

  • Never commit tokens
  • Use ${VAR} references
  • Rotate credentials
  • chmod 600 on mcp.json

Least privilege

  • Minimal token scopes
  • Disable destructive tools
  • Prefer workspace config for project servers

autoApprove

  • Only for trusted, low-risk tools
  • Never for write/delete operations by default

disabledTools

{
  "disabledTools": [
    "delete_repository",
    "force_push"
  ]
}
flowchart LR A[Agent] --> PERM[Permission / autoApprove] PERM --> VAL[Input validation] VAL --> TOOL[MCP Tool] TOOL --> EXT[External system] EXT --> AUD[Logs / metrics]

08 · Registry (enterprise)

Source: kiro.dev/docs/mcp/registry

Without registry (default)
Users can add any MCP server.
With registry (enterprise)
Admin configures allowed servers. Users select from the registry list. Servers not in the registry are hidden and not started — even ones you define in mcp.json.

Overrides still work

{
  "mcpServers": {
    "github": {
      "type": "registry",
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      },
      "timeout": 60000
    }
  }
}

Override fields for local servers: env, timeout. For remote: headers, timeout.

flowchart TD ADM[Enterprise Admin] --> REG[MCP Registry] REG --> ALLOW[Allowed servers] USER[Kiro User] --> REG USER --> CFG[mcp.json overrides] CFG --> MERGE[Registry defaults + local overrides] MERGE --> RUN[Server can run] HIDDEN[Non-allowlisted server] --> STOP[Hidden / not started] style STOP fill:#5b2030,color:#fff

09 · Interview-ready answers

Q1. What is MCP?
A protocol that lets Kiro communicate with external servers to access specialized tools, prompts, and resources.
Q2. Is Kiro an MCP server?
No. Kiro is the MCP client / agent host. The MCP server exposes capabilities to Kiro.
Q3. Why do we need mcp.json?
It tells Kiro how to start or connect to each MCP server (command/args for local, url/headers for remote) and optional controls like disabled, autoApprove, disabledTools.
Q4. Workspace vs user MCP config?
Workspace (.kiro/settings/mcp.json) is project-specific. User (~/.kiro/settings/mcp.json) is global. Prefer workspace for project-specific servers.
Q5. What does command do?
The executable Kiro launches for a local (stdio) MCP server.
Q6. What does autoApprove do?
Listed tools run without an approval prompt. Use only for trusted, low-risk tools.
Q7. What does disabledTools do?
Prevents specific MCP tools from being available to the agent.
Q8. What is Tool Search?
A mechanism that indexes MCP tools and loads full schemas only when the agent needs them, keeping context smaller when many servers are present.
Q9. Loading priority?
Agent config → Workspace mcp.json → User mcp.json.
Q10. When should you avoid MCP?
When a simple local function or deterministic pipeline is enough and the protocol adds unnecessary complexity or latency.
Q11. What is the enterprise MCP registry?
An admin-controlled allow-list. Servers outside the registry are hidden and never started.
Q12. Security warning for local servers?
They run as processes with the agent’s privileges, including access to workspace files, environment variables, and credentials. Treat them like any executable you install.

10 · Flashcards

Expert ladder

  1. Explain client vs server
  2. Write a local mcp.json
  3. Write a remote mcp.json
  4. Explain loading priority
  5. Use autoApprove / disabledTools safely
  6. Enable and explain Tool Search
  7. Explain enterprise registry behavior
Goal: derive the config from the architecture, don’t memorize JSON.

11 · 60-second explanation

“Kiro is the agent host. MCP is the standard way it reaches external tools, prompts, and resources. I configure servers in .kiro/settings/mcp.json (workspace) or ~/.kiro/settings/mcp.json (user). Local servers use command + args + env; remote servers use url + headers. I keep secrets in environment variables, use autoApprove only for low-risk tools, and disabledTools for anything destructive. When many servers are present I enable Tool Search so schemas load on demand. In enterprise, the MCP registry acts as a central allow-list.”
Kiro × MCP Learning Dashboard · Single-page study artifact based only on current kiro.dev/docs. Always verify against the latest official documentation before production use.

No comments:

Post a Comment