Model Context Protocol (MCP)

Build AI-powered insurance workflows with the Model Context Protocol.

What is MCP?

MCP is an open standard that connects AI assistants to external tools and data sources. Think of it as USB for AI — a universal way for AI models to interact with the world.

┌─────────────────────────────────────────────────────────────────────┐
│                     HOW MCP WORKS                                   │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   ┌──────────┐         ┌─────────────┐         ┌──────────────┐    │
│   │          │         │             │         │              │    │
│   │  Claude  │◄───────►│  MCP Server │◄───────►│   Opensure   │    │
│   │    AI    │  JSON   │  (Bridge)   │   API   │   Platform   │    │
│   │          │         │             │         │              │    │
│   └──────────┘         └─────────────┘         └──────────────┘    │
│                                                                     │
│   AI Assistant         Protocol Layer          Your Data & Tools    │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Why MCP + Insurance?

Insurance operations involve complex workflows: quoting, underwriting, claims, compliance. MCP enables AI to execute these workflows, not just discuss them.

Traditional Approach	With MCP
"Here's how to file a claim..."	Actually files the claim
"You should check the policy..."	Retrieves and analyzes the policy
"The premium calculation is..."	Calculates and returns the quote

The Opportunity

MCP unlocks powerful capabilities for insurance:

1. Conversational Underwriting

Ask Claude to assess a risk, and it queries your underwriting rules, pulls loss history, and returns a decision — all through natural conversation.

2. Automated Claims Processing

"Process this claim for policy #12345" triggers document extraction, coverage verification, and reserve calculation automatically.

3. Real-Time Compliance

AI monitors transactions against regulatory requirements, flagging issues before they become problems.

4. Intelligent Document Processing

Upload a submission, and MCP tools extract structured data, validate against your schema, and populate your systems.

┌─────────────────────────────────────────────────────────────────────┐
│                    MCP INSURANCE WORKFLOW                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  User: "Quote commercial auto for ABC Trucking"                     │
│                           │                                         │
│                           ▼                                         │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                    Claude + MCP                              │   │
│  └─────────────────────────────────────────────────────────────┘   │
│           │              │              │              │            │
│           ▼              ▼              ▼              ▼            │
│   ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐       │
│   │  Lookup   │  │   Check   │  │ Calculate │  │  Return   │       │
│   │  Client   │  │  History  │  │  Premium  │  │   Quote   │       │
│   └───────────┘  └───────────┘  └───────────┘  └───────────┘       │
│                                                                     │
│  Response: "Quote ready: $12,450/year. 3 vehicles, clean MVRs."    │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Getting Started

Prerequisites

• Claude Desktop or Claude Code CLI
• Node.js 18+ (for running MCP servers)
• Opensure API access

Quick Start

1. Install the Opensure MCP Server

npm install -g @opensure/mcp-server

2. Configure Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "opensure": {
      "command": "npx",
      "args": ["@opensure/mcp-server"],
      "env": {
        "OPENSURE_API_KEY": "your-api-key"
      }
    }
  }
}

3. Start Using MCP Tools

Open Claude and try:

"List all active policies for tenant ABC"

Claude will use the MCP tools to query your Opensure instance and return results.

Available Tools

Tool	Description
list_policies	Query policies with filters
get_policy	Retrieve policy details
create_claim	File a new claim
get_client	Look up client information
calculate_premium	Run rating calculations
search_documents	Find policy documents

Architecture Deep Dive

┌─────────────────────────────────────────────────────────────────────┐
│                      MCP ARCHITECTURE                               │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                     MCP CLIENT                               │   │
│  │              (Claude Desktop / Claude Code)                  │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                              │                                      │
│                              │ stdio / SSE                          │
│                              ▼                                      │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                     MCP SERVER                               │   │
│  │                 (@opensure/mcp-server)                       │   │
│  │                                                              │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │   │
│  │  │  Tools   │  │Resources │  │ Prompts  │  │ Sampling │    │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘    │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                              │                                      │
│                              │ HTTPS                                │
│                              ▼                                      │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                   OPENSURE API                               │   │
│  │              (api.opensure.dev/api/v1/)                      │   │
│  │                                                              │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │   │
│  │  │ Policies │  │  Claims  │  │ Clients  │  │  Billing │    │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘    │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Learn More

Official Resources

• MCP Specification — The official protocol documentation
• MCP GitHub — Reference implementations and examples
• Anthropic MCP Guide — Claude-specific integration guide

Opensure Resources

• API Reference — Full Opensure API documentation
• Schema Reference — Database schema and data models
• Developer Setup — Set up your development environment

Example: Building a Claims Bot

Here's a complete example of an MCP-powered claims intake bot:

// User says: "I need to file a claim for policy POL-2025-001234"

// MCP automatically:
// 1. Validates the policy exists
const policy = await opensure.getPolicy("POL-2025-001234");

// 2. Checks coverage is active
if (policy.status !== "active") {
  return "This policy is not currently active.";
}

// 3. Creates the claim
const claim = await opensure.createClaim({
  policy_id: policy.id,
  loss_date: "2025-01-15",
  description: "Water damage from burst pipe",
  estimated_amount: 15000
});

// 4. Returns confirmation
return `Claim ${claim.claim_number} created successfully.
        An adjuster will contact you within 24 hours.`;

Security Considerations

MCP servers run locally and communicate with Claude through stdio. Your API keys never leave your machine:

┌──────────────────────────────────────────────────┐
│              YOUR LOCAL MACHINE                  │
│                                                  │
│  ┌────────────┐      ┌─────────────────────┐    │
│  │   Claude   │◄────►│    MCP Server       │    │
│  │   Desktop  │      │  (API Key stored    │    │
│  └────────────┘      │   locally only)     │    │
│                      └──────────┬──────────┘    │
│                                 │               │
└─────────────────────────────────┼───────────────┘
                                  │ HTTPS (encrypted)
                                  ▼
                        ┌─────────────────┐
                        │  Opensure API   │
                        │  (Cloud)        │
                        └─────────────────┘

• API keys are stored in your local config file
• All API communication is encrypted (HTTPS)
• MCP servers don't have network access beyond configured endpoints
• Claude cannot access tools you haven't explicitly enabled

---

Ready to build? Start with the Developer Setup →