Skip to main content
Glama
lyw405

Code Intelligence MCP

by lyw405
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

Code Intelligence MCP

License: MIT Node.js Version TypeScript pnpm

English | 中文

Intelligent code suggestion MCP service that provides AI-powered component and utility method recommendations for AI IDEs.

Introduction

This is an intelligent code suggestion service based on Model Context Protocol (MCP). It analyzes user requirements through AI and recommends the most suitable components and utility methods from private code repositories, helping developers improve code reuse and development efficiency.

Core Capabilities

🎨 UI Component Intelligent Recommendation

  • Analyze UI development requirements (pages, forms, interfaces, etc.)

  • Match the most relevant private components from the knowledge base

  • Generate optimized prompts with component imports and usage

  • Provide complete implementation guides and code examples

🔧 Utility Method Intelligent Recommendation

  • Analyze logic function requirements (data processing, format conversion, utility functions, etc.)

  • Find reusable utility methods from the method knowledge base

  • Generate optimized prompts with method imports and invocation

  • Avoid reinventing the wheel and improve code quality

Related MCP server: CodeWalker

Features

Intelligent Analysis Engine

  • Requirement Understanding: Deep understanding of user development intentions based on AI

  • Keyword Extraction: Automatically identify core elements in requirements

  • Complexity Assessment: Intelligently evaluate implementation difficulty and component fit

Knowledge Base Management

  • Component Knowledge Base: Manage private UI component library (props, events, slots, examples)

  • Method Knowledge Base: Manage utility method library (parameters, return values, types, 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 complete solutions including import statements and implementation steps

  • Best Practices: Integrate code standards and usage recommendations

Project Structure

code-intelligence-mcp/
├── src/
│   ├── core/                          # Core functional modules
│   │   ├── knowledge-base.ts          # Component knowledge base management
│   │   ├── utility-knowledge-base.ts  # Utility method knowledge base management
│   │   ├── prompt-redesigner.ts       # UI component prompt redesign
│   │   ├── logic-prompt-redesigner.ts # Logic method prompt redesign
│   │   ├── ai-suggester.ts            # AI component recommendation engine
│   │   ├── ai-utility-suggester.ts    # AI method recommendation engine
│   │   └── index.ts
│   ├── config/                        # Configuration management
│   │   ├── model-manager.ts           # AI model manager
│   │   ├── ai-client-adapter.ts       # AI client adapter
│   │   ├── types.ts                   # Configuration type definitions
│   │   └── index.ts
│   ├── tools/                         # MCP tool definitions
│   │   ├── suggestion.ts              # Component suggestion tool
│   │   ├── utility-suggestion.ts      # Method suggestion tool
│   │   ├── query.ts                   # Query tool
│   │   └── index.ts
│   ├── resources/                     # MCP resource definitions
│   │   └── index.ts
│   ├── types/                         # Type definitions
│   │   └── mcp-types.ts
│   ├── utils/                         # Utility functions
│   │   ├── logger.ts                  # Logger utility
│   │   ├── ai-caller.ts               # AI unified caller
│   │   ├── path-utils.ts              # Path resolution utilities
│   │   └── index.ts
│   └── mcp-server.ts                  # MCP server main entry
├── ci-mcp-data/                       # Configuration data (user-specific)
│   ├── components.example.json        # UI component knowledge base example
│   ├── utils.example.json             # Utility method knowledge base example
│   └── config.example.json            # AI model configuration example
├── scripts/                           # Script tools
│   ├── setup.js                       # Setup script
│   └── start.sh                       # Startup script
├── package.json
├── tsconfig.json
└── .npmignore                         # NPM publish exclusions

Installation and Usage

Method 1: Use with npx (Recommended)

This is the recommended way for using the MCP server with AI IDEs like Claude Desktop.

Step 1: Prepare Configuration Files

Create a configuration directory (recommended location: ~/.config/ci-mcp):

mkdir -p ~/.config/ci-mcp

Download or create the following three configuration files:

  1. config.json - AI model configuration

  2. components.json - UI component knowledge base

  3. utils.json - Utility method knowledge base

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

Step 2: Configure AI IDE

Add to your AI IDE configuration (e.g., 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

Path Formats Supported:

  • 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 start automatically via npx.

Method 2: Local Development

Prerequisites

Configure Knowledge Base Data Files

The project requires manual configuration of the following data files in 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, will not be committed to the repository

  • components.json and utils.json need to be configured based on your actual code repository

  • Refer to example files like config.example.json for configuration format

Install Dependencies

pnpm install

Development Mode

pnpm dev

Build

pnpm build

Production Mode

pnpm start:prod

MCP Tools

🎨 UI Component Suggestion Tools

1. suggest_components

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

Use Cases:

  • Create pages, forms, interfaces and other UI features

  • Quick development using private component library

  • Get complete 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 of 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

  • Need encryption, validation and other utility functions

  • Avoid reinventing the wheel

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 of 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

MCP Resources

code-intelligence://component-library

Component Library Resource

Provides complete private component library information, including:

  • List of all available components

  • Component categories and tags

  • Component capability overview

code-intelligence://utility-library

Utility Method Library Resource

Provides complete utility method library information, 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

  • Use TypeScript for type-safe development

  • Follow ESLint and Prettier code standards

  • Use Husky for Git hooks management

Configuration

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

Register MCP service in 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 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: Default model name to use, must exist in providers

  • providers: List of supported AI providers

    • provider: Provider type (anthropic, openai, deepseek, ollama)

    • models: 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

MIT

Contributing

We welcome contributions! Please see CONTRIBUTING.md for details on how to contribute to this project.

Changelog

See CHANGELOG.md for version history and release notes.

Available Tools

4 tools
query_componentA

根据组件名称查询详细信息，包括 props、events、slots、使用示例等。用于了解推荐组件的具体用法。

ParametersJSON Schema
NameRequiredDescriptionDefault
componentNameYes要查询的组件名称，例如 "das-button"

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full transparency burden. It does disclose the type of information returned (props, events, slots, examples), but it doesn't mention side effects, permissions, or error behavior. The word 'query' implies read-only, providing some implicit reassurance, but this isn't explicitly stated.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences, immediately front-loading the action ('query component name') and purpose ('understand specific usage'). Every word earns its place with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple single-parameter query tool, the description adequately conveys the return content (props, events, slots, examples) and the use case. It doesn't address output formatting or error cases, but given the tool's simplicity and lack of output schema, these are minor gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% — the single parameter 'componentName' has a clear description with an example ('das-button'). The tool description only refers to 'component name' without adding extra semantic detail beyond what the schema already provides, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool's function: querying detailed component information by name, and enumerates the specific fields returned (props, events, slots, usage examples). This distinguishes it from sibling tools like query_utility, which likely handles utilities.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It states the tool is used to understand the specific usage of recommended components, providing clear context for when to invoke it (after a component recommendation). However, it doesn't explicitly mention when not to use it or name direct alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

query_utilityA

根据工具方法名称查询详细信息，包括参数、返回值、使用示例等。用于了解推荐工具方法的具体用法。

ParametersJSON Schema
NameRequiredDescriptionDefault
utilityNameYes要查询的工具方法名称，例如 "formatNumber"

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the transparency burden. It discloses that the tool returns parameters, return values, and usage examples, and the verb '查询' (query) implies a read-only operation. However, it does not explicitly state safety (e.g., no side effects) or other behavioral details like error conditions or permission requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the core function in the first sentence and the use case in the second. Every word is purposeful; no filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (1 parameter, no output schema) and the lack of annotations, the description adequately covers purpose, return content (parameters, return values, examples), and usage context. It could be more complete with explicit read-only confirmation or error handling notes, but for a query tool it is sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema covers 100% of the single parameter with a clear description and an example ('formatNumber'). The tool description adds little beyond the schema, merely restating the parameter's role ('根据工具方法名称'). This meets the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: '根据工具方法名称查询详细信息' (query detailed information based on utility method name). It specifies the verb (query), resource (utility method), and distinguishes from siblings like query_component (which targets components) and suggest_utilities (which suggests rather than queries).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context: '用于了解推荐工具方法的具体用法' (used to understand usage of recommended utility methods). This implies when to use it—when you have a recommended utility and need details. It doesn't explicitly mention exclusions or alternatives, but the context is unambiguous enough.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

suggest_componentsA

USE WHEN: 用户想要创建/生成/新建/开发页面、组件或界面时。分析用户需求，从私有组件库@private-basic-components中智能推荐最合适的组件，生成包含具体实现建议的优化提示词。自动触发场景："创建页面"、"生成组件"、"新建界面"、"开发表单"、"实现功能"等所有UI开发任务。

ParametersJSON Schema
NameRequiredDescriptionDefault
promptYes用户的原始需求提示词，例如"生成一个登录页面"、"创建用户列表"、"新建表单组件"

TDQS

A4.1/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of disclosing behavior. It reveals that the tool generates an optimized prompt (the output) and that it draws from a private component library. It does not mention side effects, permissions, or access constraints, but for a suggestion tool these are minimal. The disclosure of the output format adds relevant context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with 'USE WHEN' and is structured clearly, with trigger examples and a statement of the tool's behavior. It is slightly verbose due to the repeated examples of UI development tasks, but each element serves a purpose and there is no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with one input parameter and no output schema, the description adequately covers when to use it, what it does, and what it returns (an optimized prompt). It does not explicitly explain how it differs from sibling tools beyond the focus on components, but the purpose and usage context are sufficiently clear.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides a detailed description for the single 'prompt' parameter with concrete examples ('generate a login page', 'create user list'), achieving 100% schema description coverage. The tool description does not add any parameter-specific meaning beyond what the schema already offers, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: it analyzes user requirements, recommends the most suitable components from a private library (@private-basic-components), and generates an optimized prompt with implementation suggestions. It uses a specific verb ('recommend'/'suggest') and resource, and the focus on components distinguishes it from siblings like suggest_utilities and query_component.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description begins with 'USE WHEN' and lists explicit trigger scenarios (creating pages, components, interfaces, forms, etc.), providing clear usage context. However, it does not explicitly mention when not to use this tool or recommend alternatives (e.g., suggest_utilities for utility tasks), so it lacks full exclusion guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

suggest_utilitiesA

USE WHEN: 用户想要实现某些逻辑功能、数据处理、格式转换、工具函数等时。分析用户的逻辑需求，从工具方法库中智能推荐可以直接复用的方法，避免重复开发。自动触发场景："实现数据格式化"、"需要加密功能"、"时间处理"、"IP校验"、"数据转换"等所有逻辑开发任务。

ParametersJSON Schema
NameRequiredDescriptionDefault
promptYes用户的逻辑需求描述，例如"需要格式化数字显示千分位"、"实现密码加密"、"转换时间戳为日期"

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It explains that the tool analyzes the prompt and recommends directly reusable methods, which is a safe, read-only operation implied. However, it does not disclose details such as the number of recommendations, what happens when no match is found, or any limitations. This is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single block with a clear 'USE WHEN' header and a list of trigger phrases. It is not excessively long and front-loads the key usage context. The repetition of examples is somewhat redundant but does not harm clarity, so it earns a 4.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with one parameter and no output schema, the description provides sufficient context: it explains the purpose, usage, and trigger scenarios. It does not describe the return format or fallback behavior, but these are less critical given the simplicity of the tool. Overall, it is complete enough for an agent to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, and the parameter 'prompt' is well described with examples. The tool description itself does not add significant semantic value beyond what the schema already provides; it repeats similar examples. Thus, the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: analyzing user logic requirements and recommending reusable methods from a utility library. It uses specific verbs like '推荐' and mentions resource ('工具方法库'), and provides multiple trigger examples. However, it doesn't explicitly distinguish itself from sibling tools like 'suggest_components' or 'query_utility', so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit 'USE WHEN' guidance with concrete trigger scenarios (e.g., '实现数据格式化', '需要加密功能') and states it covers '所有逻辑开发任务'. This gives clear context for when to use the tool. It lacks explicit exclusions or alternatives, so it doesn't reach a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 4 tool updatesv1.0.0
    • First observedquery_component
    • First observedquery_utility
    • First observedsuggest_components
    • First observedsuggest_utilities
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.2/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose: suggesting components vs. utilities, and querying component vs. utility details. There is no overlap or ambiguity between the four tools.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern: suggest_components, query_component, suggest_utilities, query_utility. The naming is uniform and predictable.

Tool Count5/5

With exactly 4 tools, the set is well-scoped for the server's purpose of suggesting and querying components and utilities. Each tool earns its place without redundancy.

Completeness5/5

The tool surface covers the full lifecycle for the stated domain: suggestion (discovery) and query (details) for both components and utilities. There are no obvious gaps for the intended use case.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/lyw405/code-intelligence-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server