doc-fetcher

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..."

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:

```python

# 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:

```python

# 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:

```python

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:

1. Official Documentation (highest priority)
2. Context7 Documentation (comprehensive reference)
3. GitHub Repository (latest examples)
4. Community Resources (supplementary)

4. Version-Specific Retrieval

What it provides:

• Version compatibility checking
• Breaking change identification
• Migration guidance
• Deprecated feature detection

Version Handling:

```python

# 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:

```python

# 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:

```python

# 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

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

```

1. Use Context7 for Depth

- Primary source for API references

- Comprehensive coverage of library features

- Semantic search capabilities

- Version-specific support

1. Use Fetch-MCP for Breadth

- Official quick start guides

- GitHub examples and READMEs

- Migration guides and changelogs

- Community tutorials (verified sources)

1. 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

1. Version Awareness

- Always specify version requirements

- Check for breaking changes

- Document version compatibility

- Provide migration notes if needed

1. Token Optimization

- Start with 2000-3000 tokens

- Adjust based on complexity

- Multiple focused queries > one large query

- Cache frequently accessed docs

1. Source Validation

- Prefer official documentation

- Verify URL authenticity

- Check documentation date

- Cross-reference when uncertain

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

Input (from Documentation Researcher agent):

```

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

```

Output (doc-fetcher skill provides):

```python

# 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"

}

```

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:

1. Analysis Specialist identifies technical stack requirements
2. Documentation Researcher receives analysis
3. doc-fetcher skill retrieves documentation (Step 3-4)
4. doc-analyzer skill analyzes documentation (Step 5-6)
5. Results synthesized into documentation summary
6. Design Orchestrator includes in PRP

---

Version: 2.0.0

Auto-Activation: Yes

Phase: 2 - Design & Planning

Created: 2025-10-29