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-plugins

Run it inside Claude Code after adding the marketplace with /plugin marketplace add qazi0/claude-plugins.

Contents

Discovered from source

Skills 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

  1. Start with structure: Always call read_wiki_structure first to see what's available
  2. Be specific: When using ask_question, ask focused questions for better answers
  3. Use repo format: Always use owner/repo format (e.g., anthropics/claude-code)
  4. Public repos only: DeepWiki only works with public GitHub repositories that have been indexed

Example Workflow

  1. User asks about a repository
  2. Call read_wiki_structure to get the documentation overview
  3. Identify relevant sections from the structure
  4. Call read_wiki_contents for detailed information
  5. Use ask_question for 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

  1. First, use read_wiki_structure with repo_name: "$ARGUMENTS.repo" to get the documentation structure

  2. Identify architecture-related sections in the documentation (look for: architecture, design, internals, how it works, system design, components, modules)

  3. Use read_wiki_contents to read the most relevant architecture sections (typically 2-3 sections)

  4. Use ask_question with 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?"
  5. 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.

  6. Focus on clarity and visual representation where possible. Use diagrams (ASCII), bullet points, and tables to make the architecture easy to understand.

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

  1. Use the ask_question tool with:

    • repo_name: "$ARGUMENTS.repo"
    • question: "$ARGUMENTS.question"
  2. Present the answer clearly and concisely

  3. If the answer references specific parts of the codebase, mention the relevant files or modules

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

  1. First, gather information about both repositories in parallel:

    • Use read_wiki_structure for both repos to understand their documentation structure
    • Use ask_question for both repos with targeted questions about their core purpose and architecture
  2. 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
  3. If a specific aspect was provided ("$ARGUMENTS.aspect"), dive deeper:

    • Use ask_question on both repos specifically about that aspect
    • Compare their approaches, trade-offs, and implementations
  4. 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.

  5. Be objective and factual. Avoid bias toward either repository.

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

  1. First, use read_wiki_structure with repo_name: "$ARGUMENTS.repo" to get the full documentation structure

  2. 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
  3. Use read_wiki_contents to read the most relevant sections (prioritize 3-4 key sections)

  4. Use ask_question with 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?"
  5. 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 usage
    

    Advanced Implementation

    # More complex scenarios
    

    Configuration Options

    All relevant configuration options with explanations.

    OptionTypeDefaultDescription
    ............

    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.

  6. Be thorough but organized. The goal is to make someone an expert on this specific topic within this repository.

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

  1. First, use the read_wiki_structure tool with repo_name: "$ARGUMENTS.repo" to get the documentation structure

  2. Analyze the structure and identify the most important sections (typically: getting started, architecture, core concepts, API reference)

  3. Use read_wiki_contents to read 2-3 of the most important sections

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

  1. Use read_wiki_structure with repo_name: "$ARGUMENTS.repo" to find getting started / installation sections

  2. Identify and read the most relevant sections using read_wiki_contents:

    • Installation / Setup
    • Getting Started / Quick Start
    • Basic Usage / First Steps
    • Configuration (if essential)
  3. Use ask_question to 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?"
  4. 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 commands
    

    Basic Configuration

    Only include if configuration is required before first use.

    # Minimal configuration example
    

    Hello World Example

    The simplest possible working example.

    # Complete, copy-paste ready code
    

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

  5. 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
  6. 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

  1. First, use read_wiki_structure with repo_name: "$ARGUMENTS.repo" to find troubleshooting-related sections:

    • Troubleshooting guides
    • FAQ
    • Common issues / Known issues
    • Migration guides (if the issue might be version-related)
  2. Use read_wiki_contents to read relevant troubleshooting documentation

  3. Use ask_question with 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?"
  4. 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:

    1. [Most Common Fix]

      # Command or code to fix
      

      Why this works: [brief explanation]

    2. [Second Most Common Fix]

      # Command or code
      
    3. [Third Option] ...

    Diagnostic Steps

    If quick fixes didn't work, follow these steps to identify the root cause:

    1. Check X

      # How to check
      

      What to look for: ...

    2. Verify Y ...

    Common Causes & Solutions

    Cause 1: [Description]

    Symptoms: What you'd see if this is the cause Solution:

    # How to fix
    

    Cause 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
  5. Prioritize actionable solutions over explanations. Users troubleshooting want to fix things quickly.

  6. If the issue is vague, provide a diagnostic flowchart to help narrow down the specific problem.

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

More from qazi0/claude-plugins

All 2