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 Finance 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 merchant data to CSV, paste into AI	AI queries merchant database directly
Open 50 invoices one by one	AI scans the invoice folder automatically
Check compliance status in 3 different systems	AI checks all 3 systems in one request
Copy transaction data, format it, paste it	AI runs SQL query, gets exactly what it needs
Manually send Slack alert when issue found	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/merchants')`	The AI decides on its own: "I need merchant 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 Merchant Data

🔌 With a Traditional API

A developer writes this code:

// Developer writes this
const resp = await fetch(
  '/api/merchants?risk=RED'
);
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 RED-rated merchants
 with their chargeback rates"

// AI automatically:
→ tools/call read_query
  SELECT * FROM merchants
  WHERE risk_rating = 'RED'
        

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 merchant data	✅ Yes — your app code calls the API	❌ No — apps don't need AI reasoning
AI agent that investigates fraud patterns	❌ No — AI can't call APIs on its own	✅ Yes — AI discovers and calls tools
Automated report that pulls from 3 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

anycompany.db

Press Play or Step Forward to watch the message flow.

🏦 MCP Servers for Finance 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	Finance use case	Setup
SQLite / PostgreSQL	Databases	Query merchant data, transaction history, compliance records	Config only
Filesystem	File directories	Process folders of invoices, scan regulatory documents	Config only
Slack / Teams	Team messaging	Send alerts when RED-rated merchant detected	API key
Google Drive / S3	Document storage	Read policy documents for RAG grounding	OAuth / IAM
Email (SMTP)	Email systems	Send compliance reports, escalation alerts	SMTP config
Custom REST API	Internal services	Call risk scoring engine, KYC verification	Custom build

💡

You design the recipe, your tech team sets up the kitchen. In the Agent Design Canvas, you specify "MCP connections needed: merchant database, 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": {
    "anycompany-db": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "./anycompany.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 — Fraud Detection Example

Layer	What it does	In the fraud detection workflow
Steering	Sets global rules	SGD currency, no PII, GREEN/AMBER/RED ratings
Skill	Defines the investigation process	Fraud Investigation Lead persona, 6-section report format, guardrails
Hook	Triggers automatically	New `.alert` file → run fraud investigation skill
MCP	Connects to data	SQLite server → query merchant profile, transactions, compliance alerts

🔍

The full automation loop: Alert file arrives (external system) → Hook detects it → Skill activates → MCP queries the database → Report generated → Human reviews the recommendation. The AI handles the investigation; you make the decision.

🗺️ Your 3-Day Journey

Day	What you learned	What you built
Day 1	What AI can do, responsible AI, use cases	Understanding + GenAI playbook
Day 2	Prompt engineering techniques	Reusable prompt templates
Day 3	Agentic AI, skills, hooks, MCP	Working agent with database connection

The thread: Day 1's responsible AI → enforced by Day 3's guardrails. Day 2's prompt templates → become Day 3's skills. Day 2's RAG grounding → becomes Day 3's MCP connections. Everything builds on what came before.