Agents with MCP Tools & Servers

The Problem MCP Solves:

Before MCP, every AI application had to build custom integrations for every tool and data source. Want to connect your AI to Slack? Build a Slack integration. Gmail? Another integration. Database? Another one. This does not scale - it is like needing a different charger for every device.

MCP is an open protocol (created by Anthropic) that provides a standard way for AI applications to connect to external tools and data sources. Build the integration once as an MCP server, and ANY MCP-compatible AI client can use it.

Real-World Analogy - UPI:

Before UPI, every bank had its own payment app. Want to send money? You needed ICICI app for ICICI, HDFC app for HDFC. UPI standardized this - one interface to connect any bank with any payment app.

MCP does the same for AI tools. One protocol to connect any AI agent with any tool or data source.

MCP Architecture:

[AI Application (MCP Client)]
  |-- Claude Desktop
  |-- VS Code with Claude extension
  |-- Any MCP-compatible app
        |
        | MCP Protocol (JSON-RPC over stdio/SSE)
        |
[MCP Server 1: GitHub]   [MCP Server 2: Slack]   [MCP Server 3: Database]
  |-- list repos         |-- send message         |-- query tables
  |-- create PR           |-- search channels      |-- insert rows
  |-- review code         |-- read history         |-- run migrations

Three Core Capabilities of MCP:

• Tools: Functions the AI can call (search, create, update, delete). Like tool calling but standardized.
• Resources: Data the AI can read (files, database records, API responses). Like giving the AI access to information.
• Prompts: Pre-defined prompt templates for common tasks. Like shortcuts the user can invoke.

What is an MCP Server?

An MCP server is a lightweight program that exposes tools, resources, and prompts through the MCP protocol. It runs as a separate process and communicates with AI clients via JSON-RPC. Think of it as a microservice specifically for AI tools.

Anatomy of an MCP Server:

MCP Server: "Indian Stock Market"

Tools:
  1. get_stock_price
     Description: Get current price of an NSE/BSE stock
     Input: { symbol: "RELIANCE", exchange: "NSE" }
     Output: { price: 2847, change: +1.2%, volume: "5.2M" }

  2. get_portfolio_value
     Description: Calculate total portfolio value
     Input: { holdings: [{symbol, quantity}] }
     Output: { total_value: 1250000, day_change: +15000 }

  3. search_stocks
     Description: Search stocks by name or sector
     Input: { query: "IT sector large cap" }
     Output: [{ symbol: "TCS", name: "Tata Consultancy", ... }]

Resources:
  1. market_summary
     URI: stock://market/summary
     Returns: Today's Nifty, Sensex, top gainers/losers

  2. stock_fundamentals
     URI: stock://fundamentals/{symbol}
     Returns: PE ratio, market cap, 52-week range

Popular Pre-Built MCP Servers:

• GitHub MCP: Create PRs, review code, manage issues
• Slack MCP: Send messages, search conversations, manage channels
• PostgreSQL MCP: Query databases, inspect schemas, run migrations
• Filesystem MCP: Read, write, search files on local disk
• Google Drive MCP: Search, read, create documents
• Brave Search MCP: Web search with Brave's API

There are 1000+ community-built MCP servers available on the official registry and GitHub.

What is an MCP Client?

An MCP client is any AI application that discovers and uses MCP servers. The client handles connecting to servers, listing available tools, and routing the AI's tool calls to the right server.

How AI Uses MCP Tools - The Flow:

1. Client starts -> connects to configured MCP servers
2. Client calls tools/list on each server
3. Server returns available tools with descriptions
4. Client sends tool descriptions to LLM (like function calling)
5. User asks: "What is Reliance stock price?"
6. LLM decides: call get_stock_price tool
7. Client routes the call to the Stock Market MCP server
8. Server executes and returns result
9. Client sends result back to LLM
10. LLM generates response: "Reliance is at Rs 2,847..."

Popular MCP Clients:

• Claude Desktop: Anthropic's desktop app - the first MCP client. Configure servers in settings.
• Claude Code (CLI): Terminal-based Claude with MCP support for developer workflows.
• Cursor IDE: AI code editor with MCP integration for development tools.
• Cline (VS Code): VS Code extension with full MCP support.
• Custom Apps: Any application using the MCP SDK (TypeScript, Python, Kotlin, C#).

MCP vs Direct Tool Calling:

When to Build a Custom MCP Server:

• Your company has internal APIs the AI needs to access
• You have a custom database with domain-specific data
• You want to expose internal tools (CI/CD, monitoring, ticketing) to AI
• No existing MCP server covers your use case

Key Design Principles:

• Clear Tool Descriptions: The LLM reads your tool descriptions to decide when to use them. Write them like documentation for a junior developer - clear, specific, with examples.
• Typed Parameters: Use JSON Schema to define exact types, required fields, and valid values. Reduces errors dramatically.
• Granular Tools: One tool per action. Do not create a "do_everything" tool. Separate "search_users" from "create_user" from "delete_user".
• Helpful Errors: Return error messages that help the LLM understand what went wrong and how to fix it. "User ID 123 not found" is better than "Error 404".
• Idempotent Operations: When possible, make tools safe to retry. If the LLM calls "create_user" twice by accident, it should not create duplicates.

Security Considerations:

• Authentication: MCP servers often run locally with access to sensitive systems. Ensure only authorized clients can connect.
• Authorization: Not every user should have access to every tool. Implement role-based access control.
• Input Validation: The LLM generates tool inputs. Always validate and sanitize - treat it like untrusted user input.
• Rate Limiting: Prevent the AI from making excessive calls to your internal systems.
• Audit Logging: Log every tool call, who made it, and what the result was.

Production Architecture with MCP:

[User] -> [AI Application (MCP Client)]
              |
              +-- [MCP Server: Company CRM]
              |     Tools: search_customers, create_lead, update_deal
              |
              +-- [MCP Server: Internal Wiki]
              |     Resources: wiki://pages/{id}, wiki://search
              |
              +-- [MCP Server: Monitoring]
              |     Tools: get_alerts, check_server_status
              |
              +-- [MCP Server: Deployment]
                    Tools: deploy_service, rollback, get_logs

Example Interaction:
User: "Check if the payment service is healthy and
       deploy the latest version if all good"

AI Agent:
  1. Calls monitoring/check_server_status("payment-service")
  2. Sees: healthy, 99.9% uptime, no alerts
  3. Calls deployment/deploy_service("payment-service", "latest")
  4. Reports: "Payment service is healthy. Deploying v2.3.1..."

Remote MCP Servers (Upcoming):

Currently most MCP servers run locally (stdio transport). The protocol is evolving to support remote servers over HTTP/SSE, enabling:

• Cloud-hosted MCP servers shared across teams
• Third-party MCP server marketplaces
• Enterprise MCP server management with auth and access control
• Scaling MCP servers independently from the client

Common Patterns:

• Gateway Pattern: One MCP server acts as a gateway to multiple internal services, handling auth and routing.
• Composable Servers: Chain multiple MCP servers - output of one becomes input to another.
• Context Enrichment: MCP resources provide context (company data, user profiles) that makes the AI smarter about your domain.

Q: What problem does MCP solve?

Q: What are the three core capabilities of MCP?

Q: What security considerations are important for MCP servers?

Q: How does MCP compare to regular function/tool calling?