home / skills / mjunaidca / mjs-agent-skills / researching-with-deepwiki

researching-with-deepwiki skill

/.claude/skills/researching-with-deepwiki

This skill helps you explore unfamiliar codebases by analyzing repositories with DeepWiki MCP, delivering architecture insights and Q&A on source code.

npx playbooks add skill mjunaidca/mjs-agent-skills --skill researching-with-deepwiki

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
4.8 KB
---
name: researching-with-deepwiki
description: |
  Research GitHub, GitLab, and Bitbucket repositories using DeepWiki MCP server. Use when exploring
  unfamiliar codebases, understanding project architecture, or asking questions about how a specific
  open-source project works. Provides AI-powered repo analysis and RAG-based Q&A about source code.
  NOT for fetching library API docs (use fetching-library-docs instead) or local files.
---

# Researching with DeepWiki

Research and understand codebases using the DeepWiki MCP server.

## MCP Server Setup

Add to your Claude Code settings:

```bash
claude mcp add -s user -t http deepwiki https://mcp.deepwiki.com/mcp
```

Or add to `settings.json`:

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

### Private Repositories

For private repos, use the Devin.ai endpoint with authentication:

```json
{
  "mcpServers": {
    "deepwiki": {
      "type": "http",
      "url": "https://mcp.devin.ai/deepwiki/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_DEVIN_API_KEY"
      }
    }
  }
}
```

---

## When to Use DeepWiki

| Scenario | Use DeepWiki? |
|----------|---------------|
| Exploring unfamiliar open-source codebase | Yes |
| Understanding project architecture | Yes |
| Finding how a feature is implemented | Yes |
| Generating documentation for a repo | Yes |
| Working with your own local code | No - use Glob/Grep |
| Quick file lookups in known structure | No - use Read tool |

---

## Core Capabilities

### 1. Repository Analysis

Ask DeepWiki to analyze any public repository:

```
"Analyze the architecture of github.com/vercel/next.js"
"How is the routing system implemented in github.com/remix-run/react-router?"
"What design patterns are used in github.com/anthropics/anthropic-sdk-python?"
```

### 2. Code Structure Understanding

Get insights into project organization:

```
"Explain the directory structure of github.com/langchain-ai/langchain"
"What are the main modules in github.com/fastapi/fastapi?"
"How are tests organized in github.com/pytest-dev/pytest?"
```

### 3. Feature Investigation

Understand how specific features work:

```
"How does streaming work in github.com/openai/openai-python?"
"Where is authentication handled in github.com/better-auth/better-auth?"
"How are middleware implemented in github.com/honojs/hono?"
```

### 4. Architecture Visualization

DeepWiki can generate Mermaid diagrams:

```
"Generate an architecture diagram for github.com/prisma/prisma"
"Show the data flow in github.com/trpc/trpc"
```

---

## Best Practices

### 1. Be Specific with Questions

```
# Good - specific question
"How does the caching system work in github.com/vercel/swr?"

# Less effective - too broad
"Tell me about github.com/vercel/swr"
```

### 2. Reference Specific Paths

```
# Good - targeted investigation
"Explain the src/core directory in github.com/pmndrs/zustand"

# Also good - feature-focused
"How is the middleware pattern implemented in github.com/pmndrs/zustand?"
```

### 3. Compare Implementations

```
"Compare how github.com/tanstack/query and github.com/vercel/swr handle cache invalidation"
```

### 4. Learn from Popular Projects

```
"What patterns from github.com/shadcn-ui/ui should I follow for my component library?"
```

---

## Common Use Cases

### Learning a New Framework

```
1. "Explain the core concepts of github.com/honojs/hono"
2. "How do I add middleware in github.com/honojs/hono?"
3. "Show example route handlers from github.com/honojs/hono"
```

### Debugging Integration Issues

```
1. "How does github.com/drizzle-team/drizzle-orm handle connection pooling?"
2. "What error types are thrown by github.com/drizzle-team/drizzle-orm?"
```

### Preparing for Contributions

```
1. "What's the contribution workflow for github.com/anthropics/claude-code?"
2. "How are issues labeled in github.com/anthropics/claude-code?"
3. "What testing patterns are used in github.com/anthropics/claude-code?"
```

---

## Supported Platforms

| Platform | URL Format |
|----------|------------|
| GitHub | `github.com/owner/repo` |
| GitLab | `gitlab.com/owner/repo` |
| Bitbucket | `bitbucket.org/owner/repo` |

---

## Limitations

- **Rate limits**: Public endpoint has usage limits
- **Private repos**: Requires Devin.ai API key
- **Large repos**: May take time to analyze
- **Real-time changes**: Cached analysis may not reflect latest commits

---

## Verification

Run: `python3 scripts/verify.py`

Expected: `✓ DeepWiki MCP server configured`

## If Verification Fails

1. Check: MCP server is configured in settings
2. Test: Try a simple query like "analyze github.com/anthropics/anthropic-sdk-python"
3. **Stop and report** if still failing

## References

- [DeepWiki](https://deepwiki.com) - Main service
- [MCP endpoint](https://mcp.deepwiki.com/mcp) - Public MCP server

Overview

This skill lets an agent research GitHub, GitLab, and Bitbucket repositories using the DeepWiki MCP server to provide AI-powered repository analysis and RAG-based Q&A. It is designed for exploring unfamiliar codebases, understanding project architecture, and answering targeted questions about implementation details. It is not intended for fetching library API docs or local files.

How this skill works

The skill sends repository references to a configured DeepWiki MCP server which crawls and indexes the repo, extracts code and metadata, and builds retrieval-augmented context for QA. Your agent can ask architecture, directory-structure, feature-implementation, or diagram-generation prompts; DeepWiki returns analyzed summaries, file-level references, and optionally Mermaid diagrams. For private repos, the skill supports authenticated MCP endpoints (Devin.ai) via headers in your settings.

When to use it

  • Exploring an unfamiliar open-source codebase
  • Understanding project architecture and module responsibilities
  • Investigating how a specific feature is implemented
  • Generating architecture diagrams or data-flow diagrams for a repo
  • Preparing to contribute or write documentation for a project

Best practices

  • Ask focused, specific questions (e.g., target a subsystem, path, or feature) rather than broad “tell me about” prompts
  • Reference specific directories or files to narrow analysis and get precise answers
  • Compare two repositories or modules when you want design tradeoffs or alternative patterns
  • Use the authenticated MCP endpoint for private repositories and verify your API key is set
  • Expect longer analysis time and potential cache staleness for very large repositories

Example use cases

  • Analyze the routing system of github.com/remix-run/react-router and get file references for handlers
  • Explain the src/core directory organization of github.com/langchain-ai/langchain with examples of main modules
  • Generate a Mermaid architecture diagram for github.com/prisma/prisma to visualize data flow
  • Compare cache invalidation strategies between github.com/tanstack/query and github.com/vercel/swr
  • Investigate where authentication and middleware are implemented in a repository before submitting a PR

FAQ

Do I need special credentials to analyze private repositories?

Yes. Configure the MCP server to use a Devin.ai endpoint and include an Authorization header with your API key in your settings.

Will analysis reflect the latest commits?

DeepWiki analysis may be cached; large or recently changed repos can take time to re-index, so verify timestamps or re-run analysis if you need the newest state.