How do I use Augments MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Augments MCP Server how to use useEffect cleanup" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Augments MCP Server

Official

by augmnt

Overview Schema Related Servers Score Discussions

TypeScript

Local

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Angular packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Drizzle ORM packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Express packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Fastify packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Framer Motion packages.

Fetches and indexes documentation from GitHub repositories, enabling search, version diffs, and GitHub Issues-based error diagnosis.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Hono packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Next.js packages.

Provides documentation, type information, version comparison, migration guides, and error diagnosis for any npm package.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Prisma packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for React packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for React Hook Form packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Redux packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Solid packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Supabase packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Svelte packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for SWR packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for tRPC packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Vitest packages.

Provides enhanced documentation, type signatures, examples, version migration guides, and error diagnosis for Zod packages.

Augments MCP Server

A next-generation framework documentation provider for Claude Code via Model Context Protocol (MCP). Returns types + prose + examples with context-aware formatting for any npm package — not just curated ones.

mcp-name: dev.augments/mcp

What's New in v7

Version 7.0 is the biggest upgrade yet — documentation-first search, 4 new tools, BM25 indexing, and production-grade reliability.

v6	v7
3 tools	8 tools (+ diagnostics)
Types-only search	Documentation-first BM25 search
8 concept synonyms	25 concept synonym clusters
Generic version diffs	Real changelog-backed breaking changes
No migration guides	Cross-version migration guides
No error diagnosis	Curated error patterns + GitHub Issues
No package comparison	Side-by-side package comparison
No dep scanning	Dependency scanner (outdated/deprecated/security)
FIFO caches	LRU caches with hit/miss stats
Fixed retry delays	Exponential backoff + circuit breaker

Related MCP server: Crawl4Claude

Quick Start

Claude Code

# Add the MCP server (runs locally via npx)
claude mcp add -s user augments -- npx -y @augmnt-sh/augments-mcp-server

# Verify configuration
claude mcp list

Cursor

Add to your MCP config:

{
  "mcpServers": {
    "augments": {
      "command": "npx",
      "args": ["-y", "@augmnt-sh/augments-mcp-server"]
    }
  }
}

Environment Variables

Set GITHUB_TOKEN for higher GitHub API rate limits when fetching examples and documentation:

{
  "mcpServers": {
    "augments": {
      "command": "npx",
      "args": ["-y", "@augmnt-sh/augments-mcp-server"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Usage

# Get API context with prose + examples (recommended first tool)
@augments get_api_context query="useEffect cleanup" framework="react"

# Natural language queries work great
@augments get_api_context query="how to use zustand middleware"

# Search for APIs by concept (synonym-aware)
@augments search_apis query="state management"

# Get version info with real breaking changes
@augments get_version_info framework="react" fromVersion="18" toVersion="19"

# Migration guide between versions
@augments get_migration_guide package="next" fromVersion="14" toVersion="15"

# Diagnose an error
@augments diagnose_error error="Objects are not valid as a React child" package="react"

# Compare packages side-by-side
@augments compare_packages packages=["zod", "yup", "joi"]

# Scan project dependencies
@augments scan_project_deps

Tools

Tool	Description
`get_api_context`	Primary tool. Returns API signatures, prose documentation, and code examples for any npm package. Handles natural language queries with intent detection. Now with documentation-first BM25 search.
`search_apis`	Search for APIs across frameworks by keyword or concept. 25 synonym clusters ("state" matches useState, createStore, atom, etc).
`get_version_info`	Get npm version info, compare versions, and detect breaking changes backed by real changelogs.
`get_migration_guide`	New. Cross-version migration guide with breaking changes, new features, deprecations, type diffs, and official migration docs.
`diagnose_error`	New. Diagnose errors using curated patterns, GitHub Issues search, and troubleshooting docs.
`compare_packages`	New. Compare 2-5 npm packages: downloads, bundle size, GitHub stars, dependencies, exported APIs.
`scan_project_deps`	New. Scan package.json for outdated, deprecated, and insecure dependencies.
`diagnostics`	Server health: version, uptime, memory, cache stats, Node.js version.

Architecture

flowchart TD
    A["Query: 'how to use useEffect cleanup'"] --> B

    B["Intent Detection → howto<br/>Query Parser → react / useEffect"]

    B --> C["Type Fetcher<br/>CDN racing · npm metadata · @types"]
    B --> D["Doc Fetcher<br/>GitHub API · BM25 search · 25 synonym clusters"]
    B --> E["Example Extractor<br/>GitHub docs · README fallback · Auto-discovery"]

    C --> F["Type Parser<br/>Signatures · Parameters · Related types"]
    D --> G["Doc Search Engine<br/>BM25 indexing · Heading-based chunks · API boost"]

    F --> H["Intent-Driven Formatter (howto)<br/>→ Examples first, prose, brief signature<br/>→ ~500-2000 tokens, 10KB max"]
    G --> H
    E --> H

Source Structure

src/
├── cli.ts                   # stdio entry point
├── server.ts                # MCP server (8 tools + diagnostics)
├── core/                    # Core modules
│   ├── query-parser.ts      # Parse natural language → framework + concept
│   ├── type-fetcher.ts      # Fetch .d.ts + README from npm/unpkg/jsdelivr
│   ├── type-parser.ts       # Parse TypeScript, extract signatures, synonym search
│   ├── example-extractor.ts # Fetch examples from GitHub docs + auto-discovery
│   ├── version-registry.ts  # npm registry integration + changelog-backed diffs
│   ├── doc-fetcher.ts       # GitHub documentation fetcher
│   ├── doc-search.ts        # BM25 inverted index search engine
│   ├── changelog-fetcher.ts # CHANGELOG.md + GitHub Releases parser
│   ├── type-differ.ts       # .d.ts diff between versions
│   └── error-patterns.ts    # Curated error pattern database
├── tools/v4/                # MCP tools
│   ├── get-api-context.ts   # Primary tool (types + docs + examples)
│   ├── search-apis.ts       # Cross-framework API search
│   ├── get-version-info.ts  # Version comparison
│   ├── get-migration-guide.ts # Cross-version migration guides
│   ├── diagnose-error.ts    # Error diagnosis
│   ├── compare-packages.ts  # Package comparison
│   └── scan-project-deps.ts # Dependency scanner
└── utils/
    ├── logger.ts            # stderr logger
    └── lru-cache.ts         # Generic LRU cache with stats

Key Features

Documentation-First Search (New in v7)

Queries like "prisma findMany with pagination" and "zustand create store with middleware" now return real documentation content. The BM25 search engine indexes docs fetched from GitHub by heading-based chunks, with API name boosting and synonym expansion.

Concept Synonyms

25 synonym clusters cover state, form, fetch, animation, routing, auth, cache, effect, middleware, pagination, validation, testing, streaming, error handling, database, layout, modal, table, upload, realtime, deployment, i18n, SSR, component, and context patterns. Bidirectional lookup means "usestate" expands to the "state" cluster.

Intent-Aware Formatting

Intent	Trigger	Format
`howto`	"how to", "example of", "guide"	Examples → prose → brief signature
`reference`	"signature", "types", "parameters"	Full signature → related types → 1 example
`migration`	"migrate", "upgrade", "breaking"	Prose → signature → examples
`balanced`	Default	Signature → prose → examples

Production Reliability (New in v7)

Exponential backoff with jitter for npm registry retries, with 429 Retry-After support
CDN circuit breaker — skips repeatedly failing CDN endpoints (3 failures / 5 min)
GitHub rate limiting — tracks remaining quota, skips fetches when exhausted
LRU caches with hit/miss statistics across all cache-using modules

Coverage

Any npm Package

Every npm package is supported out of the box — no curation or configuration needed. Augments resolves documentation automatically through four layers:

Documentation search — fetches real docs from GitHub repos, indexes with BM25
TypeScript types — bundled ("types" in package.json) or DefinitelyTyped (@types/*)
Auto-discovered docs — parses the npm repository field, finds the GitHub repo, probes docs/ directories
README fallback — extracts concept-relevant code blocks and prose from README.md

This means augments works with the entire npm ecosystem (~2.5M packages), not just a curated subset.

Enhanced Results for Popular Frameworks

22 frameworks have curated doc sources for richer examples: React, Next.js, Vue, Prisma, Zod, Supabase, TanStack Query, tRPC, React Hook Form, Framer Motion, Express, Zustand, Jotai, Drizzle, SWR, Vitest, Playwright, Fastify, Hono, Solid, Svelte, Angular, Redux

Barrel Export Handling

Special sub-module resolution for: React Hook Form, TanStack Query, Zustand, Jotai, tRPC, Drizzle ORM, Next.js

Local Development

# Clone and install
git clone https://github.com/augmentscode/augments-mcp-server.git
cd augments-mcp-server
npm install

# Build with tsup
npm run build

# Run locally
npm start

# Watch mode
npm run dev

# Run tests
npm test

# Run e2e tests (real network calls)
npm run test:e2e

# Type check
npm run type-check

How Augments Compares to Context7

Aspect	Context7	Augments v7
Source	Parsed prose docs	Types + BM25-indexed docs + README
Accuracy	Docs can be wrong	Types must be correct, docs supplement
Context size	~5-10KB chunks	~500-2000 tokens (intent-aware)
Coverage	Manual submission	Any npm package (auto-discovery)
Format	One-size-fits-all	Intent-aware (how-to vs reference)
Search	Keyword match	BM25 + 25 concept synonym clusters
Freshness	Crawl schedule	On-demand from npm + GitHub
Migration	No	Cross-version migration guides
Error help	No	Curated patterns + GitHub Issues
Dep scanning	No	Outdated/deprecated/security checks

Contributing

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes
Run tests: npm test
Submit a pull request

License

MIT License - see LICENSE for details.

Support

Built for the Claude Code ecosystem | Version 7.0.0

Available Tools

8 tools

compare_packagesAInspect

Compare npm packages side-by-side: downloads, bundle size, dependencies, GitHub stars, exported APIs. Great for choosing between alternatives.

ParametersJSON Schema

Name	Required	Description	Default
`packages`	Yes	Package names to compare (2-5)
`criteria`	No	Focus area (e.g., "bundle size", "popularity")

TDQS

A4.1/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the burden. It lists what is compared but does not disclose data sources, network dependencies, rate limits, or whether results are real-time. This is adequate but not thorough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences—first describing functionality, second suggesting use case. No redundant information; every word is purposeful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given low complexity (2 parameters, no nested objects) and no output schema, the description covers purpose and usage adequately. However, it omits details about result format or potential limitations, leaving some gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema covers both parameters with descriptions (100% coverage). The description adds value by enumerating comparison dimensions (e.g., 'downloads, bundle size') that are not in the schema, providing richer context beyond parameter names.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it compares npm packages side-by-side, listing specific aspects like downloads and bundle size. It distinguishes itself from sibling tools (e.g., diagnose_error, scan_project_deps) by focusing on comparison for alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear guidance: 'Great for choosing between alternatives.' It implies when to use but lacks explicit when-not-to-use or direct references to alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

diagnose_errorAInspect

Diagnose an error message or stack trace. Matches against known error patterns, searches GitHub issues, and finds relevant documentation.

ParametersJSON Schema

Name	Required	Description
`error`	Yes	The error message or stack trace to diagnose
`package`	No	Package or framework the error is from
`version`	No	Package version

TDQS

A3.9/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, description fully bears burden: it states it matches, searches, and finds documentation, implying a read-only, aggregating behavior. No contradictions; could mention response format but sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with verb and resource, no wasted words—every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema; description doesn't specify return format (e.g., list of links or text), leaving some ambiguity. Adequate but not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers all 3 parameters with descriptions; tool description adds no extra meaning beyond what schema already provides, so baseline 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states verb 'diagnose' and resource 'error message or stack trace', and lists specific actions (matching patterns, searching issues, finding docs), distinguishing it from siblings like search_apis or get_migration_guide.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied (when you have an error), but no explicit guidance on when not to use or comparison with alternative tools like search_apis.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

diagnosticsAInspect

Get server health information: version, uptime, memory usage, cache statistics, and Node.js version.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden of behavioral disclosure. It lists the data categories returned but does not mention response format, potential side effects (none expected), or any access requirements. This is adequate for a simple read-only tool but lacks depth.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that front-loads the main purpose ('Get server health information') and lists specific items efficiently. Every word serves a purpose with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description partially compensates by enumerating returned data fields. However, it omits details on response structure (e.g., JSON object) and does not address missing annotation information. For a simple health tool, it is largely complete but could be more explicit.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are zero parameters, and the schema coverage is 100%. Per guidelines, the baseline is 4. The description does not need to add parameter-specific meaning, and it does not detract.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and the resource 'server health information', and lists specific items (version, uptime, memory, cache, Node.js version). This distinguishes it from sibling tools like 'diagnose_error' (focused on errors) and 'get_version_info' (version-only).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for general health monitoring but does not explicitly state when to use this tool versus alternatives like 'diagnose_error' or 'get_version_info'. No when-not or exclusion criteria are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_api_contextAInspect

RECOMMENDED: Get precise API signatures, parameters, return types, prose documentation, and code examples for any npm package. Handles natural language like "react useEffect cleanup" or "how to use zustand". Always try this first.

ParametersJSON Schema

Name	Required	Description
`query`	Yes	Natural language query (e.g., "useEffect cleanup" or "how to use prisma findMany")
`framework`	No	Specific framework to search in (e.g., "react", "prisma")
`version`	No	Specific version (e.g., "19.0.0" or "latest")
`includeExamples`	No	Whether to include code examples
`maxExamples`	No	Maximum number of examples to include

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It states that the tool returns API signatures, parameters, etc., but does not explicitly declare it as read-only or mention any side effects, rate limits, or prerequisites. The name implies it is a lookup, but explicit transparency would improve the score.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long: the first states the core purpose, and the second gives examples and a usage recommendation. It is front-loaded, concise, and avoids unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the tool's inputs (natural language query, optional filters) and outputs (signatures, params, docs, examples). However, it does not specify the output format or structure (since no output schema), nor does it mention constraints like network requirements or limits. For a 5-parameter tool, this is mostly complete but missing a few details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and the input schema already provides clear descriptions for all parameters. The description adds only a brief mention of natural language handling, which relates to the 'query' parameter, but does not provide additional semantic value beyond what the schema already includes.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it gets 'precise API signatures, parameters, return types, prose documentation, and code examples for any npm package.' The verb 'Get' and specific resource are well-defined, and the scope (npm packages) distinguishes it from siblings like 'diagnose_error' or 'scan_project_deps'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly recommends this tool ('RECOMMENDED: ... Always try this first.'), implying it is the default for API queries. It provides example queries, which clarifies the kind of input to use. However, it does not list alternative sibling tools or specify when not to use this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_migration_guideAInspect

Get a detailed migration guide between package versions. Returns breaking changes, new features, deprecations, type diffs, and official migration docs.

ParametersJSON Schema

Name	Required	Description
`package`	Yes	Package or framework name (e.g., "react", "next", "prisma")
`fromVersion`	Yes	Version to migrate from (e.g., "18", "14.0.0")
`toVersion`	No	Version to migrate to (defaults to latest)

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It states the operation is non-destructive and lists return contents, but does not disclose potential behaviors such as error handling for invalid versions, data freshness, or whether external API calls are made. This provides moderate transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single focused sentence that immediately states the action and what is returned. No unnecessary words, and the structure supports quick comprehension.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple retrieval tool with three well-described parameters and no output schema, the description covers the essential functionality and return types. Minor gaps exist (e.g., no mention of version format validation), but overall it is sufficiently complete for the agent to understand and invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description does not add any semantic meaning beyond the schema descriptions; it merely restates the overall purpose. No parameter-specific guidance is offered.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves a migration guide between package versions, listing specific returned elements (breaking changes, new features, deprecations, etc.). This distinguishes it from sibling tools like 'compare_packages' which compares packages rather than versions within a package.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, limitations, or typical use cases, leaving the agent to infer usage from the name and description alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_version_infoAInspect

Get version info, available versions, and breaking change detection for any npm package. Now includes actual breaking changes and new features from changelogs.

ParametersJSON Schema

Name	Required	Description
`framework`	Yes	Framework or package name
`fromVersion`	No	Compare from this version
`toVersion`	No	Compare to this version

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that the tool accesses changelogs for breaking changes and new features, indicating a read-only behavior. However, it does not describe error handling, rate limits, or what happens if a package is not found.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, each serving a purpose: the first defines core functionality, the second highlights recent enhancements. No unnecessary information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of output schema, the description provides a good overview of what the tool returns: version info, available versions, breaking changes, and features from changelogs. It could be more specific about the output format, but it is largely sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, but the description adds value by explaining that the tool provides 'breaking change detection' and 'available versions', which clarifies the purpose of the fromVersion and toVersion parameters. This goes beyond the schema's basic definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it gets version info, available versions, and breaking change detection for npm packages, with specific verb and resource. It also mentions included features from changelogs, which distinguishes it from sibling tools like compare_packages or get_migration_guide.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no explicit guidance on when to use this tool versus alternatives, such as compare_packages for comparing packages or get_migration_guide for migration steps. Context signals indicate sibling tools but no usage rules are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_project_depsCInspect

Scan project dependencies for outdated packages, major updates, deprecated packages, and security advisories. Reads package.json.

ParametersJSON Schema

Name	Required	Description	Default
`packageJsonPath`	No	Path to package.json (defaults to ./package.json)
`checkTypes`	No	Types of checks to run

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states the tool reads package.json, but does not disclose whether it modifies files, error handling (e.g., file not found), rate limits, or output behavior. The description is too minimal to inform the agent of operational traits beyond the obvious read-only scan.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no wasted words. It front-loads the primary purpose and immediately mentions the input file. Every sentence is essential and clear.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description should explain what the tool returns (e.g., list of issues, formatted report) or any side effects. It does not. For a scanning tool with two parameters, the agent is left guessing the output structure and failure modes. This is a significant gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% with both parameters documented. The description adds value by linking the check types ('updates', 'deprecated', 'security') to their meanings (outdated packages, major updates, deprecated packages, security advisories). However, it does not provide additional syntax, format, or dependency context beyond what the schema already offers.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool scans project dependencies for outdated packages, major updates, deprecated packages, and security advisories. It specifies it reads package.json. However, it does not explicitly differentiate from sibling tools like compare_packages or get_version_info, which could be confused for similar purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, typical use cases, or when to avoid using it. The usage context is only implied by the action description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_apisAInspect

Search for APIs across multiple frameworks when you don't know the exact name. Supports concept search like 'state management' which matches useState, createStore, atom, etc.

ParametersJSON Schema

Name	Required	Description
`query`	Yes	Search query (e.g., "state management hook" or "form validation")
`frameworks`	No	Limit search to specific frameworks
`limit`	No	Maximum results per framework

TDQS

A4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It does not mention that the tool is read-only, nor any related side effects, rate limits, or output details. The only behavioral insight is support for concept search, which is more of a feature than a transparency about side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise with two sentences, no redundancy, and begins with the core purpose. Every word adds value, and the structure efficiently communicates the tool's utility.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the schema covers all parameters and no output schema is present, the description adequately explains the search functionality and concept matching. It lacks details on how matches are ranked or how framework limiting works, but overall it provides sufficient context for an AI agent to decide when to invoke this tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with descriptions for all parameters. The description adds significant value for the 'query' parameter by providing concrete examples (e.g., 'state management' matching useState, createStore), enhancing understanding beyond the schema. For 'frameworks' and 'limit', the schema already provides adequate descriptions, so the description adds minimal extra meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: searching for APIs by concept when exact name is unknown. It provides examples like 'state management' matching multiple APIs, which effectively communicates the tool's function and distinguishes it from siblings that likely handle exact lookups or dependency scanning.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly advises use when 'you don't know the exact name' and supports concept search, providing clear context. However, it does not explicitly state when not to use this tool or mention alternatives like get_api_context for exact lookups, slightly reducing clarity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

8 tool updatesv7.1.0Jun 3, 2026
- First observedcompare_packages
- First observeddiagnose_error
- First observeddiagnostics
- First observedget_api_context
- First observedget_migration_guide
- First observedget_version_info
- First observedscan_project_deps
- First observedsearch_apis

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.8/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: comparison, error diagnosis, server health, API details, migration guides, version info, dependency scanning, and API search. No overlapping functionality.

Naming Consistency4/5

Most tools use a consistent verb_noun pattern (compare_packages, diagnose_error, get_api_context, get_migration_guide, get_version_info, scan_project_deps, search_apis). 'diagnostics' is a noun-only outlier, slightly breaking consistency.

Tool Count5/5

Eight tools is well-scoped for the domain of npm package analysis and development assistance. Each tool covers a key area without redundancy.

Completeness5/5

The tool surface covers all major development needs: package comparison, error diagnosis, API exploration, version management, migration planning, project auditing, and concept search. No obvious gaps.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

docfork-mcpOAuth
ai.smithery
@latest documentation and code examples to 9000+ libraries for LLMs and AI code editors in a singl…
Documentation Access Developer Tools Code Analysis
2488
developer-tools-mcp-server A
com.thenextgennexus
Search GitHub, npm, PyPI, StackOverflow, ArXiv from one MCP — built for coding agents.
Developer Tools Search
72
Npm Package Info Mcp
io.github.varvararatta
Dive into the world of npm with our NPM Package Info MCP. Access crucial metadata about any npm
Developer Tools Search
2
ref-tools-ref-tools-mcpOAuth
ai.smithery
Provide your AI coding tools with token-efficient access to up-to-date technical documentation for…
Documentation Access Developer Tools Code Analysis
21,164

Related MCP Servers

DocsFetcher MCP Server
Documentation Access Developer Tools
cdugo
A
license
D
quality
D
maintenance
Fetches and extracts comprehensive package documentation from multiple programming language ecosystems (JavaScript, Python, Java, etc.) for LLMs like Claude without requiring API keys.
Updated a year ago (2025-03-13 21:50 UTC)
4
28
15
MIT
Crawl4Claude
Web Scraping Documentation Access Developer Tools
dragomirweb
F
license
Not graded
quality
C
maintenance
A comprehensive, domain-agnostic documentation scraping and AI integration toolkit. Scrape any documentation website, create structured databases, and integrate with Claude Desktop via MCP (Model Context Protocol) for seamless AI-powered documentation assistance.
Updated a year ago (2025-06-01 08:32 UTC)
5
-
Open Context
Developer Tools Knowledge & Memory Documentation Access
niawjunior
A
license
Not graded
quality
C
maintenance
AI context management for codebases – enables Claude Code to read, search, and update project documentation via MCP.
Updated 5 months ago (2026-03-29 15:26 UTC)
MIT
@imqueue/mcp
Developer Tools Documentation Access Software Architecture
imqueue
A
license
A
quality
A
maintenance
Model Context Protocol (MCP) server for @imqueue — lets AI coding agents (Claude Code, Cursor and others) search the docs, scaffold typed services & clients and use @imqueue/cli live.
Updated 3 days ago (2026-09-03 12:40 UTC)
14
1,378
1
GPL 3.0

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/augmnt/augments-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server