# cuttalo/depscope [Health: Active]

**Category:** 🔒 Security  
**Repository:** https://github.com/cuttalo/depscope  
**GitHub Stars:** 1  
**npm Downloads (last month):** 428  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/cuttalo-depscope

## Description
Package Intelligence for AI agents. 22 tools across 17 ecosystems (npm/pypi/cargo/go/maven/nuget/rubygems/composer/pub/hex/swift/cocoapods/cpan/hackage/cran/conda/homebrew) — check health, vulnerabilities (OSV + CISA KEV + EPSS), typosquats, malicious flags, alternatives, known bugs, breaking changes, stack compatibility and error-to-fix. 31k+ packages, 2.2k+ CVEs enriched. Zero auth, MIT. Remote URL https://mcp.depscope.dev/mcp or stdio npx depscope-mcp.

## Tools
Capabilities this server exposes over MCP:

- **check_malicious** — Supply-chain malware check against OpenSSF/OSV. USE WHEN: about to suggest install of an unvetted/unfamiliar package; name came from a blog/tutorial. Call BEFORE check_package for untrusted pkgs. RETURNS: {is_malicious, threat_tier, source}.
- **check_typosquat** — Typosquat detector. USE WHEN: name differs from a well-known package by 1-2 chars (`lodsh`, `reqeusts`); copy-paste from unreliable source; downloads near zero but name looks familiar. RETURNS: {is_typosquat, likely_target, confidence}.
- **check_bulk** — Fast pre-flight filter for a batch of (ecosystem, package) pairs. DB-only, <100ms for 100 items. USE WHEN: about to emit `npm install a b c …` or `pip install a b c …` — catches hallucinated names, stdlib, typos, and known-bad in ONE call. NOT a dep-tree audit (use scan_project for that). RETURNS: per-item {status: exists|stdlib|malicious|typosquat_suspect|historical_incident|unknown}.
- **package_exists** — Boolean registry existence check. USE WHEN: about to emit a package name in an install command but unsure it exists; verifying a name generated from training data. RETURNS: {exists}.
- **get_latest_version** — Latest published version + deprecation flag — the cheapest call. USE WHEN: only a version string matters (pinning a dep, answering 'what version of X'). If you also need health/vulns use check_package. RETURNS: {latest, deprecated, published_at}.
- **get_health_score** — Single 0-100 health score — cheapest go/no-go gate (>=70 safe). USE WHEN: CI gating or pkg already screened for malware/typos. NOT a first screen — run check_malicious + check_typosquat first. For a verbal verdict use get_package_prompt. RETURNS: {score, verdict}.
- **install_command** — Canonical install command(s) across every package manager of the ecosystem (npm/pnpm/yarn/bun, pip/uv/poetry, cargo, go, composer, maven+gradle, nuget, …). USE WHEN: emitting an install line and you want correct flags. RETURNS: {primary, variants[]}.
- **get_package_prompt** — LLM-optimised package brief — plain text ~300 tokens (~75% cheaper than JSON). Verdict (SAFE/AVOID/URGENT/MALICIOUS) + health + vulns + alternatives + maintainer alerts. USE WHEN: you want to reason over a package and drop the output directly in context; 'is X safe'. PREFER THIS over check_package in 95% of LLM cases. RETURNS: plain-text brief.
- **check_package** — Full machine-readable JSON report (~2k tokens). USE WHEN: you need to programmatically parse specific fields (CI gating, UI, sub-field extraction). Otherwise prefer get_package_prompt. RETURNS: {package, health:{score}, vulnerabilities[], latest, deprecated, maintainers, recommendation}.
- **get_vulnerabilities** — CVE/OSV advisories affecting the latest (or specified) version. USE WHEN: security-sensitive project; user asks 'any CVEs in X'; you already know the pkg exists. RETURNS: {vulnerability_count, vulnerabilities[]: {id, severity, cvss, fixed_in}}.
- **find_alternatives** — Curated replacements for deprecated/unhealthy packages, including stdlib built-ins (e.g. `fs.rm` for rimraf). USE WHEN: pkg flagged AVOID/URGENT; 'what to use instead of X'; before guessing a replacement name. RETURNS: {alternatives[]: {name, reason, is_stdlib}}.
- **get_migration_path** — Prescriptive migration plan between DIFFERENT packages — rationale + literal code diff + breaking changes + effort minutes. USE WHEN: replacing `request`→`axios`, `moment`→`dayjs`, `flask`→`fastapi`, etc.; both endpoints known. RETURNS: {rationale, diff, breaking_changes[], estimated_minutes}.
- **get_breaking_changes** — Breaking changes between two majors of the SAME package (`next@14`→`15`). USE WHEN: user is bumping a major; before recommending a major upgrade. Different from get_migration_path (same pkg vs. different pkg). RETURNS: {breaking_changes[]: {area, description, hint}}.
- **pin_safe** — Highest version below the chosen CVE severity tier, respecting a semver constraint. USE WHEN: writing a package.json/requirements.txt line; resolving dependabot by lowest-risk patched version. RETURNS: {recommended_version, walk_log[]}.
- **scan_project** — Audit a project's dependencies in one shot. Returns a single-sentence `verdict` (e.g. "DO NOT INSTALL — 1 hallucinated: fastapi-turbo") that an agent can paste into its reply, plus per-package health/vulns/recommendation. Detects hallucinated packages, deprecated, typosquats, critical vulnerabilities. Accepts EITHER {ecosystem, packages:[name@ver, …]} (up to 100, returns JSON) OR {packages:[{ecosystem, package}, …]} (up to 50, mixed ecosystems, returns text brief). USE WHEN: user pastes package.json/requirements.txt/Cargo.toml; agent generated install command; 'is my stack OK'. RETURNS: JSON with `verdict`, `project_risk`, `summary.hallucinated_packages`, `summary.deprecated_packages`, per-package health.
- **compare_packages** — Side-by-side comparison (health, vulns, downloads, maintainers, last release) of 2-10 packages in the same ecosystem. USE WHEN: 'X vs Y' / 'should I pick X or Y'. RETURNS: table-shaped JSON, one row per package.
- **check_compatibility** — Is this specific multi-package version combo verified to work together? USE WHEN: pinning a stack (next@15 + react@19 + node@22); before recommending a version matrix. RETURNS: {compatible, conflicts[], notes}.
- **resolve_error** — Map error OR free-text query to a verified fix. USE WHEN: user pastes a concrete error/stack (ENOENT, ImportError, build failure) — pass `error`. OR user describes a symptom ('webpack slow', 'pip stuck') — pass `query`. Always prefer this over guessing a fix. RETURNS: exact-match {status, solution, confidence, source_url} or search results [{title, summary, source_url}].
- **get_known_bugs** — Non-CVE known bugs for a specific package version. USE WHEN: unexpected behavior that is NOT a security issue; a pinned version misbehaves. RETURNS: {bugs[]: {title, fixed_in, workaround}}.
- **get_trust_signals** — One-call aggregate of ALL non-CVE supply-chain trust signals: maintainer trust (bus factor, ownership changes), OpenSSF Scorecard, quality (criticality, release velocity, publish security), and SLSA/Sigstore provenance. USE WHEN: deep-vetting a package beyond CVEs (hardened/regulated env, SBOM/compliance, small-pkg ownership review, choosing between healthy candidates). Runs 4 backend endpoints in parallel. RETURNS: {maintainer, scorecard, quality, provenance} — each may be null if its backend call failed.
- **get_trending** — Live trending packages with rank-delta and weekly growth %. USE WHEN: 'what is rising in npm/PyPI/Cargo right now'; recommendation not biased by training-data cutoff. RETURNS: {items[]: {name, rank, rank_delta, weekly_growth_pct}}.
- **contact_depscope** — Inbound ticket: bug/listing/security/anomaly/partnership. USE WHEN: reporting wrong data (`bug`), requesting a new pkg/ecosystem index (`listing`), disclosing a DepScope security issue (`security`), flagging a concrete mismatch in another tool's output vs. authoritative source (`anomaly` — provide tool_called+observed+expected), or partnership/press (`partnership`). RETURNS: {ticket_id} or {anomaly_id}.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "depscope": {
    "command": "npx",
    "args": ["-y","depscope-mcp"]
  }
}
```

## Documentation

## What cuttalo/depscope MCP server does

The cuttalo/depscope MCP server exposes 22 package-analysis tools for AI agents working with ecosystems such as npm, PyPI, Cargo, Go, Maven, NuGet, RubyGems, Composer, Pub, Hex, Swift, CocoaPods, CPAN, Hackage, CRAN, Conda, Homebrew, JSR, and Julia. Its main purpose is to reduce dependency mistakes before an agent produces an install command or recommends a library.

The tools cover both individual packages and complete dependency sets. An agent can verify that a name exists, identify likely typosquats, check for malicious or historical supply-chain incidents, retrieve vulnerability data, and inspect package health. Other tools compare packages, find alternatives, create migration plans, check compatibility between versions, identify breaking changes, and return known non-CVE bugs.

## How it works

Requests are sent through MCP to the hosted DepScope backend. The remote endpoint is `https://mcp.depscope.dev/mcp`. A local client can instead start the npm package `depscope-mcp` over stdio; the client remains a local process while the intelligence backend is hosted by DepScope.

For quick decisions, `get_package_prompt` returns a compact, language-model-oriented brief with a verdict, health information, vulnerabilities, alternatives, and maintainer alerts. `check_package` provides a larger machine-readable report when an application needs structured fields. `scan_project` accepts dependency lists from one ecosystem or mixed ecosystem inputs and reports hallucinated, deprecated, typosquatted, vulnerable, and otherwise risky packages. `check_bulk` is intended for fast pre-install filtering of batches rather than dependency-tree auditing.

The service also includes tools for operational package work: `install_command` produces ecosystem-specific installation syntax, `pin_safe` suggests a version below a selected vulnerability tier, and `resolve_error` maps an error or symptom to a verified solution or search results.

## Setup and configuration

For Claude Desktop, Cursor, or Windsurf, configure an MCP server with the remote URL:

```json
{
  "mcpServers": {
    "depscope": {
      "url": "https://mcp.depscope.dev/mcp"
    }
  }
}
```

For a local stdio configuration, run the cuttalo/depscope MCP server through npx:

```json
{
  "mcpServers": {
    "depscope": {
      "command": "npx",
      "args": ["-y", "depscope-mcp"]
    }
  }
}
```

No API key or other credential is required. The hosted service is described as free, with rate limits; higher quotas, SLA support, and on-premises deployment are available by contacting the provider.

## Tools and capabilities

- Validate package names and retrieve the latest published version.
- Detect malicious packages, typosquats, deprecations, vulnerabilities, and known bugs.
- Review health scores, maintainer signals, OpenSSF Scorecard data, quality indicators, and provenance signals.
- Compare packages and locate alternatives, including standard-library replacements where available.
- Check version compatibility, major-version changes, migration paths, and safer pins.
- Audit dependency batches or project manifests and produce an overall risk verdict.
- View trending packages and submit tickets for data errors, missing listings, security reports, or partnerships.

The cuttalo/depscope MCP server also exposes the same underlying data through documented HTTPS REST endpoints, so applications that do not use MCP can query package checks directly.

## Limitations and notes

The MCP client source is open source under AGPL-3.0, while the backend API and intelligence layer are proprietary hosted services. The landing-page repository and its documentation use CC-BY-4.0, so these licenses should not be treated as interchangeable.

Results depend on the backend data and its supported ecosystems. `check_bulk` is a database-backed preflight filter, not a complete dependency-tree audit; use `scan_project` for project-level dependency review. Likewise, `get_health_score` is intended as a later go/no-go signal after malware and typosquat checks, not as the sole first screening step. The service has rate limits, although the material does not specify their values.

_Full upstream README: https://allmcps.com/mcp/cuttalo-depscope/readme_