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

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:

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 and related components:

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:

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, 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:

npm run tauri dev

This command compiles the Rust crate in 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:

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.
• 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.
• 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, while insight detection is implemented in 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 for the Rust backend and 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, 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.

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 and related Rust modules communicate with whatever provider you configure, allowing fully offline operation if you use local models and skip web-search integrations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}