Skip to main content
Glama

wiki_question

Ask questions about any GitHub repository and get AI answers with exact code snippets, file contents, and references. Supports follow-up queries and deep analysis for complex code.

Instructions

A powerful tool for asking questions about GitHub repositories using DeepWiki's AI analysis. This tool provides intelligent answers based on deep codebase analysis, with the ability to retrieve specific code snippets and file contents. DeepWiki's AI examines the entire repository structure, code patterns, and relationships to provide accurate, context-aware answers.

When to use this tool:

  • Understanding how a specific feature or system works in a repository

  • Getting explanations of complex code implementations

  • Finding where specific functionality is implemented

  • Understanding architectural decisions and patterns

  • Retrieving exact code snippets that answer your questions

  • Getting full file contents for detailed analysis

  • Following up on previous questions with cached results

  • Going deeper on existing queries for more detailed analysis

  • Sending follow-up questions to continue conversations

⚠️ Important: Do NOT ask for specific files in new questions (e.g., "show me auth.js"). Instead ask conceptual questions and use queryId to retrieve referenced files.

Key features:

  • Ask natural language questions about any GitHub repository

  • Retrieve exact code snippets that DeepWiki referenced in its answer

  • Get complete file contents or specific line ranges

  • Use cached results for efficient follow-up queries

  • Optional deep research mode for comprehensive analysis (3-15 minutes) - consider running in tmux for background processing

  • Go deeper functionality for existing queries to get more detailed analysis

  • Follow-up questions to continue conversations with existing queries (supports deep research)

  • Save responses to files for documentation or sharing

  • Flexible output control to show only what you need

CRITICAL: Understanding when to use queryId vs new question:

  • USE queryId when: Getting references/files from previous response, asking follow-ups about the same topic, going deeper, sending follow-up questions

  • USE new question when: Asking something completely different, no previous query exists

Usage examples:

  1. Ask a new question: question: "How does the authentication system work?", includeReferencesList: true

  2. Get specific references from previous query: queryId: "query-12345", referencesNumbers: [1, 2], includeAnswer: false

  3. Get full file content from previous query: queryId: "query-12345", contextFiles: ["src/auth/login.ts"], includeAnswer: false

  4. Get specific line ranges: queryId: "query-12345", contextFiles: ["src/index.ts"], contextRanges: {"src/index.ts": {"start": 100, "end": 150}}

  5. Deep research with file saving: question: "Explain the entire data flow architecture", useDeepResearch: true, saveToFile: "save-and-show"

  6. Go deeper on existing query: queryId: "query-12345", goDeeper: true

  7. Send follow-up question (shows only new response): queryId: "query-12345", followUpQuestion: "Can you explain how error handling works?", includeFullConversation: false

  8. Send follow-up with deep research (shows full conversation): queryId: "query-12345", followUpQuestion: "What are the security implications?", useDeepResearch: true, includeFullConversation: true

  9. Get all code snippets without the explanation: queryId: "query-12345", referencesAll: true, includeAnswer: false, includeReferencesList: false

Important notes:

  • referencesNumbers gets the EXACT snippets DeepWiki used (not full files)

  • contextFiles gets COMPLETE file contents (not just snippets)

  • Always check the queryId in responses for follow-up queries

  • Deep research mode provides more comprehensive analysis but takes significantly longer - consider using tmux for background execution

  • goDeeper creates a new query with deeper analysis on existing queries - returns a new queryId

  • followUpQuestion continues existing conversation with same queryId, supports deep research

  • includeFullConversation=false (default) shows only new response; true shows complete conversation

  • Use queryId instead of question when following up on previous responses

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
repoYesGitHub repository in 'owner/repo' format
queryIdNoID from previous response (required when using cached data)
goDeeperNoGo deeper on existing query for more detailed analysis (requires queryId)
questionNoYour question about the repository (required for NEW queries only)
contextAllNoGet complete contents of ALL available files
saveToFileNo'save-only' or 'save-and-show' to save output
contextFilesNoGet complete contents of specific files (e.g., ['src/index.ts', 'lib/utils.js'])
saveLocationNoCustom file path for saving
contextRangesNoGet specific line ranges from files (e.g., {'src/index.ts': {'start': 10, 'end': 50}})
includeAnswerNoShow the AI's text explanation (default: true)
referencesAllNoGet ALL exact code snippets DeepWiki referenced
useDeepResearchNoEnable deep analysis mode (takes 3-15 minutes, use sparingly)
followUpQuestionNoSend a follow-up question to existing query (requires queryId)
referencesNumbersNoGet specific reference snippets by number (e.g., [1, 2, 3])
includeReferencesListNoShow numbered list of referenced files (default: true)
includeFullConversationNoFor follow-ups: include full conversation history (default: false, shows only new response)
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description fully discloses behavioral traits. It explains that deep research takes 3-15 minutes, that referencesNumbers returns exact snippets while contextFiles returns full files, that goDeeper creates a new queryId, and that includeFullConversation controls response visibility. These details go far beyond basic operation and set clear expectations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but well-structured with clear section headings, bullet points, and numbered examples. It is front-loaded with purpose and usage context. Some redundancy exists between 'Key features,' 'Usage examples,' and 'Important notes,' but each section adds value for a complex 16-parameter tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (16 parameters, nested objects, no output schema, no annotations), the description is remarkably complete. It covers all major workflows, warns about pitfalls, explains response-related parameters, and includes guidance on background execution for long operations. It leaves little ambiguity about how to invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although schema coverage is 100%, the description adds substantial meaning beyond field descriptions. It clarifies the semantic difference between referencesNumbers and contextFiles, explains the behavior of includeFullConversation with defaults, and provides concrete examples for parameters like contextRanges, saveToFile, and followUpQuestion. This is far more than a restatement of the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'asking questions about GitHub repositories using DeepWiki's AI analysis.' It also explicitly lists capabilities like retrieving code snippets and file contents, and differentiates from the sibling tool by focusing on Q&A and deep analysis rather than parsing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit 'When to use this tool' scenarios, a critical distinction between using queryId vs new question, and multiple usage examples covering key parameter combinations. It also warns against asking for specific files in new questions, giving clear guidance on when not to use certain approaches.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ai-vivid/deepwiki-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server