# How to Set Up and Use Local Ollama Models for Offline Wiki Generation with DeepWiki

> Generate wikis offline with DeepWiki using local Ollama models. Set up Ollama for embedding and text generation, keeping your data local and eliminating API keys.

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

---

**You can run DeepWiki completely offline by configuring it to use Ollama as both the embedding engine and text generator, eliminating the need for external API keys while keeping all data processing local.**

DeepWiki is an open-source tool that transforms code repositories into interactive documentation wikis. By leveraging **local Ollama models for offline wiki generation with DeepWiki**, you can create comprehensive documentation without sending proprietary code to third-party cloud services. This guide walks through the exact configuration steps, source code architecture, and practical implementation based on the `AsyncFuncAI/deepwiki-open` repository.

## Why Use Local Ollama Models for Offline Wiki Generation?

Running DeepWiki with local Ollama models provides three critical advantages for developers working with sensitive codebases. First, **complete data privacy** ensures your source code never leaves your local machine during the embedding and generation phases. Second, **zero API costs** eliminate per-token pricing associated with commercial LLM providers. Third, **offline capability** allows documentation generation in air-gapped environments or locations with unreliable internet connectivity.

The architecture achieves this by routing all LLM and embedding requests to a local Ollama server running on `http://localhost:11434` (or your configured `OLLAMA_HOST`), rather than external endpoints.

## Architecture Overview

Understanding how DeepWiki integrates with Ollama requires examining the specific components that handle model communication, configuration dispatching, and document processing.

### OllamaClient and API Communication

The `OllamaClient` class serves as the primary interface between DeepWiki and your local Ollama instance. Located in [`api/websocket_wiki.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/websocket_wiki.py) and [`api/simple_chat.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/simple_chat.py), this client communicates via HTTP requests to the Ollama API endpoints. When you select the local model option in the UI, the backend instantiates `OllamaClient` instead of cloud-based providers, ensuring all `generate` and `embed` requests route to `localhost:11434`.

### Configuration Dispatcher

The configuration system in [`api/config.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config.py) dynamically loads embedder and generator settings based on environment variables. When `DEEPWIKI_EMBEDDER_TYPE` is set to `ollama`, the `get_embedder_config()` function injects the `OllamaClient` class into the runtime configuration. Similarly, `get_model_config()` in [`api/config.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config.py) reads [`api/config/generator.json`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config/generator.json) to determine that the `ollama` provider should use the `qwen3:1.7b` model by default, constructing the appropriate `model_kwargs` payload for local inference.

### Embedding Processor

Unlike cloud providers that support batch embedding, Ollama processes documents individually. The `OllamaDocumentProcessor` in [`api/ollama_patch.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/ollama_patch.py) handles this limitation by iterating over each code chunk, obtaining single-vector embeddings using the `nomic-embed-text` model, and validating dimensional consistency across all processed documents. This processor also implements the model-availability guard, checking that required models are installed before attempting generation and logging clear warnings if `ollama pull` is needed.

## Prerequisites and Model Installation

Before configuring DeepWiki, you must install Ollama and download the specific models used for embedding and generation.

```bash

# Install Ollama (Linux one-liner)

curl -fsSL https://ollama.com/install.sh | sh

# For Windows or macOS, download from https://ollama.com/download

# Pull the required models

ollama pull nomic-embed-text        # Embedding model for code chunks

ollama pull qwen3:1.7b              # Default generator model for wiki content

```

Verify Ollama is running by accessing `http://localhost:11434` in your browser or running `ollama list` to confirm both models appear in your local registry.

## Step-by-Step Configuration for Offline Wiki Generation

With Ollama installed and models downloaded, configure DeepWiki to route all AI operations locally.

### Environment Variables

Create or edit the `.env` file in the project root to specify Ollama as the embedder and set the local server endpoint:

```dotenv
PORT=8001
OLLAMA_HOST=http://localhost:11434
DEEPWIKI_EMBEDDER_TYPE=ollama

# No API keys required for offline operation

```

The `DEEPWIKI_EMBEDDER_TYPE=ollama` variable triggers the configuration dispatcher in [`api/config.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config.py) to load the Ollama-specific embedder client.

### Embedder Configuration

DeepWiki uses JSON configuration files to define embedder parameters. Copy the Ollama-specific template to activate local embeddings:

```bash
cp api/config/embedder.ollama.json.bak api/config/embedder.json

```

This file specifies the `OllamaClient` class and configures it to use the `nomic-embed-text` model for converting code chunks into vector representations. The `OllamaDocumentProcessor` in [`api/ollama_patch.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/ollama_patch.py) handles the per-document embedding logic required by Ollama's API structure.

### Generator Configuration

The generator configuration in [`api/config/generator.json`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config/generator.json) already includes the Ollama provider definition, defaulting to the `qwen3:1.7b` model. When the frontend sends a request with the local model flag enabled, `get_model_config()` in [`api/config.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config.py) constructs the appropriate `model_kwargs` payload, specifying the model name and any local-specific parameters required by the Ollama API.

## Running DeepWiki with Local Ollama Models

With configuration complete, start both the backend and frontend services to begin generating wikis offline.

### Start the Backend

Navigate to the API directory and launch the FastAPI server using Poetry:

```bash

# Install Poetry if not present

python -m pip install poetry==2.0.1

# Install dependencies

poetry install -C api

# Run the server

python -m api.main

```

The backend will connect to Ollama at the `OLLAMA_HOST` specified in your `.env` file, validating that the required models are available before accepting generation requests.

### Start the Frontend

In a separate terminal, install and launch the Next.js frontend:

```bash
npm install
npm run dev

```

The UI will be available at `http://localhost:3000`.

### Generate Your Wiki

1. Open `http://localhost:3000` in your browser.
2. Enter a public repository URL (e.g., `https://github.com/AsyncFuncAI/deepwiki-open`).
3. **Check** the *"Local Ollama Model"* checkbox in the generation options.
4. Click **Generate Wiki**.

DeepWiki will now process the repository using `OllamaDocumentProcessor` for embeddings via `nomic-embed-text` and generate documentation using `qwen3:1.7b` (or your configured model) through the local Ollama server, producing a fully interactive wiki without any external API calls.

## Summary

Running DeepWiki with local Ollama models provides a complete offline documentation pipeline. Key takeaways include:

- **Privacy-first architecture**: All code processing happens locally via the `OllamaClient` in [`api/websocket_wiki.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/websocket_wiki.py) and [`api/simple_chat.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/simple_chat.py), ensuring proprietary code never leaves your machine.
- **Configuration-driven setup**: Setting `DEEPWIKI_EMBEDDER_TYPE=ollama` in `.env` and copying `embedder.ollama.json.bak` to [`embedder.json`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/embedder.json) activates the local pipeline.
- **Model-specific processing**: The `OllamaDocumentProcessor` in [`api/ollama_patch.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/ollama_patch.py) handles Ollama's single-document embedding limitation and validates model availability before generation.
- **Default model stack**: DeepWiki defaults to `nomic-embed-text` for embeddings and `qwen3:1.7b` for generation, both pulled via standard Ollama commands.

## Frequently Asked Questions

### What hardware requirements are needed to run DeepWiki with Ollama locally?

You need a machine capable of running the selected Ollama models efficiently. For the default `qwen3:1.7b` generator and `nomic-embed-text` embedder, a modern CPU with at least 8GB RAM is sufficient, though a GPU with 4GB+ VRAM significantly improves generation speed. Ollama automatically utilizes available CUDA or Metal acceleration on compatible systems.

### Can I use different Ollama models than the defaults?

Yes, you can configure alternative models by modifying the configuration files. Edit [`api/config/generator.json`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/config/generator.json) to change the default model name in the `ollama` provider section, or set environment variables to override the model selection. Ensure you run `ollama pull <model-name>` to download your chosen model before starting DeepWiki, as the `OllamaDocumentProcessor` in [`api/ollama_patch.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/ollama_patch.py) validates model availability before processing.

### How does DeepWiki handle Ollama's lack of batch embedding support?

The `OllamaDocumentProcessor` class in [`api/ollama_patch.py`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/api/ollama_patch.py) implements a sequential processing strategy. Instead of sending batches of documents to the embedding endpoint, it iterates through each code chunk individually, obtains the embedding vector from the `nomic-embed-text` model, and validates that all vectors maintain consistent dimensions before storing them. This approach ensures compatibility with Ollama's API while maintaining embedding quality.

### Is it possible to run DeepWiki with Ollama in a Docker container?

Yes, DeepWiki supports containerized deployment with Ollama. The [`README.md`](https://github.com/AsyncFuncAI/deepwiki-open/blob/main/README.md) file in the repository includes a "Quick Start" section with Docker instructions that allow you to run both DeepWiki and Ollama within containerized environments. You can mount the Ollama socket or use network bridging to connect the DeepWiki container to an Ollama container running on the same Docker network, ensuring the `OLLAMA_HOST` environment variable points to the correct container address.