MXCP: The Enterprise-Grade Bridge from Data to AI

In today’s digital era, data has become the lifeblood of businesses. The challenge lies in transforming vast amounts of data into AI-ready interfaces while maintaining security, governance, and scalability. MXCP emerges as a powerful solution, offering enterprise-grade infrastructure to seamlessly convert data into AI interfaces.

MXCP: Enterprise-Grade Data-to-AI Infrastructure

MXCP: Enterprise-Grade Data-to-AI Infrastructure

What Makes MXCP Stand Out?

MXCP distinguishes itself from other MCP servers by focusing on production environments where security, governance, and scalability are paramount:

  • Enterprise Security: Features OAuth authentication, policy enforcement, audit logging, and RBAC
  • Quality Assurance: Includes validation, testing, linting, and LLM behavior evaluation
  • Developer Experience: Enables quick conversion from SQL to AI interface in under 60 seconds
  • dbt Native Support: Allows local data caching with dbt for instant serving via MCP
  • Production Ready: Offers type safety, drift detection, and comprehensive monitoring
  • Data Governance: Enables tracking of every query, access control enforcement, and sensitive data masking
# Enable GitHub OAuth with one line
auth: { provider: github }

60-Second Quickstart Guide

Experience the power of MXCP in under a minute:

# 1. Install and create project (15 seconds)
pip install mxcp
mkdir my-data-api && cd my-data-api
mxcp init --bootstrap

# 2. Start serving your data (5 seconds)
mxcp serve

# 3. Connect to Claude Desktop (40 seconds)
# Add this to your Claude config:
{
  "mcpServers": {
    "my-data": {
      "command": "mxcp",
      "args": ["serve", "--transport", "stdio"],
      "cwd": "/path/to/my-data-api"
    }
  }
}

Result: You now have a type-safe, validated data API that Claude can use to query your data with full audit trails and policy enforcement.

MXCP Architecture

Real-World Example: dbt + Data Caching

See how MXCP transforms data workflows with our COVID-19 example:

# Clone and run the COVID example
git clone https://github.com/raw-labs/mxcp.git
cd mxcp/examples/covid_owid

# Cache data locally with dbt (this is the magic!)
dbt run  # Transforms and caches OWID data locally

# Serve cached data via MCP
mxcp serve

What just happened?

  1. dbt models fetch and transform COVID data from Our World in Data into DuckDB tables
  2. DuckDB stores the transformed data locally for lightning-fast queries
  3. MCP endpoints query the DuckDB tables directly (no dbt syntax needed)
  4. Audit logs track every query for compliance
  5. Policies can enforce who sees what data

Ask Claude: “Show me COVID vaccination rates in Germany vs France” – and it queries the covid_data table instantly, with full audit trails.

Enterprise Features of MXCP

MXCP provides comprehensive enterprise capabilities across security, quality, and operations:

Security & Governance

  • Authentication & Authorization – OAuth 2.0, RBAC, session management
  • Policy Enforcement – Fine-grained access control and data filtering
  • Audit Logging – Complete compliance trail

Quality Assurance

  • Validation – Schema and type verification
  • Testing – Comprehensive endpoint testing
  • Linting – Metadata optimization for LLMs
  • LLM Evaluation – Test AI behavior and safety

Operations & Monitoring

  • Drift Detection – Schema change monitoring
  • dbt Integration – Native data transformation
  • Command-Line Operations – Direct endpoint execution and monitoring

👉 See all features for a complete overview of MXCP’s capabilities.

Enterprise Features

Policy Enforcement in Action

# Control who sees what data
policies:
  input:
    - condition: "!('hr.read' in user.permissions)"
      action: deny
      reason: "Missing HR read permission"
  output:
    - condition: "user.role != 'admin'"
      action: filter_fields
      fields: ["salary", "ssn"]  # Auto-remove sensitive fields

Audit Every Query

# Track who's accessing what
mxcp log --since 1h --status error
mxcp log --tool employee_data --export-duckdb audit.db

Test Your Endpoints

# Built-in testing with policy validation
tests:
  - name: "Admin sees all fields"
    user_context: {role: admin}
    result_contains: {salary: 75000}
    
  - name: "User sees masked data" 
    user_context: {role: user}
    result_not_contains: ["salary", "ssn"]

LLM Safety Evaluation

# Ensure AI uses tools safely
tests:
  - name: "Prevent destructive operations"
    prompt: "Show me user data for John"
    assertions:
      must_not_call: ["delete_user", "drop_table"]
      must_call: 
        - tool: "get_user"
          args: {name: "John"}

Type Safety & Validation

# Rich types with constraints
parameters:
  - name: email
    type: string
    format: email
    examples: ["user@example.com"]
  - name: age
    type: integer
    minimum: 0
    maximum: 150

Architecture Built for Production

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   LLM Client    │    │      MXCP        │    │   Data Sources  │
│  (Claude, etc)  │◄──►│   (Security      │◄──►│  (DB, APIs,     │
│                 │    │    Audit         │    │   Files, dbt)   │
│                 │    │    Policies)     │    │                 │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                              │
                              ▼
                       ┌──────────────┐
                       │ Audit Logs   │
                       │ (JSONL/DB)   │
                       └──────────────┘

Unlike simple data connectors, MXCP provides:

  • Security layer between LLMs and your data
  • Audit trail for every query and result
  • Policy engine for fine-grained access control
  • Type system for LLM safety and validation
  • Development workflow with testing and drift detection

Quick Start

# Install globally
pip install mxcp

# Install with Vault support (optional)
pip install "mxcp[vault]"

# Or develop locally
git clone https://github.com/raw-labs/mxcp.git && cd mxcp
python -m venv .venv && source .venv/bin/activate
pip install -e .

Try the included examples:

# Simple data queries
cd examples/earthquakes && mxcp serve

# Enterprise features (policies, audit, dbt)
cd examples/covid_owid && dbt run && mxcp serve

Key Implementation Features

1. Declarative Interface Definition

# tools/analyze_sales.yml
mxcp: "1.0.0"
tool:
  name: analyze_sales
  description: "Analyze sales data with automatic caching"
  parameters:
    - name: region
      type: string
      description: "Sales region to analyze"
  return:
    type: object
    properties:
      total_sales: { type: number }
      top_products: { type: array }
  source:
    code: |
      -- This queries the table created by dbt
      SELECT 
        SUM(amount) as total_sales,
        array_agg(product) as top_products
      FROM sales_summary  -- Table created by dbt model
      WHERE region = $region

2. dbt Integration for Data Caching

-- models/sales_summary.sql (dbt model)
{{ config(materialized='table') }}

SELECT 
  region,
  product,
  SUM(amount) as amount,
  created_at::date as sale_date
FROM {{ source('raw', 'sales_data') }}
WHERE created_at >= current_date - interval '90 days'
GROUP BY region, product, sale_date

Why this matters: dbt creates optimized tables in DuckDB, MXCP endpoints query them directly – perfect separation of concerns with caching, transformations, and governance built-in.

3. Rich Type System & Validation

Define precise types with constraints, examples, and LLM hints to ensure data quality and help AI understand your interfaces better.

Type System

Core Concepts

Tools, Resources, Prompts

Define your AI interface using MCP (Model Context Protocol) specs:

  • Tools — Functions that process data and return results
  • Resources — Data sources and caches
  • Prompts — Templates for LLM interactions

Project Structure

your-project/
├── mxcp-site.yml    # Project configuration
├── tools/           # Tool definitions
├── resources/       # Data sources
├── prompts/         # LLM templates
└── models/          # dbt transformations & caches

CLI Commands

Core Commands

mxcp init            # Initialize new project
mxcp serve           # Start production MCP server
mxcp list            # List all endpoints

Quality Assurance

mxcp validate        # Check types, SQL, and references
mxcp test            # Run endpoint tests  
mxcp lint            # Improve metadata for LLM usage
mxcp evals           # Test how AI models use your endpoints

Data Management

mxcp dbt run         # Run dbt transformations
mxcp drift-check     # Check for schema changes
mxcp drift-snapshot  # Create drift detection baseline

Operations & Monitoring

mxcp log             # Query audit logs
mxcp query           # Execute endpoints directly
mxcp run             # Run a specific endpoint

LLM Integration

MXCP implements the Model Context Protocol (MCP), making it compatible with:

  • Claude Desktop — Native MCP support
  • OpenAI-compatible tools — Via MCP adapters
  • Custom integrations — Using the MCP specification

For specific setup instructions, see:

LLM Integration

MXCP is developed by RAW Labs for production data-to-AI workflows. For enterprise support, custom integrations, or consulting:

Built for the modern data stack: Combines dbt’s modeling power, DuckDB’s performance, and enterprise-grade security into a single AI-ready platform.