Skip to main content
Glama

Atlas MCP Server

npm version npm downloads License: MIT TypeScript Node.js

Enterprise-Grade Agentic AI Pipeline for Modern IDEs

Advanced AI/ML-powered development tools with RAG search, ML bug prediction, intelligent code migration, and comprehensive test generation.

Installation • Features • Tools • Usage • Documentation


Overview

Atlas MCP Server transforms your IDE with intelligent development capabilities through a comprehensive analysis pipeline:

Intent → Context → Decomposition → Variants → Critique → Optimization

Natively integrated with Cursor, Windsurf, Claude Desktop, GitHub Copilot, and VS Code.


Related MCP server: FastApply MCP Server

What's New in Latest Version

Advanced Development Tools Suite

The latest version introduces six powerful tools designed to address complex development challenges:

New Advanced Analysis Tools:

Enhanced Development Experience:

Frontend Developer Tools

Comprehensive suite for modern frontend development:


Senior Developer Tools

Expert-level guidance and analysis:

AI/ML Powered Tools

Advanced machine learning capabilities:

Core Professional Tools

Essential development utilities:


Key Features

AI/ML Capabilities

  • RAG Search - Semantic code understanding with knowledge graphs

  • ML Prediction - Bug & performance forecasting (70-85% accuracy)

  • Code Migration - 12 intelligent migration types

  • Test Generation - Advanced test suites with edge cases

  • Bug Oracle - Predictive bug detection and prevention

  • Semantic Search - Natural language code discovery

Professional Tools

  • Full Pipeline - Intent → Context → Variants → Optimize

  • Quality Analysis - Code review, security, complexity

  • Performance - Profiling, bottleneck detection

  • Automation - Tests, docs, refactoring

  • Tech Debt - Quantification and tracking

  • Merge Resolution - Intelligent conflict handling

Why Choose Atlas?

  • Zero Configuration: No API keys required - leverages your IDE's built-in AI (Copilot/Cursor)

  • 33 Professional Tools: Comprehensive suite covering all development needs

  • Agentic Workflow: DAG-based task decomposition for complex problems

  • Context Aware: Deep project structure, dependencies, and git history analysis

  • High Performance: LRU caching, request deduplication, parallel execution

  • Enterprise Ready: Production-grade tools with security and compliance features


Installation

Step 1: Install Globally

Open your terminal and run:

npm install -g atlas-pipeline-mcp

Step 2: Run Auto-Setup

Automatically configure your IDE (Cursor or VS Code):

atlas-mcp-setup

Step 3: Restart IDE

Restart your editor. The Atlas server will be automatically connected and ready to use.


Available Tools

Advanced Development & Analysis Tools

AI/ML Powered Tools

Core Pipeline & Analysis Tools

Quality & Optimization Tools

Senior Developer Tools

UI/UX Design Tools

Frontend Developer Tools

Development Productivity Tools

Utility Tools


Usage Guide

Once installed, interact with your AI Assistant (Copilot Chat or Cursor Chat). The appropriate tool is automatically activated based on your request.

Advanced Development Tools

Goal

Example Request

Tool Used

Predict Bugs

"Analyze bug probability in this module"

atlas_bug_oracle

Get Code Suggestions

"Suggest improvements for this function"

atlas_code_whisperer

Large-Scale Refactoring

"Refactor the entire authentication system"

atlas_codebase_surgeon

Search by Intent

"Find where we handle payment processing"

atlas_semantic_search

Resolve Conflicts

"Help resolve this merge conflict intelligently"

atlas_smart_merge

Measure Tech Debt

"Quantify technical debt in this project"

atlas_tech_debt

AI/ML Tools

Goal

Example Request

Tool Used

Semantic Code Search

"Search for authentication code using RAG"

atlas_rag_search

Predict Issues

"Predict bug probability in payment-processor.ts"

atlas_ml_predict

Migrate Codebase

"Migrate this file from JavaScript to TypeScript"

atlas_migrate

Advanced Testing

"Generate comprehensive tests with edge cases"

atlas_testgen_advanced

Professional Development Tools

Goal

Example Request

Tool Used

Full Pipeline

"Run the pipeline on utils.ts to refactor it"

atlas_pipeline

Refactor Code

"Refactor this code and reduce complexity"

atlas_refactor

Performance Analysis

"Profile this code for performance bottlenecks"

atlas_profiler

Code Review

"Review this PR for quality and security"

atlas_review

Check Dependencies

"Analyze dependencies and find unused packages"

atlas_dependencies

Plan Feature

"Decompose the task of adding JWT auth"

atlas_decompose

Explore Solutions

"Generate 3 variants for this button component"

atlas_variants

Review Code

"Critique this code for security issues"

atlas_critique

Polish Code

"Optimize this function based on best practices"

atlas_optimize

Security Scan

"Scan this code for security vulnerabilities"

atlas_security

Generate Tests

"Generate tests for this authentication module"

atlas_test

Add Documentation

"Document this API with examples"

atlas_docs

Understand Code

"Explain how this algorithm works"

atlas_explain

Debug Error

"Debug this TypeError, here's the stack trace..."

atlas_debug

Complex Reasoning

"Think through how to design this system"

atlas_think

Project Context

"Analyze the project context and dependencies"

atlas_context


Advanced Integration

Using Local LLMs

If you prefer running models locally (e.g., Ollama) or want to use your own API keys instead of your IDE's subscription, configure the server manually in your settings:

{
  "atlas": {
    "command": "npx",
    "args": ["-y", "atlas-pipeline-mcp"],
    "env": {
      "OLLAMA_BASE_URL": "http://localhost:11434",
      "OPENAI_API_KEY": "sk-...",
      "ANTHROPIC_API_KEY": "sk-..."
    }
  }
}

Note: If no API keys are provided, Atlas defaults to Client Sampling mode, delegating generation to your IDE's AI capabilities.


Contributing

We welcome contributions to improve the Atlas pipeline.


License

MIT License - see LICENSE file for details


Built by Nishant Unavane


🌐 Check out my portfolio: nishantunavane.qzz.io

For support, documentation, or questions, visit our GitHub repository.

Available Tools

38 tools
atlas_animation_studioA

Professional animation generator that creates CSS animations, Framer Motion code, GSAP timelines, and micro-interactions. Supports entrance, exit, hover, loading, scroll, and gesture animations with accessibility support.

Inputs: type (required), element (required), library (required), style, +3 more.

atlas_api_helperB

API integration helper that generates TypeScript types from API responses, creates React Query/SWR hooks, generates mock data for testing, builds API clients with interceptors, and creates Zod validation schemas.

Inputs: baseUrl (required), library (required), endpoints (required), authType, +4 more.

atlas_bug_oracleC

PREDICTIVE BUG DETECTION & RISK ANALYSIS ENGINE

ML-inspired bug prediction capabilities:

  • Predict where bugs are likely to occur BEFORE they happen

  • Calculate bug probability scores for each file/function

  • Identify high-risk code changes before they cause issues

  • Detect bug-prone patterns (complexity, coupling, churn)

  • Generate pre-emptive test recommendations

  • Track historical bug patterns

  • Provide confidence intervals for predictions

  • Integration with git history for churn analysis

This is NOT a static analyzer - it predicts FUTURE bugs using ML-like heuristics.

Inputs: projectPath (required), timeRange, targetFiles, analysisDepth, +2 more.

atlas_codebase_surgeonB

AUTONOMOUS MULTI-FILE SURGICAL REFACTORING ENGINE

Revolutionary capabilities far beyond basic refactoring:

  • Autonomous multi-file refactoring with dependency graph tracking

  • Semantic code transplant (move code between files maintaining all refs)

  • Blast radius analysis before any change

  • Auto-rollback generation for every change

  • Cross-file rename with 100% accuracy

  • Dead code autopsy and elimination across entire codebase

  • Interface extraction across entire codebase

  • Pattern propagation (apply pattern to all similar code)

  • Dry-run mode for safe testing

Use this for surgical precision code modifications that affect multiple files.

Inputs: operation (required), projectPath (required), dryRun, targetFiles, +3 more.

atlas_code_whispererB

INTELLIGENT CODE COMPLETION & PREDICTION ENGINE

Next-generation code completion that goes far beyond basic autocomplete:

  • Predict entire code blocks, not just single lines

  • Learn from codebase patterns and conventions

  • Context-aware suggestions based on project architecture

  • Multi-file aware completions (knows about related files)

  • Intent prediction (what are you trying to accomplish?)

  • Smart imports/dependency suggestions

  • API usage pattern completion

  • Error-resistant suggestions (predicts and avoids bugs)

  • Style-matched code generation

  • Natural language to code translation

Use for intelligent code generation that understands your project's DNA.

Inputs: mode (required), prefix (required), currentFile (required), projectPath (required), +5 more.

atlas_confidence_scorerC

Provides confidence scoring for code suggestions, solutions, and responses. Helps understand reliability and certainty of recommendations.

Inputs: suggestion (required), context, language, verificationData.

atlas_contextC

Gather context about a project or codebase. Analyzes files, dependencies, and project structure.

Inputs: projectPath (required), query, filePaths.

atlas_context_prioritizerC

Automatically determines what files, functions, and context matter most for a given task. Provides relevance scoring and suggests optimal context to include.

Inputs: task (required), projectPath (required), maxFiles, currentFile, +1 more.

atlas_critiqueC

Review and critique code for quality, security, and best practices. Returns detailed feedback and scores.

Inputs: code (required), focus, language.

atlas_css_wizardB

CSS architecture analyzer that detects specificity conflicts, generates design tokens, converts between CSS methodologies (BEM, CSS Modules, Tailwind, styled-components), and provides refactored CSS.

Inputs: css (required), html, framework, generateTokens, +1 more.

atlas_dashboardA

Generate beautiful HTML dashboard with live code metrics: complexity trends, test coverage, dependency graphs, security audit, performance hotspots, and git stats. Creates interactive visualizations.

Inputs: projectPath (required), theme, title, outputPath, +7 more.

atlas_debugA

Analyze errors and provide debugging assistance. Parses stack traces, identifies root causes, suggests fixes with code examples, and explains common error patterns.

Inputs: code, error, context, language, +2 more.

atlas_decomposeB

Break down a complex task into smaller subtasks with dependencies. Creates a DAG of work items.

Inputs: task (required), context, maxDepth.

atlas_dependenciesA

Comprehensive dependency analysis: dependency graph, circular dependencies, unused packages, security vulnerabilities, license compliance, bundle size impact, and upgrade recommendations.

Inputs: projectPath (required), findUnused, checkLicenses, checkSecurity, +2 more.

atlas_docsB

Generate documentation for code. Creates JSDoc/TSDoc/PyDoc comments, README files, API documentation, and usage examples.

Inputs: code (required), style, format, verbose, +3 more.

atlas_error_predictorA

Predicts potential runtime errors, edge cases, and failure scenarios before code execution. Analyzes code for null refs, type mismatches, race conditions, and more.

Inputs: code (required), context, checkFor, language.

atlas_execution_sandboxA

Safely executes code snippets in an isolated environment to test before suggesting. Supports JavaScript, TypeScript, Python with timeout and resource limits.

Inputs: code (required), language (required), input, timeout, +1 more.

atlas_explainA

Explain code in plain language. Provides line-by-line explanations, algorithm analysis, complexity analysis, design pattern detection, and beginner-friendly glossary.

Inputs: code (required), type, level, language, +3 more.

atlas_gitA

Analyze Git history and repository state. Returns recent commits, active branches, and file change history.

Inputs: repoPath (required), filePath, maxCommits.

atlas_intentB

Analyze user intent from a natural language request. Extracts action type, target, context, and constraints.

Inputs: message (required), conversationHistory.

atlas_memory_bankB

Long-term memory storage across sessions. Store and retrieve important context, decisions, patterns, and learnings. Supports tagging, importance scoring, and semantic search.

Inputs: action (required), key, tags, limit, +4 more.

atlas_optimizeB

Optimize code based on critique feedback. Applies improvements while maintaining functionality.

Inputs: code (required), critique, language, preserveApi.

atlas_pattern_learnerB

Learns and adapts to coding patterns, style preferences, and architectural choices from the codebase. Provides style-consistent suggestions.

Inputs: action (required), code, aspects, language, +1 more.

atlas_performance_doctorA

Frontend performance analyzer that detects React/Vue re-render issues, bundle bloat, memory leaks, and provides specific code fixes with estimated improvement percentages.

Inputs: code (required), framework (required), analysisType, targetMetrics, +1 more.

atlas_pipelineB

Run the full Atlas pipeline: Intent → Context → Git → Decompose → Variants → Critique → Optimize

Inputs: message (required), projectPath (required), options.

atlas_profilerA

Performance profiling and Big-O analysis. Analyzes time/space complexity, identifies CPU/memory/IO hotspots, detects memory leaks, and generates optimization suggestions with benchmark code.

Inputs: code (required), language (required), filePath, inputSizes, +7 more.

atlas_providersA

Check available LLM providers and their status.

Inputs: no named parameters.

atlas_refactorB

AI-powered code refactoring with pattern detection, complexity reduction, SOLID principles enforcement, and automated optimizations. Detects code smells, applies design patterns, and modernizes code.

Inputs: code (required), language (required), targets, addTypes, +7 more.

atlas_reviewB

AI code review assistant with multi-dimensional quality analysis: code quality, security, performance, architecture, testing, and documentation. Provides grades, detailed findings, and actionable suggestions.

Inputs: code (required), language (required), filePath, framework, +9 more.

atlas_securityA

Scan code for security vulnerabilities. Detects SQL injection, XSS, hardcoded secrets, weak crypto, and more. Returns findings with severity, CWE IDs, and remediation suggestions.

Inputs: code (required), context, language.

atlas_self_validatorA

Validates code, suggestions, or solutions before presenting them. Checks for syntax errors, logic flaws, security issues, edge cases, and provides confidence scoring.

Inputs: code (required), context, language, checkTypes.

atlas_smart_mergeA

AI-POWERED MERGE CONFLICT RESOLUTION

Automatically resolve merge conflicts using AI:

  • Automatically resolve merge conflicts using AI

  • Understand code intent from both branches

  • Detect semantic conflicts (not just textual)

  • Preserve functionality from both sides when possible

  • Generate test cases for merged code

  • Confidence scoring for auto-resolutions

  • Interactive suggestions for manual review

  • Integration with git workflow

Never waste hours on merge conflicts again - let AI handle them.

Inputs: projectPath (required), autoResolve, generateTests, conflictedFiles, +2 more.

atlas_tech_debt_quantifierA

FINANCIAL TECH DEBT ANALYSIS ENGINE

Calculate the ACTUAL COST of technical debt in dollars:

  • Calculate actual monetary cost of technical debt

  • Estimate time to fix each debt item

  • Priority ranking with ROI calculations

  • Track debt accumulation over time with compound interest model

  • Predict future maintenance burden

  • Cost-benefit analysis for refactoring decisions

  • Team velocity impact estimation

  • Breaking point prediction (when debt becomes critical)

Get executive-level financial reports on technical debt to justify refactoring budgets.

Inputs: projectPath (required), teamSize, hourlyRate, targetFiles, +2 more.

atlas_testA

Generate comprehensive test cases for code. Supports Jest, Vitest, Pytest, Mocha. Includes unit tests, integration tests, edge cases, and mocking suggestions.

Inputs: code (required), context, language, testType, +2 more.

atlas_thinkA

Advanced sequential thinking for complex problem-solving. Features dynamic branching, hypothesis testing, confidence tracking, and AI-enhanced reasoning.

Use this tool for:

  • Breaking down complex problems step-by-step

  • Multi-path reasoning with branch and merge

  • Hypothesis generation and verification

  • Problems requiring backtracking and revision

  • Building confidence through iterative analysis

Each thought can: question previous steps, branch into alternatives, mark dead ends, propose/verify hypotheses, and merge conclusions.

Inputs: thought (required), thoughtNumber (required), totalThoughts (required), nextThoughtNeeded (required), +14 more.

atlas_ui_ux_designerA

Advanced UI/UX designer that finds best design inspirations from the internet and generates production-ready code. Provides multiple design options with images, code generation, and accessibility guidance.

Inputs: requirements (required), framework, colorScheme, constraints, +3 more.

atlas_variantsA

Generate multiple solution variants for a coding task. Returns different approaches with pros/cons.

Inputs: task (required), context, language, numVariants.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    C2.9/5.0

    Scored across 38 tools

    Disambiguation2/5

    Many tools have overlapping purposes, such as atlas_critique, atlas_review, and atlas_self_validator all providing code quality analysis, and atlas_error_predictor and atlas_bug_oracle both predicting bugs. While descriptions are detailed, agents would struggle to reliably select the correct tool for a given task due to these unclear boundaries.

    Naming Consistency2/5

    All tool names share the 'atlas_' prefix, but the remainder is inconsistent: some use verbs (atlas_test, atlas_decompose), others nouns (atlas_context, atlas_git), and many are multi-word noun phrases (atlas_codebase_surgeon, atlas_tech_debt_quantifier). This mixed convention makes it hard to predict tool names from their function.

    Tool Count2/5

    With 38 tools, the server is heavily overloaded. While it aims to cover a broad coding assistant domain, the sheer number exceeds what is coherent for an MCP server, and many tools could be merged or removed without losing capability. This count falls into the 'too many' category (25+).

    Completeness4/5

    The tool set covers a wide range of coding assistance features: testing, debugging, refactoring, documentation, security, performance, UI design, and more. There are minor gaps, such as no direct tool for running project tests or executing git operations, but the overall surface is quite comprehensive for its stated purpose.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      Provides unified development tools including code analysis, debugging, refactoring, documentation, testing, and project automation through multiple LLM providers (KIMI, GLM, OpenRouter). Features agentic audit capabilities with multi-model consensus for finding issues and generating direct fixes.
      Apache 2.0
    • F
      license
      C
      quality
      D
      maintenance
      Enterprise-grade code intelligence platform providing AI-powered code analysis, semantic search, security scanning, and automated refactoring capabilities. Integrates with local AI models for zero-cost operations while delivering comprehensive development workflow automation.
      2
      8
      -
    • A
      license
      B
      quality
      B
      maintenance
      A comprehensive development toolkit with 23 tools covering code quality analysis, development efficiency, and project management. Enables AI-assisted code review, test generation, performance analysis, SQL generation, UI component creation, and automated project documentation.
      8
      29
      137 npm
      41
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides AI-powered development tools including code generation, refactoring, debugging, performance optimization, and test generation, along with smart prompts for code analysis and documentation, and a built-in knowledge base of coding best practices.
      MIT