# io.github.tosin2013/mcp-adr-analysis-server (npm · mcp-adr-analysis-server)

AI-powered MCP server for analyzing Architectural Decision Records (ADRs).

- Trust score: 77/100 (medium)
- Change this week: +24
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `mcp-adr-analysis-server`: 77/100 (this document), [markdown](https://verifymcp.io/servers/tosin2013-mcp-adr-analysis-server/mcp-adr-analysis-server.md), [page](https://verifymcp.io/servers/tosin2013-mcp-adr-analysis-server/mcp-adr-analysis-server)

## Channel facts

- Registry: `npm`
- Package: `mcp-adr-analysis-server`
- Version: `2.6.9`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 88/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (149 of 150), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (149 of 150), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to tosin2013/mcp-adr-analysis-server).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 55 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 63/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (poor).
  - Context-footprint check failed: tool/resource definitions use about 10378 tokens (~102/item across 101 items; 75 tools + 26 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 23/100
  - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add tosin2013-mcp-adr-analysis-server -- npx -y mcp-adr-analysis-server
```

### Codex

```bash
codex mcp add tosin2013-mcp-adr-analysis-server -- npx -y mcp-adr-analysis-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tosin2013-mcp-adr-analysis-server": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "mcp-adr-analysis-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add tosin2013-mcp-adr-analysis-server --command npx --arg -y --arg mcp-adr-analysis-server
```

### Hermes

```yaml
mcp_servers:
  tosin2013-mcp-adr-analysis-server:
    command: "npx"
    args: ["-y", "mcp-adr-analysis-server"]
```

### Other

```json
{
  "mcpServers": {
    "tosin2013-mcp-adr-analysis-server": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-adr-analysis-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 77, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 76, +50)

- [security improvement] Install scripts: unverified → pass
- [security improvement] Provenance: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [security] The attested source repository moved: tosin2013/mcp-adr-analysis-server
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Stability: unverified → 0.20
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Schema quality: unverified → poor
- [functional] Licence: MIT

### 2026-07-31 (score 26, −27)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 53, +28)

- [functional regression] Dependency health: partial → unverified
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] Tool coverage: unverified → 100

### 2026-07-28 (score 25, −28)

- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional improvement] Dependency health: unverified → partial

### 2026-07-27 (score 53)

First indexed and scored.

## MCP tools (75)

### `search_tools` (~147 tokens)

Search and discover available tools by category, keyword, or capability. Use this to find the right tool for a task without loading all tool schemas. Returns lightweight tool metadata by default; use includeSchema:true for full schemas.

Input parameters:

- `category` (string): Filter tools by category
- `cemcpOnly` (boolean): Only return tools with CE-MCP directive support (more token-efficient)
- `complexity` (string): Filter by tool complexity level
- `includeSchema` (boolean): Include full input schemas in response (increases token count)
- `limit` (number): Maximum number of tools to return
- `query` (string): Search query to match tool names, descriptions, and keywords

### `analyze_project_ecosystem` (~229 tokens)

Comprehensive recursive project ecosystem analysis with advanced prompting techniques (Knowledge Generation + Reflexion)

Input parameters:

- `analysisDepth` (string): Depth of ecosystem analysis
- `analysisScope` (array): Specific analysis areas to focus on (e.g., ["security", "performance", "architecture", "dependencies"])
- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `enhancedMode` (boolean): Enable advanced prompting features (Knowledge Generation + Reflexion)
- `includeEnvironment` (boolean): Automatically include comprehensive environment analysis (default: true)
- `includePatterns` (array): File patterns to include in analysis
- `knowledgeEnhancement` (boolean): Enable Knowledge Generation for technology-specific insights
- `learningEnabled` (boolean): Enable Reflexion learning from past analysis outcomes
- `projectPath` (string): Path to the project directory to analyze (optional, uses configured PROJECT_PATH if not provided)
- `recursiveDepth` (string): Depth of recursive project analysis
- `technologyFocus` (array): Specific technologies to focus analysis on (auto-detected if not provided)

### `get_architectural_context` (~97 tokens)

Get detailed architectural context for specific files or the entire project, automatically sets up ADR infrastructure if missing, and provides outcome-focused workflow for project success

Input parameters:

- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `filePath` (string): Specific file path to analyze (optional, analyzes entire project if not provided)
- `includeCompliance` (boolean): Include compliance checks in the analysis

### `generate_adrs_from_prd` (~158 tokens)

Generate Architectural Decision Records from a Product Requirements Document with advanced prompting techniques (APE + Knowledge Generation)

Input parameters:

- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `enhancedMode` (boolean): Enable advanced prompting features (APE + Knowledge Generation)
- `knowledgeEnhancement` (boolean): Enable Knowledge Generation for domain-specific insights
- `outputDirectory` (string): Directory to output generated ADRs (optional, uses configured ADR_DIRECTORY if not provided)
- `prdPath` (string, required): Path to the PRD.md file
- `prdType` (string): Type of PRD for optimized knowledge generation
- `promptOptimization` (boolean): Enable Automatic Prompt Engineering for optimized ADR generation

### `compare_adr_progress` (~219 tokens)

Compare TODO.md progress against ADRs and current environment to validate implementation status

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `deepCodeAnalysis` (boolean): Perform deep code analysis to distinguish mock from production implementations
- `environment` (string): Target environment context for validation (auto-detect will infer from project structure)
- `environmentConfig` (object): Environment-specific configuration and requirements
- `environmentValidation` (boolean): Enable environment-specific validation rules and checks
- `functionalValidation` (boolean): Validate that code actually functions according to ADR goals, not just exists
- `includeFileChecks` (boolean): Include file existence and implementation checks
- `includeRuleValidation` (boolean): Include architectural rule compliance validation
- `projectPath` (string): Path to project root for environment analysis
- `strictMode` (boolean): Enable strict validation mode with reality-check mechanisms against overconfident assessments
- `todoPath` (string): Path to TODO.md file to analyze
- `validationType` (string): Type of validation to perform

### `analyze_content_security` (~120 tokens)

Analyze content for sensitive information using AI-powered detection with optional memory integration for security pattern learning

Input parameters:

- `content` (string, required): Content to analyze for sensitive information
- `contentType` (string): Type of content being analyzed
- `enableMemoryIntegration` (boolean): Enable memory entity storage for security pattern learning and institutional knowledge building
- `enhancedMode` (boolean): Enable advanced prompting features
- `knowledgeEnhancement` (boolean): Enable Generated Knowledge Prompting for security and privacy expertise
- `userDefinedPatterns` (array): User-defined sensitive patterns to detect

### `generate_content_masking` (~54 tokens)

Generate masking instructions for detected sensitive content

Input parameters:

- `content` (string, required): Content to mask
- `detectedItems` (array, required): Detected sensitive items to mask
- `maskingStrategy` (string): Strategy for masking content

### `configure_custom_patterns` (~42 tokens)

Configure custom sensitive patterns for a project

Input parameters:

- `existingPatterns` (array): Existing patterns to consider
- `projectPath` (string, required): Path to the project directory

### `apply_basic_content_masking` (~45 tokens)

Apply basic content masking (fallback when AI is not available)

Input parameters:

- `content` (string, required): Content to mask
- `maskingStrategy` (string): Strategy for masking content

### `validate_content_masking` (~41 tokens)

Validate that content masking was applied correctly

Input parameters:

- `maskedContent` (string, required): Content after masking
- `originalContent` (string, required): Original content before masking

### `manage_cache` (~47 tokens)

Manage MCP resource cache (clear, stats, cleanup)

Input parameters:

- `action` (string, required): Cache management action to perform
- `key` (string): Specific cache key to invalidate (for invalidate action)

### `configure_output_masking` (~63 tokens)

Configure content masking for all MCP outputs

Input parameters:

- `action` (string): Configuration action
- `customPatterns` (array): Custom patterns to mask
- `enabled` (boolean): Enable or disable output masking
- `strategy` (string): Masking strategy to use

### `suggest_adrs` (~226 tokens)

Suggest architectural decisions with advanced prompting techniques (Knowledge Generation + Reflexion). TIP: Read @.mcp-server-context.md first for project history, patterns, and previous ADRs to ensure consistency.

Input parameters:

- `afterCode` (string): Code after changes (for code_changes analysis)
- `analysisType` (string): Type of analysis to perform
- `beforeCode` (string): Code before changes (for code_changes analysis)
- `changeDescription` (string): Description of the changes (for code_changes analysis)
- `commitMessages` (array): Related commit messages (for code_changes analysis)
- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `enhancedMode` (boolean): Enable advanced prompting features (Knowledge Generation + Reflexion)
- `existingAdrs` (array): List of existing ADR titles to avoid duplication
- `knowledgeEnhancement` (boolean): Enable Knowledge Generation for domain-specific insights
- `learningEnabled` (boolean): Enable Reflexion learning from past experiences
- `projectPath` (string): Path to the project directory

### `generate_adr_from_decision` (~92 tokens)

Generate a complete ADR from decision data. TIP: Reference @.mcp-server-context.md to align with existing architectural patterns and decisions.

Input parameters:

- `adrDirectory` (string): Directory where ADRs are stored
- `decisionData` (object, required)
- `existingAdrs` (array): List of existing ADRs for numbering and references
- `templateFormat` (string): ADR template format to use

### `generate_adr_bootstrap` (~224 tokens)

Generate bootstrap.sh and validate_bootstrap.sh scripts to ensure deployed code follows ADR requirements. **CRITICAL**: Before generating scripts, use WebFetch to query the base code repository (e.g., https://github.com/validatedpatterns/common for OpenShift) and authoritative pattern documentation (e.g., https://play.validatedpatterns.io/). Merge the base repository code into your project and have bootstrap.sh call the pattern's scripts rather than generating everything from scratch. This ensures compliance with validated deployment patterns.

Input parameters:

- `adrDirectory` (string): Directory where ADRs are stored
- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `customValidations` (array): Custom validation commands to include
- `includeDeployment` (boolean): Include deployment steps in bootstrap
- `includeTests` (boolean): Include test execution in bootstrap
- `outputPath` (string): Directory where to generate scripts
- `projectPath` (string): Path to the project directory
- `scriptType` (string): Which scripts to generate

### `bootstrap_validation_loop` (~457 tokens)

\**GUIDED EXECUTION MODE**: This tool guides you through an interactive, step-by-step deployment validation workflow. It does NOT execute commands internally - instead, it tells YOU what commands to run and processes the results iteratively. **Workflow**: (1) First call with iteration=0: Detects platform (OpenShift/K8s/Docker), validates environment connection, and requests human approval for target platform. (2) Subsequent calls: After running each command and reporting back with output, the tool provides next steps. **Environment Validation**: Before deployment, the tool verifies connection to the target platform (e.g., `oc status` for OpenShift, `kubectl cluster-info` for K8s) and requires explicit human confirmation. **Validated Patterns Integration**: Automatically identifies base code repositories (e.g., validatedpatterns/common for OpenShift) and guides you to merge them into your project. **Deployment Cleanup**: Supports CI/CD-style workflows with deployment teardown/restart guidance. **Call this tool iteratively**, passing previous command output back each time.

Input parameters:

- `adrDirectory` (string): Directory where ADRs are stored
- `autoFix` (boolean): Whether to generate auto-fix suggestions in guidance
- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `currentIteration` (number): Current iteration number (0 for initial call, then increment). Used to track workflow progress.
- `deploymentCleanupRequested` (boolean): Set to true to request deployment cleanup/teardown guidance (for CI/CD workflows that need to delete and restart deployments).
- `maxIterations` (number): Maximum validation/fix iterations
- `previousExecutionOutput` (string): Output from the previous command execution. Paste the stdout/stderr from running the command that was recommended in the previous iteration.
- `previousExecutionSuccess` (boolean): Whether the previous command execution succeeded (exit code 0). Set to true if command succeeded, false if it failed.
- `projectPath` (string): Path to the project directory
- `targetEnvironment` (string): Target deployment environment
- `updateAdrsWithLearnings` (boolean): Update ADRs with deployment learnings (non-sensitive)

### `discover_existing_adrs` (~49 tokens)

Discover and catalog existing ADRs in the project

Input parameters:

- `adrDirectory` (string): Directory to search for ADRs
- `includeContent` (boolean): Whether to include ADR content in analysis

### `analyze_adr_timeline` (~170 tokens)

Analyze ADR timeline with smart time tracking, adaptive thresholds, and actionable recommendations. Auto-detects project context (startup/growth/mature) and generates prioritized work queue based on staleness, implementation lag, and technical debt.

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `autoDetectContext` (boolean): Auto-detect project phase from git activity and ADR patterns
- `forceExtract` (boolean): Force timeline extraction even if ADRs have dates
- `generateActions` (boolean): Generate actionable work items with priority and effort estimates
- `includeContent` (boolean): Include ADR content for better analysis
- `projectPath` (string): Path to the project directory
- `thresholdProfile` (string): Threshold profile for action generation (auto-detected if not specified)

### `review_existing_adrs` (~159 tokens)

Review existing ADRs against actual code implementation with cloud/DevOps expertise. TIP: After review, call get_server_context to update @.mcp-server-context.md with findings.

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `analysisDepth` (string): Depth of analysis to perform
- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `generateUpdatePlan` (boolean): Generate action plan for updating non-compliant ADRs
- `includeTreeSitter` (boolean): Use tree-sitter for enhanced code analysis
- `projectPath` (string): Path to the project directory
- `specificAdr` (string): Specific ADR filename or title to review (optional)

### `validate_adr` (~115 tokens)

Validate an existing ADR against actual infrastructure reality using research-driven analysis. TIP: Compare findings against patterns in @.mcp-server-context.md for consistency checks.

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `adrPath` (string, required): Path to the ADR file to validate (relative or absolute)
- `confidenceThreshold` (number): Minimum research confidence threshold (0-1)
- `includeEnvironmentCheck` (boolean): Include live environment verification in validation
- `projectPath` (string): Path to the project directory

### `validate_all_adrs` (~79 tokens)

Validate all ADRs in a directory against actual infrastructure reality

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `includeEnvironmentCheck` (boolean): Include live environment verification in validation
- `minConfidence` (number): Minimum research confidence for validation (0-1)
- `projectPath` (string): Path to the project directory

### `incorporate_research` (~121 tokens)

Incorporate research findings into architectural decisions

Input parameters:

- `adrDirectory` (string): Path to ADR directory
- `adrId` (string): ADR ID for update generation
- `analysisType` (string): Type of research analysis to perform
- `existingTopics` (array): Previously identified research topics
- `researchFindings` (array): Research findings for update generation
- `researchPath` (string): Path to research directory
- `researchTopics` (array): Research topics for impact evaluation
- `updateType` (string): Type of ADR update to generate

### `create_research_template` (~51 tokens)

Create a research template file for documenting findings

Input parameters:

- `category` (string): Research category
- `researchPath` (string): Path to research directory
- `title` (string, required): Title of the research

### `request_action_confirmation` (~55 tokens)

Request confirmation before applying research-based changes

Input parameters:

- `action` (string, required): Description of the action to be performed
- `details` (string, required): Detailed information about the action
- `impact` (string): Impact level of the action

### `generate_rules` (~80 tokens)

Generate architectural rules from ADRs and code patterns

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `existingRules` (array): Existing rules to avoid duplication
- `outputFormat` (string): Output format for rules
- `projectPath` (string): Path to project for pattern analysis
- `source` (string): Source for rule generation

### `validate_rules` (~97 tokens)

Validate code against architectural rules

Input parameters:

- `fileContent` (string): Content to validate (alternative to filePath)
- `fileName` (string): Name of file being validated (when using fileContent)
- `filePath` (string): Path to file to validate
- `reportFormat` (string): Format for validation report
- `rules` (array, required): Rules to validate against
- `validationType` (string): Type of validation to perform

### `create_rule_set` (~106 tokens)

Create machine-readable rule set in JSON/YAML format

Input parameters:

- `adrRules` (array): Rules extracted from ADRs
- `author` (string): Author of the rule set
- `description` (string): Description of the rule set
- `name` (string, required): Name of the rule set
- `outputFormat` (string): Output format for rule set
- `patternRules` (array): Rules generated from code patterns
- `rules` (array): Additional rules to include

### `analyze_environment` (~144 tokens)

Analyze environment context and provide optimization recommendations with optional memory integration for environment snapshot tracking

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `analysisType` (string): Type of environment analysis to perform
- `currentEnvironment` (object): Current environment specifications (for compliance analysis)
- `enableMemoryIntegration` (boolean): Enable memory entity storage for environment snapshot tracking and historical analysis
- `enableTrendAnalysis` (boolean): Enable analysis of environment changes over time using stored snapshots
- `industryStandards` (array): Industry standards to assess compliance against
- `projectPath` (string): Path to project directory
- `requirements` (object): Environment requirements (for compliance analysis)

### `generate_research_questions` (~132 tokens)

Generate context-aware research questions and create research tracking system

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `analysisType` (string): Type of research analysis to perform
- `currentProgress` (array): Current research progress
- `knowledgeGraph` (object): Architectural knowledge graph
- `problems` (array): Problems to correlate with knowledge graph
- `projectPath` (string): Path to project directory
- `relevantKnowledge` (object): Relevant knowledge for question generation
- `researchContext` (object): Research context and objectives
- `researchQuestions` (array): Research questions for task tracking

### `perform_research` (~102 tokens)

Perform research using cascading sources: project files → knowledge graph → environment resources → web search (fallback)

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `confidenceThreshold` (number): Minimum confidence threshold (0-1) before suggesting web search
- `performWebSearch` (boolean): Enable web search recommendations when confidence is low
- `projectPath` (string): Path to project directory
- `question` (string, required): The research question to answer

### `search_codebase` (~151 tokens)

Atomic tool for searching codebase files based on query patterns. Returns raw file matches with relevance scores. Extracted from ResearchOrchestrator per ADR-018.

Input parameters:

- `enableTreeSitter` (boolean): Use tree-sitter for enhanced analysis
- `includeContent` (boolean): Include file content in results
- `maxFiles` (number): Maximum files to return
- `projectPath` (string): Path to project root
- `query` (string, required): Search query (e.g., "Docker configuration", "authentication")
- `relevanceThreshold` (number): Minimum relevance threshold (0-1)
- `scope` (array): Optional file scope patterns (e.g., ["src/**", "config/**"])

### `llm_web_search` (~99 tokens)

LLM-managed web search using Firecrawl for cross-platform support

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `includeContent` (boolean): Include full content in results
- `llmInstructions` (string): LLM instructions for search optimization
- `maxResults` (number): Maximum results to return
- `projectPath` (string): Path to project directory
- `query` (string, required): The search query to execute

### `llm_cloud_management` (~102 tokens)

LLM-managed cloud provider operations with research-driven approach

Input parameters:

- `action` (string, required): Action to perform
- `adrDirectory` (string): Directory containing ADR files
- `llmInstructions` (string, required): LLM instructions for command generation
- `parameters` (object): Action parameters
- `projectPath` (string): Path to project directory
- `provider` (string, required): Cloud provider to use
- `researchFirst` (boolean): Research best approach first

### `llm_database_management` (~102 tokens)

LLM-managed database operations with research-driven approach

Input parameters:

- `action` (string, required): Database action to perform
- `adrDirectory` (string): Directory containing ADR files
- `database` (string, required): Database type to use
- `llmInstructions` (string, required): LLM instructions for command generation
- `parameters` (object): Action parameters
- `projectPath` (string): Path to project directory
- `researchFirst` (boolean): Research best approach first

### `analyze_deployment_progress` (~152 tokens)

Analyze deployment progress and verify completion with outcome rules

Input parameters:

- `actualOutcomes` (array): Actual deployment outcomes
- `adrDirectory` (string): Directory containing ADR files
- `analysisType` (string): Type of deployment analysis to perform
- `cicdLogs` (string): CI/CD pipeline logs for analysis
- `cicdStatus` (object): CI/CD pipeline status data
- `deploymentTasks` (array): Deployment tasks for progress calculation
- `environmentStatus` (object): Environment status data
- `outcomeRules` (array): Outcome rules for completion verification
- `pipelineConfig` (string): CI/CD pipeline configuration
- `todoPath` (string): Path to TODO.md file for task identification

### `check_ai_execution_status` (~23 tokens)

Check AI execution configuration and status for debugging prompt-only mode issues

### `get_workflow_guidance` (~190 tokens)

Get intelligent workflow guidance and tool recommendations based on your goals and project context to achieve expected outcomes efficiently

Input parameters:

- `availableAssets` (array): What assets you already have (e.g., ["PRD.md", "existing ADRs", "codebase", "documentation", "test suite"])
- `goal` (string, required): What you want to accomplish (e.g., "analyze new project", "document existing decisions", "security audit", "modernize legacy system")
- `primaryConcerns` (array): Main areas of concern (e.g., ["security", "performance", "maintainability", "scalability", "compliance"])
- `projectContext` (string, required): Current state of your project (e.g., "new project", "existing project with ADRs", "legacy codebase", "greenfield development")
- `timeframe` (string): Available time/effort level

### `get_development_guidance` (~172 tokens)

Get comprehensive development guidance that translates architectural decisions and workflow recommendations into specific coding tasks, implementation patterns, and development roadmap

Input parameters:

- `adrsToImplement` (array): List of ADR titles or file paths that need to be implemented in code
- `currentProgress` (string): What has already been implemented or current state of development
- `developmentPhase` (string, required): Current development phase
- `focusAreas` (array): Specific areas to focus on (e.g., ["API design", "database schema", "testing strategy", "deployment pipeline"])
- `teamContext` (object)
- `technologyStack` (array): Current technology stack (e.g., ["TypeScript", "React", "Node.js", "PostgreSQL", "Docker"])
- `timeline` (string): Development timeline or deadline constraints

### `list_roots` (~31 tokens)

List available file system roots that can be accessed. Use this to discover what directories are available before reading files.

### `read_directory` (~47 tokens)

List files and folders in a directory. Use this to explore the file structure within accessible roots.

Input parameters:

- `path` (string, required): Directory path to list (relative to project root or absolute within roots)

### `read_file` (~46 tokens)

Read contents of a file

Input parameters:

- `filePath` (string): Path to the file to read
- `path` (string): Path to the file to read (alias for filePath)

### `write_file` (~40 tokens)

Write content to a file

Input parameters:

- `content` (string, required): Content to write to the file
- `path` (string, required): Path to the file to write

### `list_directory` (~27 tokens)

List contents of a directory

Input parameters:

- `path` (string, required): Path to the directory to list

### `generate_deployment_guidance` (~163 tokens)

Generate deployment guidance and instructions from ADRs with environment-specific configurations

Input parameters:

- `adrDirectory` (string): Directory containing ADR files
- `customRequirements` (array): Additional custom requirements
- `environment` (string): Target deployment environment
- `format` (string): Output format for guidance
- `generateFiles` (boolean): Actually generate files (vs just guidance)
- `includeConfigs` (boolean): Generate configuration files
- `includeRollback` (boolean): Include rollback procedures
- `includeScripts` (boolean): Generate deployment scripts
- `includeValidation` (boolean): Include validation and health checks
- `projectPath` (string): Project root path (optional, uses configured PROJECT_PATH if not provided)
- `technologyFilter` (array): Filter by specific technology categories

### `smart_git_push` (~166 tokens)

AI-driven security-focused git push with credential detection, file filtering, and deployment metrics tracking. Tests should be run by calling AI and results provided.

Input parameters:

- `branch` (string): Target branch for push (optional, uses current branch if not specified)
- `dryRun` (boolean): Show what would be pushed without actually pushing
- `forceUnsafe` (boolean): Override security blocks and test failures (DANGEROUS)
- `message` (string): Commit message (optional, commits staged files if provided)
- `projectPath` (string): Path to project directory (defaults to current working directory)
- `skipSecurity` (boolean): Skip security scanning (NOT RECOMMENDED)
- `testResults` (object): Test results from AI-executed tests (required for proper deployment tracking)

### `deployment_readiness` (~411 tokens)

Comprehensive deployment readiness validation with test failure tracking, deployment history analysis, and hard blocking for unsafe deployments. Integrates with smart_git_push for deployment gating.

Input parameters:

- `allowMockCode` (boolean): Allow mock code in deployment (NOT RECOMMENDED)
- `approvalRequired` (boolean): Require approval for overrides
- `blockOnFailingTests` (boolean): Block deployment if tests are failing
- `blockOnRecentFailures` (boolean): Block if recent deployments failed
- `businessJustification` (string): Business justification for overrides (required for emergency_override)
- `deploymentSuccessThreshold` (number): Minimum deployment success rate required (%)
- `emergencyBypass` (boolean): Emergency bypass for critical fixes
- `enableMemoryIntegration` (boolean): Enable memory entity storage for deployment assessment tracking and historical analysis
- `integrateTodoTasks` (boolean): Auto-create blocking tasks for issues
- `maxRecentFailures` (number): Maximum recent deployment failures allowed
- `maxTestFailures` (number): Maximum test failures allowed (0 = zero tolerance)
- `migrateExistingHistory` (boolean): Migrate existing JSON-based deployment history to memory entities
- `mockCodeMaxAllowed` (number): Maximum mock code indicators allowed
- `operation` (string, required): Type of deployment readiness check to perform
- `productionCodeThreshold` (number): Minimum production code quality score (0-100)
- `projectPath` (string): Path to project directory (defaults to current working directory)
- `requireAdrCompliance` (boolean): Require ADR compliance validation
- `requireTestCoverage` (number): Minimum test coverage percentage required
- `rollbackFrequencyThreshold` (number): Maximum rollback frequency allowed (%)
- `strictMode` (boolean): Enable strict validation (recommended for production)
- `targetEnvironment` (string): Target deployment environment
- `testSuiteRequired` (array): Required test suites that must pass
- `triggerSmartGitPush` (boolean): Trigger smart git push validation
- `updateHealthScoring` (boolean): Update project health scores

### `release_tracking` (~397 tokens)

Track releases mapped to ADR decisions. Generates changelogs, manages milestones, compares releases, and assesses release readiness. Supports greenfield and brownfield projects. Writes CHANGELOG.md, creates GitHub Releases and Milestones.

Input parameters:

- `compareFrom` (string): Starting version for comparison
- `compareTo` (string): Ending version for comparison
- `createGithubRelease` (boolean): Create a GitHub Release (requires gh CLI)
- `format` (string): Changelog output format
- `groupByAdr` (boolean): Group changelog entries by ADR
- `includeAdrLinks` (boolean): Include ADR references in changelog
- `includeCommitHashes` (boolean): Include commit hashes in output
- `includeReadiness` (boolean): Include release readiness score
- `includeTimeline` (boolean): Include mermaid timeline diagram
- `localOnly` (boolean): For create_milestone: persist locally instead of calling gh CLI. Useful when gh auth is unavailable.
- `milestoneDescription` (string): GitHub milestone description
- `milestoneDueDate` (string): Milestone due date (YYYY-MM-DD)
- `milestoneTitle` (string): GitHub milestone title (for create_milestone)
- `operation` (string, required): Operation to perform
- `projectPath` (string): Project root path (defaults to current working directory)
- `releasePlanPath` (string): Path to RELEASE_PLAN.md (relative to projectPath).
- `syncGithubMilestones` (boolean): Sync milestones to GitHub (requires gh CLI)
- `updateTodo` (boolean): Update TODO.md with milestone status
- `version` (string): Release version to track (e.g., v2.3.0)
- `writeReleasePlan` (boolean): For create_milestone/push_local_milestones: also render local milestones into RELEASE_PLAN.md (bounded section).
- `writeToFile` (boolean): Write CHANGELOG.md to repo

### `generate_adr_todo` (~229 tokens)

Generate TODO.md from ADRs with comprehensive task breakdown. Decomposes each ADR into paired test+production tasks (TDD), links tasks to release milestones, and preserves manual edits via a bounded HTML-comment section. Re-runs are idempotent; tasks for deleted/superseded ADRs move to a Stale Tasks section.

Input parameters:

- `adrDirectory` (string): Directory containing ADR files (relative to projectPath)
- `dryRun` (boolean): Compute changes but do not write TODO.md (preview only)
- `linkToMilestones` (boolean): Link generated tasks to release milestones (local + GitHub merged)
- `phase` (string): TDD pairing — "both" emits paired test+production tasks (default), "production" or "test" narrows output
- `projectPath` (string): Project root path (defaults to current working directory)
- `scope` (string): Which ADRs to decompose: all, pending (proposed/draft), or accepted only
- `todoPath` (string): Output TODO file (relative to projectPath)

### `troubleshoot_guided_workflow` (~202 tokens)

Structured failure analysis and test plan generation with memory integration for troubleshooting session tracking and intelligent ADR/research suggestion capabilities - provide JSON failure info to get specific test commands

Input parameters:

- `adrDirectory` (string): ADR directory path
- `conversationContext` (object): Rich context from the calling LLM about user goals and discussion history
- `enableAdrSuggestion` (boolean): Enable automatic ADR suggestion based on recurring failures
- `enableMemoryIntegration` (boolean): Enable memory entity storage for troubleshooting session tracking and pattern recognition
- `enablePatternRecognition` (boolean): Enable automatic pattern recognition and failure classification
- `enableResearchGeneration` (boolean): Enable automatic research question generation for persistent problems
- `failure` (object): Structured failure information (required for analyze_failure and generate_test_plan)
- `operation` (string, required): Type of troubleshooting operation
- `projectPath` (string): Path to project directory (optional)
- `todoPath` (string): Path to TODO.md file

### `smart_score` (~343 tokens)

Central coordination for project health scoring system - recalculate, sync, diagnose, optimize, and reset scores across all MCP tools

Input parameters:

- `analysisMode` (string): Method for weight optimization (for optimize_weights operation)
- `checkDataFreshness` (boolean): Validate data freshness across tools (for diagnose_scores operation)
- `component` (string): Score component to reset (for reset_scores operation)
- `components` (array): Score components to recalculate (for recalculate_scores operation)
- `customWeights` (object): Custom weight overrides (for optimize_weights operation)
- `forceUpdate` (boolean): Force update even if data is fresh
- `includeHistory` (boolean): Include score history analysis (for diagnose_scores operation)
- `intentId` (string): Intent ID to get score trends for (for get_intent_scores operation)
- `operation` (string, required): Smart scoring operation to perform
- `preserveHistory` (boolean): Preserve score history in backup (for reset_scores operation)
- `previewOnly` (boolean): Preview changes without applying (for optimize_weights operation)
- `projectPath` (string, required): Path to project directory
- `rebalanceWeights` (boolean): Recalculate optimal scoring weights (for sync_scores operation)
- `recalculateAfterReset` (boolean): Immediately recalculate after reset (for reset_scores operation)
- `suggestImprovements` (boolean): Provide score improvement suggestions (for diagnose_scores operation)
- `todoPath` (string): Path to TODO.md file (for sync_scores operation)
- `triggerTools` (array): Tools to trigger for fresh data (for sync_scores operation)
- `updateSources` (boolean): Trigger source tool updates before recalculating

### `mcp_planning` (~399 tokens)

Enhanced project planning and workflow management tool - phase-based project management, team resource allocation, progress tracking, risk analysis, and executive reporting

Input parameters:

- `action` (string): Management action (for manage_phases/manage_resources operations)
- `allocationData` (object): Resource allocation data
- `analysisType` (string): Type of risk analysis
- `description` (string): Project description (for create_project operation)
- `format` (string): Report output format
- `generateMitigation` (boolean): Generate mitigation strategies
- `importFromAdrs` (boolean): Import phases from existing ADRs (for create_project operation)
- `importFromTodos` (boolean): Import tasks from TODO system (for create_project operation)
- `includeAdrRisks` (boolean): Analyze risks from ADR complexity
- `includeCharts` (boolean): Include progress charts and graphs
- `includeDependencyRisks` (boolean): Analyze dependency chain risks
- `includeResourceRisks` (boolean): Analyze resource allocation risks
- `includeVisuals` (boolean): Include visual progress indicators
- `memberData` (object): Team member data for resource operations
- `memberId` (string): Team member ID for resource operations
- `operation` (string, required): Project planning operation to perform
- `phaseData` (object): Phase data for create/update operations
- `phaseId` (string): Phase ID for phase operations
- `phases` (array): Initial project phases (for create_project operation)
- `projectName` (string): Project name (for create_project operation)
- `projectPath` (string, required): Project root path
- `reportType` (string): Type of progress report or generated report
- `targetStatus` (string): Target status for phase transition
- `team` (array): Team structure (for create_project operation)
- `timeframe` (string): Time frame for reports and tracking
- `updateTaskProgress` (boolean): Sync progress from TODO system

### `interactive_adr_planning` (~145 tokens)

Interactive guided ADR planning and creation tool - walks users through structured decision-making process with research integration, option evaluation, and automatic ADR generation. TIP: Start by reading @.mcp-server-context.md to understand project context and previous decisions.

Input parameters:

- `autoResearch` (boolean): Automatically trigger research when needed
- `generateTodos` (boolean): Automatically generate TODO items from decisions
- `input` (string): User input for the current phase (varies by phase)
- `operation` (string, required): Interactive planning operation to perform
- `projectPath` (string, required): Project root path
- `sessionId` (string): Planning session ID (required for all operations except start_session)

### `memory_loading` (~115 tokens)

Advanced memory loading tool for the memory-centric architecture. Query, explore, and manage memory entities and relationships. Load ADRs into memory system and perform intelligent queries.

Input parameters:

- `action` (string): Memory operation to perform
- `entityId` (string): Entity ID for get_entity and find_related actions
- `forceReload` (boolean): Force reload of ADRs (load_adrs action)
- `maxDepth` (number): Maximum depth for relationship traversal (find_related action)
- `query` (object): Query parameters for entity search

### `expand_analysis_section` (~102 tokens)

Retrieve full analysis content from tiered responses. Expand entire analysis or specific sections stored in memory. Use this when a tool returns a summary with an expandable ID.

Input parameters:

- `expandableId` (string, required): ID of the expandable analysis (provided in tiered response)
- `format` (string): Output format (default: markdown)
- `section` (string): Optional: Specific section to expand (omit to get full analysis). Available sections are listed in the tiered response.

### `tool_chain_orchestrator` (~119 tokens)

AI-powered dynamic tool sequencing - intelligently analyze user requests and generate structured tool execution plans

Input parameters:

- `allowParallel` (boolean): Allow parallel execution of independent steps
- `availableTools` (array): List of available MCP tools to orchestrate
- `contextHints` (array): Additional context hints for better plan generation
- `executionMode` (string): Orchestration mode
- `maxSteps` (number): Maximum number of steps in the execution plan
- `userRequest` (string, required): User request to analyze and create tool execution plan for

### `expand_memory` (~72 tokens)

Phase 3: Retrieve and expand stored content from a tiered response using its expandable ID

Input parameters:

- `expandableId` (string, required): Expandable ID from a tiered response
- `includeContext` (boolean): Include related conversation context and knowledge graph state
- `section` (string): Optional: specific section to expand

### `query_conversation_history` (~87 tokens)

Phase 3: Search and retrieve conversation sessions based on filters

Input parameters:

- `dateRange` (object): Filter by date range
- `keyword` (string): Search keyword in conversation turns
- `limit` (number): Maximum number of sessions to return
- `projectPath` (string): Filter by project path
- `toolsUsed` (array): Filter by tools used in the session

### `get_conversation_snapshot` (~40 tokens)

Phase 3: Get current conversation context snapshot for resumption or analysis

Input parameters:

- `recentTurnCount` (number): Number of recent turns to include

### `get_memory_stats` (~20 tokens)

Phase 3: Get statistics about stored conversation memory

### `update_knowledge` (~157 tokens)

ADR-018: Simple CRUD operations for knowledge graph. Add/remove entities (intents, ADRs, tools, code) and relationships. Use knowledge://graph resource to read current state (zero token cost).

Input parameters:

- `entity` (string): Entity ID (for add_entity/remove_entity operations)
- `entityType` (string): Type of entity (required for add_entity operation)
- `metadata` (object): Additional metadata for the entity or relationship
- `operation` (string, required): Type of operation to perform on the knowledge graph
- `relationship` (string): Relationship type (for add_relationship/remove_relationship)
- `source` (string): Source node ID (for relationship operations)
- `target` (string): Target node ID (for relationship operations)

### `get_server_context` (~110 tokens)

Generate a comprehensive context file showing the server's current state, memory, and capabilities. Creates .mcp-server-context.md that can be @ referenced in conversations for instant LLM awareness

Input parameters:

- `includeDetailed` (boolean): Include detailed information
- `maxRecentItems` (number): Maximum number of recent items to show
- `outputPath` (string): Custom output path for the context file
- `writeToFile` (boolean): Whether to write the context to .mcp-server-context.md file

### `get_current_datetime` (~139 tokens)

Get the current date and time in various formats. Useful for timestamping ADRs, research documents, and other architectural artifacts. Returns ISO 8601, human-readable, and ADR-specific date formats.

Input parameters:

- `format` (string): Output format: "iso" for ISO 8601, "human" for human-readable, "adr" for ADR date format (YYYY-MM-DD), "all" for all formats
- `includeTimestamp` (boolean): Include Unix timestamp in milliseconds
- `timezone` (string): Timezone for the datetime (e.g., "UTC", "America/New_York", "Europe/London"). Defaults to UTC.

### `set_project_path` (~96 tokens)

Dynamically set the active project path for the current session. Call this at the start of a session to switch between projects without restarting the server or modifying environment variables. All subsequent tool calls will use this path as the default.

Input parameters:

- `path` (string, required): Absolute path to the project directory. Must be an existing directory.
- `validatePath` (boolean): Whether to validate that the path exists and is a directory (default: true)

### `load_prompt` (~154 tokens)

Load a specific prompt or prompt section on-demand. Part of CE-MCP lazy loading system that reduces token usage by ~96% by loading prompts only when needed. Use this to retrieve prompt templates for ADR generation, analysis, deployment, and other operations.

Input parameters:

- `estimateOnly` (boolean): If true, returns only token estimate without loading the full prompt content
- `promptName` (string, required): Name of the prompt to load (e.g., "adr-suggestion", "deployment-analysis", "environment-analysis", "research-question", "rule-generation", "analysis", "security")
- `section` (string): Specific section within the prompt to load. If not provided, loads the entire prompt. Available sections depend on the prompt.

### `sync_to_aggregator` (~173 tokens)

Sync ADRs to ADR Aggregator platform (https://adraggregator.com) for centralized tracking, visualization, and team collaboration. Supports incremental and full sync modes with optional metadata.

Input parameters:

- `adr_paths` (array): Specific ADR paths to sync (syncs all if not provided)
- `full_sync` (boolean): Replace all ADRs instead of incremental sync
- `include_code_links` (boolean): Include AST-based code links (Pro+ tier)
- `include_diagrams` (boolean): Include Mermaid diagrams (Pro+ tier)
- `include_metadata` (boolean): Include analysis metadata in sync
- `include_security_scan` (boolean): Include security scan results
- `include_timeline` (boolean): Include timeline/staleness data
- `projectPath` (string): Project path (defaults to PROJECT_PATH)

### `get_adr_context` (~144 tokens)

Fetch ADR context from ADR Aggregator including summaries, diagrams, timeline data, and code links. Useful for getting a consolidated view of architectural decisions.

Input parameters:

- `graph_depth` (number): Knowledge graph depth (Team tier)
- `include_code_links` (boolean): Include code links (Pro+ tier)
- `include_diagrams` (boolean): Include Mermaid diagrams (Pro+ tier)
- `include_research` (boolean): Include research context (Pro+ tier)
- `include_timeline` (boolean): Include timeline data
- `projectPath` (string): Project path (defaults to PROJECT_PATH)
- `staleness_filter` (string): Filter by staleness level

### `get_staleness_report` (~67 tokens)

Get ADR staleness report from ADR Aggregator with review compliance metrics. Identifies stale ADRs that need attention and provides governance insights.

Input parameters:

- `projectPath` (string): Project path (defaults to PROJECT_PATH)
- `threshold` (number): Days threshold for staleness

### `get_adr_templates` (~65 tokens)

Get domain-specific ADR templates and anti-patterns from ADR Aggregator. Includes best practices for web applications, microservices, APIs, and more. No authentication required.

Input parameters:

- `domain` (string): Domain filter (web_application, microservices, api, data_platform, etc.)

### `get_adr_diagrams` (~68 tokens)

Get Mermaid diagrams for ADRs from ADR Aggregator. Includes workflow, relationship, and impact diagrams. Requires Pro+ tier.

Input parameters:

- `adr_path` (string): Specific ADR path (returns all if not specified)
- `projectPath` (string): Project path (defaults to PROJECT_PATH)

### `validate_adr_compliance` (~75 tokens)

Validate ADR compliance against implementation via ADR Aggregator. Checks that code actually implements documented decisions. Requires Pro+ tier.

Input parameters:

- `adr_paths` (array): Specific ADR paths to validate
- `projectPath` (string): Project path (defaults to PROJECT_PATH)
- `validation_type` (string): Type of validation to perform

### `get_knowledge_graph` (~76 tokens)

Get cross-repository knowledge graph from ADR Aggregator with analytics and insights. Visualize ADR relationships across repositories. Requires Team tier.

Input parameters:

- `include_analytics` (boolean): Include graph analytics and insights
- `projectPath` (string): Project path (defaults to PROJECT_PATH)
- `scope` (string): Scope of the graph

### `update_implementation_status` (~72 tokens)

Update the implementation status of synced ADRs directly from the IDE. Supports statuses: not_started, in_progress, implemented, deprecated, blocked. Requires Pro+ tier.

Input parameters:

- `projectPath` (string): Project path (defaults to PROJECT_PATH)
- `updates` (array, required): Array of ADR status updates to apply

### `get_adr_priorities` (~70 tokens)

Get ADR priorities for roadmap and backlog planning from ADR Aggregator. Returns prioritized ADRs with scores, dependencies, blockers, implementation status, and gap counts.

Input parameters:

- `include_ai` (boolean): Include AI-based priority recommendations
- `projectPath` (string): Project path (defaults to PROJECT_PATH)

### `analyze_gaps` (~175 tokens)

Scan local codebase and compare with ADRs to detect bi-directional gaps. Finds: (1) ADR-to-code gaps: file references in ADRs that do not exist, (2) Code-to-ADR gaps: technologies in package.json and architectural patterns without ADR coverage. Reports gaps to ADR Aggregator for tracking.

Input parameters:

- `excludePatterns` (array): File patterns to exclude from scan (regex)
- `includeDismissed` (boolean): Include previously dismissed gaps in analysis
- `includePatterns` (array): File patterns to include in scan (regex)
- `projectPath` (string): Project path (defaults to PROJECT_PATH)
- `reportToAggregator` (boolean): Whether to report gaps to ADR Aggregator
- `scanDirectories` (array): Specific directories to scan (defaults to src, lib, app, packages)

### `get_gaps` (~73 tokens)

Get current code gaps from ADR Aggregator. Returns gaps with their status (open, dismissed, resolved) for tracking and management.

Input parameters:

- `includeDismissed` (boolean): Include dismissed gaps
- `includeResolved` (boolean): Include resolved gaps
- `projectPath` (string): Project path (defaults to PROJECT_PATH)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/tosin2013-mcp-adr-analysis-server/mcp-adr-analysis-server#diagnostics

## Score history

- 2026-08-03: 77
- 2026-08-02: 76
- 2026-08-01: 26
- 2026-07-31: 26
- 2026-07-30: 53
- 2026-07-28: 25
- 2026-07-27: 53

## Links

- npm package: https://www.npmjs.com/package/mcp-adr-analysis-server
- Socket report: https://socket.dev/npm/package/mcp-adr-analysis-server
- Repository: https://github.com/tosin2013/mcp-adr-analysis-server
- Changelog RSS feed: https://verifymcp.io/servers/tosin2013-mcp-adr-analysis-server/mcp-adr-analysis-server/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/tosin2013-mcp-adr-analysis-server/mcp-adr-analysis-server/changelog.json
- HTML version of this page: https://verifymcp.io/servers/tosin2013-mcp-adr-analysis-server/mcp-adr-analysis-server