DeepWiki MCP

Live

NO AUTH

REPO DOCS

Developer Tools

DeepWiki MCP gives agents access to repo docs: ask questions about any public GitHub repository and read its AI-generated documentation without leaving the workflow.

  • Per-user credentials: read-only access to public repo docs, delivered through the same vault and audit path as every other connector.
  • Encrypted per-tenant vault: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: pre-call scope check, 90-day SIEM-exportable audit chain.
DeepWiki MCP
agent · Acme Q3
Run
How does this library handle retries, and where is that configured?
S
deepwikimcp_ask_question
88ms
DeepWiki agent
Retries use exponential backoff in client.ts. Configure via the maxRetries option; default is 3, documented in the Configuration section.
Repo: 1, sections: 2
deepwikimcp
1 repo
18:29
Message Claude...

Tools your engineering agent reaches for in DeepWiki, scoped per user.

CALL ANY TOOL
Understand a codebase fast: ask natural-language questions about a public GitHub repo, read its generated documentation, and browse the wiki structure.
deepwikimcp_ask_question
Ask question
Ask any question about a GitHub repository and get an AI-powered, context-grounded response.
Parameters
Name
Type
Required
Description
question
string
Required
The question to ask about the repository.
repoName
string
Required
GitHub repository or list of repositories (max 10) in owner/repo format.
schema_version
string
Optional
Optional schema version to use for tool execution
tool_version
string
Optional
Optional tool version to use for tool execution
deepwikimcp_read_wiki_contents
Read wiki contents
deepwikimcp_read_wiki_structure
Read wiki structure
Build your Agent
Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// DeepWiki tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepwikimcp"], toolNames: [
    "deepwikimcp_ask_question",
    "deepwikimcp_read_wiki_contents",
    "deepwikimcp_read_wiki_structure"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "How does this library handle retries, and where is that configured?" }] });
import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepwikimcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "How does this library handle retries, and where is that configured?" }],
  tools,
});

// Execute the tool call with the user's vaulted DeepWiki credential
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");
import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepwikimcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "How does this library handle retries, and where is that configured?" }],
  tools,
});

// Tool call runs with the user's vaulted DeepWiki credential
await sk.tools.executeTool(msg.content, "user_123");
import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepwikimcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "deepwiki_agent",
  model: "gemini-2.5-pro",
  instruction: "Manage DeepWiki for the signed-in user.",
  tools,
});

await agent.run("How does this library handle retries, and where is that configured?");
Try these prompts
Copy any prompt into your agent. Each maps directly to a DeepWiki tool. Click to copy, paste into your agent, done.
Ask the repo
Copy the prompt
Copied
How does this library handle retries?
Copy the prompt
Copied
What is the entry point for the CLI?
Copy the prompt
Copied
Explain how auth flows through this codebase.
Read the docs
Copy the prompt
Copied
Read the getting-started docs for this repo.
Copy the prompt
Copied
Summarize the architecture section.
Copy the prompt
Copied
What does the configuration reference cover?
Navigate
Copy the prompt
Copied
Show me the wiki structure for this repo.
Copy the prompt
Copied
Which sections cover the public API?
Copy the prompt
Copied
Where are the deployment docs?
SEE HOW AUTH WORKS
Your users connect once. Their DeepWiki credentials stay vaulted, every call is scope-checked, and every action is logged.
1
Authorize
Your user connects
DeepWiki MCP
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
DeepWiki MCP
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
DeepWiki MCP
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
DeepWiki MCP
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other developer tools connectors.
People Ops and HR teams
New Hire Provisioning Agent
Open-source Python template. Creates or detects the hire in Deel, provisions their Workspace account, builds the Notion onboarding page, posts the welcome.
People Ops and HR teams
PTO & Leave Request Agent
Open-source Python template. Resolves the employee in Deel, validates against their real entitlement, submits the request for approval, blocks the calendar.
Engineering Teams
Incident Response Agent
Open-source Python template. Triggers the PagerDuty page, opens the Jira incident, notifies the on-call Slack channel, and drafts the Confluence postmortem.
GTM and RevOps Teams
Competitive intelligence briefing agent
Scans Gong calls for competitor mentions, matches each one to its Notion battlecard, and DMs every affected rep a single Slack digest per cycle. Every call runs as the PMM who owns the briefing, never a shared bot.
Test other agents
See the same per-user auth pattern across other developer tools connectors.
ENGINEERING
DevOps assistant agent
Poll GitHub for failing checks and stale pull requests, open Linear issues for the ones that need work, and digest to Slack.
ENGINEERING
Auto-release notes agent
Group merged GitHub PRs into structured release notes, publish the page to Notion, and announce the release in Slack.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
01.
Even read-only access belongs in the audit chain
DeepWiki needs no upstream credential, but the agent calling it still does. Routing it through Scalekit means every repo question is attributed to the actual user and logged alongside your authenticated connectors, not a nameless integration.
// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
DeepWiki today. Ten connectors tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions

Does the agent access DeepWiki as the user or as a shared key?
As the user. Each workspace member authorizes once and Scalekit resolves their credential at request time. Audit logs attribute every action to that user, not a shared service account.

Where is the DeepWiki token stored?
In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Tokens never appear in prompts, logs, or LLM context.

Can I limit what the agent is allowed to do in DeepWiki?
Yes. Pass a tool name filter to listScopedTools so the DevOps agent only sees the subset you authorize. Pre-API-call scope checks block out-of-policy actions before the request reaches DeepWiki.

What happens when a user revokes DeepWiki access?
The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Does the agent respect DeepWiki permissions?
Yes. Every call runs as the authorizing user. Native roles, sharing settings, and scope restrictions in DeepWiki apply to each request, and actions log to the audit chain.

Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""deepwikimcp"": {
""url"": ""https://mcp.scalekit.com/deepwikimcp"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.deepwikimcp]
url = ""https://mcp.scalekit.com/deepwikimcp""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""deepwikimcp"": {
""url"": ""https://mcp.scalekit.com/deepwikimcp"",
""type"": ""http""
}
}
}