# DeepWiki Backend API Endpoints: Complete Reference Guide

> Explore the core DeepWiki backend API endpoints like wiki_cache chat completions stream and export wiki. Get a complete reference for this FastAPI application and enhance your integration.

- Repository: [ASYNCFUNC/deepwiki-open](https://github.com/asyncfuncai/deepwiki-open)
- Tags: api-reference
- Published: 2026-02-16

---

**The DeepWiki backend exposes REST and WebSocket endpoints including `/chat/completions/stream` for LLM streaming, `/export/wiki` for documentation export, and `/api/wiki_cache` for caching, all implemented in a FastAPI application.**

DeepWiki is an open-source tool that automatically generates documentation for code repositories using large language models. The backend API, found in the `AsyncFuncAI/deepwiki-open` repository, provides the core infrastructure for streaming chat completions, managing wiki caches, and exporting documentation. Understanding these DeepWiki backend API endpoints is essential for developers integrating with the service or extending its functionality.

## Core DeepWiki Backend API Endpoints

The FastAPI application registers several high-level routes that handle repository analysis, chat streaming, and data persistence.

### Streaming Chat Completion (/chat/completions/stream)

The **`/chat/completions/stream`** endpoint handles real-time LLM interactions for repository-specific questions. Located in [`api/simple_chat.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/simple_chat.py) at line 76, this `POST` endpoint accepts a JSON payload containing the repository URL, chat history, and optional file-path hints.

The implementation parses the request, builds a `RAG` (Retrieval-Augmented Generation) instance, and streams responses using Server-Sent Events (`text/event-stream`). It supports multiple providers including Google Gemini, OpenAI, Ollama, Azure AI, and DashScope.

```bash
curl -X POST http://localhost:8001/chat/completions/stream \
  -H "Content-Type: application/json" \
  -d '{
        "repo_url":"https://github.com/AsyncFuncAI/deepwiki-open",
        "messages":[{"role":"user","content":"Summarize the project"}],
        "provider":"google",
        "model":"gemini-2.5-flash"
      }' --no-buffer

```

### Wiki Export (/export/wiki)

The **`/export/wiki`** endpoint, defined in [`api/api.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py) at line 227, enables downloading generated documentation as **Markdown** or **JSON** files. This `POST` endpoint returns a downloadable file with the `Content-Disposition: attachment` header set.

The request body must include the repository URL, an array of page objects (each with `id`, `title`, and `content`), and the desired format.

```bash
curl -X POST http://localhost:8001/export/wiki \
  -H "Content-Type: application/json" \
  -d '{
        "repo_url":"https://github.com/AsyncFuncAI/deepwiki-open",
        "pages":[
          {"id":"1","title":"Intro","content":"..."},
          {"id":"2","title":"Installation","content":"..."}
        ],
        "format":"markdown"
      }' -OJ

```

The `-OJ` flag instructs `curl` to use the server-provided filename, typically formatted as `{repo_name}_wiki_{timestamp}.{ext}`.

### Wiki Cache Management (/api/wiki_cache)

The **`/api/wiki_cache`** endpoint provides full CRUD operations for persisting generated wiki data, implemented across multiple methods in [`api/api.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py).

**GET** (line 461): Retrieves cached wiki structure and generated pages for a specific repository and language. Returns `null` when no cache exists.

```bash
curl "http://localhost:8001/api/wiki_cache?owner=AsyncFuncAI&repo=deepwiki-open&repo_type=github&language=en"

```

**POST** (line 486): Stores a fresh wiki cache including repository metadata, language, wiki structure, generated pages, and the LLM provider information used for generation.

```bash
curl -X POST http://localhost:8001/api/wiki_cache \
  -H "Content-Type: application/json" \
  -d '{
        "repo":{"owner":"AsyncFuncAI","repo":"deepwiki-open","type":"github"},
        "language":"en",
        "wiki_structure":{...},
        "generated_pages":{...},
        "provider":"google",
        "model":"gemini-2.5-flash"
      }'

```

**DELETE** (line 504): Removes a specific cache file, protected by an optional authentication code.

### Project Listing and Utilities

**`/api/processed_projects`** (line 577 in [`api/api.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py)): Returns an array of all repositories that currently have cached wiki files. Each entry includes the cache ID, owner, repository name, type, submission timestamp, and language code.

```bash
curl http://localhost:8001/api/processed_projects

```

**`/local_repo/structure`** (line 275 in [`api/api.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py)): Returns a JSON representation of a local repository's file tree along with its README content, useful for analyzing repositories not yet hosted on remote Git servers.

**`/health`** (line 540 in [`api/api.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py)): A simple health-check endpoint returning status 200, used by Docker and Kubernetes probes to verify service availability.

## WebSocket Real-Time Communication

In addition to REST endpoints, DeepWiki provides WebSocket support for interactive chat sessions.

### /ws/chat Endpoint

The **`/ws/chat`** WebSocket endpoint, defined in [`api/websocket_wiki.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/websocket_wiki.py), handles bi-directional communication for real-time streaming chat. This endpoint is used by the DeepWiki UI to maintain persistent connections during documentation queries, allowing for incremental token delivery without the overhead of repeated HTTP requests.

The WebSocket handler processes incoming messages containing repository context and chat history, then streams LLM responses back to the client as they are generated.

## Implementation Architecture

The DeepWiki backend organizes its functionality across several key modules:

- **[`api/api.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py)**: Core FastAPI application registering all REST routes, wiki-cache helpers (`get_wiki_cache_path`, `read_wiki_cache`, `save_wiki_cache`), export logic, health checks, and the root endpoint.
- **[`api/simple_chat.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/simple_chat.py)**: Implements the streaming chat completion endpoint with RAG integration.
- **[`api/websocket_wiki.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/websocket_wiki.py)**: Manages WebSocket connections for real-time chat.
- **[`api/rag.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/rag.py)**: Core retrieval-augmented generation logic, building retrievers and managing memory.
- **[`api/config.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config.py)**: Central configuration for language settings, authentication modes, and default model providers.

Cache files are stored as JSON under the directory returned by `get_adalflow_default_root_path()` in a `wikicache/` subdirectory.

## Summary

- **DeepWiki backend API endpoints** provide comprehensive functionality for automated documentation generation, including streaming LLM chat, wiki export, and cache management.
- The **`/chat/completions/stream`** endpoint in [`api/simple_chat.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/simple_chat.py) handles real-time chat with multiple LLM providers via Server-Sent Events.
- The **`/export/wiki`** endpoint generates downloadable Markdown or JSON documentation files with proper content disposition headers.
- The **`/api/wiki_cache`** endpoint supports full CRUD operations for persisting generated wiki data, located at lines 461, 486, and 504 in [`api/api.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/api.py).
- **WebSocket support** via `/ws/chat` in [`api/websocket_wiki.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/websocket_wiki.py) enables bi-directional real-time communication for interactive documentation queries.

## Frequently Asked Questions

### What authentication does the DeepWiki backend API require?

Most DeepWiki backend API endpoints are open by default, but the DELETE method on `/api/wiki_cache` supports an optional authentication code for protection. The authentication mode and codes are configured in [`api/config.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config.py). For production deployments, you should implement additional middleware or reverse proxy authentication as the codebase does not include built-in JWT or OAuth flows.

### How does the streaming chat endpoint handle different LLM providers?

The `/chat/completions/stream` endpoint abstracts provider differences through a `RAG` class defined in [`api/rag.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/rag.py). The endpoint accepts a `provider` parameter (e.g., "google", "openai", "ollama") and a `model` string, then instantiates the appropriate client wrapper from files like [`api/openai_client.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/openai_client.py), [`api/azureai_client.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/azureai_client.py), or [`api/dashscope_client.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/dashscope_client.py). All providers return responses through a unified streaming interface using Server-Sent Events.

### What is the difference between the REST chat endpoint and the WebSocket endpoint?

The REST endpoint `/chat/completions/stream` in [`api/simple_chat.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/simple_chat.py) uses HTTP POST with Server-Sent Events for one-way streaming from server to client, suitable for stateless request-response cycles. The WebSocket endpoint `/ws/chat` in [`api/websocket_wiki.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/websocket_wiki.py) maintains a persistent bi-directional connection, allowing the client to send multiple messages and receive incremental updates without re-establishing connections, which is preferred for interactive UI chat interfaces.

### How is the wiki cache storage organized on disk?

Wiki caches are stored as JSON files in a `wikicache/` subdirectory under the path returned by `get_adalflow_default_root_path()`. The filename is generated from repository metadata using the pattern `deepwiki_cache_{repo_type}_{owner}_{repo}_{language}.json`. The `WikiCacheData` schema includes fields for repository info, language code, wiki structure, generated pages, and the LLM provider details used during generation.