Package Version MCP 服务器

一个 MCP 服务器，提供用于从多个包注册中心检查最新稳定包版本的工具：

• npm (Node.js/JavaScript)
• PyPI (Python)
• Maven Central (Java)
• Go Proxy (Go)
• Swift Packages (Swift)
• AWS Bedrock (AI 模型)
• Docker Hub (容器镜像)
• GitHub Container Registry (容器镜像)
• GitHub Actions

此服务器帮助 LLM 确保在编写代码时推荐最新的软件包版本。

<a href="https://glama.ai/mcp/servers/zkts2w92ba"><img width="380" height="200" src="https://glama.ai/mcp/servers/zkts2w92ba/badge" alt="https://github.com/sammcj/mcp-package-version MCP server" /></a>

截图

运行

通过 Smithery 安装

要通过 Smithery 为 Claude Desktop 自动安装 Package Version：

npx -y @smithery/cli install mcp-package-version --client claude

配置 MCP 设置

将以下内容添加到您的 MCP 设置文件中：

{
  "mcpServers": {
    "package-version": {
      "command": "npx",
      "args": ["-y", "mcp-package-version"]
    }
  }
}

如果您位于通过 MITM 拦截流量的企业代理之后，您可能需要额外指定代理 CA 证书包：

{
  "mcpServers": {
    "package-version": {
      "command": "npx",
      "args": ["-y", "mcp-package-version"],
      "env": {
        "NODE_EXTRA_CA_CERTS": "/path/to/mitm/cert.pem"
      }
    }
  }
}

• 对于 Cline VSCode 扩展，这将是 ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
• 对于 Claude Desktop，这将是 ~/Library/Application\ Support/Claude/claude_desktop_config.json
• 对于 GoMCP，这将是 ~/.config/gomcp/config.yaml

工具

1. JavaScript/Node.js

check_npm_versions

从 package.json 依赖项对象检查 npm 包的最新稳定版本。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_npm_versions",
  arguments: {
    dependencies: {
      "express": "^4.17.1",
      "react": "^17.0.2"
    }
  }
});

2. Python

check_python_versions

从 requirements.txt 条目检查 Python 包的最新稳定版本。

check_pyproject_versions

从 pyproject.toml 检查 Python 包的最新稳定版本。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_pyproject_versions",
  arguments: {
    dependencies: {
      dependencies: {
        "requests": "^2.28.0",
        "pandas": ">=1.5.0"
      },
      "optional-dependencies": {
        "test": {
          "pytest": ">=7.0.0"
        }
      },
      "dev-dependencies": {
        "black": "^22.0.0"
      }
    }
  }
});

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_python_versions",
  arguments: {
    requirements: [
      "requests==2.26.0",
      "pandas>=1.3.0"
    ]
  }
});

3. Go

check_go_versions

从 go.mod 检查 Go 包的最新稳定版本。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_go_versions",
  arguments: {
    dependencies: {
      module: "example.com/mymodule",
      require: [
        {
          path: "github.com/gin-gonic/gin",
          version: "v1.7.0"
        }
      ],
      replace: [
        {
          old: "github.com/old/pkg",
          new: "github.com/new/pkg",
          version: "v2.0.0"
        }
      ]
    }
  }
});

4. Java

但说真的，2025 年不要再写 Java 了。

check_maven_versions

从 pom.xml 检查 Java 包的最新稳定版本。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_maven_versions",
  arguments: {
    dependencies: [
      {
        groupId: "org.springframework.boot",
        artifactId: "spring-boot-starter-web",
        version: "2.7.0",
        scope: "compile"
      }
    ]
  }
});

check_gradle_versions

从 build.gradle 检查 Java 包的最新稳定版本。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_gradle_versions",
  arguments: {
    dependencies: [
      {
        configuration: "implementation",
        group: "com.google.guava",
        name: "guava",
        version: "31.0-jre"
      }
    ]
  }
});

5. check_package_versions

批量检查来自 npm 和 PyPI 的多个包的最新稳定版本。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_package_versions",
  arguments: {
    packages: [
      { name: "react", registry: "npm" },
      { name: "requests", registry: "pypi" },
      { name: "typescript", registry: "npm", currentVersion: "5.0.0" }
    ]
  }
});

6. AWS Bedrock

check_bedrock_models

搜索、列出并获取有关 Amazon Bedrock AI 模型的信息。

// 列出所有可用的 Bedrock 模型
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_bedrock_models",
  arguments: {
    action: "list"
  }
});

// 搜索特定模型
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_bedrock_models",
  arguments: {
    action: "search",
    query: "claude",
    provider: "anthropic"
  }
});

// 通过 ID 获取特定模型
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_bedrock_models",
  arguments: {
    action: "get",
    modelId: "anthropic.claude-3-sonnet-20240229-v1:0"
  }
});

get_latest_bedrock_model

从 Amazon Bedrock 获取最新的 Claude Sonnet 模型（最适合编码任务）。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "get_latest_bedrock_model",
  arguments: {}
});

7. Swift

check_swift_versions

检查 Package.swift 中 Swift 包的最新稳定版本。

use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_swift_versions",
  arguments: {
    dependencies: [
      {
        url: "https://github.com/apple/swift-argument-parser",
        version: "1.0.0",
        requirement: "from"
      },
      {
        url: "https://github.com/apple/swift-log.git",
        version: "1.4.0",
        requirement: "upToNextMajor"
      }
    ],
    constraints: {
      "https://github.com/apple/swift-argument-parser": {
        majorVersion: 1
      }
    }
  }
});

8. GitHub Actions

check_github_actions

检查 GitHub Actions 的最新版本。

// 检查 GitHub Actions 的最新版本
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_github_actions",
  arguments: {
    actions: [
      {
        owner: "actions",
        repo: "checkout",
        currentVersion: "v3"
      },
      {
        owner: "actions",
        repo: "setup-node",
        currentVersion: "v3"
      }
    ],
    includeDetails: true // 可选：包括发布日期和 URL
  }
});

9. Docker 容器镜像

check_docker_tags

检查来自 Docker Hub、GitHub Container Registry 或自定义注册表的 Docker 容器镜像的可用标签。

// 检查 Docker Hub 镜像
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_docker_tags",
  arguments: {
    image: "nginx",
    limit: 5
  }
});

// 检查 GitHub Container Registry 镜像
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_docker_tags",
  arguments: {
    image: "ghcr.io/owner/repo",
    registry: "ghcr"
  }
});

// 检查自定义注册表镜像
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_docker_tags",
  arguments: {
    image: "my-image",
    registry: "custom",
    customRegistry: "registry.example.com"
  }
});

// 使用正则表达式模式过滤标签
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_docker_tags",
  arguments: {
    image: "node",
    filterTags: ["^18", "^20"],
    includeDigest: true
  }
});

LLM 指南

在编写包含包依赖项的代码时，LLM 应该：

0. 选择适合工作的工具

   • 使用特定于语言的工具进行详细的依赖项管理：
     • check_npm_versions 用于 package.json
     • check_python_versions 用于 requirements.txt
     • check_pyproject_versions 用于 pyproject.toml
     • check_maven_versions 用于 pom.xml
     • check_gradle_versions 用于 build.gradle
     • check_go_versions 用于 go.mod
     • check_swift_versions 用于 Package.swift
   • 使用 check_package_versions 快速批量检查 npm 和 PyPI
   • 使用 AWS Bedrock 工具获取 AI 模型信息：
     • check_bedrock_models 搜索、列出或获取特定模型信息
     • get_latest_bedrock_model 获取最新的 Claude Sonnet 模型（最适合编码任务）
   • 使用 GitHub Actions 工具：
     • check_github_actions 查找 GitHub Actions 的最新版本
   • 使用 Docker 容器镜像工具：
     • check_docker_tags 查找来自 Docker Hub、GitHub Container Registry 或自定义注册表的 Docker 镜像的可用标签

1. 始终在编写之前检查版本

   • 在编写 package.json 或 requirements.txt 文件之前，使用适当的工具检查最新版本
   • 在处理多个包时使用批量检查工具
   • 在决定是使用确切版本还是版本范围时，请考虑项目的需求

2. Package.json 最佳实践

   // 在编写 package.json 之前，检查版本
   const versions = await use_mcp_tool({
     server_name: "package-version",
     tool_name: "check_package_versions",
     arguments: {
       packages: [
         { name: "express", registry: "npm" },
         { name: "react", registry: "npm" }
       ]
     }
   });
   
   // 在 package.json 中使用返回的版本
   {
     "dependencies": {
       "express": `^${versions.find(p => p.name === 'express').latestVersion}`,
       "react": `^${versions.find(p => p.name === 'react').latestVersion}`
     }
   }
   

3. Requirements.txt 最佳实践

   // 在编写 requirements.txt 之前，检查版本
   const versions = await use_mcp_tool({
     server_name: "package-version",
     tool_name: "check_package_versions",
     arguments: {
       packages: [
         { name: "requests", registry: "pypi" },
         { name: "pandas", registry: "pypi" }
       ]
     }
   });
   
   // 在 requirements.txt 中使用返回的版本
   requests=={requests.latestVersion}
   pandas=={pandas.latestVersion}
   

4. 版本范围注意事项

   • 对于应用程序：考虑使用确切版本（Python 使用 =，npm 不使用前缀）
   • 对于库：考虑使用兼容范围（Python 使用 >=，npm 使用 ^）
   • 始终在注释中记录版本选择

5. 错误处理

   • 如果包的版本检查失败，请在注释中记录
   • 如果检查失败，请考虑回退到已知的稳定版本
   • 警告用户任何无法验证的包

示例集成

以下是 LLM 应如何处理使用不同包管理器创建新项目：

Node.js 项目

// 1. 检查 npm 包版本
const versions = await use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_npm_versions",
  arguments: {
    dependencies: {
      "express": "^4.17.1",
      "typescript": "~4.5.0"
    }
  }
});

// 2. 在 package.json 中使用版本
write_to_file({

  path: "package.json",
  content: {
    "name": "my-project",
    "version": "1.0.0",
    "dependencies": {
      "express": `^${versions.find(p => p.name === 'express').latestVersion}`,
      "typescript": `^${versions.find(p => p.name === 'typescript').latestVersion}`
    }
  }
});

带有 pyproject.toml 的 Python 项目

// 1. 检查 Python 包版本
const versions = await use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_pyproject_versions",
  arguments: {
    dependencies: {
      dependencies: {
        "requests": "^2.28.0",
        "pandas": ">=1.5.0"
      },
      "dev-dependencies": {
        "pytest": ">=7.0.0"
      }
    }
  }
});

// 2. 在 pyproject.toml 中使用版本
write_to_file({
  path: "pyproject.toml",
  content: `
[project]
name = "my-project"
version = "1.0.0"
dependencies = [
    "requests>=${versions.find(p => p.name === 'requests').latestVersion}",
    "pandas>=${versions.find(p => p.name === 'pandas').latestVersion}"
]

[project.optional-dependencies]
test = [
    "pytest>=${versions.find(p => p.name === 'pytest (dev)').latestVersion}"
]
`
});

Go 项目

// 1. 检查 Go 包版本
const versions = await use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_go_versions",
  arguments: {
    dependencies: {
      module: "example.com/mymodule",
      require: [
        {
          path: "github.com/gin-gonic/gin",
          version: "v1.7.0"
        }
      ]
    }
  }
});

// 2. 在 go.mod 中使用版本
write_to_file({
  path: "go.mod",
  content: `
module example.com/mymodule

go 1.21

require (
    github.com/gin-gonic/gin ${versions.find(p => p.name === 'github.com/gin-gonic/gin').latestVersion}
)
`
});

带有 Maven 的 Java 项目

// 1. 检查 Maven 包版本
const versions = await use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_maven_versions",
  arguments: {
    dependencies: [
      {
        groupId: "org.springframework.boot",
        artifactId: "spring-boot-starter-web",
        version: "2.7.0"
      }
    ]
  }
});

// 2. 在 pom.xml 中使用版本
write_to_file({
  path: "pom.xml",
  content: `
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-project</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${versions.find(p => p.name === 'org.springframework.boot:spring-boot-starter-web').latestVersion}</version>
        </dependency>
    </dependencies>
</project>
`
});

Swift 项目

// 1. 检查 Swift 包版本
const versions = await use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_swift_versions",
  arguments: {
    dependencies: [
      {
        url: "https://github.com/apple/swift-argument-parser",
        version: "1.0.0",
        requirement: "from"
      }
    ]
  }
});

// 2. 在 Package.swift 中使用版本
write_to_file({
  path: "Package.swift",
  content: `
// swift-tools-version:5.5
import PackageDescription

let package = Package(
    name: "MyProject",
    products: [
        .library(name: "MyProject", targets: ["MyProject"]),
    ],
    dependencies: [
        .package(url: "https://github.com/apple/swift-argument-parser", from: "${versions.find(p => p.name === 'swift-argument-parser').latestVersion}"),
    ],
    targets: [
        .target(name: "MyProject", dependencies: [.product(name: "ArgumentParser", package: "swift-argument-parser")]),
        .testTarget(name: "MyProjectTests", dependencies: ["MyProject"]),
    ]
)
`
});

这确保了新项目始终以最新的稳定软件包版本开始。

---

示例系统提示

在编写包含包依赖项的代码时，您必须：

1. 在编写任何依赖项文件之前，使用 package-version MCP 服务器检查最新的稳定版本：

// 对于 Node.js (package.json):
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_npm_versions",
  arguments: {
    dependencies: {
      "package-name": "version"
    }
  }
});

// 对于 Python (requirements.txt):
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_python_versions",
  arguments: {
    requirements: [
      "package-name==version"
    ]
  }
});

// 对于 Python (pyproject.toml):
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_pyproject_versions",
  arguments: {
    dependencies: {
      dependencies: {
        "package-name": "version"
      }
    }
  }
});

// 对于 Java Maven (pom.xml):
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_maven_versions",
  arguments: {
    dependencies: [
      {
        groupId: "group",
        artifactId: "artifact",
        version: "version"
      }
    ]
  }
});

// 对于 Java Gradle (build.gradle):
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_gradle_versions",
  arguments: {
    dependencies: [
      {
        configuration: "implementation",
        group: "group",
        name: "name",
        version: "version"
      }
    ]
  }
});

// 对于 Go (go.mod):
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_go_versions",
  arguments: {
    dependencies: {
      module: "module-name",
      require: [
        {
          path: "package-path",
          version: "version"
        }
      ]
    }
  }
});

// 对于 Swift (Package.swift):
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_swift_versions",
  arguments: {
    dependencies: [
      {
        url: "https://github.com/package/repo",
        version: "version",
        requirement: "from" // 或 "upToNextMajor" 或 "exact"
      }
    ]
  }
});

// 对于 AWS Bedrock 模型:
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_bedrock_models",
  arguments: {
    action: "search",
    query: "claude",
    provider: "anthropic"
  }
});

// 对于获取最新的 Claude Sonnet 模型:
use_mcp_tool({
  server_name: "package-version",
  tool_name: "get_latest_bedrock_model",
  arguments: {}
});

// 对于 GitHub Actions:
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_github_actions",
  arguments: {
    actions: [
      {
        owner: "owner",
        repo: "repo",
        currentVersion: "version" // optional
      }
    ],
    includeDetails: false // optional, default is false
  }
});

// 对于 Docker 容器镜像:
use_mcp_tool({
  server_name: "package-version",
  tool_name: "check_docker_tags",
  arguments: {
    image: "image-name",
    registry: "dockerhub", // 或 "ghcr" 或 "custom"
    customRegistry: "registry.example.com", // 当 registry 为 "custom" 时是必需的
    limit: 10, // optional, default is 10
    filterTags: ["regex-pattern"], // optional
    includeDigest: false // optional, default is false
  }
});

2. 在您的依赖项文件中使用返回的最新版本：
   - 对于应用程序：使用确切版本
   - 对于库：使用兼容范围
     - npm: ^ 用于次要更新，~ 用于补丁更新
     - Python: >= 用于兼容版本，== 用于确切版本
     - Java: 直接使用版本（Maven/Gradle 以不同的方式处理范围）
     - Go: 使用语义版本前缀（例如，v1.2.3）
     - Swift: 使用 from、upToNextMajor 或确切的版本要求
   - 在注释中记录任何特定于版本的需求

3. 如果版本检查失败：
   - 在注释中记录
   - 使用已知的稳定版本作为回退
   - 考虑项目需求和兼容性

用户示例系统提示：

在编写包含依赖项的代码时，您必须在使用 package-version MCP 服务器检查最新的稳定版本之后，才能编写任何依赖项文件（package.json、requirements.txt、pyproject.toml、pom.xml、build.gradle、go.mod、Package.swift）。 对于应用程序，请使用确切的版本，对于库，请根据包管理器的约定使用适当的版本范围。 在注释中记录任何特定于版本的需求或失败的检查。 对于 AI 模型信息，请使用 AWS Bedrock 工具搜索、列出或获取特定模型详细信息。 对于 GitHub Actions，请使用 check_github_actions 工具查找最新版本。 对于 Docker 容器镜像，请使用 check_docker_tags 工具查找来自 Docker Hub、GitHub Container Registry 或自定义注册表的可用标签。

开发

1. 克隆并安装依赖项

   git clone https://github.com/sammcj/mcp-package-version.git
   cd mcp-package-version
   npm i
   

2. 构建服务器

   npm run build
   

3. 开发工作流程

   • 使用 npm run watch 进行开发，以便在更改时自动重建
   • 使用 npm run build 进行生产构建

4. 发布流程

   # 1. 进行更改
   vim src/your-file.ts
   
   # 2. 提交更改
   git add .
   git commit -m "feat: your new feature"
   
   # 3. 运行 bump 命令（这将）：
   # - 更新 package.json 中的版本
   # - 更新 CHANGELOG.md
   # - 提交更改
   # - 推送到 GitHub
   npm run bump
   
   # GitHub Actions 将会：
   # - 创建一个 git 标签
   # - 创建一个 GitHub 发布
   # - 发布到 npm（手动触发时）
   

5. 手动 npm 发布

   # 要触发手动 npm 发布
   gh workflow run publish.yml
   

由于此服务器使用公共注册表和文档站点，因此不需要任何环境变量：

• npm 注册表 (registry.npmjs.org)
• PyPI (pypi.org)
• Go Proxy (proxy.golang.org)
• Maven Central (search.maven.org)
• Swift Packages (GitHub API)
• AWS Bedrock 文档 (docs.aws.amazon.com/bedrock)
• Docker Hub (hub.docker.com)
• GitHub Container Registry (ghcr.io)

许可证

MIT