To run DeepWiki on your own server, you use the open-source project deepwiki-open (MIT licence). It clones a private repository, writes architecture pages with diagrams from it and answers questions about the code, while the models run locally through Ollama or through a server with an OpenAI-compatible API such as vLLM. A small team gets by with one 24 GB card; a development department that wants a model trained on code needs a 72 or 96 GB card.

DeepWiki itself belongs to Cognition. According to its documentation, the free version at deepwiki.com covers public GitHub repositories, whereas wikis for repositories a team has connected are produced in the Devin app, and medium- and high-effort wikis are billed against the team's usage. The documentation says nothing about running it on your own server, so companies that may not hand code to a cloud service pick an open-source implementation.

In brief

  • Cognition's documentation describes DeepWiki only as a service (deepwiki.com and the Devin app) and mentions no self-hosted deployment.
  • deepwiki-open by AsyncFuncAI (MIT, 18.3k stars) received commits on 23 and 28 October 2026; the Docker deployment with Ollama is still in the repository, although the English README now advertises a separate app called Grok-Wiki.
  • Out of the box deepwiki-open writes pages with Google Gemini and computes embeddings with OpenAI's text-embedding-3-small, which means your code reaches cloud APIs until both roles are moved to a local server.
  • By our calculation, a 24 GB card with gpt-oss-20b serves 7 concurrent 32K-token requests, and an RTX PRO 6000 with 96 GB running Qwen3-Coder-30B-A3B in FP8 serves 17.
  • deepwiki-open has a single protection, a shared authorisation code, so the server goes behind a reverse proxy with company sign-in; roles and departments are available in OpenDeepWiki.

How a wiki generator turns a repository into documentation

All tools of this kind follow the same pattern. The repository is cloned, the code is split into chunks, an embedding model converts each chunk into a vector, and a language model plans the page structure and writes every page from the closest-matching chunks. deepwiki-open draws its diagrams as Mermaid code, and the same index later doubles as a chat about the repository.

Such a wiki pays off most when new developers join, when the people who wrote the code have left, and when a contractor hands over a project. Help while writing code is covered in our article on a private coding assistant; this one deals with documentation only.

Installing deepwiki-open with Docker: status in October 2026

The project from AsyncFuncAI has 18.3k stars on GitHub, and work goes on: there are commits from 28 October 2026 (a DeepResearch fix) and 23 October (higher minimum dependency versions after security advisories), and a Docker profile for LiteLLM arrived in September.

The English README has been trimmed to a description and a link reading "Deepwiki-Open 2.0 (Grok Wiki is now live)". That points to a separate product, "a local-first desktop workspace" for macOS which hands model calls to command-line agents like Codex CLI or Claude Code. The server version has not gone anywhere: the Dockerfiles, configuration and Ollama instructions remain in the repository, and the translated READMEs, the French one for instance, still contain the complete installation guide.

Per that guide, the Next.js web interface listens on port 3000 and the API on port 8001, launched with docker-compose up or from the image ghcr.io/asyncfuncai/deepwiki-open:latest. Data sits in the mounted directory ~/.adalflow: repositories in repos/, embeddings and indexes in databases/, pages in wikicache/. Compose caps the container at 6 GB of memory.

deepwiki-open reaches private repositories with a personal access token typed into the interface; the guide covers GitHub and GitLab and names Bitbucket among the supported hosts. Self-managed GitLab or Bitbucket installations are not mentioned, but a local copy can be mounted at /app/local-repos, which works with any Git server you clone from.

deepwiki-open with Ollama or vLLM: keeping the code in your network

deepwiki-open relies on two models, and by default both jobs go to the cloud. generator.json presets Google as the provider, with gemini-2.5-flash, and embedder.json presets OpenAI's text-embedding-3-small. The README says plainly that embeddings need an OpenAI key unless Ollama mode is switched on. To keep code inside the company, you therefore switch both the generator and the embedder.

The documented path runs through Ollama: the instructions download nomic-embed-text to build the index and qwen3:1.7b to write pages, while the embedder_ollama entry takes the place of the OpenAI embedder. The generator file lists qwen3:1.7b and qwen3:8b at a num_ctx of 32,000 and llama3:8b at 8,000, yet any model you have pulled can be entered, and a larger one produces better pages. The instructions themselves admit that local models may fall short of the newest cloud ones. Option two is vLLM: the OPENAI_BASE_URL variable points the OpenAI provider at it, and the README describes a separate file for compatible embedding services.

The retrieval parameters in embedder.json explain the load. Text is cut into 350-word chunks that overlap by 100 words, meaning a fresh chunk begins every 250 words, and each search returns the 20 nearest chunks. By our count, a request built on one search carries roughly 7,000 words of code and text plus the instructions. How many tokens that makes depends on the language and the code itself, so 32K tokens of context is a reasonable minimum. If you need the wiki pages in Ukrainian, test it in a pilot: we found no published data on Ukrainian for gpt-oss-20b or Qwen3-Coder.

Equally important is the file filter in repo.json. Out of the box it ignores docs folders, lock files, config files like .env and pyproject.toml, CI definitions and binaries, and only reads a fixed set of types: Python, JavaScript, TypeScript, Java, C, C++, Go, Rust, PHP, Swift, C#, HTML, CSS, Markdown, plain text, JSON and YAML. Kotlin and COBOL are missing, so compare the list with your languages before the first run.

OpenDeepWiki and other DeepWiki alternatives

A second open-source implementation, OpenDeepWiki by AIDotNet, is also MIT-licensed and has 3.6k stars. According to its README, it is built on ASP.NET Core with .NET 10, Next.js and SQLite or PostgreSQL, and it imports code from a Git URL, a ZIP archive or a local directory that has been approved. Models are configured in the admin panel. In compose.yaml the main model is set through the ENDPOINT variable with the request type OpenAI, and that is where a server such as vLLM goes (check this in a pilot). OPENAI_BASE_URL and the Ollama settings there belong to the optional Graphify add-on.

Unlike what deepwiki-open documents, it offers user accounts with JWT, roles, departments, API keys and per-repository MCP endpoints (/api/mcp). The README prints the default administrator credentials and itself demands that the JWT secret and the password be changed before any real deployment.

If your company already runs an internal AI search over Confluence or SharePoint, repositories can be added there, as described in our article on Onyx on your own server. A wiki generator, by contrast, writes ordered pages that a new developer reads one after another.

Which graphics card a self-hosted DeepWiki needs

For a small team both models share one card. nomic-embed-text v1.5 has 137 million parameters, takes 274 MB in the Ollama library and is released under Apache 2.0; its Hugging Face card gives 8,192 as the maximum sequence length. Whatever memory remains goes to the generation model. We size with our own rule: 90 per cent of the memory reported by the driver, minus 3 GiB per card, minus the weights of both models, with the remainder divided by the cache of one request. Before the weights are subtracted, the RTX PRO 4000 (24 GB) keeps 18.5 GiB, the RTX PRO 5000 keeps 40.0 GiB with 48 GB and 61.5 GiB with 72 GB, and the RTX PRO 6000 (96 GB) keeps 83.0 GiB. The general formulas are collected in our article on GPU memory for LLMs.

Level and card Concurrent 32K requests Generation model Typical use
Starter: one RTX PRO 4000 (24 GB) 7 gpt-oss-20b in MXFP4 several repositories, between 5 and 20 readers
Starter: one RTX PRO 4500 (32 GB) 16 gpt-oss-20b in MXFP4 the same model with a larger readership
Middle: one RTX PRO 5000 (48 GB) 3 (7) Qwen3-Coder-30B-A3B in FP8 overnight generation, a handful of readers
Middle: one RTX PRO 5000 (72 GB) 10 (21) Qwen3-Coder-30B-A3B in FP8 tens of repositories
Top: each RTX PRO 6000 Server Edition card 17 (35) Qwen3-Coder-30B-A3B in FP8 sharing a server with the coding assistant

Source: our calculation with the rule above, next to nomic-embed-text (274 MB), BF16 cache (FP8 cache in brackets; gpt-oss-20b with BF16 cache only). Model weights on Hugging Face as read on 30.10.2026: 13.76 GB for gpt-oss-20b, 31.2 GB for Qwen3-Coder-30B-A3B FP8. Cache per 32K: 0.75 GiB (gpt-oss-20b) and 3 GiB (Coder-30B-A3B), our arithmetic from each model's config.json.

gpt-oss-20b (21 billion parameters, 3.6 billion active, Apache 2.0) runs "within 16GB of memory" thanks to MXFP4, as OpenAI's card puts it; its pages read well, and it fits on the smallest card. Qwen3-Coder-30B-A3B (30.5 billion, 3.3 billion active, Apache 2.0) is trained on code and needs at least 48 GB; on such a card there is little room for requests, so the comfortable mid tier starts at 72 GB. ETE picks the workstation from the number of repositories and readers, and if the wiki is to share a server with a coding assistant, sizes both jobs together.

Both versions of the RTX PRO 5000 draw 300 W, and a workstation with one of them takes about 0.75 kW from the socket by our estimate (the card, a 350 W-class processor and 15 per cent for everything else). Given the power cuts in Ukraine, it is worth connecting it through a UPS.

The duration of the first pass depends on the repository size, the number and length of pages and the number of concurrent requests; deepwiki-open publishes no performance figures of its own. The closest published figure is in NVIDIA's maximum-throughput table: a single RTX PRO 6000 Server Edition running Qwen3-30B-A3B in FP4 delivers 1,914 output tokens/s at a prompt length of 8,192 tokens and 374 tokens/s at 32,768, with every request submitted simultaneously. A tool that writes pages one at a time gets far less. Embeddings are light in comparison: by our count, a full index of two million words of code comes to about 8,000 chunks.

Keeping the wiki current and checked

A generated wiki goes stale with every branch merge. deepwiki-open caches pages in wikicache/ and documents no refresh after a merge, so regeneration is scheduled out of hours, and you check how your version triggers it. An overnight run is enough for most teams, while a repository in the middle of a big refactoring is better served after each release. On a server shared with a coding assistant, these runs use the hours when developers' agents sit idle; sizing such a server is covered in our article on a server for coding agents.

Treat the wiki pages as drafts: the language model may invent an architecture that the code does not have. Label the wiki as generated, give every repository a maintainer to read its overview pages once the first run is done, and leave the human-written architecture decisions where they are.

Access to the wiki and to the model server

A wiki generated from a private repository holds the same knowledge as the code and is open to anyone who can load it. deepwiki-open has just one shared safeguard: an authorisation code set through DEEPWIKI_AUTH_MODE and DEEPWIKI_AUTH_CODE. The README warns that this code does not fully block generation when the API is called directly. The compose file exposes ports 3000 and 8001 on the host.

  • Place the server behind a reverse proxy with company sign-in.
  • Do not expose port 8001 to the network.
  • For repositories with different groups of readers, run separate instances or use OpenDeepWiki with its roles.
  • Make Git server access tokens read-only and tie them to a service account.

The model server deserves the same attention: Ollama 0.35.0 or newer and vLLM listen on an internal address only, and for an installation without internet access the models and images are brought in beforehand. Vixen.UNO engineers can set up the wiki, the models and access to them on your infrastructure.

FAQ

Can I install DeepWiki on my own server?

Cognition's documentation describes DeepWiki only as a service and mentions no self-hosted option. In its place you install the open-source deepwiki-open or OpenDeepWiki, both MIT-licensed, and connect a local model.

Does deepwiki-open work with Ollama and private repositories?

Yes. Its Ollama guide indexes with nomic-embed-text and writes with a Qwen3 model, and private GitHub and GitLab repositories connect with a personal token. For self-managed GitLab or Bitbucket, you mount a local copy into the container.

Does deepwiki-open send code to the cloud by default?

Yes, the standard configuration uses Google Gemini and OpenAI's text-embedding-3-small. Before indexing a private repository, switch both generator and embedder over to Ollama or a vLLM of your own.

Which graphics card do I need for a code wiki?

For a few repositories a 24 GB card is enough: with gpt-oss-20b it serves 7 concurrent 32K-token requests by our rule. For dozens of repositories and Qwen3-Coder-30B-A3B in FP8, you need a 72 GB card (10 requests) or a 96 GB one (17).

How long does generating a wiki for a large repository take?

deepwiki-open publishes no performance figures: the time depends on repository size, pages, model and parallel requests. Embeddings are light: roughly 8,000 chunks come from two million words of code.

How do I keep the generated wiki up to date?

Regenerate on a schedule, nightly for example, since a refresh after every merge is not documented. The repository's maintainer rereads the overview pages.

What ETE supplies for this

Need a workstation for a wiki from your code?

Tell us how many repositories need documenting, which languages they are written in and who will read the wiki. ETE works out the configuration, and if needed Vixen.UNO engineers install deepwiki-open or OpenDeepWiki with local models and set up access.

Discuss your project

Author: ETE Engineer