Skip to main content
Glama
UrbanDiver

Local DeepWiki MCP Server

by UrbanDiver

Lokaler DeepWiki MCP-Server

Ein lokaler, datenschutzorientierter MCP-Server, der DeepWiki-artige Dokumentation für private Repositories mit RAG-basierten Q&A-Funktionen generiert.

Schnellstart

Sofort ausprobieren — ein vorab erstelltes Wiki dieses Projekts ist enthalten:

git clone https://github.com/UrbanDiver/local-deepwiki-mcp.git
cd local-deepwiki-mcp
uv sync                          # Install dependencies
deepwiki serve .deepwiki         # Browse the wiki at http://localhost:8080

Eigenes Repo indizieren — erfordert einen LLM-Anbieter (OpenAI, Anthropic oder Ollama):

export OPENAI_API_KEY="..."      # Or ANTHROPIC_API_KEY for Anthropic
deepwiki init                    # Configure LLM + embedding providers
deepwiki config health-check     # Verify providers are working
deepwiki update /path/to/repo    # Index a repository and generate wiki
deepwiki serve /path/to/repo/.deepwiki

Voraussetzungen: Python 3.11+, uv (siehe uv installieren unten) und ein LLM-Anbieter:

  • OpenAI (Standard) — Umgebungsvariable OPENAI_API_KEY setzen

  • Anthropic — Umgebungsvariable ANTHROPIC_API_KEY setzen

  • Ollama (vollständig lokal, erfordert GPU) — Ollama installieren, dann ollama pull qwen3-coder:30b ausführen

Funktionen

  • Sprachübergreifendes Code-Parsing mittels tree-sitter (Python, TypeScript/JavaScript, Go, Rust, Java, C/C++, Objective-C, Swift, Ruby, PHP, Kotlin, C#)

  • AST-basiertes Chunking, das die Codestruktur respektiert (Funktionen, Klassen, Methoden)

  • Semantische Suche unter Verwendung der LanceDB-Vektordatenbank

  • LLM-gestützte Wiki-Generierung mit Unterstützung für Ollama (lokal), Anthropic und OpenAI

  • Konfigurierbare Embeddings - lokal (sentence-transformers) oder OpenAI

  • Inkrementelle Indizierung - nur geänderte Dateien werden neu verarbeitet

  • RAG-basiertes Q&A - Fragen zur Codebase stellen

  • Architektur-Gesundheit - 9-dimensionale Bewertung (Komplexität, Kopplung, Smells, Schichten, Churn, Kohäsion, Duplizierung, Testbarkeit, Wartbarkeit)

  • Deep Research-Modus - mehrstufiges Schlussfolgern für komplexe Architekturfragen

  • Web-UI - generiertes Wiki im Browser durchsuchen

  • Export als HTML - statische HTML-Seite zum Teilen generieren

  • Export als PDF - druckbare PDF-Dokumentation mit Mermaid-Diagrammen generieren

  • Interaktive Codemap - Visualisierung des Ausführungsflusses über Dateien hinweg mit Mermaid-Diagrammen

  • Lazy Page Generation - fehlende Wiki-Seiten werden bei Bedarf beim Aufruf generiert

Installation

Mit uv (empfohlen)

cd local-deepwiki-mcp
uv sync

Alle LLM-Anbieter und die Web-UI sind standardmäßig enthalten. Optionales Extra für PDF-Export:

uv sync --extra pdf              # Add WeasyPrint for PDF export
uv sync --extra all              # Same as --extra pdf (all optional extras)

Mit pip

cd local-deepwiki-mcp
pip install -e ".[all]"          # Recommended: install with all extras
# or: pip install -e .           # Minimal: core only

Konfiguration

Führen Sie den Initialisierungs-Assistenten aus, um automatisch eine Konfigurationsdatei zu erstellen:

deepwiki init                    # Interactive wizard
deepwiki init --non-interactive  # Auto-detect defaults (CI/CD)

Oder erstellen Sie manuell eine unter ~/.config/local-deepwiki/config.yaml:

embedding:
  provider: "local"  # or "openai"
  local:
    model: "all-MiniLM-L6-v2"
  openai:
    model: "text-embedding-3-small"

llm:
  provider: "openai"  # or "anthropic" or "ollama"
  openai:
    model: "gpt-4o"
    # base_url: "https://your-proxy.example.com/v1"  # For OpenAI-compatible proxies
  anthropic:
    model: "claude-sonnet-4-20250514"
  ollama:
    model: "qwen3-coder:30b"
    base_url: "http://localhost:11434"

parsing:
  languages:
    - python
    - typescript
    - javascript
    - go
    - rust
    - java
    - c
    - cpp
  max_file_size: 1048576
  exclude_patterns:
    - "node_modules/**"
    - "venv/**"
    - ".git/**"

chunking:
  max_chunk_tokens: 512
  overlap_tokens: 50

output:
  wiki_dir: ".deepwiki"
  vector_db_name: "vectors.lance"

uv installieren

uv ist ein schneller Python-Paketmanager. Falls Sie ihn nicht haben:

# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Or with pip
pip install uv

# Or with Homebrew
brew install uv

Starten Sie nach der Installation Ihr Terminal neu oder führen Sie source ~/.bashrc (oder ~/.zshrc) aus.

MCP-Server-Integration

Der MCP-Server läuft über stdio und funktioniert mit jedem MCP-kompatiblen KI-Tool. Starten Sie ihn manuell mit:

deepwiki mcp

Oder konfigurieren Sie Ihr KI-Tool so, dass es ihn automatisch startet:

Claude Code

Fügen Sie dies zu ~/.claude/claude_code_config.json hinzu:

{
  "mcpServers": {
    "local-deepwiki": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/local-deepwiki-mcp", "local-deepwiki"],
      "env": {
        "OPENAI_API_KEY": "${OPENAI_API_KEY}"
      }
    }
  }
}

Cursor

Fügen Sie dies zu den MCP-Einstellungen von Cursor hinzu (Settings > MCP Servers > Add):

{
  "mcpServers": {
    "local-deepwiki": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/local-deepwiki-mcp", "local-deepwiki"],
      "env": {
        "OPENAI_API_KEY": "${OPENAI_API_KEY}"
      }
    }
  }
}

Windsurf

Fügen Sie dies zu ~/.codeium/windsurf/mcp_config.json hinzu:

{
  "mcpServers": {
    "local-deepwiki": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/local-deepwiki-mcp", "local-deepwiki"],
      "env": {
        "OPENAI_API_KEY": "${OPENAI_API_KEY}"
      }
    }
  }
}

VS Code (Copilot)

Fügen Sie dies zu .vscode/mcp.json in Ihrem Workspace hinzu:

{
  "servers": {
    "local-deepwiki": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/local-deepwiki-mcp", "local-deepwiki"],
      "env": {
        "OPENAI_API_KEY": "${OPENAI_API_KEY}"
      }
    }
  }
}

Generisch (jeder MCP-Client)

Der Server kommuniziert über stdio unter Verwendung des MCP-Protokolls. Starten mit:

uv run --directory /path/to/local-deepwiki-mcp local-deepwiki

Oder ohne uv (nach pip install -e .):

local-deepwiki

Hinweis: Ersetzen Sie /path/to/local-deepwiki-mcp durch den tatsächlichen Pfad, unter dem Sie das Repository geklont haben. Fügen Sie ANTHROPIC_API_KEY zum env-Block hinzu, falls Sie Anthropic anstelle von OpenAI verwenden.

MCP-Tools (64 Tools)

Der Server stellt 64 MCP-Tools in 8 Kategorien bereit. Nachfolgend finden Sie die am häufigsten verwendeten Tools mit Beispielen, gefolgt von der vollständigen Tool-Referenz.

Core-Tools

index_repository

Indiziert ein Repository und generiert Wiki-Dokumentation.

{
  "repo_path": "/path/to/repo",
  "full_rebuild": false,
  "llm_provider": "ollama",
  "embedding_provider": "local"
}

ask_question

Stellt eine Frage zur Codebase mittels RAG.

{
  "repo_path": "/path/to/repo",
  "question": "How does the authentication system work?",
  "max_context": 5
}

deep_research

Mehrstufiges Schlussfolgern für komplexe Architekturfragen. Führt Abfragedekomposition, paralleles Abrufen, Lückenanalyse und umfassende Synthese durch.

{
  "repo_path": "/path/to/repo",
  "question": "How does the authentication system interact with the database layer?",
  "max_chunks": 30
}

Tool

Beschreibung

index_repository

Indiziert ein Repository und generiert Wiki-Dokumentation

ask_question

RAG-basiertes Q&A zur Codebase

deep_research

Mehrstufiges Schlussfolgern mit Abfragedekomposition und Synthese

read_wiki_structure

Inhaltsverzeichnis des Wikis abrufen

read_wiki_page

Eine bestimmte Wiki-Seite lesen

search_code

Semantische Suche in der gesamten Codebase

export_wiki_html

Wiki als statische HTML-Seite exportieren

export_wiki_pdf

Wiki als PDF mit Mermaid-Diagramm-Rendering exportieren

Generator-Tools (12)

Tool

Beschreibung

get_diagrams

Mermaid-Diagramme generieren (Klasse, Abhängigkeit, Modul, Sequenz)

get_call_graph

Funktionsaufruf-Graph-Analyse

get_glossary

Durchsuchbares Glossar der Code-Entitäten

get_inheritance

Klassenhierarchie-Baum

get_coverage

Analyse der Dokumentationsabdeckung

get_changelog

Git-basiertes Changelog generieren

get_api_docs

Extraktion von Parametern und Rückgabetypen

get_test_examples

Testbeispiele für Entitäten extrahieren

detect_stale_docs

Veraltete Wiki-Seiten erkennen

detect_secrets

Nach hartcodierten Anmeldedaten scannen

get_index_status

Indexstatus und Gesundheit des Repositorys

list_indexed_repos

Alle indizierten Repositories auflisten

Analyse- & Such-Tools (10)

Tool

Beschreibung

search_wiki

Volltextsuche über Wiki-Seiten und Code-Entitäten

fuzzy_search

Levenshtein-basierter Namensabgleich ("Meinten Sie?")

get_file_context

Importe, Aufrufer und verwandte Dateien für eine Quelldatei

explain_entity

Komposit: Glossar + Aufrufgraph + Vererbung + Tests + API-Doks

impact_analysis

Analyse des Wirkungsbereichs mit umgekehrtem Aufrufgraph und Risikostufe

get_complexity_metrics

Zyklomatische Komplexität und Verschachtelungstiefe via tree-sitter AST

analyze_diff

Git-Diff auf betroffene Wiki-Seiten und Entitäten abbilden

ask_about_diff

RAG-basiertes Q&A zu Codeänderungen

get_project_manifest

Geparste Metadaten aus pyproject.toml, package.json, etc.

get_wiki_stats

Wiki-Gesundheits-Dashboard: Index, Seiten, Abdeckung, Status

Architektur-Gesundheits-Tools (17)

Tool

Beschreibung

get_architecture_health

Zusammengesetzte Gesundheitsnote (A-F) über 9 Dimensionen

get_hotspots

Funktionen nach Komplexität, kognitiver Komplexität, Parametern, Länge oder Verschachtelung sortieren

get_coupling_metrics

Robert C. Martin Kopplungsmetriken (Ca, Ce, I, A, D)

get_design_smells

God-Classes, Feature Envy, lange Methoden etc. erkennen

get_layer_dependencies

Erkennung von Schichtverletzungen (Handler→Services→Core)

get_churn_metrics

Häufigkeit von Dateiänderungen mit Churn×Komplexität-Verbund

get_co_change

Co-Change-Kopplung via Jaccard-Ähnlichkeit

get_cohesion_metrics

LCOM4-Klassen-Kohäsion und Modul-Import-Kohäsion

get_duplication_metrics

Typ 1 (exakt) und Typ 2 (strukturell) Klon-Erkennung

get_testability_metrics

Test-zu-Code-Verhältnis, Abdeckungs-Mapping, Assertionsdichte

get_maintainability_metrics

Wartbarkeitsindex pro Funktion (Halstead + CC + LOC)

get_recommendations

Priorisierte Refactoring-Vorschläge mit Aufwand/Auswirkung

compare_architecture

Gesundheit zwischen zwei Git-Refs vergleichen

get_architecture_trends

Historische Snapshots der Gesundheitsbewertung

get_module_health

Modul-spezifische Komplexität, Smells, Kopplung, Risiko

get_onboarding_guide

Onboarding-Leitfaden für neue Entwickler

get_guided_tour

Interaktive geführte Touren durch die Codebase

Codemap-Tools (2)

Tool

Beschreibung

generate_codemap

Ausführungsfluss-Karten über Dateien hinweg mit Mermaid-Diagrammen und LLM-Narrativ

suggest_codemap_topics

Interessante Einstiegspunkte aus Aufrufgraph-Hubs entdecken

Forschungs- & Fortschritts-Tools (4)

Tool

Beschreibung

list_research_checkpoints

Gespeicherte Deep-Research-Checkpoints auflisten

resume_research

Eine zuvor gespeicherte Forschungssitzung fortsetzen

cancel_research

Einen laufenden Forschungsvorgang abbrechen

get_operation_progress

Fortschritt lang laufender Vorgänge prüfen

Agentische Tools (5)

Tool

Beschreibung

suggest_next_actions

Kontextbezogene Vorschläge für die nächsten zu verwendenden Tools basierend auf kürzlichen Aktionen

run_workflow

Vordefinierte mehrstufige Workflows ausführen (z. B. vollständige Analyse, Schnellprüfung)

batch_explain_entities

Batch-Version von explain_entity für mehrere Entitäten gleichzeitig

query_codebase

Agentisches RAG: bewertet Chunk-Relevanz, schreibt Abfragen für bessere Ergebnisse um

find_tools

Relevante Tools basierend auf einer natürlichsprachlichen Abfrage entdecken

Web-Server-Tools (2)

Tool

Beschreibung

serve_wiki

Wiki-Webserver zum Durchsuchen der Dokumentation starten

stop_wiki_server

Einen laufenden Wiki-Webserver stoppen

CLI-Befehle

Alle Befehle sind Unterbefehle der einheitlichen deepwiki CLI. Legacy-Einstiegspunkte (deepwiki-serve, deepwiki-export etc.) funktionieren weiterhin aus Gründen der Abwärtskompatibilität.

Befehl

Beschreibung

deepwiki init

Interaktiver Einrichtungsassistent für die Konfiguration

deepwiki status

Index-Gesundheit, Aktualität und Wiki-Abdeckung anzeigen

deepwiki update

Repo indizieren und Wiki neu generieren (inkrementell)

deepwiki mcp

MCP-Server starten (für IDE-Integration)

deepwiki serve

Wiki mit Web-UI bereitstellen

deepwiki watch

Watch-Modus - automatische Neuindizierung bei Dateiänderungen

deepwiki export

Wiki als statisches HTML exportieren

deepwiki export-pdf

Wiki als PDF exportieren

deepwiki config

Konfigurationsmanagement (validieren, anzeigen, Gesundheitscheck, Profil)

deepwiki search

Interaktive Fuzzy-Codesuche

deepwiki cache

Cache-Management (Statistiken, leeren, bereinigen)

# Setup
deepwiki init                                   # Interactive wizard
deepwiki init --non-interactive                  # Auto-detect defaults (CI/CD)
deepwiki init --non-interactive --force          # Overwrite existing config

# Indexing & status
deepwiki update                                  # Index repo and regenerate wiki
deepwiki update --full-rebuild                   # Force full rebuild
deepwiki update --dry-run                        # Preview what would change
deepwiki status                                  # Show index health dashboard
deepwiki status --json                           # Machine-readable output
deepwiki status --verbose                        # Detailed file-level info

# MCP server
deepwiki mcp                                     # Start MCP server (stdio)

# Web UI & export
deepwiki serve .deepwiki --port 8080             # Browse wiki in browser
deepwiki export .deepwiki --output ./html-export # Export to static HTML
deepwiki export-pdf .deepwiki -o docs.pdf        # Export to single PDF
deepwiki export-pdf .deepwiki --separate -o dir/ # Export each page as PDF

# Configuration
deepwiki config show                             # Show effective configuration
deepwiki config show --raw                       # Show raw YAML
deepwiki config validate                         # Check config for errors
deepwiki config health-check                     # Verify provider connectivity
deepwiki config profile list                     # List saved config profiles
deepwiki config profile save dev                 # Save current config as profile
deepwiki config profile use prod                 # Switch to a profile

# Utilities
deepwiki search                                  # Interactive fuzzy code search
deepwiki watch /path/to/repo                     # Auto-reindex on file changes
deepwiki cache stats                             # Show cache hit rates and sizes
deepwiki cache clear --llm --embedding           # Clear caches
deepwiki cache cleanup                           # Remove expired entries

API-Schlüssel

OpenAI (Standard)

  1. Gehen Sie zu platform.openai.com/api-keys

  2. Melden Sie sich an (oder erstellen Sie ein Konto)

  3. Klicken Sie auf Create new secret key

  4. Kopieren Sie den Schlüssel und setzen Sie ihn in Ihrer Umgebung:

export OPENAI_API_KEY="sk-..."

Um ihn dauerhaft zu speichern, fügen Sie den Export zu Ihrer ~/.zshrc oder ~/.bashrc hinzu.

Anthropic

  1. Gehen Sie zu console.anthropic.com/settings/keys

  2. Klicken Sie auf Create Key

  3. Setzen Sie ihn in Ihrer Umgebung:

export ANTHROPIC_API_KEY="sk-ant-..."

Verwendung eines OpenAI-kompatiblen Proxys

Wenn Ihre Organisation einen OpenAI-kompatiblen API-Endpunkt bereitstellt (z. B. über GitHub Copilot Enterprise oder einen Unternehmens-Proxy), setzen Sie die base_url in Ihrer Konfiguration:

llm:
  provider: "openai"
  openai:
    model: "gpt-4o"
    base_url: "https://your-proxy.example.com/v1"

Die Umgebungsvariable OPENAI_API_KEY ist weiterhin für die Authentifizierung erforderlich.

Voraussetzungen

Für lokale LLM-Unterstützung:

  • Ollama installiert und laufend

  • Ein Modell geladen (z. B. ollama pull llama3.2)

Für PDF-Export:

  • Systembibliotheken: pango, cairo, gdk-pixbuf (WeasyPrint-Abhängigkeiten)

    • macOS: brew install pango

    • Ubuntu/Debian: apt install libpango-1.0-0 libpangocairo-1.0-0

  • Optional für Mermaid-Diagramme: npm install -g @mermaid-js/mermaid-cli

Fehlerbehebung

Ollama-Verbindungsfehler

Falls Sie "Failed to connect to Ollama" sehen:

  1. Stellen Sie sicher, dass Ollama läuft: ollama serve

-
security - not tested
A
license - permissive license
-
quality - not tested

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

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/UrbanDiver/local-deepwiki-mcp'

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