Maven Tools MCP Server

Universal Maven Central dependency intelligence for JVM build tools

MCP server providing AI assistants with Maven Central dependency intelligence for all JVM build tools (Maven, Gradle, SBT, Mill). Get instant, accurate dependency information that's faster and more reliable than web searches. Features Context7 integration for documentation support.

🎯 Why This Matters

• Problem: Dependency management involves time-intensive manual searches across Maven Central for version updates and compatibility analysis
• Solution: AI-assisted dependency intelligence with instant bulk analysis, trend insights, and risk assessment for any JVM build tool

⚡ Quick Demo

Ask your AI assistant:

• "Check all dependencies in this build file for latest versions" (paste your build.gradle, pom.xml, build.sbt)
• "What's the latest Spring Boot version?"
• "Which dependencies in my project need updates?" (any build tool)
• "Show me only stable versions for production deployment"
• "How old are my dependencies and which ones need attention?" (v1.1.0)
• "Analyze the release patterns for my key dependencies" (v1.1.0)
• "Give me a health check for all my project dependencies" (v1.1.0)
• "How do I upgrade Spring Boot from 2.7.0 to the latest version? Show me migration guidance" (v1.2.0 with Context7 guidance)
• "Check these dependencies for upgrades and suggest documentation searches" (paste your pom.xml/build.gradle) (v1.2.0)
• "I'm still using Jackson 2.12.0. Should I upgrade and how?" (v1.2.0 with guided delegation)

🔧 Supported Build Tools

Working with any build tool that uses Maven Central Repository:

All tools use standard Maven coordinates - just provide groupId:artifactId and we handle the rest.

⚡ Competitive Advantages

vs Simple Lookup Tools

• ✅ Bulk Operations - Analyze 20+ dependencies in one call
• ✅ Version Comparison - Understand upgrade impact (major/minor/patch)
• ✅ Stability Filtering - Choose stable-only or include pre-release versions
• ✅ Enterprise Performance - <100ms cached responses, native images
• ✅ Analytical Intelligence - Age analysis, release patterns, project health scoring (v1.1.0)
• ✅ Context7 Guidance - Smart documentation hints with guided delegation architecture (v1.2.0)

vs Manual Dependency Management

• ✅ Risk Assessment - Identify breaking changes before upgrading
• ✅ Universal Support - Works with any JVM build tool
• ✅ Complete Analysis - All version types with intelligent prioritization
• ✅ Maintenance Intelligence - Predict maintenance activity and sustainability (v1.1.0)

Setup for Claude Desktop

Step 1: Locate your Claude Desktop configuration file

• Windows: %APPDATA%\Claude\claude_desktop_config.json
• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json

Step 2: Add this configuration (using pre-built Docker image):

{
  "mcpServers": {
    "maven-tools": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm", "-e", "SPRING_PROFILES_ACTIVE=docker",
        "arvindand/maven-tools-mcp:latest"
      ]
    }
  }
}

Step 3: Restart Claude Desktop

Prerequisites: Docker installed and running

Note: The Docker image supports both AMD64 (Intel/AMD) and ARM64 (Apple Silicon) architectures. Docker automatically selects the correct version for your platform.

Setup for VS Code with GitHub Copilot

Option 1: Workspace Configuration - Create .vscode/mcp.json:

{
  "servers": {
    "maven-tools": {
      "type": "stdio",
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "SPRING_PROFILES_ACTIVE=docker", "arvindand/maven-tools-mcp:latest"]
    }
  }
}

Option 2: User Settings - Add to your VS Code settings:

{
  "mcp": {
    "servers": {
      "maven-tools": {
        "type": "stdio", 
        "command": "docker",
        "args": ["run", "-i", "--rm", "-e", "SPRING_PROFILES_ACTIVE=docker", "arvindand/maven-tools-mcp:latest"]
      }
    }
  }
}

Usage: Open Chat view (Ctrl+Alt+I), select Agent mode, then use the Tools button to enable Maven tools.

What it does

Core Dependency Intelligence:

• Get latest or stable versions of Maven dependencies
• Check if specific versions exist
• Bulk version checking for multiple dependencies
• Compare versions and get update recommendations

Advanced Analytics (v1.1.0):

• Analyze dependency age and freshness (fresh/current/aging/stale)
• Assess maintenance activity and release patterns
• Predict next release timeframes
• Comprehensive project health scoring with risk assessment

Available Tools

Core Maven Intelligence Tools (8 tools)

Raw Context7 Documentation Tools (2 tools - Enabled by Default)

Tool Parameters

Core Parameters:

• preferStable - Prioritize stable versions in analysis
• stableOnly - Filter to production-ready versions only
• onlyStableTargets - Only suggest upgrades to stable versions

Analytical Parameters (v1.1.0):

• maxAgeInDays - Set acceptable age threshold for dependencies
• monthsToAnalyze - Specify analysis period for release patterns (default: 24)
• versionCount - Number of recent versions to analyze in timeline (default: 20)
• includeRecommendations - Include detailed recommendations in health analysis

Context7 Integration (v1.2.0):

Context7 integration is enabled by default (context7.enabled=true). Maven tools automatically include Context7 guidance hints in response models when upgrades or modernization are needed. Additionally, the server acts as an MCP client to expose raw Context7 tools (resolve-library-id, get-library-docs) directly to your AI assistant. When disabled, responses contain only core dependency analysis without guidance hints or Context7 tools.

Universal Compatibility: All tools work with standard Maven coordinates (groupId:artifactId) and support any JVM build tool.

get_latest_version

Get latest version of any dependency from Maven Central (works with Maven, Gradle, SBT, Mill) with stability preferences.

Parameters:

• dependency (string, required): Maven coordinate in format groupId:artifactId (NO version)
• preferStable (boolean, optional): When true, prioritizes stable version in response (default: false)

Examples:

{
  "dependency": "org.springframework:spring-core",
  "preferStable": false
}

{
  "dependency": "org.springframework:spring-boot",
  "preferStable": true
}

Response:

{
  "dependency": "org.springframework:spring-core",
  "latest_stable": { "version": "6.2.7", "type": "stable" },
  "latest_rc": { "version": "7.0.0-RC1", "type": "rc" },
  "latest_beta": { "version": "7.0.0-beta1", "type": "beta" },
  "latest_alpha": { "version": "7.0.0-alpha1", "type": "alpha" },
  "latest_milestone": { "version": "7.0.0-M5", "type": "milestone" },
  "total_versions": 100
}

check_version_exists

Check if specific dependency version exists and identify its stability type. Works with any JVM build tool.

Parameters:

• dependency (string, required): Maven coordinate in format groupId:artifactId (NO version)
• version (string, required): Version to check

Example:

{
  "dependency": "org.jetbrains.kotlin:kotlin-stdlib",
  "version": "1.9.0"
}

Response:

{
  "exists": true,
  "version": "6.0.0",
  "type": "stable"
}

check_multiple_dependencies

Check latest versions for multiple dependencies with filtering options. Works with any JVM build tool.

Parameters:

• dependencies (string, required): Comma- or newline-separated list of Maven coordinates (NO versions)
• stableOnly (boolean, optional): When true, filters to production-ready versions only (default: false)

Examples:

{
  "dependencies": "org.jetbrains.kotlin:kotlin-stdlib,com.squareup.retrofit2:retrofit,org.apache.spark:spark-core_2.13",
  "stableOnly": false
}

{
  "dependencies": "org.springframework:spring-boot,com.fasterxml.jackson.core:jackson-core",
  "stableOnly": true
}

Response (array):

[
  {
    "dependency": "org.springframework:spring-core",
    "primary_version": "6.2.7",
    "primary_type": "stable",
    "total_versions": 100,
    "stable_versions": 82,
    "latest_stable": { "version": "6.2.7", "type": "stable" },
    "latest_rc": { "version": "7.0.0-RC1", "type": "rc" },
    "latest_beta": null,
    "latest_alpha": null,
    "latest_milestone": { "version": "7.0.0-M5", "type": "milestone" }
  },
  // ...more results
]

compare_dependency_versions

Compare current dependency versions with latest available and show upgrade recommendations with safety controls.

Parameters:

• currentDependencies (string, required): Comma- or newline-separated list of Maven coordinates with versions (groupId:artifactId:version)
• onlyStableTargets (boolean, optional): When true, only suggests upgrades to stable versions (default: false)

Examples:

{
  "currentDependencies": "org.jetbrains.kotlin:kotlin-stdlib:1.8.0,com.squareup.retrofit2:retrofit:2.9.0",
  "onlyStableTargets": false
}

{
  "currentDependencies": "org.springframework:spring-boot:2.7.0,org.hibernate:hibernate-core:5.6.0",
  "onlyStableTargets": true
}

Response:

{
  "comparison_date": "2025-06-07T22:38:47Z",
  "dependencies": [
    {
      "dependency": "org.springframework:spring-core:6.0.0",
      "current_version": "6.0.0",
      "latest_version": "7.0.0-M5",
      "latest_type": "milestone",
      "update_type": "major",
      "update_available": true,
      "status": "success",
      "error": null
    }
  ],
  "update_summary": {
    "major_updates": 1,
    "minor_updates": 0,
    "patch_updates": 0,
    "no_updates": 0
  }
}

Raw Context7 MCP Tools

Note: Context7 integration is enabled by default. The following raw Context7 MCP tools are automatically available through the server's dual MCP architecture (acting as both MCP server and MCP client):

resolve-library-id

Search for library documentation using intelligent name resolution.

Parameters:

• libraryName (string, required): Search term for library lookup (e.g., "spring boot", "testcontainers")

Example:

{
  "libraryName": "testcontainers postgresql"
}

get-library-docs

Get comprehensive documentation for a library using its Context7 ID.

Parameters:

• context7CompatibleLibraryID (string, required): Context7-compatible library ID (from resolve-library-id)
• topic (string, optional): Topic for focused documentation (e.g., "setup", "migration", "configuration")
• tokens (integer, optional): Maximum tokens to retrieve (default: 10000)

Example:

{
  "context7CompatibleLibraryID": "/testcontainers/testcontainers-java",
  "topic": "postgresql setup",
  "tokens": 5000
}

These tools are automatically available by default through Spring AI MCP client integration. The server acts as both an MCP server (exposing Maven tools) and an MCP client (exposing Context7 tools), providing a unified interface for both dependency analysis and documentation access.

Usage Examples

Getting Started Examples

Simple Questions:

• "Get latest Spring Boot version but prioritize stable releases"
• "Check if Kotlin 1.9.0 exists and what stability type it is"
• "Show me latest stable version of Retrofit for production deployment"

Multi-Build Tool Support:

• "Check these Gradle dependencies: org.jetbrains.kotlin:kotlin-stdlib,com.squareup.retrofit2:retrofit"
• "I need stable versions only for my SBT project dependencies"
• "Compare my Maven versions but only suggest stable upgrades for production"

Advanced Stability Controls:

• "Check multiple dependencies but filter to stable versions only"
• "Compare my current versions with onlyStableTargets=true for safety"
• "Get complete analysis but prefer stable versions in results"

🚀 Real-World Use Cases

Gradle Project Analysis

Action: Paste your build.gradle: "Analyze my Gradle dependencies for outdated versions"
Result: Universal dependency analysis in seconds across any build tool

Security Response

Action: "Show me latest stable versions for these affected dependencies"
Result: Instant security patch identification with production-safe recommendations

Multi-Build Tool Projects

Action: "What are the latest stable versions for Spring Boot, Spring Security, and Jackson for both Maven and Gradle?"
Result: Universal dependency intelligence across all JVM build tools

Migration Planning with Risk Assessment

Action: "Compare my current versions but only suggest stable upgrades for production safety"
Result: Risk-assessed upgrade recommendations with stability filtering

🆚 Why Not Just Web Search?

✨ Advanced Features Examples

Analytical Intelligence (v1.1.0) & Documentation Enrichment (v1.2.0)

Dependency Age Analysis

Usage: "How old is my Spring Boot dependency and should I update it?"
Tool: analyze_dependency_age

{
  "dependency": "org.springframework.boot:spring-boot-starter",
  "age_classification": "current",
  "days_since_release": 45,
  "recommendation": "Actively maintained - consider updating if needed"
}

Release Pattern Analysis

Usage: "What's the maintenance pattern for Jackson? When might the next release be?"
Tool: analyze_release_patterns

{
  "dependency": "com.fasterxml.jackson.core:jackson-core",
  "maintenance_level": "active",
  "release_velocity": 1.2,
  "next_release_prediction": "Expected in 3 weeks"
}

Project Health Check

Usage: "Give me a health assessment for all my key dependencies"
Tool: analyze_project_health

{
  "overall_health": "good",
  "average_health_score": 78,
  "age_distribution": {"fresh": 2, "current": 8, "aging": 3, "stale": 1}
}

Version Timeline Intelligence

Usage: "Show me the recent release timeline for JUnit with gap analysis"
Tool: get_version_timeline

{
  "insights": ["High release frequency indicates active development"],
  "recent_activity": {"activity_level": "active", "releases_last_quarter": 4}
}

Features

• Version lookup (latest, stable, or specific versions)
• Version type classification (stable, RC, beta, alpha, milestone)
• Bulk operations for multiple dependencies
• Version comparison tools
• Dependency age analysis with actionable insights (v1.1.0)
• Maintenance pattern analysis and predictions (v1.1.0)
• Project health scoring and recommendations (v1.1.0)
• Context7 migration guidance and upgrade strategies (v1.2.0)
• Documentation enrichment for complex upgrades (v1.2.0)
• Caching for better performance
• Works with MCP-compatible AI assistants

Note: Snapshot versions are not supported. This is because the Maven Central API does not index or provide access to snapshot artifacts. Only released versions (stable, rc, beta, alpha, milestone) are available.

Context7 Guided Delegation Architecture (v1.2.0)

Default Behavior: Context7 integration is enabled by default in v1.2.0. The server acts as both an MCP server (providing Maven tools) and an MCP client (exposing Context7 tools), giving your AI assistant access to both dependency intelligence and documentation guidance in a single connection. When disabled (context7.enabled=false), Maven tools work independently without Context7 guidance hints or raw Context7 tools.

Dual MCP Architecture

Maven Tools MCP uses a dual MCP architecture with guided delegation for Context7 integration:

1. MCP Server: Provides 8 Maven dependency analysis tools with intelligent Context7 guidance hints
2. MCP Client: Acts as Context7 MCP client to expose raw Context7 tools (resolve-library-id, get-library-docs)
3. Intelligent Integration: Maven tools include smart Context7 search suggestions when upgrades/modernization are needed
4. Direct Access: Your AI assistant can use both Maven analysis AND Context7 documentation tools in a single connection

This dual architecture provides both dependency intelligence and documentation access through one MCP server connection, with intelligent guidance for effective Context7 tool usage.

Context7 Tools (Enabled by Default)

Context7 tools are automatically enabled by default. To disable Context7 integration entirely, set the environment variable:

{
  "mcpServers": {
    "maven-tools": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm", 
        "-e", "SPRING_PROFILES_ACTIVE=docker",
        "-e", "CONTEXT7_ENABLED=false",
        "arvindand/maven-tools-mcp:latest"
      ]
    }
  }
}

Graceful Design: Context7 integration is enabled by default, providing guidance hints and raw Context7 tools out of the box. When disabled, Maven tools work independently without Context7 features, providing only core dependency analysis.

Context7 Guidance Hints (v1.2.0)

Intelligent LLM Orchestration:

Maven Tools MCP provides Context7 guidance hints in response models to help LLMs effectively use the raw Context7 MCP tools when documentation is needed. This guided delegation approach ensures reliable functionality while maintaining simplicity.

Context7 Guidance Example:

Usage: "Compare my Spring Boot version and show upgrade path"

Tool: compare_dependency_versions

{
  "dependencies": [{
    "dependency": "org.springframework.boot:spring-boot-starter:2.7.0",
    "current_version": "2.7.0",
    "latest_version": "3.2.0", 
    "update_type": "major",
    "context7_guidance": {
      "suggested_search": "Spring Boot major version upgrade migration guide",
      "search_hints": [
        "Search for 'Spring Boot migration' or 'Spring Framework upgrade'",
        "Include version numbers for specific migration paths",
        "Look for official Spring.io documentation"
      ],
      "complexity": "high",
      "documentation_focus": "migration guides, breaking changes, upgrade paths"
    }
  }]
}

Modernization Guidance Example:

Usage: "Analyze my aging dependencies with modernization suggestions"

Tool: analyze_dependency_age

{
  "dependency": "org.hibernate:hibernate-core",
  "age_classification": "AGING",
  "days_since_last_release": 180,
  "recommendation": "Consider upgrading - dependency is showing age",
  "context7_guidance": {
    "suggested_search": "Hibernate ORM upgrade to latest best practices",
    "search_hints": [
      "Search for 'Hibernate ORM Java' to avoid NHibernate (.NET) results",
      "Include 'JPA' keyword for persistence-related guidance",
      "Look for official Hibernate documentation"
    ],
    "complexity": "moderate",
    "documentation_focus": "best practices, modern usage, latest features"
  }
}

Performance Notes

• Cache effectiveness: ~90% of repeated requests served from cache
• Recommended batch sizes: 10-20 dependencies for bulk operations
• First requests: Build cache (normal), subsequent requests much faster
• Cache duration: 24 hours

🤔 Frequently Asked Questions

Q: How is this different from Dependabot/Renovate?
A: Those tools create automated PRs. This gives you instant, interactive dependency intelligence through your AI assistant for decision-making and planning.

Q: How much time does this actually save?
A: For single dependencies: from 3-5 seconds (web search) to <100ms. For 20+ dependencies: from 60+ seconds of manual searching to <500ms bulk analysis.

Q: Why not just search Maven Central directly?
A: This provides structured, cached responses optimized for AI consumption with intelligent version classification and bulk operations - plus the time savings above.

Q: Can this replace my IDE's dependency management?
A: No, it complements your IDE by providing instant dependency intelligence during natural conversations with AI assistants for planning and decision-making.

Q: What AI assistants does this work with?
A: Any MCP-compatible assistant including Claude Desktop, GitHub Copilot, and other MCP clients. Works through natural conversation.

Q: Does it work with private Maven repositories?
A: Currently only Maven Central.

Q: What about Gradle dependencies?
A: Maven Central hosts both Maven and Gradle dependencies, so it works for Gradle projects too (using Maven coordinates).

Q: What is Context7 and how does the guided delegation work?
A: Context7 is an MCP server by Upstash that provides up-to-date documentation and code examples. Maven Tools MCP uses a guided delegation architecture (v1.2.0) - our tools provide Context7 guidance hints to help your AI assistant effectively use the raw Context7 tools when documentation is needed. This keeps the system simple while providing intelligent orchestration.

Alternative Setup Methods

Using Docker Compose

Alternative Claude Desktop configuration (if you prefer compose):

Download docker-compose.yml and configure:

{
  "mcpServers": {
    "maven-tools": {
      "command": "docker",
      "args": [
        "compose", "-f", "/absolute/path/to/docker-compose.yml", 
        "run", "--rm", "maven-tools-mcp"
      ]
    }
  }
}

For development/testing only:

docker compose up -d  # Runs server in background for testing

Build from Source (for contributors)

Prerequisites:

• Java 24
• Maven 3.9+

# Clone the repository
git clone https://github.com/arvindand/maven-tools-mcp.git
cd maven-tools-mcp

# Quick build (CI-friendly - unit tests only)
./mvnw clean package -Pci

# Full build with all tests (requires network access)
./mvnw clean package -Pfull

# Run the JAR
java -jar target/maven-tools-mcp-1.2.0.jar

Claude Desktop configuration for JAR:

{
  "mcpServers": {
    "maven-tools": {
      "command": "java",
      "args": [
        "-jar",
        "/absolute/path/to/maven-tools-mcp-1.2.0.jar"
      ]
    }
  }
}

Build Scripts

For easier builds, use the provided scripts in the build/ folder:

# Linux/macOS - Complete build helper
./build/build.sh

# Windows - Complete build helper
.\build\build.cmd

Enterprise & Custom Clients

This server implements MCP Protocol 2024-11-05 with stdio transport, making it compatible with any MCP-compliant client.

Configuration

The server can be configured via application.yaml:

# Cache configuration
spring:
  cache:
    type: caffeine
    caffeine:
      spec: maximumSize=2000,expireAfterWrite=3600s

# Maven Central API settings
maven:
  central:
    base-url: https://search.maven.org/solrsearch/select
    timeout: 10s
    max-results: 100

# Logging (minimal for MCP stdio transport)
logging:
  level:
    root: ERROR

Technical Details

• Framework: Spring Boot 3.5.4 with Spring AI MCP
• MCP Protocol: 2024-11-05
• Java Version: 24
• Transport: stdio
• HTTP Client: Spring Web RestClient
• Cache: Caffeine (24-hour TTL, 2000 entries max)
• API: Maven Central Search API

References & Resources

Model Context Protocol (MCP)

• Official Website: modelcontextprotocol.io
• GitHub Repository: modelcontextprotocol/specification
• Protocol Documentation: MCP Specification

Spring AI MCP

• Documentation: Spring AI MCP Reference
• GitHub: spring-projects/spring-ai

Maven Central API

• Search API: search.maven.org
• REST API Guide: Using the REST API

Context7 MCP Server

• GitHub Repository: upstash/context7
• NPM Package: @upstash/context7-mcp
• Documentation: Upstash Context7 Blog

📝 Community & Discussion

Blog Posts:

• How I Connected Claude to Maven Central (and Why You Should Too)
• Guided Delegation: Adding Context7 Documentation to My Maven Tools MCP Server

Get Involved

• 💬 Discuss: Share your experiences and ask questions on dev.to
• 🐛 Issues: Report bugs or request features
• ⭐ Support: Star this repo if it improves your workflow

License

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

Author

Arvind Menon

• GitHub: @arvindand
• Version: 1.2.0