Code Intelligence MCP

🚀 Code Intelligence MCP

An intelligent code suggestion MCP service that offers AI-powered recommendations for components and utility methods in AI IDEs.

🚀 Quick Start

Code Intelligence MCP is an intelligent code suggestion service based on the Model Context Protocol (MCP). It harnesses AI to analyze user requirements and recommends the most suitable components and utility methods from private code repositories, thereby enhancing code reuse and development efficiency for developers.

✨ Features

Intelligent Analysis Engine

• Requirement Understanding: Leverage AI to deeply comprehend user development intentions.
• Keyword Extraction: Automatically identify core elements within requirements.
• Complexity Assessment: Intelligently evaluate implementation difficulty and component fit.

Knowledge Base Management

• Component Knowledge Base: Manage the private UI component library, including props, events, slots, and examples.
• Method Knowledge Base: Manage the utility method library, covering parameters, return values, types, and usage.
• Relevance Algorithm: Calculate recommendation scores based on semantic matching.

Prompt Optimization

• Bidirectional Optimization: Support prompt redesign for both component and method scenarios.
• Structured Output: Generate comprehensive solutions that include import statements and implementation steps.
• Best Practices: Incorporate code standards and usage recommendations.

📦 Installation

Method 1: Use with npx (Recommended)

This is the recommended approach for integrating the MCP server with AI IDEs such as Claude Desktop.

Step 1: Prepare Configuration Files

Create a configuration directory (it is recommended to use ~/.config/ci-mcp):

mkdir -p ~/.config/ci-mcp

Download or create the following three configuration files:

1. - AI model configuration
2. - UI component knowledge base
3. - Utility method knowledge base

You can find example files in the npm package or repository.

Step 2: Configure AI IDE

Add the following to your AI IDE configuration (for example, in Claude Desktop's claude_desktop_config.json):

{
  "mcpServers": {
    "code-intelligence": {
      "command": "npx",
      "args": ["-y", "code-intelligence-mcp"],
      "env": {
        "CI_MCP_DATA_DIR": "~/.config/ci-mcp"
      }
    }
  }
}

Environment Variables:

• CI_MCP_DATA_DIR (Recommended): Specify the configuration directory. All three files will be loaded from this directory.
• CI_MCP_CONFIG: Directly specify the path to config.json.
• CI_MCP_COMPONENTS: Directly specify the path to components.json.
• CI_MCP_UTILS: Directly specify the path to utils.json.

Supported Path Formats:

• Absolute path: /Users/xxx/.config/ci-mcp
• Home directory: ~/.config/ci-mcp or $HOME/.config/ci-mcp
• Environment variables: ${MY_CONFIG_DIR}/ci-mcp

Step 3: Restart AI IDE

Restart your AI IDE (e.g., Claude Desktop), and the MCP service will automatically start via npx.

Method 2: Local Development

Prerequisites

Configure Knowledge Base Data Files The project necessitates manual configuration of the following data files in the ci-mcp-data/ directory:

1. ci-mcp-data/config.json - AI model configuration (including API Key)

cp ci-mcp-data/config.example.json ci-mcp-data/config.json
# Edit config.json and fill in your API Key

2. ci-mcp-data/components.json - UI component knowledge base

cp ci-mcp-data/components.example.json ci-mcp-data/components.json
# Edit components.json based on your private component library

- Add component information following the existing format: `description`, `import`, `relativePath`, etc.

3. ci-mcp-data/utils.json - Utility method knowledge base

cp ci-mcp-data/utils.example.json ci-mcp-data/utils.json
# Edit utils.json based on your utility method library

- Include method information: `description`, `import`, `params`, `returns`, etc.

Note:

• config.json contains sensitive information (API Key) and is added to .gitignore, so it will not be committed to the repository.
• components.json and utils.json need to be configured according to your actual code repository.
• Refer to example files like config.example.json for the configuration format.

Install Dependencies

pnpm install

Development Mode

pnpm dev

Build

pnpm build

Production Mode

pnpm start:prod

💻 Usage Examples

🎨 UI Component Suggestion Tools

1. suggest_components

Intelligently analyze UI development requirements and recommend the most appropriate private components.

Use Cases:

• Create UI features such as pages, forms, and interfaces.
• Facilitate rapid development using the private component library.
• Obtain comprehensive implementation solutions.

Input Parameters:

{
  prompt: string; // User requirement description, e.g. "Create user login page"
}

Output:

• Requirement Analysis: Keywords, component types, complexity assessment
• Suggested Components: Component list + relevance score + recommendation reason
• Optimized Prompt: Including specific component imports and usage
• Implementation Guide: Step-by-step development suggestions

Example:

// Input
{"prompt": "Generate a user information edit form"}

// Output
{
  "analysis": {
    "keywords": ["form", "edit", "user information"],
    "componentTypes": ["form", "input", "button"]
  },
  "suggestedComponents": [
    {
      "name": "das-form",
      "relevance": 0.95,
      "reason": "Most suitable for user information editing scenarios"
    }
  ],
  "redesignedPrompt": "Create using das-form component...",
  "implementationGuide": "1. Import component...\n2. Configure form fields..."
}

2. query_component

Query detailed information about a specific component.

Input Parameters:

{
  componentName: string; // Component name, e.g. "das-button"
}

Output:

• Component description, category, tags
• Props parameter list
• Events list
• Slots description
• Usage example code
• Import path

🔧 Utility Method Suggestion Tools

1. suggest_utilities

Intelligently analyze logic development requirements and recommend reusable utility methods.

Use Cases:

• Implement data processing and format conversion functions.
• Fulfill requirements for encryption, validation, and other utility functions.
• Avoid redundant development.

Input Parameters:

{
  prompt: string; // Logic requirement description, e.g. "Need to format numbers with thousand separators"
}

Output:

• Requirement Analysis: Key function points, method types
• Suggested Methods: Method list + relevance score + recommendation reason
• Optimized Prompt: Including method imports and invocation
• Implementation Guide: Usage steps and notes

Example:

// Input
{"prompt": "Implement password encryption function"}

// Output
{
  "analysis": {
    "keywords": ["encryption", "password", "security"],
    "methodTypes": ["encryption", "security"]
  },
  "suggestedUtilities": [
    {
      "name": "encryptPassword",
      "relevance": 0.98,
      "reason": "Provides MD5/SHA256 password encryption"
    }
  ],
  "redesignedPrompt": "Use encryptPassword method...",
  "implementationGuide": "1. Import method...\n2. Call encryption..."
}

2. query_utility

Query detailed information about a specific utility method.

Input Parameters:

{
  utilityName: string; // Method name, e.g. "formatNumber"
}

Output:

• Method description, category, type
• Parameter list (parameter name, type, description)
• Return value type and description
• Usage example code
• Import path

📚 Documentation

MCP Resources

code-intelligence://component-library

Component Library Resource Provides comprehensive information about the private component library, including:

• List of all available components
• Component categories and tags
• Component capability overview

code-intelligence://utility-library

Utility Method Library Resource Provides complete information about the utility method library, including:

• List of all available methods
• Method categories and functions
• Method capability overview

code-intelligence://usage-guide

Usage Guide Resource Includes:

• MCP tools usage instructions
• Best practice recommendations
• FAQs
• Integration configuration guide

Tech Stack

Core Framework

• TypeScript - Type-safe development
• Node.js - Runtime environment
• MCP SDK (@modelcontextprotocol/sdk) - Model Context Protocol implementation

AI Integration

• Vercel AI SDK - Unified AI interface
• OpenAI - GPT series model support
• Anthropic - Claude series model support
• DeepSeek - Domestic large model support

Development Tools

• pnpm - Package manager
• tsx - TypeScript executor
• ESLint + Prettier - Code standards
• Husky - Git hooks

Development Standards

• Employ TypeScript for type-safe development.
• Adhere to ESLint and Prettier code standards.
• Utilize Husky for Git hooks management.

Configuration

1. MCP Service Configuration (mcp-config.json)

Register the MCP service in the AI IDE:

{
  "mcpServers": {
    "code-intelligence": {
      "command": "/bin/zsh",
      "args": ["/path/to/code-intelligence-mcp/scripts/start.sh"]
    }
  }
}

2. AI Model Configuration (data/config.json)

Configure the AI models used by the recommendation engine:

{
  "defaultModel": "claude-3-7-sonnet-latest",
  "providers": [
    {
      "provider": "anthropic",
      "models": [
        {
          "model": "claude-3-7-sonnet-latest",
          "title": "Claude 3.7 Sonnet",
          "baseURL": "https://api.302.ai/v1",
          "apiKey": "your-api-key"
        }
      ]
    },
    {
      "provider": "openai",
      "models": [
        {
          "model": "gpt-4o",
          "title": "GPT-4o",
          "baseURL": "https://api.openai.com/v1",
          "apiKey": "your-api-key"
        }
      ]
    }
  ]
}

Configuration Description:

• defaultModel: The default model name to use, which must exist in providers.
• providers: A list of supported AI providers.
  • provider: Provider type (anthropic, openai, deepseek, ollama).
  • models: A list of model configurations for this provider.
    • model: Model name (must match defaultModel).
    • title: Model display name.
    • baseURL: API endpoint address.
    • apiKey: API key.

Supported Providers:

• anthropic - Claude series models
• openai - GPT series models
• deepseek - DeepSeek domestic models
• ollama - Local models

3. Knowledge Base Data

Component Knowledge Base (data/components.json)

{
  "components": [
    {
      "name": "das-button",
      "description": "Button component",
      "category": "Basic component",
      "tags": ["button", "interaction"],
      "props": [...],
      "events": [...],
      "example": "..."
    }
  ]
}

Utility Method Knowledge Base (data/utils.json)

{
  "utilities": [
    {
      "name": "formatNumber",
      "description": "Format number with thousand separators",
      "category": "Formatting",
      "type": "formatter",
      "params": [...],
      "returns": {...},
      "example": "..."
    }
  ]
}

📄 License

This project is licensed under the MIT License.

Contributing

We welcome contributions! Please refer to CONTRIBUTING.md for detailed instructions on how to contribute to this project.

Changelog

For version history and release notes, please see CHANGELOG.md.