# Duck Framework MCP

> Official Duck Framework MCP server for AI-assisted development and project scaffolding.

- name: io.github.duckframework/duckframework-mcp
- version: 1.2.0
- connection class: unknown (unknown)
- trust: 97/100
- quality: 83/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.duckframework%2Fduckframework-mcp
- tools: https://api.protogrid.dev/v1/servers/io.github.duckframework%2Fduckframework-mcp/tools

**Not classified yet.** The remote endpoints have not been probed successfully, or the listing has nothing to connect to.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "duckframework-mcp": {
      "type": "http",
      "url": "https://duckframework.com/mcp"
    }
  }
}
```


## Trust

- hygiene: 100
- liveness: 99
- freshness: 100
- provenance: 90
- drivers: +repository +namespace-matches-repo +website +reachable +uptime-98% +updated-22d-ago
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 83/100 (good)

### protocol: n/a (weight 25)

- n/a `protocol.modern`, `protocol.stateless`, `protocol.transport`, `protocol.list_ttl`: no remote answered a protocol handshake (not probed yet, unreachable, or local-only)

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 75 (weight 30)

- pass `tools.descriptions`: every tool has a description
- pass `tools.description_length`: descriptions are concise
- pass `tools.schemas`: every tool has an object input schema
- fail `tools.annotations`: no tool declares readOnlyHint or destructiveHint, so clients cannot tell safe calls from risky ones
- fail `tools.directory_hints`: no tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: get_blueprint_locations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); get_blueprint_structure (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); get_component_api (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); …
- pass `tools.token_cost`: about 1,203 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump
- pass `tools.hidden_text`: no hidden text in tool names, descriptions, schemas or annotations

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name
- pass `stability.new_links`: no tool change named a new site

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 13, about 1,203 tokens to load them all
- tool set hash: c24163fc6b2b8fec5cb19f1fa30f02c9
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.duckframework/duckframework-mcp.svg)](https://protogrid.dev/servers/io.github.duckframework/duckframework-mcp)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://duckframework.com/mcp (streamable-http, auth unknown, reachable true, uptime30d 0.9764706)

## Packages

_none_

## Tools (13)

- `fetch_ai_guide`: Fetch an official Duck Framework AI guide.
Use this after get_ai_guides() to retrieve the full guide content for
AI-assisted Duck Framework development.
Always read the relevant guide before generating code instead of relying
on memory.
- `get_ai_guides`: List available Duck Framework AI guides.
Use this to discover available guides before fetching one with
fetch_ai_guide().
Returns guide identifiers and their descriptions.
- `get_blueprint_locations`: Explain where Duck Framework blueprints can be located.
Describes the supported blueprint layouts and when each organization
approach is appropriate.
- `get_blueprint_structure`: Return the standard internal structure of a Duck Framework blueprint.
Use this before generating a new blueprint or adding files to an existing
one to understand where components, pages, templates, automations, and
views belong.
- `get_component_api`: Look up a built-in Duck Framework component API.
Returns the confirmed import path, container type, and supported keyword
arguments for a component without requiring the full HTML components guide
to be loaded.
Use this before using any component that has not already been confirmed.
Returns close-name suggestions when the component does not exist.
- `get_project_structure`: Return the standard Duck Framework project directory structure.
Use this before creating or modifying projects to understand where files
and directories belong.
- `lint_component_code`: Check Duck Framework component or page code for common mistakes.
Detects known patterns such as incorrect component imports, invalid page
imports, incorrect Heading usage, leading-underscore method names, and
separator comments.
This is a pattern check for known issues, not a complete correctness
validator. An empty result only means no known issues were detected.
Run this on generated component code before presenting it as final.
- `list_doc_categories`: List all Duck Framework documentation categories and their pages.
Use this when browsing available documentation without a specific
search query.
- `plan_feature`: Analyze a Duck Framework feature request and create an implementation plan.
Returns relevant documentation to read and a suggested order of operations
before writing code. Use this before implementing non-trivial Duck
Framework features.
- `reindex_docs`: Rebuild the Duck Framework documentation index.
Crawls the live documentation sitemap for a given version and merges
the result in: curated tags/summary/category are preserved, new pages
are added, and pages no longer in the sitemap are removed.
Requires the admin scope.
- `scaffold_blueprint`: Scaffold a new Duck Framework blueprint.
Generates a blueprint structure containing blueprint.py, views.py, and
optional UI, template, and static directories following the documented
Duck blueprint conventions.
Returns generated file contents and the settings configuration needed to
register the blueprint. This tool does not write files.
- `scaffold_project`: Scaffold a new Duck Framework project.
Returns the required CLI commands and generated file contents for
supported features with confirmed APIs. Unsupported features return
documentation guidance instead of generated code to avoid guessing
framework APIs.
This tool does not write files. It only returns generated content for the
calling client to add to the user's project directory.
- `search_docs`: Fuzzy-search the Duck Framework documentation.
Use this whenever the correct documentation page for a feature is
unknown. Returns ranked matches containing title, URL, category,
summary, and relevance score.