# How to Set Up the LLM Wiki Project Locally: Complete Installation Guide

> Set up the LLM Wiki project locally with our complete installation guide. Clone the repo, install dependencies, and run the Tauri app in minutes. Get started now.

- Repository: [nash_su/llm_wiki](https://github.com/nashsu/llm_wiki)
- Tags: how-to-guide
- Published: 2026-09-13

---

**Clone the repository, install Node 20+ and Rust 1.88+, run `npm install` and `npm run mcp:build`, then launch with `npm run tauri dev` to start the Tauri-based desktop application with hot-reloading enabled.**

The LLM Wiki project by nashsu is a cross-platform desktop application that transforms personal documents into an auto-generated, interlinked knowledge base. Setting up this project locally requires configuring both the React frontend and Rust backend environments, along with the optional Model Context Protocol (MCP) server. This guide covers the complete installation workflow from the initial `git clone` to importing your first documents, based on the actual source structure in the `nashsu/llm_wiki` repository.

## Prerequisites

Before cloning the repository, ensure your system meets the following requirements:

- **Node.js 20+** – Required for the React 19 frontend and build tooling
- **Rust 1.88+** – Required for compiling the Tauri v2 backend in `src-tauri/`
- **protoc** – The Protocol Buffers compiler, needed for certain dependencies

Platform-specific installation commands for `protoc` are documented in the README at lines 97-102 of the repository root.

## Step-by-Step Installation

### Clone the Repository

Start by cloning the LLM Wiki source code from GitHub:

```bash
git clone https://github.com/nashsu/llm_wiki.git
cd llm_wiki

```

### Install JavaScript Dependencies

Install the frontend dependencies using npm. This covers the React 19 + TypeScript + Vite stack defined in [`src/main.tsx`](https://github.com/nashsu/llm_wiki/blob/main/src/main.tsx) and related components:

```bash
npm install

```

### Build the MCP Server Component

The project includes a bundled MCP server that enables external AI agents to interact with your knowledge base. Build this component separately using the following commands:

```bash
npm --prefix mcp-server ci
npm run mcp:build

```

The `npm --prefix mcp-server ci` command installs the server's Node modules, while `npm run mcp:build` produces a bundled binary shipped as a Tauri resource. According to the source code in [`src-tauri/src/clip_server.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/clip_server.rs), this binary is loaded as a sidecar resource within the compiled application.

### Launch in Development Mode

Run the application in development mode with hot-reloading enabled for both the Rust backend and React frontend:

```bash
npm run tauri dev

```

This command compiles the Rust crate in [`src-tauri/src/main.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/main.rs) (which sets up the Tauri application, registers commands, and starts the local HTTP server) and launches the Vite development server for the UI. The application window will open automatically, allowing you to iterate on both layers simultaneously.

### Build Production Release (Optional)

To create native installers for distribution (`.dmg`, `.msi`, `.deb`, or `.AppImage`), run:

```bash
npm run tauri build

```

The compiled binaries will appear in `src-tauri/target/release/bundle/` with platform-appropriate extensions.

## Project Architecture Overview

Understanding the stack helps troubleshoot setup issues. The codebase consists of three distinct layers:

- **Desktop Layer (Tauri v2 + Rust)** – Handles native window management, bundles the backend API, and exposes local HTTP/MCP servers. The core implementation lives in [`src-tauri/src/main.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/main.rs).
- **Frontend Layer (React 19 + TypeScript + Vite)** – Renders the three-column UI (Knowledge Tree, Chat, Preview) and manages state with Zustand. The entry point is [`src/main.tsx`](https://github.com/nashsu/llm_wiki/blob/main/src/main.tsx).
- **Data/AI Layer** – Includes the two-step Chain-of-Thought ingest pipeline, graph engine (sigma.js + graphology), and optional LanceDB vector store. Graph relevance calculations reside in [`src/lib/graph-relevance.ts`](https://github.com/nashsu/llm_wiki/blob/main/src/lib/graph-relevance.ts), while insight detection is implemented in [`src/lib/graph-insights.ts`](https://github.com/nashsu/llm_wiki/blob/main/src/lib/graph-insights.ts).

## First-Run Configuration

After successfully launching `npm run tauri dev`, complete the initial setup:

### Configure LLM Providers

Open the **Settings** panel within the application. Configure your preferred LLM provider by entering the API key and model name. The system supports **OpenAI**, **Anthropic**, **Ollama**, and others, plus optional web-search tools like **Tavily**, **SerpApi**, and **SearXNG**. These credentials are persisted in the `.llm-wiki/` directory via the Tauri Store, as implemented in the Rust backend.

### Import Your First Documents

1. Create a new project from one of the built-in templates
2. Navigate to **Sources** → **Import** to add files (PDF, DOCX, MD, etc.)
3. Monitor the **Activity Panel** as the two-step ingest pipeline automatically generates YAML-front-matter wiki pages in the `wiki/` hierarchy
4. Query your knowledge base through the **Chat** panel or explore the **Knowledge Graph** visualization

## Optional: Install the Chrome Extension

To enable web clipping capabilities, load the `extension/` folder as an unpacked Chrome extension:

1. Open Chrome and navigate to `chrome://extensions/`
2. Enable "Developer mode"
3. Click "Load unpacked" and select the `extension/` directory from the repository root
4. Refer to the "Chrome Extension" section in the README (lines 120-126) for specific configuration details

## Summary

- **Node 20+, Rust 1.88+, and protoc** are mandatory prerequisites for compiling the application
- **Development workflow** uses `npm run tauri dev` for hot-reloading across the Rust backend and React frontend
- **MCP server** requires a separate build step via `npm run mcp:build` to enable external AI agent compatibility
- **Production builds** use `npm run tauri build` to generate platform-specific installers (.dmg, .msi, .deb, .AppImage)
- **Configuration persistence** occurs in the `.llm-wiki/` directory using Tauri Store, storing LLM credentials and model parameters
- **Source entry points** include [`src-tauri/src/main.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/main.rs) for the Rust backend and [`src/main.tsx`](https://github.com/nashsu/llm_wiki/blob/main/src/main.tsx) for the React frontend

## Frequently Asked Questions

### What are the minimum system requirements for running LLM Wiki locally?

You need **Node.js 20 or higher**, **Rust 1.88 or higher**, and the **protoc** (Protocol Buffers) compiler installed on your system. These dependencies support the Tauri v2 desktop framework and the React 19 frontend. The application runs on macOS, Windows, and Linux without requiring Docker or external services beyond optional LLM API credentials.

### Why does the MCP server require a separate build step?

The MCP server is a standalone Node.js application located in the `mcp-server/` directory that provides compatibility with external AI agents. According to [`src-tauri/src/clip_server.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/clip_server.rs), the `npm run mcp:build` command bundles this server into a binary that Tauri loads as a sidecar resource. This architectural separation allows the Rust backend to spawn and communicate with the MCP process via stdio, enabling standardized tool use without bloating the main application binary.

### Where does LLM Wiki store my LLM API keys and settings?

All configuration data—including API keys, model parameters, and provider selections—is stored in a **Tauri Store** located in the `.llm-wiki/` directory within your user data folder. This local-first approach ensures your credentials never leave your machine. The Rust backend manages this storage, and the React frontend retrieves settings via the Tauri API bridge defined in [`src-tauri/src/main.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/main.rs).

### Can I use local LLM models like Ollama instead of cloud providers?

Yes, the application supports **Ollama** as a first-class provider alongside OpenAI and Anthropic. Configure Ollama in the Settings panel by selecting it as your provider and ensuring your local Ollama instance is running. The ingest pipeline in [`src-tauri/src/commands/search.rs`](https://github.com/nashsu/llm_wiki/blob/main/src-tauri/src/commands/search.rs) and related Rust modules communicate with whatever provider you configure, allowing fully offline operation if you use local models and skip web-search integrations.