Purpose

The doc-fetcher skill provides comprehensive capabilities for fetching library and framework documentation from multiple sources using MCP integrations. This skill helps the Documentation Researcher agent retrieve up-to-date, version-specific documentation that enables informed implementation decisions and adherence to library best practices.

This skill emphasizes:

• Latest Documentation: Always fetch current, version-specific documentation

• Multiple Sources: Leverage both context7-mcp (deep context) and fetch-mcp (web content)

• Comprehensive Coverage: Retrieve API references, examples, guides, and best practices

• Version Awareness: Track version compatibility and breaking changes

• Efficient Retrieval: Optimize MCP usage for token efficiency and accuracy

The doc-fetcher skill ensures that implementation guidance is based on authoritative, current documentation from official sources.

When to Use

This skill auto-activates when the agent describes:

• "Fetch documentation for..."

• "Retrieve API reference for..."

• "Get library documentation..."

• "Access documentation for..."

• "Find documentation about..."

• "Retrieve latest docs for..."

• "Look up documentation..."

• "Fetch API docs from..."

Provided Capabilities

1. Context7-MCP Documentation Retrieval

What it provides:

• Deep documentation retrieval with semantic search

• Version-specific API references

• Code examples from documentation

• Library-specific patterns and conventions

• Integration guidance

Context7 Workflow:

Step 1: Resolve library name to context7 ID

library_id = invoke_mcp( "context7-mcp", tool="resolve-library-id", params={ "libraryName": "fastapi" # or "react", "django", etc. } )

Step 2: Fetch comprehensive documentation

docs = invoke_mcp( "context7-mcp", tool="get-library-docs", params={ "context7CompatibleLibraryID": library_id["library_id"], # e.g., "/tiangolo/fastapi" "topic": "API routing and dependency injection", # Focus area "tokens": 3000 # Amount of documentation to retrieve } )

Result contains:

- documentation: Markdown-formatted docs

- version: Library version

- examples: Code examples

- metadata: Additional context

Context7 Best Practices:

• Use specific topics to focus documentation retrieval

• Start with 2000-3000 tokens for comprehensive coverage

• Adjust token count based on complexity

• Combine multiple focused queries for complex features

2. Fetch-MCP Web Content Retrieval

What it provides:

• Official documentation page fetching

• GitHub README and Wiki retrieval

• Community resource access

• Tutorial and guide retrieval

• Changelog and migration guide access

Fetch-MCP Workflow:

Fetch official documentation page

official_docs = invoke_mcp( "fetch-mcp", tool="fetch", params={ "url": "https://fastapi.tiangolo.com/tutorial/first-steps/", "prompt": "Extract quick start guide, installation steps, and first API example" } )

Fetch GitHub README

github_readme = invoke_mcp( "fetch-mcp", tool="fetch", params={ "url": "https://github.com/tiangolo/fastapi/blob/master/README.md", "prompt": "Extract key features, installation, and basic usage examples" } )

Result contains:

- Extracted content focused on the prompt

- Markdown-formatted for easy parsing

- Cleaned and processed for relevance

Fetch-MCP Best Practices:

• Use specific prompts to extract relevant content

• Prefer official documentation URLs over third-party

• Fetch READMEs for overview and quick start

• Retrieve changelogs for version migration info

3. Multi-Source Documentation Strategy

What it provides:

• Combined documentation from multiple sources

• Cross-reference validation

• Comprehensive coverage

• Authoritative source prioritization

Multi-Source Workflow:

documentation_sources = { "primary": { # Context7: Deep, comprehensive docs "context7": fetch_via_context7(library_name, topic),

    # Official docs: Quick start and guides
    "official": fetch_via_fetch_mcp(official_docs_url),
},
"supplementary": {
    # GitHub: Latest examples and README
    "github": fetch_via_fetch_mcp(github_url),

    # Migration guides (if version upgrade)
    "migration": fetch_via_fetch_mcp(migration_guide_url) if needs_migration else None,
}

}

Synthesize documentation from multiple sources

synthesized_docs = synthesize_documentation(documentation_sources)

Source Prioritization:

• Official Documentation (highest priority)

• Context7 Documentation (comprehensive reference)

• GitHub Repository (latest examples)

• Community Resources (supplementary)

4. Version-Specific Retrieval

What it provides:

• Version compatibility checking

• Breaking change identification

• Migration guidance

• Deprecated feature detection

Version Handling:

Specify version in context7 (if supported)

docs_v2 = invoke_mcp( "context7-mcp", tool="get-library-docs", params={ "context7CompatibleLibraryID": "/tiangolo/fastapi/v0.100.0", # Version-specific "topic": "API routing", "tokens": 2000 } )

Fetch version-specific changelog

changelog = invoke_mcp( "fetch-mcp", tool="fetch", params={ "url": "https://github.com/tiangolo/fastapi/blob/master/CHANGELOG.md", "prompt": "Extract changes between version 0.95.0 and 0.100.0, focusing on breaking changes" } )

Compare versions and identify migration needs

migration_notes = analyze_version_changes(changelog)

5. Code Example Extraction

What it provides:

• Working code examples

• Integration patterns

• Configuration examples

• Test examples

Example Extraction:

Extract examples from context7 docs

examples = [] for code_block in docs["examples"]: examples.append({ "code": code_block["code"], "language": code_block["language"], "description": code_block["description"], "category": categorize_example(code_block) })

Extract examples from official docs

official_examples = extract_code_blocks(official_docs["content"], language="python")

Combine and deduplicate

all_examples = deduplicate_examples(examples + official_examples)

6. Documentation Caching

What it provides:

• Reduced MCP calls

• Faster subsequent retrievals

• Token usage optimization

• Consistent documentation state

Caching Strategy:

Check cache before fetching

cache_key = f"{library_name}:{version}:{topic_hash}"

if cache_key in documentation_cache: return documentation_cache[cache_key]

Fetch and cache

docs = fetch_documentation(library_name, version, topic) documentation_cache[cache_key] = docs documentation_cache[cache_key]["cached_at"] = datetime.utcnow()

return docs

Cache Invalidation:

• Expire after 24 hours

• Clear on version change

• Manual refresh option

Usage Guide

Step 1: Identify Documentation Needs

Analysis doc → Extract libraries → Identify topics → Prioritize sources

Step 2: Resolve Library IDs (context7)

Library name → context7 resolve-library-id → Library ID

Step 3: Fetch Context7 Documentation

Library ID + Topic → get-library-docs → Comprehensive docs

Step 4: Fetch Web Resources (fetch-mcp)

URLs + Prompts → fetch → Supplementary docs

Step 5: Extract Examples

Documentation → Code blocks → Categorized examples

Step 6: Synthesize Documentation

Multiple sources → Prioritize → Combine → Structured output

Best Practices

Use Context7 for Depth

• Primary source for API references

• Comprehensive coverage of library features

• Semantic search capabilities

• Version-specific support

Use Fetch-MCP for Breadth

• Official quick start guides

• GitHub examples and READMEs

• Migration guides and changelogs

• Community tutorials (verified sources)

Focus Documentation Retrieval

• Use specific topics in context7

• Use targeted prompts in fetch-mcp

• Avoid generic "get all documentation"

• Retrieve only what's needed for feature

Version Awareness

• Always specify version requirements

• Check for breaking changes

• Document version compatibility

• Provide migration notes if needed

Token Optimization

• Start with 2000-3000 tokens

• Adjust based on complexity

• Multiple focused queries > one large query

• Cache frequently accessed docs

Source Validation

• Prefer official documentation

• Verify URL authenticity

• Check documentation date

• Cross-reference when uncertain

Resources

doc-sources.md

Curated list of documentation sources:

• Official documentation URLs by framework

• GitHub repository locations

• Community resource repositories

• API reference locations

• Tutorial and guide sources

• Changelog and release note locations

fetching-strategies.md

Documentation fetching strategies:

• When to use context7 vs fetch-mcp

• Token optimization techniques

• Version-specific retrieval

• Caching strategies

• Error handling patterns

• Multi-source synthesis

• Example extraction methods

Example Usage

Input (from Documentation Researcher agent):

"Fetch documentation for FastAPI framework focusing on API routing, dependency injection, and Pydantic integration."

Output (doc-fetcher skill provides):

Comprehensive documentation retrieval

1. Context7 Documentation

fastapi_docs = { "library_id": "/tiangolo/fastapi", "version": "0.100.0", "documentation": """ # FastAPI API Routing

FastAPI provides a powerful routing system based on Python type hints...

## Dependency Injection

FastAPI's dependency injection system allows you to declare dependencies...

## Pydantic Integration

FastAPI uses Pydantic models for request validation...
""",
"examples": [
    {
        "title": "Basic API with dependency injection",
        "code": """

from fastapi import FastAPI, Depends

app = FastAPI()

def get_query_param(q: str = None): return {"q": q}

@app.get("/items/") async def read_items(commons: dict = Depends(get_query_param)): return commons """, "language": "python" } ] }

2. Official Documentation (fetch-mcp)

official_docs = { "url": "https://fastapi.tiangolo.com/tutorial/", "content": """ # First Steps

Create a file `main.py` with:

```python
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}
```

Run the server with: `uvicorn main:app --reload`
"""

}

3. GitHub README (fetch-mcp)

github_readme = { "url": "https://github.com/tiangolo/fastapi", "content": """ # FastAPI

FastAPI framework, high performance, easy to learn, fast to code, ready for production

## Key features:
- Fast: Very high performance, on par with NodeJS and Go
- Fast to code: Increase the speed to develop features by about 200% to 300%
- Fewer bugs: Reduce about 40% of human errors
- Intuitive: Great editor support
- Easy: Designed to be easy to use and learn
- Short: Minimize code duplication
- Robust: Get production-ready code
- Standards-based: Based on OpenAPI and JSON Schema
"""

}

4. Synthesized Output

{ "library": "fastapi", "version": "0.100.0", "sources": { "context7": "Primary documentation source", "official": "Quick start and tutorials", "github": "Overview and features" }, "api_routing": { "overview": "FastAPI provides decorator-based routing...", "examples": [...], "best_practices": [...] }, "dependency_injection": { "overview": "Dependency injection via Depends()...", "examples": [...], "best_practices": [...] }, "pydantic_integration": { "overview": "Pydantic models for validation...", "examples": [...], "best_practices": [...] }, "version_notes": "Compatible with Pydantic v2.x" }

Integration

Used By:

• @documentation-researcher (Primary) - Phase 2 sub-agent for documentation research

Integrates With:

• doc-analyzer skill - Fetched documentation is analyzed for patterns and best practices

• context7-mcp - Primary documentation retrieval mechanism

• fetch-mcp - Supplementary web content retrieval

Workflow Position:

• Analysis Specialist identifies technical stack requirements

• Documentation Researcher receives analysis

• doc-fetcher skill retrieves documentation (Step 3-4)

• doc-analyzer skill analyzes documentation (Step 5-6)

• Results synthesized into documentation summary

• Design Orchestrator includes in PRP

Version: 2.0.0 Auto-Activation: Yes Phase: 2 - Design & Planning Created: 2025-10-29