MOIDVK

The Ultimate DevKit

Version License MCP Server Built with Rust Powered by Bun

The Ultimate DevKit - A comprehensive Model Context Protocol (MCP) server that unifies development best practices across JavaScript/TypeScript, Rust, Python, and Go into a single, powerful toolkit.

MOIDVK provides 43+ intelligent development tools with security-first design, high-performance Rust core, and seamless integration with your favorite AI assistants and development environments.

✨ Key Features

🚀 Multi-Language Mastery

JavaScript/TypeScript: ESLint analysis, Prettier formatting, accessibility checks
Rust: Clippy analysis, rustfmt formatting, performance optimization, safety checks
Python: Ruff analysis, Black formatting, type checking, dependency scanning
Go: go vet analysis, gofmt/goimports formatting, security scanning, performance analysis

🔒 Security-First Architecture

Comprehensive vulnerability scanning across all languages
Production readiness validation
NASA JPL safety rule compliance checking
Secure command execution with sandbox isolation

⚡ High-Performance Core

Rust-powered vector operations and file search
NAPI bindings for seamless JavaScript integration
Local semantic embeddings for intelligent code search
Optimized algorithms for large codebases

🧠 Intelligent Development

KB-MCP bidirectional integration for enhanced workflows
Semantic code search with contextual understanding
Development session management across tools
Intelligent tool routing and optimization

🛠️ Developer Experience

43+ tools in one unified MCP server
CLI interface for standalone usage
Comprehensive error handling and fallbacks
Extensive documentation and examples

🚀 Quick Start

Installation

# Using Bun (recommended) bun install -g moidvk # Using npm npm install -g moidvk

MCP Server Setup

Add MOIDVK to your MCP client configuration:

{ "mcpServers": { "moidvk": { "command": "moidvk", "args": ["serve"], "env": {} } } }

CLI Usage

# Start the MCP server moidvk serve # Analyze JavaScript code echo "const x = 1;" | moidvk check-code # Format Rust code moidvk rust-format -f src/lib.rs # Check production readiness moidvk check-production -f server.js --strict # Semantic code search moidvk search-semantic -p /path/to/project --query "authentication logic"

🛠️ Tool Categories

🔍 Code Quality & Analysis

Tool	Language	Description
`check_code_practices`	JS/TS	ESLint analysis with pagination and filtering
`rust_code_practices`	Rust	Clippy analysis with configurable lint levels
`python_code_analyzer`	Python	Ruff-powered analysis with comprehensive rules

🎨 Code Formatting

Tool	Language	Description
`format_code`	JS/TS/CSS/HTML/MD	Prettier formatting with project config
`eslint_auto_fixer`	JS/TS	ESLint auto-fix with comprehensive linting
`multi_language_auto_fixer`	All Languages	Universal auto-fixer with language detection
`rust_formatter`	Rust	rustfmt with configurable style options
`python_formatter`	Python	Black formatting with line length control

🔒 Security & Safety

Tool	Language	Description
`scan_security_vulnerabilities`	All	Project dependency vulnerability scanning
`check_safety_rules`	JS/TS	NASA JPL safety-critical programming rules
`rust_safety_checker`	Rust	Memory safety and ownership validation
`python_security_scanner`	Python	Bandit-powered security analysis

🚀 Production & Performance

Tool	Language	Description
`check_production_readiness`	JS/TS	Production deployment validation
`rust_production_readiness`	Rust	Production deployment best practices
`rust_performance_analyzer`	Rust	Performance hotspot identification
`python_test_analyzer`	Python	Test coverage and quality metrics

♿ Accessibility & Standards

Tool	Technology	Description
`check_accessibility`	HTML/JSX/CSS	WCAG 2.2 compliance validation
`check_graphql_schema`	GraphQL	Schema validation and best practices
`check_graphql_query`	GraphQL	Query complexity and security analysis
`check_redux_patterns`	Redux	State management pattern validation

🧠 Intelligent Development

Tool	Purpose	Description
`intelligent_development_analysis`	Workflow	Optimal tool sequence orchestration
`semantic_development_search`	Search	Context-aware code search with embeddings
`development_session_manager`	Sessions	Cross-client development session management

🔧 New Critical Tools

Tool	Purpose	Description
`js_test_analyzer`	Testing	JavaScript/TypeScript test analysis and quality
`bundle_size_analyzer`	Performance	Bundle size analysis and optimization
`container_security_scanner`	Security	Docker/container security analysis
`documentation_quality_checker`	Quality	Documentation analysis and completeness
`openapi_rest_validator`	API	OpenAPI/REST API validation and compliance

🚀 New Performance & Infrastructure Tools

Tool	Purpose	Description
`js_performance_analyzer`	Performance	JavaScript/TypeScript performance analysis and optimization
`python_performance_analyzer`	Performance	Python performance hotspot detection and optimization
`cicd_configuration_analyzer`	DevOps	CI/CD pipeline analysis for GitHub Actions, GitLab CI, Jenkins
`license_compliance_scanner`	Compliance	License compatibility and compliance scanning
`environment_config_validator`	Config	Environment configuration validation and security

🏗️ Architecture

High-Performance Core

┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐ │ JavaScript │ │ Rust Core │ │ Python Tools │ │ Tools & MCP │◄──►│ (NAPI Bridge) │◄──►│ Integration │ │ Server │ │ │ │ │ └─────────────────┘ └──────────────────┘ └─────────────────┘ ▲ ▲ ▲ │ │ │ ▼ ▼ ▼ ┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐ │ Development │ │ Vector Ops & │ │ Security & │ │ Intelligence │ │ Embeddings │ │ Validation │ └─────────────────┘ └──────────────────┘ └─────────────────┘

Integration Layer

KB-MCP Bidirectional Integration: Intelligent routing between MOIDVK and KB-MCP
Semantic Search: Local embeddings with cross-project intelligence
Session Management: Persistent development context across tools
Security Sandbox: Isolated command execution with comprehensive validation

📊 Performance Metrics

Vector Operations: 10x faster than pure JavaScript implementations
File Search: Rust-powered search across large codebases
Memory Usage: Optimized with intelligent caching and cleanup
Tool Execution: Sub-second response times for most operations
Concurrent Processing: Up to 5 parallel tool executions

🔧 Configuration

Basic Configuration (`.mcp.json`)

{ "mcpServers": { "moidvk": { "command": "moidvk", "args": ["serve"], "env": {}, "integration": { "kbMcp": { "enabled": true, "intelligentRouting": true, "preferredTools": { "semanticSearch": "hybrid", "codeAnalysis": "moidvk", "securityScanning": "moidvk" } } } } } }

Advanced Features

Intelligent Routing: Automatic tool selection based on context
Caching: Result caching with configurable TTL
Error Handling: Comprehensive fallback mechanisms
Performance Monitoring: Built-in metrics and optimization

🤝 Integration Examples

Claude Desktop

{ "mcpServers": { "moidvk": { "command": "moidvk", "args": ["serve"] } } }

VS Code with MCP Extension

{ "mcp.servers": [ { "name": "moidvk", "command": "moidvk serve" } ] }

Programmatic Usage

import { createMCPClient } from '@modelcontextprotocol/client'; const client = createMCPClient({ command: 'moidvk', args: ['serve'], }); const result = await client.callTool('check_code_practices', { code: 'const x = 1;', production: true, });

🚀 Development

Prerequisites

Bun v1.0+ (recommended) or Node.js v18+
Rust v1.70+ (for building native components)
Python v3.8+ (for Python tool integration)

Building from Source

# Clone the repository git clone https://github.com/moidvk/moidvk cd moidvk # Install dependencies bun install # Build Rust core bun run build:rust # Start development server bun run dev

Running Tests

# Run comprehensive test suite bun test # Test specific language tools bun test:rust bun test:python bun test:javascript

Project Structure

moidvk/ ├── lib/ │ ├── tools/ # Language-specific analysis tools │ ├── rust-core/ # High-performance Rust implementations │ ├── security/ # Security and safety validation │ ├── integration/ # KB-MCP and external integrations │ └── local-ai/ # Semantic search and embeddings ├── docs/ # Comprehensive documentation ├── test/ # Test suites and examples └── scripts/ # Build and deployment scripts

📚 Documentation

Getting Started Guide - Setup and first steps
Tool Reference - Complete tool documentation
Integration Guide - MCP client integration
Development Guide - Contributing and development
API Documentation - Technical specifications

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Workflow

Fork the repository
Create a feature branch
Make your changes with tests
Run the full test suite
Submit a pull request

Code Standards

All code must pass security scans
Maintain test coverage above 80%
Follow language-specific style guides
Document new features and APIs

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Model Context Protocol - Foundation for tool integration
Bun - Fast JavaScript runtime and toolkit
Rust - Systems programming language for performance-critical components
Community Contributors - Thanks to all who make MOIDVK better

Built with ❤️ by the MOIDVK team

Website • Documentation • Issues • Discussions

This server cannot be installed

security - not tested

license - not found

quality - not tested

How are these scores calculated?

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

A comprehensive Model Context Protocol (MCP) server that provides 37+ intelligent development tools across JavaScript/TypeScript, Rust, and Python with security-first design and high-performance features.

Related MCP Servers

MCP-Guide
qpd-v
A
security
A
license
A
quality
A beginner-friendly Model Context Protocol (MCP) server that helps users understand MCP concepts, provides interactive examples, and lists available MCP servers. This server is designed to be a helpful companion for developers working with MCP. Also comes with a huge list of servers you can install.
Last updated -
3
24
63
Apache 2.0
MCP Framework
ronangrant
-
security
F
license
-
quality
A TypeScript framework for building Model Context Protocol (MCP) servers with automatic discovery and loading of tools, resources, and prompts.
Last updated -
0
MCPKit
ribeirogab
A
security
A
license
A
quality
A simple TypeScript library for creating Model Context Protocol (MCP) servers with features like type safety, parameter validation, and a minimal code API.
Last updated -
1
1
1
MIT License
AgentModeofficial
agentmode
A
security
F
license
A
quality
An all-in-one Model Context Protocol (MCP) server that connects your coding AI to numerous databases, data warehouses, data pipelines, and cloud services, streamlining development workflow through seamless integrations.
Last updated -
3

View all related MCP servers