The Ultimate Llm Wiki Review (2026): What You Must Know

The Problem of Session Amnesia

You spend four hours wrestling with a complex migration in Claude Code or Cursor. You solve the bug, the code deploys, and you close the terminal. Ten minutes later, that entire logical journey—the "why" behind the architectural choices and the discarded failed attempts—is buried in a massive .jsonl file you will never open again. This is digital amnesia, and it is the biggest tax on the modern AI-assisted developer workflow.

I tested llm wiki to see if it could actually fix this. The promise is simple: take those dormant transcripts and turn them into a structured, searchable, and interlinked knowledge base. It is an implementation of Andrej Karpathy's LLM Wiki pattern, and after running my own messy session history through it, I have some strong opinions on whether it belongs in your stack.

What is llm wiki?

llm wiki is an open-source AI knowledge management tool that transforms local chat logs from Claude Code, Cursor, and Gemini into a searchable, interlinked wiki — providing a permanent, machine-readable memory of your technical decisions, code evolution, and architectural choices that usually vanish after a terminal session ends.

Built by developer Pratiyush, this tool targets the "dark data" sitting in your ~/.claude/sessions or Copilot history. Unlike a standard note-taking app, it does not expect you to manually write entries. It extracts entities, concepts, and syntheses from your actual work sessions. It is a bridge between your past actions and your future context needs.

llm wiki review: My Hands-On Experience

Turning Raw Logs into Logic

The first thing you notice when running llm wiki is that it does not just dump text into a folder. It categorizes your history. I fed it three months of chaotic Cursor and Claude Code sessions, and it parsed them into distinct buckets: sources, entities, concepts, and syntheses. The Karpathy-style wiki structure is visible immediately. Instead of a chronological list of chats, you get a web of [[wikilinks]]. If you discussed "JWT implementation" in five different sessions over two weeks, those sessions are now linked under a single concept page. This is where the tool moves from being a log viewer to a genuine knowledge base.

The "Karpathy Pattern" in Practice

The interface is surprisingly fast for a local tool. The Cmd+K command palette uses fuzzy matching over a pre-built index, making it feel more like Obsidian than a static site generator. During my testing, the "Activity Heatmap" on the home page was a standout feature. It provides a visual pulse of your development velocity across different projects. You can see exactly when you were most active and which models (Claude, Gemini, or Codex) you were leaning on during those sprints. The model info cards also add a layer of metadata I didn't know I needed, showing pricing and benchmarks for the specific versions of the LLMs used in each session.

AI-Consumable Exports: The Real Value

While the human-readable HTML site is nice, the machine-readable siblings are the actual "killer feature." Every page llm wiki generates also creates a .txt and .json version. It even builds an llms.txt file following the llmstxt.org spec. When I started a new project, I was able to point a fresh Claude session to my existing llm wiki export. The AI could "read" my previous project's logic without me having to copy-paste old code snippets. This creates a recursive loop where your past work directly informs your future prompts.

Where the Polish Ends

It is not all smooth sailing. The tool is opinionated and strictly follows a 5-state lifecycle machine (draft, reviewed, verified, stale, archived). If you don't care about "stale" content or 90-day auto-archiving, the governance features might feel like overkill. Also, the "Auto Dream" feature and the 11 lint rules (which check for things like link integrity and LLM-powered contradictions) require a bit of configuration to get right. If your session data is particularly messy or lacks clear structure, the automated synthesis can sometimes produce generic summaries that don't capture the nuance of a specific bug fix.

Getting Started with llm wiki

Setting up llm wiki requires a basic comfort level with the Python CLI. You won't find a "Download .exe" button here, but the process is straightforward for anyone already using tools like Claude Code.

• Step 1: Clone the repository from GitHub and install the dependencies using pip install -r requirements.txt.
• Step 2: Point the tool to your session directories. It supports Claude Code, Codex CLI, Copilot, Cursor, and Gemini.
• Step 3: Run the build command. This will parse your .jsonl files and generate the dist/ folder containing your static site.
• Step 4: (Optional) Deploy the dist/ folder to GitHub Pages or browse it locally using a simple Python server (python -m http.server).

Common beginner mistake: forgetting to gitignore your raw/ directory. llm wiki is built to keep your data local, but if you accidentally commit your raw session transcripts to a public repo, you're in for a bad time. Stick to the generated llms.txt for sharing context.

Pricing Breakdown

Pricing is not publicly listed on a traditional SaaS page because llm wiki is currently an open-source project. You can find the codebase and licensing details at https://github.com/Pratiyush/llm-wiki.

• Open Source Tier: Free. You get the full Python source code under the MIT License. You run it on your own hardware, so your only costs are the API tokens used if you trigger the LLM-powered linting or synthesis features.
• Self-Hosted: No subscription fees. Since it generates a static site, you can host it for free on platforms like Vercel, Netlify, or GitHub Pages.
• Enterprise/Cloud: Not currently offered. This is a tool for developers who want to own their data and their workflow.

If you are looking for a managed service where someone else handles the parsing and hosting, this isn't it. You are paying in setup time rather than monthly recurring revenue.

Strengths vs. Limitations

The llm wiki excels at privacy and structural depth but requires a "hacker" mindset to maintain effectively. Here is how the trade-offs stack up:

Competitive Analysis

The market for "AI memory" is split between manual note-taking apps and automated repository indexers. llm wiki occupies a unique middle ground by focusing specifically on the transcript-to-knowledge pipeline rather than just indexing code or hosting static notes.

Pick llm wiki if: You use Claude Code or Cursor heavily and want a local, machine-readable archive of your logic.
Pick Obsidian if: You prefer manual curation and a visual graph over automated session parsing.
Pick Greptile if: You need an enterprise-grade, cloud-hosted AI that understands your entire codebase without managing local logs.

FAQ

Does llm wiki support local LLMs for synthesis?
Yes, you can configure the tool to use Ollama or local OpenAI-compatible endpoints to avoid external API costs.

Can I import my existing ChatGPT history?
Currently, you must convert ChatGPT exports to the supported .jsonl format, as the tool prioritizes developer-centric tools like Cursor and Claude Code.

Is the generated wiki mobile-friendly?
The output is a standard static HTML site, making it fully responsive and easy to browse on any mobile browser if hosted.

Verdict: 4.2/5 Stars

llm wiki is a specialized, high-utility tool for developers who are tired of losing their "train of thought" between AI sessions. It successfully implements the Karpathy pattern, turning messy logs into a structured asset.

• Who should use it: Power users of Claude Code and Cursor who want to build a long-term "second brain" for their technical decisions.
• Who should pick a competitor: Non-technical users or those who want a "set it and forget it" cloud solution should look at Greptile or Mem.
• Who should wait: Developers who strictly require a GUI or those who find the 5-state lifecycle governance too restrictive for their workflow.