Skip to main content
Glama

SSD-AI

npm version License: MIT MCP Compatible Tests Coverage

AI Development Assistant based on Model Context Protocol

TypeScript + Python Support · 36 Specialized Tools · Intelligent Memory Management · Code Analysis · Reasoning Framework · Tasks Support

English | 한국어


Table of Contents


Related MCP server: Code-MCP

Overview

Hi-AI is an AI development assistant that implements the Model Context Protocol (MCP) standard. It provides 36 specialized tools through natural language keyword recognition, helping developers perform complex tasks intuitively.

Core Values

  • Natural Language: Execute tools automatically through Korean/English keywords

  • Intelligent Memory: Context management and compression using SQLite

  • Multi-Language Support: TypeScript, JavaScript, Python code analysis

  • Performance Optimization: Project caching system

  • Enterprise Quality: 100% test coverage and strict type system

  • Long-Running Support: Task management for asynchronous operations

  • Large-Scale Data: Cursor-based pagination


Key Features

1. Memory Management System

10 tools for maintaining context across sessions:

  • Intelligent Storage: Information classification and priority management by category

  • Context Compression: Priority-based context compression system

  • Session Restoration: Perfect recreation of previous work states

  • SQLite-Based: Concurrent control, indexing, transaction support

Key Tools:

  • save_memory - Store information in long-term memory

  • recall_memory - Search stored information

  • auto_save_context - Automatic context saving

  • restore_session_context - Session restoration

  • prioritize_memory - Memory priority management

2. Semantic Code Analysis

AST-based code analysis and navigation tools:

  • Symbol Search: Locate function, class, variable positions across projects

  • Reference Tracking: Track all usages of specific symbols

  • Multi-Language: TypeScript, JavaScript, Python support

  • Project Caching: Performance optimization through LRU cache

Key Tools:

  • find_symbol - Search for symbol definitions

  • find_references - Find symbol references

3. Code Quality Analysis

Comprehensive code metrics and quality evaluation:

  • Complexity Analysis: Cyclomatic, Cognitive, Halstead metrics

  • Coupling/Cohesion: Structural soundness evaluation

  • Quality Scores: A-F grade system

  • Improvement Suggestions: Actionable refactoring recommendations

Key Tools:

  • analyze_complexity - Complexity metric analysis

  • validate_code_quality - Code quality evaluation

  • check_coupling_cohesion - Coupling/cohesion analysis

  • suggest_improvements - Improvement suggestions

  • apply_quality_rules - Quality rule application

  • get_coding_guide - Coding guide lookup

4. Project Planning Tools

Systematic requirements analysis and roadmap generation:

  • PRD Generation: Automatic product requirements document creation

  • User Stories: Story writing including acceptance criteria

  • MoSCoW Analysis: Requirements prioritization

  • Roadmap Creation: Step-by-step development schedule planning

Key Tools:

  • generate_prd - Product requirements document generation

  • create_user_stories - User story creation

  • analyze_requirements - Requirements analysis

  • feature_roadmap - Feature roadmap creation

5. Sequential Thinking Tools

Structured problem solving and decision making support:

  • Problem Decomposition: Break down complex problems step by step

  • Thinking Chains: Sequential reasoning process generation

  • Multiple Perspectives: Analytical/Creative/Systematic/Critical thinking

  • Execution Plans: Convert tasks into executable plans

Key Tools:

  • create_thinking_chain - Thinking chain creation

  • analyze_problem - Problem analysis

  • step_by_step_analysis - Step-by-step analysis

  • break_down_problem - Problem decomposition

  • think_aloud_process - Thinking process expression

  • format_as_plan - Plan formatting

6. Prompt Engineering

Prompt quality improvement and optimization:

  • Automatic Enhancement: Convert vague requests to specific ones

  • Quality Evaluation: Score clarity, specificity, contextuality

  • Structuring: Goal, background, requirements, quality criteria

Key Tools:

  • enhance_prompt - Prompt enhancement

  • analyze_prompt - Prompt quality analysis

7. Browser Automation

Web-based debugging and testing:

  • Console Monitoring: Browser console log capture

  • Network Analysis: HTTP request/response tracking

  • Cross-Platform: Chrome, Edge, Brave support

Key Tools:

  • monitor_console_logs - Console log monitoring

  • inspect_network_requests - Network request analysis

8. UI Preview

Pre-coding UI layout visualization:

  • ASCII Art: Support for 6 layout types

  • Responsive Preview: Desktop/mobile views

  • Pre-Approval: Confirm structure before coding

Key Tools:

  • preview_ui_ascii - ASCII UI preview

9. Time Utilities

Various format time queries:

Key Tools:

  • get_current_time - Current time query (ISO, UTC, timezones, etc.)

10. Tasks and Pagination Support

Long-running operations and large-scale data processing:

  • Tasks: MCP 2025-11-25 experimental feature for long-running task management

  • Pagination: Cursor-based pagination for large dataset processing

  • Asynchronous Operations: Execute complex analysis tasks in background

  • Status Tracking: Real-time task progress monitoring

Tasks-Enabled Tools:

  • find_symbol, find_references (semantic analysis)

  • analyze_complexity, check_coupling_cohesion, validate_code_quality, suggest_improvements (code quality)

  • analyze_requirements, feature_roadmap, generate_prd (project planning)

  • apply_reasoning_framework, enhance_prompt_gemini (reasoning and prompts)


v1.6.0 Update

New Features (2025-01-27)

Tasks Support (Experimental MCP Feature)

Long-Running Task Management

  • Implementation of MCP 2025-11-25 Tasks specification

  • Execute complex analysis tasks in background

  • Real-time task status tracking and monitoring

  • TTL-based automatic cleanup (default 5 minutes, max 1 hour)

Tasks API

  • tasks/get - Query task status

  • tasks/result - Query task result (wait until completion)

  • tasks/list - List all tasks (with pagination)

  • tasks/cancel - Cancel running task

  • notifications/tasks/status - Status change notifications

Task-Enabled Tools (11 tools)

  • Semantic Analysis: find_symbol, find_references

  • Code Quality: analyze_complexity, check_coupling_cohesion, validate_code_quality, suggest_improvements

  • Project Planning: analyze_requirements, feature_roadmap, generate_prd

  • Reasoning/Prompts: apply_reasoning_framework, enhance_prompt_gemini

Pagination Support

Cursor-Based Pagination

  • MCP specification compliant cursor-based implementation

  • Efficient processing of large lists

  • Enhanced security through opaque cursors

Supported List Operations

  • tools/list - Tool list (20 items by default)

  • resources/list - Resource list

  • prompts/list - Prompt list

  • tasks/list - Task list

Integration Effects

  • Asynchronous Operation Support: Execute complex analysis in background

  • Large-Scale Data Processing: Improved memory efficiency through pagination

  • Real-Time Monitoring: Task progress tracking

  • Enhanced User Experience: Perform other tasks during long operations


Installation

System Requirements

  • Node.js 18.0 or higher

  • TypeScript 5.0 or higher

  • MCP-compatible client (Claude Desktop, Cursor, Windsurf)

  • Python 3.x (for Python code analysis)

Installation Methods

NPM Package

# Global installation
npm install -g @ssdeanx/ssd-ai

# Local installation
npm install @ssdeanx/ssd-ai

Smithery Platform

# One-click installation
https://smithery.ai/server/@su-record/hi-ai

MCP Client Configuration

Add to your Claude Desktop or other MCP client's configuration file:

{
  "mcpServers": {
    "hi-ai": {
      "command": "hi-ai",
      "args": [],
      "env": {}
    }
  }
}

Tool Catalog

Complete Tool List (36 tools)

Category

Count

Tool List

Memory

10

save_memory, recall_memory, list_memories, search_memories, delete_memory, update_memory, auto_save_context, restore_session_context, prioritize_memory, start_session

Semantic

2

find_symbol, find_references

Thinking

6

create_thinking_chain, analyze_problem, step_by_step_analysis, break_down_problem, think_aloud_process, format_as_plan

Reasoning

1

apply_reasoning_framework

Code Quality

6

analyze_complexity, validate_code_quality, check_coupling_cohesion, suggest_improvements, apply_quality_rules, get_coding_guide

Planning

4

generate_prd, create_user_stories, analyze_requirements, feature_roadmap

Prompt

2

enhance_prompt, analyze_prompt

Browser

2

monitor_console_logs, inspect_network_requests

UI

1

preview_ui_ascii

Time

1

get_current_time

Tasks-Enabled Tools (11 tools)

The following tools support long-running operations through Tasks:

  • Semantic Analysis: find_symbol, find_references

  • Code Quality: analyze_complexity, check_coupling_cohesion, validate_code_quality, suggest_improvements

  • Project Planning: analyze_requirements, feature_roadmap, generate_prd

  • Reasoning/Prompts: apply_reasoning_framework, enhance_prompt_gemini

Keyword Mapping Examples

Memory Tools

Tool

English

Korean

save_memory

remember, save this

기억해, 저장해

recall_memory

recall, remind me

떠올려, 기억나

auto_save_context

commit, checkpoint

커밋, 저장

Code Analysis Tools

Tool

English

Korean

find_symbol

find function, where is

함수 찾아, 클래스 어디

analyze_complexity

complexity, how complex

복잡도, 복잡한지

validate_code_quality

quality, review

품질, 리뷰

Tasks Tools

Tool

English

Korean

tasks/get

task status, progress

작업 상태, 진행 상황

tasks/result

get result, wait for completion

결과 가져와, 완료될 때까지

tasks/cancel

cancel task, stop

작업 취소, 중지해


Architecture

System Structure

graph TB
    subgraph "Client Layer"
        A[Claude Desktop / Cursor / Windsurf]
    end

    subgraph "MCP Server"
        B[Hi-AI v1.6.0]
    end

    subgraph "Core Libraries"
        C1[MemoryManager]
        C2[ContextCompressor]
        C3[ProjectCache]
        C4[PythonParser]
        C5[TaskManager]
    end

    subgraph "Tool Categories"
        D1[Memory Tools x10]
        D2[Semantic Tools x2]
        D3[Thinking Tools x6]
        D4[Quality Tools x6]
        D5[Planning Tools x4]
        D6[Prompt Tools x2]
        D7[Browser Tools x2]
        D8[UI Tools x1]
        D9[Time Tools x1]
        D10[Tasks Support]
    end

    subgraph "Data Layer"
        E1[(SQLite Database)]
        E2[Project Files]
        E3[Task Store]
    end

    A <--> B
    B --> C1 & C2 & C3 & C4 & C5
    B --> D1 & D2 & D3 & D4 & D5 & D6 & D7 & D8 & D9 & D10
    C1 --> E1
    C3 --> E2
    C4 --> E2
    C5 --> E3
    D1 --> C1 & C2
    D2 --> C3 & C4
    D4 --> C4
    D10 --> C5

Core Components

TaskManager

  • Role: Lifecycle management of long-running tasks

  • Features: Task creation, status tracking, result storage, TTL management

  • States: working, input_required, completed, failed, cancelled

  • Notifications: Real-time status change notifications

Pagination System

  • Role: Efficient processing of large list data

  • Method: Cursor-based pagination

  • Security: Prevent data exposure through opaque cursors

Data Flow

User Input (Natural Language)
    ↓
Keyword Matching (Tool Selection)
    ↓
Tasks Support Check
    ↓
Normal Execution or Task Creation
    ↓
Asynchronous Execution (Tasks)
    ↓
Status Polling or Real-time Notifications
    ↓
Result Return

Performance

Major Optimizations

Project Caching

  • Performance improvement for repeated analysis through LRU cache

  • Maintain latest state with 5-minute TTL

  • Resource management through memory limits

Memory Operations

  • Batch operation optimization through SQLite transactions

  • Time complexity improvement: O(n²) → O(n)

  • Fast lookup through indexing

Tasks Optimization

  • Improved UI responsiveness through background execution

  • Prevent memory leaks through TTL-based automatic cleanup

  • Efficient monitoring through status-based polling

Response Format

  • Switch to concise response format

  • Output focused on core information

v1.5.0 Response Example:

{
  "action": "save_memory",
  "key": "test-key",
  "value": "test-value",
  "category": "general",
  "timestamp": "2025-01-16T12:34:56.789Z",
  "status": "success",
  "metadata": { ... }
}

v1.6.0 Response Example:

✓ Saved: test-key
Category: general

Development Guide

Environment Setup

# Clone repository
git clone https://github.com/ssdeanx/ssd-ai.git
cd ssd-ai

# Install dependencies
npm install

# Build
npm run build

# Development mode
npm run dev

Testing

# Run all tests
npm test

# Watch mode
npm run test:watch

# UI mode
npm run test:ui

# Coverage report
npm run test:coverage

Code Style

  • TypeScript: strict mode

  • Types: Use src/types/tool.ts

  • Tests: Maintain 100% coverage

  • Commits: Conventional Commits format

Adding New Tools

  1. Create file in src/tools/category/ directory

  2. Implement ToolDefinition interface

  3. Register tool in src/index.ts

  4. Write tests in tests/unit/ directory

  5. Update README

Pull Request

  1. Create feature branch: feature/tool-name

  2. Write and pass tests

  3. Confirm successful build

  4. Create PR and request review


Contributors

Special Thanks

  • Smithery - MCP server deployment and one-click installation platform


License

MIT License - Free to use, modify, and distribute


Citation

If you use this project for research or commercial purposes:

@software{hi-ai2024,
  author = {ssdeanx},
  title = {Hi-AI: Natural Language MCP Server for AI-Assisted Development},
  year = {2024},
  version = {1.6.0},
  url = {https://github.com/su-record/hi-ai}
}

Star History

Star History Chart

Hi-AI v1.6.0

Tasks Support · Cursor-Based Pagination · 36 Specialized Tools · 122 Tests · 100% Coverage

Made with ❤️ by Su

🏠 Homepage · 📚 Documentation · 🐛 Issues · 💬 Discussions

Available Tools

36 tools
analyze_complexityC

complexity|how complex|complexity|how complex|difficulty - Analyze code complexity

Inputs: code (required), metrics.

analyze_problemC

analyze this|how to approach|break this down|problem analysis|examine|investigate - Break down complex problem into structured steps

Inputs: problem (required), domain.

analyze_promptC

analyze prompt|rate this|score|how good|prompt quality|evaluate prompt|assess - Analyze prompt quality and provide improvement suggestions

Inputs: prompt (required), criteria.

analyze_requirementsD

requirements analysis|what we need|requirements analysis|what we need|analyze requirements|essential features - Analyze project requirements

Inputs: requirements (required), stakeholders, constraints, analysisMethod.

apply_quality_rulesD

apply rules|apply standards|apply rules|apply standards|follow conventions|apply - Apply quality rules

Inputs: scope (required), language.

apply_reasoning_frameworkC

reasoning framework|systematic analysis|logical thinking|structured reasoning|methodical approach - Apply 9-step reasoning framework to analyze complex problems systematically

Inputs: problem (required), context, focus_steps.

auto_save_contextC

commit|checkpoint|backup|compress|auto-save - Auto-save and compress context

Inputs: urgency (required), contextType (required), sessionId, summary, +2 more.

break_down_problemB

break down|divide|split into parts|decompose|step by step|subdivide - Break complex problems into sub-problems

Inputs: problem (required), maxDepth, approach.

check_coupling_cohesionC

coupling|cohesion|coupling|cohesion|dependencies check|module structure - Check coupling and cohesion

Inputs: code (required), type, checkDependencies.

create_thinking_chainC

thinking process|chain of thought|reasoning chain|thought flow|sequential thinking - Create sequential thinking chain

Inputs: topic (required), steps.

create_user_storiesB

story|user story|user story|user stories|as a user - Generate user stories from requirements

Inputs: features (required), userTypes, priority, includeAcceptanceCriteria.

delete_memoryC

forget|delete|remove|erase - Delete specific memory

Inputs: key (required).

enhance_promptA

be specific|more detail|clarify|elaborate|vague|enhance|improve prompt - Transform vague requests into clear, actionable prompts

Inputs: prompt (required), context, enhancement_type.

enhance_prompt_geminiC

prompt improvement|gemini strategies|quality improvement|prompt enhancement|gemini strategies|quality improvement - Enhance prompts using Gemini API prompting strategies (Few-Shot, Output Format, Context)

Inputs: prompt (required), agent_role, strategies.

feature_roadmapC

roadmap|schedule|timeline|roadmap|timeline|project plan|development schedule - Generate development roadmap

Inputs: projectName (required), features (required), timeframe, approach, +1 more.

find_referencesC

where used|references|usages|find usage|references|where used - Find symbol references

Inputs: symbolName (required), projectPath (required), filePath, line.

find_symbolC

find function|where is class|variable location|find function|where is|locate - Find symbol definitions

Inputs: symbolName (required), projectPath (required), symbolType.

format_as_planC

as a plan|organize|checklist|format as plan|make a plan|organize this|checklist - Format content into clear plans

Inputs: content (required), priority, includeTimeEstimates, includeCheckboxes.

generate_prdC

PRD|product requirements document|product requirements|requirements document|spec document - Generate Product Requirements Document

Inputs: productName (required), productVision (required), targetAudience, businessObjectives, +2 more.

get_coding_guideC

guide|rules|convention|guide|rules|convention|standards|best practices - Get coding guide

Inputs: name (required), category.

get_current_timeB

what time|current time|time now|get time - Get current time

Inputs: format, timezone.

inspect_network_requestsC

network|API calls|check requests|network|API calls|check requests|network traffic - Inspect network requests

Inputs: url (required), filterType, includeHeaders.

list_memoriesC

list|saved items|show saved|what memories - List saved memories

Inputs: category, limit.

monitor_console_logsC

console log|check errors|show logs|console|check logs|debug output|console errors - Monitor browser console

Inputs: url (required), logLevel, duration.

preview_ui_asciiC

create page|build UI|design component|make page|develop page - Preview UI before coding

Inputs: page_name (required), components (required), layout_type, width, +1 more.

prioritize_memoryC

important|priority|prioritize|what matters - Prioritize memories by importance

Inputs: currentTask (required), criticalDecisions, codeChanges, blockers, +1 more.

recall_memoryC

recall|remember|what was|remind|retrieve - Retrieve from memory

Inputs: key (required), category.

restore_session_contextC

restore|revert|go back|recover session - Restore previous session context

Inputs: sessionId (required), restoreLevel, filterType.

save_memoryB

remember|save|store|memorize|keep - Save to long-term memory

Inputs: key (required), value (required), category.

search_memoriesB

find|search|look for|query memories - Search memories by content

Inputs: query (required), category.

start_sessionC

hi-ai|hello|start|begin session - Start session with context

Inputs: greeting, loadMemory, loadGuides, restoreContext.

step_by_step_analysisC

step by step|one at a time|gradually|step by step|one by one|gradually - Perform detailed step-by-step analysis

Inputs: task (required), context, detailLevel.

suggest_improvementsC

improve|make better|refactoring|improve|make better|refactor|optimize|enhance code - Suggest improvements

Inputs: code (required), focus, priority.

think_aloud_processC

think about|consider|what do you think|think about it|let me think|reasoning - Generate think-aloud reasoning process

Inputs: scenario (required), perspective, verbosity.

update_memoryC

update|modify|change|edit memory - Update existing memory

Inputs: key (required), value (required), append.

validate_code_qualityC

quality|review|check|quality|review code|check quality|validate|code review - Validate code quality

Inputs: code (required), type, strict, metrics.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.4/5.0

    Scored across 36 tools

    Disambiguation2/5

    Multiple tools have overlapping purposes that could cause confusion, such as analyze_problem, break_down_problem, and step_by_step_analysis all focusing on problem decomposition; enhance_prompt and enhance_prompt_gemini both targeting prompt improvement; and analyze_prompt, analyze_requirements, and generate_prd all dealing with requirements analysis. While descriptions provide some differentiation, the boundaries between these tools are unclear, leading to potential misselection.

    Naming Consistency4/5

    The tools mostly follow a consistent verb_noun naming pattern (e.g., analyze_complexity, create_user_stories, delete_memory), which is predictable and readable. There are minor deviations like auto_save_context (which uses a hyphen-like structure) and start_session (which is more imperative), but overall the naming is coherent and follows a clear convention throughout the set.

    Tool Count2/5

    With 36 tools, the count feels excessive for a general-purpose AI assistant server, leading to potential cognitive overload and redundancy. While the domain is broad (covering analysis, memory, coding, etc.), many tools could be consolidated (e.g., multiple analysis tools), making the surface heavy and less scoped than ideal for efficient agent use.

    Completeness3/5

    The tool set covers a wide range of domains like analysis, memory management, coding, and UI, but there are notable gaps in lifecycle coverage. For example, in memory operations, there are save, delete, update, list, search, and recall tools, which is fairly complete, but in analysis, there is no clear update or delete for generated artifacts like PRDs or roadmaps. The surface is functional but not fully cohesive for end-to-end workflows.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      D
      maintenance
      A simple AI development tool that helps users interact with AI through natural language commands, offering 29 tools across thinking, memory, browser, code quality, planning, and time management capabilities.
      35
      49 npm
      3
      MIT
    • F
      license
      B
      quality
      Not graded
      maintenance
      Turns AI assistants into full-stack software engineers with 36 tools for cognitive reasoning, code validation, project scaffolding, and AI/IDE configuration generation across 130+ programming languages, databases, and frameworks.
      35
      13 npm
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides AI-powered development assistance with continuous chain-of-thought reasoning (CoConuT), automated task planning and execution, quality validation, and persistent memory of project context and decisions.
      11 npm
      2
      MIT