Skip to main content

Inside MCP: A Protocol for AI Integration

Modern AI models are incredibly powerful at understanding and generating text, code, and ideas. But to be truly useful, they need to connect with the real world - to read your code, query your database, or send messages to your team. This is where Model Context Protocol (MCP) comes in.

MCP is an open standard that creates a common language between AI systems and the tools they need to help you. It defines clear rules for how AI assistants can securely access and work with external resources, from local files to cloud services. Think of it as building bridges between AI models and the digital world around them.

Why MCP Matters

MCP solves a critical problem in AI development: giving AI models secure, standardized access to the real-world data and tools they need to be truly useful. Whether you're building a coding assistant, a data analysis tool, or any AI-powered application, MCP provides the bridge between your AI and the resources it needs.

The Building Blocks: MCP Architecture​

Let's break down how MCP works. At its core, MCP is a protocol that standardizes how AI systems communicate with external tools and data sources. Here's how the pieces fit together:

AI Assistant: "Let me create a ticket for that"AI decides to use the create_ticket tool
💻

Host Application

The AI-powered application (IDE, chat interface) that initiates requests for tools and context.

🔌

MCP Client

Handles the MCP protocol, routing messages between the Host and available Servers.

🛠️

Tool Server

Provides specific tools or resources (e.g., file system, git) via the MCP protocol.

Host: The Command Center​

  • Your AI application (like Cursor IDE or Claude Desktop)
  • Manages multiple client connections
  • Handles user authorization
  • Aggregates context from different sources

Client: The Bridge Builder​

  • Maintains one-to-one connections with servers
  • Routes messages between host and server
  • Tracks server capabilities
  • Manages protocol versions and compatibility

Server: The Tool Provider​

  • Exposes specific capabilities:
    • Tools (executable functions)
    • Resources (read-only data)
    • Prompt templates
  • Can be local (file system) or remote (API services)

How It All Works Together​

Let's explore the complete lifecycle of an MCP connection:

MCP Connection Simulator

Client (IDE)●
Status: idle
Server (Tools)●
Status: idle

Connection Lifecycle​

Every MCP connection goes through three distinct phases:

1. Initialization​

When a connection first starts, several critical handshakes occur:

  • The client sends its supported protocol version
  • The server responds with compatibility information
  • Both sides exchange their capabilities:
    • Client shares available tools and sampling preferences
    • Server declares its tools, resources, and prompt templates
  • Connection parameters are established

2. Operation​

Once initialized, the connection enters its active phase:

  • Tools can be invoked
  • Resources can be accessed
  • Real-time updates flow between client and server
  • All communication respects the negotiated capabilities

3. Shutdown​

When work is complete, the connection closes gracefully:

  • Pending operations are completed
  • Resources are released
  • Both sides acknowledge the termination
  • Connection is closed cleanly

This structured lifecycle ensures reliable and predictable behavior across all MCP implementations. The simulation above shows these phases in action, demonstrating how each step contributes to establishing a robust connection.

Throughout this guide, we'll explore:

  • How MCP transforms AI applications from isolated systems into context-aware assistants
  • The architecture that makes MCP both powerful and secure
  • Real-world examples of MCP in action
  • How you can start using MCP in your own projects

Let's dive in and discover how MCP is shaping the future of AI integration.

The "protocol" in MCP​

At its heart, MCP creates persistent, stateful connections between AI assistants and development tools. Let's explore how this works with two popular tools: GitHub and Supabase.

Understanding MCP Through Real Tools​

Imagine you're building a feature that needs both code changes and database updates. Here's how MCP enables your AI assistant to help:

GitHub Integration​

Your AI assistant can:

  • Read & Analyze Code: Fetch repository contents, analyze changes, understand project structure
  • Manage Pull Requests: Create, review, and merge PRs with detailed feedback
  • Monitor Changes: Watch branches, commits, and review comments
  • Handle Issues: Create, update, and link issues to code changes
  • Access CI/CD: Monitor build status, test results, and deployment info

Supabase Integration​

Your AI assistant can:

  • Manage Database: Create tables, modify schemas, handle migrations
  • Query Data: Execute SQL, analyze query performance, suggest optimizations
  • Monitor Changes: Track schema updates, data modifications, and realtime events
  • Handle Auth: Manage users, roles, and security policies
  • Access Logs: Monitor database performance, errors, and access patterns

Message Explorer

Explore different MCP message types and see how they enable AI tools to work with GitHub and Supabase. Each example shows a real-world development scenario.

Examples

1️⃣ Create GitHub PR

Request to create a new pull request with changes

3️⃣ Database Migration

Create and execute a Supabase migration

1️⃣ Create GitHub PR

Request to create a new pull request with changes

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "github/create_pr",
    "args": {
      "owner": "acme-corp",
      "repo": "backend-api",
      "branch": {
        "name": "feat/add-user-profiles",
        "from": "main"
      },
      "changes": [
        {
          "file": "src/models/user.ts",
          "content": "interface UserProfile {\n  id: string;\n  userId: string;\n  displayName: string;\n  avatarUrl?: string;\n  createdAt: Date;\n  updatedAt: Date;\n}\n\nexport const userProfileSchema = {\n  // ... schema definition\n};"
        },
        {
          "file": "src/routes/profiles.ts",
          "content": "import { Router } from 'express';\nimport { validateProfile } from '../validators';\n\nconst router = Router();\n\nrouter.get('/profiles/:id', async (req, res) => {\n  // ... handler implementation\n});\n\nrouter.post('/profiles', async (req, res) => {\n  // ... handler implementation\n});\n\nexport default router;"
        }
      ],
      "pr": {
        "title": "Add user profiles feature",
        "body": "This PR adds user profile support:\n              \n- Adds UserProfile interface and schema\n- Implements profile API endpoints\n- Includes validation and error handling\n\nRelated to issue #123",
        "labels": [
          "feature",
          "user-profiles"
        ],
        "reviewers": [
          "sarah",
          "john"
        ],
        "draft": false
      }
    }
  }
}

This message is sent by the AI to request an action

How MCP Makes This Possible​

MCP defines three key message types that enable these integrations:

  1. Requests: Commands sent to tools (e.g., "create a PR", "modify a table")
  2. Responses: Results returned from tools (e.g., PR details, table schema)
  3. Notifications: Real-time updates from tools (e.g., new commits, schema changes)

But the real power of MCP comes from how these pieces work together. For example, when you're adding user authentication:

  1. The AI assistant can:

    • Create a new branch in GitHub
    • Add auth tables in Supabase
    • Generate API endpoints
    • Update environment configs
    • Monitor deployment status

  2. All while maintaining context about:

    • Your codebase structure
    • Database schema
    • Security requirements
    • API conventions

This creates a truly integrated development experience where your AI assistant understands and can work with your entire stack.

Transport Mechanisms: How MCP Connects​

At its core, MCP is designed to be flexible in how it transmits data between components. This flexibility allows it to adapt to different environments and use cases while maintaining a consistent protocol interface.

Local Communication: The stdio Bridge​

Think of stdio transport as a direct phone line between processes on your computer:

  • How it Works:
    • Client sends JSON messages through stdin (standard input)
    • Server responds with JSON messages via stdout (standard output)
    • Debug and error logs flow through stderr (standard error)
    • All communication happens through standard OS streams
  • Key Benefits:
    • Lower Latency
    • Perfect for development workflows
    • Seamless integration with system tools
  • Ideal Use Cases:
    • IDE integrations
    • Command-line tools
    • Local development
    • System automation

Network Communication: The SSE Bridge​

SSE transport acts more like a modern messaging app, enabling real-time communication across networks:

  • How it Works:
    • Long-lived HTTP connections for real-time updates
    • Resilient to network interruptions
    • Efficient one-way streaming from server to client
    • Standard HTTP for client requests
  • Key Benefits:
    • Works everywhere HTTP works
    • Built-in error recovery
    • Scales to thousands of clients
    • Friendly to corporate networks
  • Ideal Use Cases:
    • Cloud services
    • Collaborative tools
    • Hosted Servers
    • Web applications

Bringing It All Together​

MCP represents a significant step forward in how we build AI-powered applications. Let's recap what makes it special:

A Universal Language​

Instead of building custom integrations for every tool and data source, MCP gives us a standard way for AI models to interact with the world. This means:

  • Less time writing integration code
  • More reliable and secure connections
  • Easier to add new capabilities

Real-World Impact​

We've seen how MCP enables practical workflows like:

  • Managing code across Git repositories
  • Working with databases and APIs
  • Coordinating multiple tools in complex tasks
  • Maintaining context across different services

The Road Ahead​

As more tools adopt MCP, we're moving toward a future where AI assistants can:

  • Seamlessly work across different platforms
  • Handle complex, multi-step tasks
  • Maintain consistent context and capabilities
  • Adapt to new tools and services as they emerge

Using MCP with Promptfoo​

Want to try MCP in your own projects? Promptfoo makes it easy to experiment with MCP-enabled AI models. Here's how to get started:

Basic Setup​

Add MCP support to any provider in your promptfooconfig.yaml:

providers:
  - id: google:gemini-2.0-flash
    config:
      mcp:
        enabled: true
        server:
          command: npx
          args: ['-y', '@modelcontextprotocol/server-memory']
          name: memory

This configuration:

  • Enables MCP for your chosen AI model
  • Launches a memory-enabled MCP server
  • Connects the model to the server automatically

Advanced Usage​

Promptfoo supports sophisticated MCP setups:

  1. Multiple Servers: Connect one model to many MCP servers
  2. Remote Servers: Use hosted MCP services via HTTP
  3. Isolated Testing: Run different models with separate MCP contexts

For example, you can test how different models handle the same tools:

providers:
  - id: google:gemini-2.0-flash
    config:
      mcp:
        enabled: true
        server:
          command: npx
          args: ['-y', '@modelcontextprotocol/server-memory']
          name: gemini-memory

  - id: anthropic:messages:claude-3-5-sonnet
    config:
      mcp:
        enabled: true
        server:
          url: http://localhost:8002
          name: claude-memory

This makes it easy to:

  • Compare how different models use the same tools
  • Test agentic workflows across providers
  • Benchmark tool usage patterns

Ready to dive deeper? Check out our complete MCP guide for detailed configuration options, troubleshooting tips, and advanced features.