CCS Verifier MCP

CCS Verifier MCP Server

Free, unlimited CCS receipt verification as a Model Context Protocol server.

What is this?

This is the Public Verifier for the CCS (Cryptographic Commitment Scheme) standard. It verifies CCS receipts using Ed25519 signatures, providing cryptographic proof that an AI evaluation occurred as claimed.

Key properties:

• ✅ Free forever - verification is a public good
• ✅ Unlimited - no rate limits, no API keys
• ✅ Open source - CC0 1.0 (public domain), self-hostable
• ✅ Model-agnostic - works with any MCP-compatible client
• ✅ Zero dependencies on LLM inference - pure cryptographic verification

Quick Start

1. Install MCP Client

This server works with any MCP-compatible client:

• Claude Desktop
• Cursor
• Continue
• Any MCP SDK implementation

2. Add to MCP Config

{
  "mcpServers": {
    "ccs-verifier": {
      "command": "npx",
      "args": ["-y", "ccs-verifier-mcp"]
    }
  }
}

3. Verify a Receipt

Ask your AI assistant:

"Verify this CCS receipt: {receipt_json}"

Or use the tool directly:

// Via MCP client
const result = await mcp.callTool('verify_receipt', {
  receipt: {
    receipt_id: "abc-123",
    evaluation_id: "eval-456",
    timestamp: 1699900000000,
    model_id: "gpt-4",
    prompt_hash: "sha256:...",
    response_hash: "sha256:...",
    commitments: ["commitment-1"],
    signature: "ed25519_signature_hex",
    public_key: "ed25519_public_key_hex"
  }
});

Available Tools

verify_receipt

Verify a CCS receipt's cryptographic integrity.

Input:

{
  "receipt": {
    "receipt_id": "string (required)",
    "evaluation_id": "string",
    "timestamp": "number (unix ms)",
    "model_id": "string",
    "prompt_hash": "string (sha256:hex)",
    "response_hash": "string (sha256:hex)",
    "commitments": "string[]",
    "signature": "string (hex, required)",
    "public_key": "string (hex, required)"
  }
}

Output:

{
  "valid": true,
  "confidence": 1.0,
  "receipt_id": "abc-123",
  "verification_id": "uuid",
  "verified_at": 1699900000000,
  "checks": [
    "structure_validation",
    "signature_verification",
    "timestamp_validation",
    "hash_integrity",
    "commitments_validation"
  ],
  "details": {
    "signature": {
      "valid": true,
      "algorithm": "Ed25519",
      "public_key": "abc123..."
    }
  }
}

get_verifier_info

Get information about the verifier (version, usage stats, pricing).

Output:

{
  "verifier": {
    "version": "1.0.0",
    "spec_version": "draft-correctover-ccs-11",
    "license": "CC0-1.0 (Public Domain)"
  },
  "usage": {
    "total_verifications": 12345,
    "successful": 12300,
    "failed": 45,
    "success_rate": "99.64%"
  },
  "pricing": {
    "verification": "FREE (unlimited)",
    "issuance": "Contact Correctover for licensing",
    "source_code": "CC0-1.0 (self-hostable)"
  }
}

generate_test_receipt

Generate a test receipt for development (requires Ed25519 private key).

⚠️ WARNING: Test receipts are for development only. Production receipts must be issued by authorized CCS issuers.

Pricing Model

This server implements the CCS ecosystem pricing:

Action	Cost	Limit
Verify receipt	FREE	Unlimited
Issue receipt	Contact Correctover	Licensed
Self-host verifier	FREE	CC0-1.0

Why is verification free?

Verification must be free and unlimited for the CCS ecosystem to work:

1. Third-party verification builds trust - anyone can verify, not just the issuer
2. Network effects - more verifiers → more trust → more issuers → more receipts
3. Public good - verification is infrastructure, not a product

How do we make money?

We charge for issuance (creating receipts), not verification. This aligns incentives:

• Issuers pay for the privilege of creating trusted receipts
• Verifiers (you) get free, unlimited verification
• The ecosystem grows because verification is frictionless

CCS Standard

This server implements draft-correctover-ccs-11, the CCS specification.

CCS provides:

• Cryptographic proof of AI evaluation
• Tamper-evident receipts
• Model-agnostic verification
• Deterministic, reproducible results

Self-Hosting

The verifier is CC0-1.0 (public domain). You can self-host it:

# Clone
git clone https://github.com/DSHCorrectover/ccs-verifier-mcp.git
cd ccs-verifier-mcp

# Install
npm install

# Run
npm start

Or use Docker:

docker run -i --rm correctover/ccs-verifier-mcp:latest

Development

# Install dependencies
npm install

# Run in dev mode (with watch)
npm run dev

# Run tests
npm test

# Build for production
npm run build

Integration Examples

LangChain

from langchain.tools import MCPTool

ccs_verifier = MCPTool.from_server(
    server_url="npx://ccs-verifier-mcp",
    tool_name="verify_receipt"
)

# Use in your chain
result = ccs_verifier.invoke({"receipt": receipt_data})

LlamaIndex

from llama_index.tools.mcp import MCPTool

ccs_verifier = MCPTool(
    command="npx",
    args=["-y", "ccs-verifier-mcp"],
    tool_name="verify_receipt"
)

Direct MCP SDK

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';

const transport = new StdioClientTransport({
  command: 'npx',
  args: ['-y', 'ccs-verifier-mcp']
});

const client = new Client({ name: 'my-app', version: '1.0.0' });
await client.connect(transport);

const result = await client.callTool('verify_receipt', { receipt });

Security

This server performs cryptographic verification only. It does not:

• Store receipts
• Transmit data to external services
• Require authentication
• Have side effects

Security properties:

• ✅ Ed25519 signature verification (128-bit security)
• ✅ SHA-256 hash validation
• ✅ Timestamp validation (24-hour window)
• ✅ Structure validation (prevents malformed input)
• ✅ No external dependencies beyond MCP SDK

Report security issues: See SECURITY.md

License

CC0 1.0 Universal (Public Domain)

You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.

Links

• CCS Standard: draft-correctover-ccs-11
• GitHub: https://github.com/DSHCorrectover/ccs-verifier-mcp
• npm: https://www.npmjs.com/package/ccs-verifier-mcp
• MCP Protocol: https://modelcontextprotocol.io
• Issues: https://github.com/DSHCorrectover/ccs-verifier-mcp/issues

---

Built by Correctover - Cryptographic evidence infrastructure for AI evaluation.