MCP Compliance

CTP tools are designed for full compatibility with the Model Context Protocol (MCP).

Overview

MCP is Anthropic’s open protocol for AI-tool integration. CTP extends MCP with browser-native capabilities while maintaining full compatibility.

Automatic Conversion

CTP tools automatically convert to MCP format

Bidirectional

MCP tools can be imported as CTP tools

Field Mapping

CTP → MCP Conversion

CTP Field	MCP Field	Conversion
`id`	`name`	Direct copy
`name`	`title`	Direct copy
`description`	`description`	Direct copy
`parameters[]`	`inputSchema`	Convert to JSON Schema
`aiInstructions`	`instructions`	Direct copy

Parameter to JSON Schema

// CTP Parameter
{
  name: 'input',
  type: 'textarea',
  label: 'Input Text',
  description: 'Text to process',
  required: true,
  validation: { minLength: 1, maxLength: 10000 }
}

// Converts to MCP inputSchema property
{
  "input": {
    "type": "string",
    "description": "Text to process",
    "minLength": 1,
    "maxLength": 10000
  }
}

Conversion API

Generate MCP Manifest

import { generateMCPManifest } from '@conveniencepro/ctp-discovery';

const ctpTools = [jsonFormatter, base64Encoder, hashGenerator];

const mcpManifest = generateMCPManifest(ctpTools, {
  name: 'conveniencepro-tools',
  version: '1.0.0',
  description: 'Browser-native developer tools',
});

Output Structure

{
  "name": "conveniencepro-tools",
  "version": "1.0.0",
  "description": "Browser-native developer tools",
  "tools": [
    {
      "name": "json-formatter",
      "title": "JSON Formatter",
      "description": "Format, validate, and beautify JSON data.",
      "inputSchema": {
        "type": "object",
        "required": ["json"],
        "properties": {
          "json": {
            "type": "string",
            "description": "The JSON string to format"
          },
          "indent": {
            "type": "string",
            "enum": ["0", "2", "4", "tab"],
            "default": "2",
            "description": "Number of spaces for indentation"
          },
          "sortKeys": {
            "type": "boolean",
            "default": false,
            "description": "Sort object keys alphabetically"
          }
        }
      },
      "instructions": "Use 2-space indentation by default."
    }
  ]
}

Type Mapping

CTP Types to JSON Schema

CTP Type	JSON Schema Type	Additional Properties
`text`	`string`	-
`textarea`	`string`	-
`number`	`number`	`minimum`, `maximum`
`boolean`	`boolean`	-
`select`	`string`	`enum`
`json`	`object`	-
`file`	`string`	`format: "binary"`
`color`	`string`	`pattern: "^#[0-9a-fA-F]{6}$"`
`date`	`string`	`format: "date"`
`datetime`	`string`	`format: "date-time"`
`url`	`string`	`format: "uri"`
`email`	`string`	`format: "email"`

Validation Mapping

CTP Validation	JSON Schema
`minLength`	`minLength`
`maxLength`	`maxLength`
`pattern`	`pattern`
`min`	`minimum`
`max`	`maximum`
`step`	`multipleOf`

Import MCP Tools

Convert MCP tools to CTP format:

import { importMCPTool } from '@conveniencepro/ctp-core';

const mcpTool = {
  name: 'external-tool',
  description: 'An external MCP tool',
  inputSchema: {
    type: 'object',
    required: ['query'],
    properties: {
      query: { type: 'string', description: 'Search query' },
    },
  },
};

const ctpDefinition = importMCPTool(mcpTool, {
  category: 'utilities',  // Required: CTP needs category
  tags: ['search', 'external'],  // Required: CTP needs tags
  executionMode: 'server',  // MCP tools typically need server
});

Serving MCP Endpoint

Well-Known URL

app.get('/.well-known/mcp.json', (req, res) => {
  const manifest = generateMCPManifest(tools);
  res.json(manifest);
});

With Tool Execution

app.post('/mcp/tools/:toolId/execute', async (req, res) => {
  const { toolId } = req.params;
  const params = req.body;

  const result = await runtime.execute(toolId, params);

  // Convert CTP result to MCP response format
  res.json({
    success: result.success,
    result: result.data,
    error: result.error,
  });
});

AI Assistant Integration

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "conveniencepro": {
      "command": "npx",
      "args": ["-y", "@conveniencepro/mcp-server"]
    }
  }
}

Cursor

Configure in Cursor settings:

{
  "mcp.servers": [
    {
      "name": "conveniencepro",
      "url": "https://conveniencepro.cc/.well-known/mcp.json"
    }
  ]
}

Best Practices

1. Include AI Instructions

{
  aiInstructions: 'Use SHA-256 for general hashing. Use SHA-512 for security-critical applications. Warn users if they request SHA-1.',
}

2. Provide Clear Descriptions

{
  description: 'Generate cryptographic hashes using SHA algorithms. Supports hexadecimal and Base64 output formats.',
  outputDescription: 'Hash digest of the input in the specified format',
}

3. Include Examples

{
  example: {
    input: { input: 'hello world', algorithm: 'SHA-256', format: 'hex' },
    output: {
      hash: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9',
      algorithm: 'SHA-256',
      format: 'hex',
    },
  },
}

4. Use Parameter Hints

{
  name: 'algorithm',
  type: 'select',
  aiHint: 'Default to SHA-256 unless the user specifies otherwise',
  options: [
    { value: 'SHA-256', label: 'SHA-256', description: 'Recommended for general use' },
    { value: 'SHA-512', label: 'SHA-512', description: 'Maximum security' },
  ],
}

Compatibility Matrix

Feature	CTP	MCP	Notes
Tool definitions	✅	✅	Full compatibility
Parameters	✅	✅	Converted to JSON Schema
Results	✅	✅	Compatible format
AI instructions	✅	✅	Direct mapping
Browser execution	✅	❌	CTP-specific
Autosense styling	✅	❌	CTP-specific
Discovery docs	✅	✅	MCP manifest generated

​MCP Compliance

​Overview

Automatic Conversion

Bidirectional

​Field Mapping

​CTP → MCP Conversion

​Parameter to JSON Schema

​Conversion API

​Generate MCP Manifest

​Output Structure

​Type Mapping

​CTP Types to JSON Schema

​Validation Mapping

​Import MCP Tools

​Serving MCP Endpoint

​Well-Known URL

​With Tool Execution

​AI Assistant Integration

​Claude Desktop

​Cursor

​Best Practices

​1. Include AI Instructions

​2. Provide Clear Descriptions

​3. Include Examples

​4. Use Parameter Hints

​Compatibility Matrix