ExMCP API Reference

This API reference provides detailed information about the Extension Model Context Protocol (ExMCP), helping you build powerful AI-enhanced extensions for ThinkCode.

Core Protocol Components

ExMCP consists of three main components that work together to enhance AI capabilities:

1. Context Providers

Context providers supply relevant information to AI models to improve their understanding and responses:

import { exmcp } from 'thinkcode';
 
// Register a context provider
export function activate(context: exmcp.ExtensionContext) {
  const provider = exmcp.registerContextProvider({
    id: 'my-context-provider',
    name: 'My Context Provider',
    
    // Define how to provide context to AI models
    provideContext: async (request) => {
      return {
        type: 'code',
        content: '// Relevant code based on request',
        metadata: {
          source: 'My Context Provider',
          relevance: 0.95,
          timestamp: Date.now()
        }
      };
    }
  });
  
  context.subscriptions.push(provider);
}

2. Model Extensions

Model extensions can enhance or modify AI model behavior:

import { exmcp } from 'thinkcode';
 
// Register a model extension
const modelExtension = exmcp.registerModelExtension({
  id: 'my-model-extension',
  name: 'My Model Extension',
  
  // Define how to transform model inputs
  transformInput: async (input) => {
    // Add additional context or modify the prompt
    return {
      ...input,
      enhancedPrompt: `Consider these best practices: [...]\n\n${input.prompt}`
    };
  },
  
  // Define how to transform model outputs
  transformOutput: async (output) => {
    // Post-process or enhance the model's response
    return {
      ...output,
      enhancedResponse: output.response.replace(/TODO/g, '// TODO:')
    };
  }
});

3. Protocol Extensions

Protocol extensions define new ways for components to communicate:

import { exmcp } from 'thinkcode';
 
// Define a custom protocol
const customProtocol = exmcp.defineProtocol({
  id: 'my-custom-protocol',
  name: 'My Custom Protocol',
  version: '1.0.0',
  
  // Define the schema for this protocol
  schema: {
    input: {
      type: 'object',
      properties: {
        query: { type: 'string' },
        options: { type: 'object' }
      },
      required: ['query']
    },
    output: {
      type: 'object',
      properties: {
        results: { type: 'array' },
        metadata: { type: 'object' }
      },
      required: ['results']
    }
  }
});
 
// Register a provider for this protocol
const protocolProvider = exmcp.registerProtocolProvider({
  protocol: customProtocol,
  handleRequest: async (request) => {
    // Process the request according to protocol
    return {
      results: [/* ... */],
      metadata: {/* ... */}
    };
  }
});

Extension Manifest

Every ExMCP extension needs a manifest file (package.json) with the following fields:

{
  "name": "my-exmcp-extension",
  "version": "1.0.0",
  "displayName": "My ExMCP Extension",
  "description": "Enhances AI capabilities with custom context",
  "engines": {
    "thinkcode": "^1.0.0"
  },
  "exmcp": {
    "version": "1.0.0",
    "main": "./dist/extension.js",
    "components": {
      "contextProviders": [
        {
          "id": "my-context-provider",
          "name": "My Context Provider",
          "description": "Provides relevant code examples"
        }
      ],
      "modelExtensions": [
        {
          "id": "my-model-extension",
          "name": "My Model Extension",
          "description": "Enhances model responses with best practices"
        }
      ],
      "protocols": [
        {
          "id": "my-custom-protocol",
          "name": "My Custom Protocol",
          "version": "1.0.0"
        }
      ]
    }
  }
}

Common API Patterns

Context Types

ExMCP supports various types of context:

// Code context
const codeContext = {
  type: 'code',
  content: '// Your code here',
  language: 'typescript', // optional
  path: 'src/index.ts',   // optional
  metadata: {/* ... */}   // optional
};
 
// Documentation context
const docsContext = {
  type: 'documentation',
  content: 'API documentation...',
  format: 'markdown',     // optional
  metadata: {/* ... */}   // optional
};
 
// Knowledge context
const knowledgeContext = {
  type: 'knowledge',
  content: 'Domain-specific information...',
  domain: 'react',        // optional
  metadata: {/* ... */}   // optional
};

Relevance Scoring

ExMCP provides utilities for scoring context relevance:

import { exmcp } from 'thinkcode';
 
// Calculate semantic similarity
const similarity = await exmcp.utils.calculateSimilarity(
  "How do I create a React component?",
  "This is how you define a React function component..."
);
 
// Rank context items by relevance
const rankedItems = await exmcp.utils.rankByRelevance(
  "How do I create a React component?",
  [contextItem1, contextItem2, contextItem3]
);