
deepwiki
Access GitHub repository documentation and AI-powered Q&A via DeepWiki - compare repos, explore architecture, quickstart guides, deep dives, and troubleshooting
- version
- 2.3.1
- GitHub stars
- 10
Install
/plugin install deepwiki@qazi0-claude-pluginsRun it inside Claude Code after adding the marketplace with /plugin marketplace add qazi0/claude-plugins.
Contents
Discovered from sourceSkills 1
DeepWiki Skill
Use DeepWiki to explore and understand GitHub repositories through AI-powered documentation and Q&A.
When to Use DeepWiki
Use the DeepWiki MCP tools when you need to:
- Understand the architecture of an unfamiliar GitHub repository
- Learn how a library or framework works
- Find specific implementation details in open-source projects
- Get context about a codebase before making contributions
- Answer technical questions about public repositories
Available Tools
read_wiki_structure
Get the documentation structure/table of contents for a repository.
Use this first to understand what documentation is available.
repo_name: "owner/repo" (e.g., "facebook/react", "vercel/next.js")
read_wiki_contents
Read specific documentation content from the wiki.
Use after read_wiki_structure to dive into specific topics.
repo_name: "owner/repo"
topic: "topic-name" (from the structure)
ask_question
Ask an AI-powered question about the repository.
Best for specific questions when you know what you're looking for.
repo_name: "owner/repo"
question: "How does authentication work in this project?"
Best Practices
- Start with structure: Always call
read_wiki_structurefirst to see what's available - Be specific: When using
ask_question, ask focused questions for better answers - Use repo format: Always use
owner/repoformat (e.g.,anthropics/claude-code) - Public repos only: DeepWiki only works with public GitHub repositories that have been indexed
Example Workflow
- User asks about a repository
- Call
read_wiki_structureto get the documentation overview - Identify relevant sections from the structure
- Call
read_wiki_contentsfor detailed information - Use
ask_questionfor specific queries not covered in docs
Limitations
- Only works with public GitHub repositories
- Repository must be indexed on DeepWiki.com
- For private repos, users need a Devin account
Commands 7
Architecture Deep Dive
You are analyzing the architecture of: $ARGUMENTS.repo
Instructions
-
First, use
read_wiki_structurewithrepo_name: "$ARGUMENTS.repo"to get the documentation structure -
Identify architecture-related sections in the documentation (look for: architecture, design, internals, how it works, system design, components, modules)
-
Use
read_wiki_contentsto read the most relevant architecture sections (typically 2-3 sections) -
Use
ask_questionwith targeted architecture questions:- "What is the high-level architecture of this project?"
- "What are the main components and how do they interact?"
- "What design patterns does this project use?"
-
Synthesize and present a comprehensive architecture overview:
Project Overview
What the project does and its primary purpose.
High-Level Architecture
Describe the overall system architecture with main components.
[Create an ASCII diagram if possible showing component relationships]Core Components
For each major component:
- Component Name: Purpose and responsibility
- Key interfaces or APIs it exposes
- Dependencies on other components
Data Flow
How data moves through the system for typical operations.
Design Patterns
Notable patterns used (e.g., MVC, event-driven, plugin architecture, middleware chain).
Extension Points
How the system is designed to be extended (plugins, hooks, middleware, etc.).
Key Abstractions
Important interfaces, base classes, or concepts that define the system.
Technology Stack
Languages, frameworks, and key dependencies.
-
Focus on clarity and visual representation where possible. Use diagrams (ASCII), bullet points, and tables to make the architecture easy to understand.
-
If architecture documentation is limited, acknowledge gaps and provide what can be inferred from available information.
Ask DeepWiki
You are answering a question about $ARGUMENTS.repo.
Question: $ARGUMENTS.question
Instructions
-
Use the
ask_questiontool with:repo_name: "$ARGUMENTS.repo"question: "$ARGUMENTS.question"
-
Present the answer clearly and concisely
-
If the answer references specific parts of the codebase, mention the relevant files or modules
-
If the question is ambiguous or the answer is incomplete, suggest follow-up questions the user might want to ask
Compare Repositories
You are comparing two GitHub repositories:
- Repository 1: $ARGUMENTS.repo1
- Repository 2: $ARGUMENTS.repo2
- Focus Aspect: $ARGUMENTS.aspect
Instructions
-
First, gather information about both repositories in parallel:
- Use
read_wiki_structurefor both repos to understand their documentation structure - Use
ask_questionfor both repos with targeted questions about their core purpose and architecture
- Use
-
For each repository, gather:
- Core purpose and philosophy
- Key features and capabilities
- Architecture and design patterns
- Performance characteristics (if available)
- Ecosystem and community (plugins, extensions, integrations)
- Learning curve and documentation quality
-
If a specific aspect was provided ("$ARGUMENTS.aspect"), dive deeper:
- Use
ask_questionon both repos specifically about that aspect - Compare their approaches, trade-offs, and implementations
- Use
-
Present a structured comparison:
Overview
Brief description of what each project is and its primary use case.
Philosophy & Approach
How each project approaches the problem domain.
Feature Comparison
Feature $ARGUMENTS.repo1 $ARGUMENTS.repo2 ... ... ... Architecture
Key architectural differences and similarities.
When to Choose Each
- Choose $ARGUMENTS.repo1 when: [specific use cases]
- Choose $ARGUMENTS.repo2 when: [specific use cases]
Trade-offs
What you gain and lose with each choice.
-
Be objective and factual. Avoid bias toward either repository.
-
If information is limited for either repository, acknowledge this and suggest what additional research might be needed.
Deep Dive: $ARGUMENTS.topic
You are doing a comprehensive deep dive on $ARGUMENTS.topic in the repository: $ARGUMENTS.repo
Instructions
-
First, use
read_wiki_structurewithrepo_name: "$ARGUMENTS.repo"to get the full documentation structure -
Analyze the structure and identify ALL sections that might relate to "$ARGUMENTS.topic":
- Direct matches (sections named after the topic)
- Related concepts (e.g., for "authentication": sessions, JWT, OAuth, middleware, security)
- Implementation sections that might cover the topic
- Best practices or guides mentioning the topic
-
Use
read_wiki_contentsto read the most relevant sections (prioritize 3-4 key sections) -
Use
ask_questionwith multiple targeted questions to fill gaps:- "How does $ARGUMENTS.topic work in this project?"
- "What are the best practices for $ARGUMENTS.topic?"
- "What are common patterns for implementing $ARGUMENTS.topic?"
- "What are the configuration options related to $ARGUMENTS.topic?"
-
Synthesize everything into a comprehensive guide:
Overview
What is $ARGUMENTS.topic in the context of $ARGUMENTS.repo? Why does it matter?
Core Concepts
Key concepts and terminology you need to understand.
How It Works
Detailed explanation of how $ARGUMENTS.topic is implemented/handled.
Implementation Guide
Basic Implementation
# Step-by-step code for basic usageAdvanced Implementation
# More complex scenariosConfiguration Options
All relevant configuration options with explanations.
Option Type Default Description ... ... ... ... Best Practices
- Recommended approaches
- Performance considerations
- Security considerations (if applicable)
Common Patterns
Patterns frequently used in the community.
Anti-Patterns & Pitfalls
What to avoid and common mistakes.
Integration with Other Features
How $ARGUMENTS.topic interacts with other parts of the system.
Examples
Real-world examples demonstrating various use cases.
Further Reading
Links to relevant documentation sections for even deeper exploration.
-
Be thorough but organized. The goal is to make someone an expert on this specific topic within this repository.
-
If information is sparse, acknowledge limitations and suggest where users might find more information (GitHub issues, discussions, source code).
Explore Repository
You are exploring the GitHub repository: $ARGUMENTS.repo
Instructions
-
First, use the
read_wiki_structuretool withrepo_name: "$ARGUMENTS.repo"to get the documentation structure -
Analyze the structure and identify the most important sections (typically: getting started, architecture, core concepts, API reference)
-
Use
read_wiki_contentsto read 2-3 of the most important sections -
Provide a comprehensive summary including:
- What the project is and its purpose
- Key features and capabilities
- Architecture overview (if available)
- How to get started
- Notable design decisions or patterns
Present the information in a clear, organized format that helps the user quickly understand the repository.
Quick Start Guide
You are creating a quick start guide for: $ARGUMENTS.repo Use case focus: $ARGUMENTS.usecase
Instructions
-
Use
read_wiki_structurewithrepo_name: "$ARGUMENTS.repo"to find getting started / installation sections -
Identify and read the most relevant sections using
read_wiki_contents:- Installation / Setup
- Getting Started / Quick Start
- Basic Usage / First Steps
- Configuration (if essential)
-
Use
ask_questionto fill in any gaps:- "What are the minimum requirements to get started with this project?"
- "What is the simplest example to verify the installation works?"
- If a use case was specified: "How do I use this project for $ARGUMENTS.usecase?"
-
Present a streamlined, actionable quick start guide:
Prerequisites
- Required software/tools (with versions if important)
- System requirements
- Required accounts or API keys (if any)
Installation
# Step-by-step installation commandsBasic Configuration
Only include if configuration is required before first use.
# Minimal configuration exampleHello World Example
The simplest possible working example.
# Complete, copy-paste ready codeVerify It Works
How to confirm the installation and setup is successful.
Next Steps
- Link to key documentation sections for going deeper
- Common next things people want to do
Common Gotchas
Quick notes on things that commonly trip up new users.
-
Keep it minimal and actionable:
- Only include what's absolutely necessary to get running
- Every code block should be copy-paste ready
- Avoid explaining concepts - focus on doing
- If there are multiple installation methods, recommend the most common one
-
If a specific use case was provided, tailor the example to that use case.
Troubleshooting: $ARGUMENTS.issue
You are helping troubleshoot "$ARGUMENTS.issue" in the repository: $ARGUMENTS.repo
Instructions
-
First, use
read_wiki_structurewithrepo_name: "$ARGUMENTS.repo"to find troubleshooting-related sections:- Troubleshooting guides
- FAQ
- Common issues / Known issues
- Migration guides (if the issue might be version-related)
-
Use
read_wiki_contentsto read relevant troubleshooting documentation -
Use
ask_questionwith targeted diagnostic questions:- "What causes $ARGUMENTS.issue and how do I fix it?"
- "What are common causes of $ARGUMENTS.issue?"
- "How do I debug $ARGUMENTS.issue?"
- "What configuration might cause $ARGUMENTS.issue?"
-
Present a structured troubleshooting guide:
Understanding the Issue
Brief explanation of what "$ARGUMENTS.issue" typically means in the context of $ARGUMENTS.repo.
Quick Fixes
Try these first - they solve the problem in most cases:
-
[Most Common Fix]
# Command or code to fixWhy this works: [brief explanation]
-
[Second Most Common Fix]
# Command or code -
[Third Option] ...
Diagnostic Steps
If quick fixes didn't work, follow these steps to identify the root cause:
-
Check X
# How to checkWhat to look for: ...
-
Verify Y ...
Common Causes & Solutions
Cause 1: [Description]
Symptoms: What you'd see if this is the cause Solution:
# How to fixCause 2: [Description]
Symptoms: ... Solution: ...
Cause 3: [Description]
...
Environment-Specific Issues
Issues that might be specific to:
- Windows: ...
- macOS: ...
- Linux: ...
- Docker: ...
Version Compatibility
Known issues with specific versions and how to resolve them.
Prevention
How to avoid this issue in the future.
Still Stuck?
- Where to search for more help (GitHub issues, Discord, Stack Overflow)
- What information to include when asking for help
- Links to relevant documentation sections
-
-
Prioritize actionable solutions over explanations. Users troubleshooting want to fix things quickly.
-
If the issue is vague, provide a diagnostic flowchart to help narrow down the specific problem.
-
Include exact commands and code that can be copy-pasted.
MCP servers 1
Sponsors
Details
- Marketplace
- qazi0/claude-plugins
- Source
- deepwiki
- Category
- Community
- Keywords
- deepwiki, github, documentation, mcp, compare, architecture, troubleshoot