How AI Connects to Your Systems — MCP Explainer

💡 Why Does AI Need MCP?

Without MCP, AI can only work with text you paste into it. It can't look things up, check databases, or take actions in your systems. MCP changes that.

📋

Without MCP

Export CSV → paste into chat → AI analyzes what you gave it. Manual, one-at-a-time.

🔌

With MCP

AI queries your database directly, gets exactly what it needs, analyzes live data. Automatic.

🔌

USB-C for AI

Just as USB-C connects any device to any peripheral, MCP connects any AI to any data source.

🌐

Open Standard

Works with Claude, ChatGPT, Kiro, Cursor, VS Code — build once, connect everywhere.

🏦 What MCP Means for Insurance Teams

Your team works with databases, spreadsheets, document stores, and internal APIs every day. MCP lets AI access these systems the same way you do — but faster.

Today (Manual)	With MCP (Automated)
Export claims data to CSV, paste into AI	AI queries claims database directly
Open 50 medical reports one by one	AI scans the claims documents folder automatically
Check policy coverage across 3 different systems	AI checks all 3 systems in one request
Copy policyholder data, format it, paste it	AI runs SQL query, gets exactly what it needs
Manually send alert when fraud detected	AI sends the alert automatically via MCP

💡

Key insight: MCP doesn't replace your systems — it connects AI to them. Your databases, APIs, and tools stay exactly where they are. MCP just gives AI a way to talk to them.

⚡ API vs MCP — What's the Difference?

Both APIs and MCP let systems talk to each other. But they solve different problems and work at different levels. Here's the clearest way to think about it:

🔌

API (Application Programming Interface)

A contract between two systems. "Send me this request, I'll give you this response." Designed for programs to talk to programs.

🧠

MCP (Model Context Protocol)

A contract between AI and systems. "Here are the tools I offer — the AI decides when and how to use them." Designed for AI to discover and use capabilities.

The Key Difference: Who Decides?

Aspect	Traditional API	MCP
Who calls it?	A developer writes code: `fetch('/api/claims')`	The AI decides on its own: "I need claims data, let me call `read_query`"
Discovery	Developer reads API docs, writes integration code	AI asks the server "what tools do you have?" and figures it out
Flexibility	Fixed endpoints — each use case needs a specific API call	AI composes tools dynamically — same tools, infinite use cases
Who builds it?	Developers build and maintain integrations	Configure once, AI handles the rest
Error handling	Developer codes retry logic, error parsing	AI reads the error, adjusts its approach, tries again

🏦 AnyCompany Example: Getting Claims Data

🔌 With a Traditional API

A developer writes this code:

// Developer writes this
const resp = await fetch(
  '/api/claims?status=pending'
);
const data = await resp.json();
// Then format, display, handle errors...
        

Requires: developer time, API knowledge, error handling code, maintenance when API changes.

🧠 With MCP

You just ask in plain English:

// You type this in Kiro:
"Show me all pending claims over $10K
 with their policy details"

// AI automatically:
→ tools/call read_query
  SELECT * FROM claims
  WHERE status = 'pending' AND amount > 10000
        

Requires: MCP server configured (one-time JSON file). No code, no API knowledge needed.

💡

The analogy: An API is like a vending machine — you press the exact button for what you want. MCP is like a personal assistant with access to the vending machine — you say "I'm thirsty" and they figure out which button to press.

🤝 They Work Together, Not Against Each Other

MCP doesn't replace APIs — it wraps them so AI can use them. Many MCP servers are just thin wrappers around existing APIs.

Scenario	Use API directly	Use MCP
Building a web app that shows claims dashboard	✅ Yes — your app code calls the API	❌ No — apps don't need AI reasoning
AI agent that investigates claims fraud patterns	❌ No — AI can't call APIs on its own	✅ Yes — AI discovers and calls tools
Automated report that pulls from policy, claims, and underwriting databases	⚠️ Possible but needs custom code	✅ Yes — AI queries all 3 via MCP
Slack bot that responds to commands	✅ Yes — fixed command → fixed response	✅ Also works — AI reasons about the request
Dashboard with real-time charts	✅ Yes — direct data pipeline	❌ No — MCP is for AI, not dashboards

🔑

Rule of thumb: If a human or program knows exactly what data it needs → use an API. If an AI needs to figure out what data it needs based on a question → use MCP. In practice, MCP servers often call APIs under the hood — you just don't have to write the integration code.

🔧 MCP Architecture

MCP follows a simple client-server pattern. The AI application (Kiro) is the host. It creates clients that connect to servers. Each server provides access to a specific data source or tool.

🤖 MCP Host Kiro / Claude / Cursor

→

🔗 MCP Client One per server

→

🗄️ MCP Server Database / API / Files

Three Core Primitives

Every MCP server can expose three types of capabilities:

🔨

Tools

Actions the AI can perform: run a SQL query, call an API, send a message. The AI decides when to use them.

📦

Resources

Data the AI can read: file contents, database schemas, API responses. Like giving the AI access to a document.

💬

Prompts

Reusable templates that structure how the AI interacts with the server. Like pre-built query patterns.

⚙️ How Connection Works

When you configure an MCP server in Kiro, here's what happens under the hood:

Step	What happens	You see
1. Configure	You add the server to `.kiro/settings/mcp.json`	Edit a JSON file
2. Connect	Kiro launches the MCP server process and negotiates capabilities	Green checkmark ✅ in MCP panel
3. Discover	Kiro asks the server "what tools do you have?" via `tools/list`	Tool names appear in the panel
4. Use	When you ask a question, Kiro decides which tool to call and sends a `tools/call` request	AI response includes data from the server

🔍

Two transport modes: MCP servers can run locally (on your machine, using stdio — like the SQLite server in the lab) or remotely (on a server, using HTTP — like a cloud API). The protocol is the same either way.

🎮 MCP Message Flow — Interactive Demo

Watch messages flow through the full MCP architecture as you ask a question. Each step shows exactly what's happening between components.

Message Flow

Step 0 / 0

👤

You

Plain English

🤖

Kiro (Host)

AI reasoning

🔗

MCP Client

JSON-RPC 2.0

⚙️

MCP Server

mcp-server-sqlite

🗄️

Database

claims.db

Press Play or Step Forward to watch the message flow.

🏦 MCP Servers for Insurance Teams

These are the most common MCP servers your team would use. You specify what connections are needed in the Agent Design Canvas — your tech team configures the actual servers.

MCP Server	Connects to	Insurance use case	Setup
SQLite / PostgreSQL	Databases	Query policy data, claims history, underwriting records	Config only
Filesystem	File directories	Process folders of medical reports, scan claim documents	Config only
Slack / Teams	Team messaging	Send alerts when fraud pattern detected	API key
Google Drive / S3	Document storage	Read policy wordings and product specs for RAG grounding	OAuth / IAM
Email (SMTP)	Email systems	Send claims decisions, escalation alerts	SMTP config
Custom REST API	Internal services	Call underwriting rules engine, claims adjudication API	Custom build

💡

You design the recipe, your tech team sets up the kitchen. In the Agent Design Canvas, you specify "MCP connections needed: claims database, policy admin system, Slack for alerts." Your engineering team then configures the actual MCP servers. The open-source community has pre-built servers for most common systems.

⚙️ Configuration Example

This is what an MCP configuration looks like in Kiro. It's a simple JSON file — no code required:

// .kiro/settings/mcp.json
{
  "mcpServers": {
    "claims-db": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "./claims.db"],
      "autoApprove": ["read_query", "list_tables"]
    }
  }
}
    

That's it — 7 lines of JSON. Kiro launches the SQLite MCP server, connects to it, and you can start querying the database in plain English.

🔗 The Complete Kiro Stack

MCP is the fourth and final layer of the Kiro automation stack. Here's how all 4 layers work together:

📋 Steering
Global rules

→

🛠️ Skills
On-demand expertise

→

⚡ Hooks
Auto-triggers

→

🔌 MCP
Data connections

How They Work Together — Claims Fraud Detection Example

Layer	What it does	In the fraud detection workflow
Steering	Sets global rules	SGD currency, no PII (NRIC/policy numbers), APPROVE/FLAG/REJECT ratings
Skill	Defines the investigation process	Claims Fraud Investigator persona, investigation report format, guardrails
Hook	Triggers automatically	New claim flagged → run fraud investigation skill
MCP	Connects to data	SQLite server → query policyholder profile, claims history, provider records

🔍

The full automation loop: Flagged claim arrives → Hook detects it → Skill activates → MCP queries claims database → Investigation report generated → Claims adjuster reviews the recommendation. The AI handles the investigation; you make the decision.

🗺️ Your Workshop Journey

Module	What you learn	What you build
M1-M2	What agents are, how they work	Understanding of agent architecture
M3	Workflow patterns (chain, parallel, route, orchestrate)	Pattern selection for insurance workflows
M4-M5	AWS tools, frameworks (Kiro, Strands, AgentCore)	Hands-on with Kiro skills, hooks, MCP
M6	Custom solutions, guardrails, evaluation	Working agent with database connection

The thread: Module 1's agent concepts → applied in Module 3's workflow patterns. Module 3's patterns → implemented in Module 5's hands-on labs. Module 4's tools → connected via Module 5's MCP. Everything builds on what came before.