Repository avatar
AI Tools
v0.6.90-beta.693
active

lilbee

io.github.tobocop2/lilbee

Local AI stack: search your files, notes, code and sites with cited answers.

Documentation

lilbee

The whole local AI stack in one executable: it runs and manages the models, and searches everything you own with them.

Project site  ·  Tutorial reels  ·  PyPI  ·  Obsidian plugin  ·  REST API  ·  Chat (#lilbee)

Latest release lilbee on PyPI Python 3.11+ License: MIT    CI Coverage Typed Ruff

Platforms Homebrew tap lilbee on the AUR Nix flake Scoop bucket Docker image on GHCR Flatpak repo Snap package Install from PyPI lilbee on npm

Release downloads Glama MCP server score Listed on mcpservers.org

Obsidian community plugin #lilbee on Libera.Chat

lilbee runs your models and puts them to work as a search engine you can talk to. It searches your files, notes, code and saved web pages, and every answer cites its source, down to the line or page. It also crawls websites into your library, launches your coding agents on local models, and gives any MCP-aware agent cited answers. Ask in plain English.

It is private. Your files, the index and your questions stay on your machine. No telemetry, no account. lilbee contacts a cloud provider only when you set its API key.

Prefer a GUI? The Obsidian plugin puts lilbee's model manager and search inside your vault, with no terminal needed.

ask lilbee "what is lilbee in one sentence?" and get a cited answer drawn from its own README

Tutorial reel: every demo on this page and more, with long-form captions, at lilbee.sh/tutorial.

Beta software. lilbee is in active beta. Every PyPI release is a pre-release, so pip needs --pre and uv needs --prerelease=allow. Commands and on-disk formats can change between betas. Bug reports are very welcome; that's the whole point of the beta. Latest pre-release: lilbee on PyPI.

Why lilbee

A small local model is fun, but limited on its own. Give it properly processed documents and a search engine over them, and it becomes genuinely powerful. Without those, it never gets past novelty.

lilbee is built for consumer hardware and for people who don't want to babysit infrastructure. It isn't another model server you point an app at; it's a local search engine with the model runner built in.

  • Install one file. Talk to your stuff. Most ways to chat with your documents locally mean Docker, a separate model server, a database service and a browser tab. lilbee needs none of them. Point it at a folder, and local AI is useful from the first question.
  • A search engine with proof. On MS MARCO (8.8M passages, 6,980 real queries), lilbee's general-purpose pipeline scores MRR@10 0.365. That is above ColBERT, a system trained only for that test. Few local tools publish a retrieval score for their own pipeline at all. See the benchmark.
  • Native speed underneath. Models run in llama.cpp (C and C++). The index, the document reader, the crawler and the code parser are Rust (LanceDB, Xberg, crawlberg, tree-sitter). Nuitka compiles lilbee itself into one native binary.
  • Runs on what you have. Native executables for macOS, Linux and Windows, with Metal, Vulkan, CUDA and ROCm builds, and a build for CPUs from before 2013. One command on Homebrew, Scoop, AUR, Nix, Flatpak, Snap, npm, PyPI or Docker. Smaller than LM Studio everywhere, and than Ollama on Windows and Linux, and it carries the whole stack.
  • Every GPU does the work. Chat, embedding, vision and rerank are placed together across all your cards, and indexing runs one embedder on each card. A model too big for one card runs across several.
  • Answers you can check. Click a citation to open the source at the line or page. When the answer isn't in your library, lilbee says so. The wiki checks every cited excerpt against the source before a page publishes.
  • Your agents, on local models. lilbee launch starts a model and your coding agent, with lilbee's search connected over MCP. Watch four agents share one model.
  • Private. Your files, the index, the embeddings, your questions and the answers stay on your machine.

The same engine works two ways:

  • An Encarta 99 over your own files. Build a library from your documents and saved web pages, then read it and ask it questions in the terminal.
  • A reference layer for code. Point it at your project, dependencies and API docs. Your coding agent answers from what is actually there, with file:line citations, instead of guessing function names.

The long-term goal: make local AI genuinely useful on hardware you already own, with no token budgets, no provider to depend on, and nothing about your files leaving your machine; the cloud's there only when you want it.

And more

One file. The whole stack.

No model server, no vector database, no container to stand up. One executable holds all of it:

Search enginehybrid search, reranking and cited answers over everything you index
Model runnerbrowse Hugging Face, pull a model, run it on Metal, Vulkan, CUDA or ROCm
Multi-GPU fleetchat, embedding, vision and rerank placed across every card, behind a load-balancing router
Web crawlersave a whole docs site to your library and search it offline
Document reader120+ file types, OCR for scans, code split by function across 300+ languages
Wiki writercited, verified pages about the concepts in your library
Agent serverMCP for coding agents, plus an Anthropic- and OpenAI-style API
HTTP API, TUI, CLIand a Python library, all from the same file

It loads on demand. Close it and it's gone; nothing stays running.

And it is still small. Even lilbee's CUDA build stays under Ollama's, and it's the whole stack, not just a model runner.

macOSWindowsLinuxWhat you get
lilbee (Metal / Vulkan)290 MB304 MB420 MBthe whole stack above
lilbee (CUDA, for NVIDIA)n/a635 MB1.22 GBthe whole stack, with the CUDA runtime
lilbee (ROCm, for AMD)n/an/a817 MBthe whole stack, with the ROCm runtime
Ollama230 MB1.86 GB (CUDA bundled)1.55 GB (CUDA bundled)a model runner, fetches its runtimes separately
LM Studio573 MB626 MB1.03 GBa desktop app (Electron)
vLLMn/an/amulti-GBa Python + CUDA serving engine

Download sizes in decimal MB and GB, models excluded, from each project's own release files. Measured 2026-11-11 from lilbee v0.6.90b692, Ollama v0.40.16 and LM Studio 0.4.28-2. The files are lilbee's macos-arm64, windows-x86_64.exe and linux-x86_64 executables (CUDA: cu125), Ollama's Ollama.dmg, OllamaSetup.exe and ollama-linux-amd64.tar.zst, and LM Studio's arm64 .dmg, x64 .exe and x64 .AppImage.

Install

curl -fsSL https://lilbee.sh/install.sh | sh     # macOS / Linux
irm https://lilbee.sh/install.ps1 | iex          # Windows

Or use your package manager:

Homebrewbrew tap tobocop2/lilbee && brew install lilbee
Scoopscoop install git; scoop bucket add lilbee https://github.com/tobocop2/scoop-lilbee; scoop install lilbee
AURparu -S lilbee
Nixnix run github:tobocop2/lilbee
npmnpm install -g lilbee
Dockerdocker run --rm -v lilbee-data:/home/lilbee/data ghcr.io/tobocop2/lilbee:latest --help
Flatpak, Snap, binarysee the install guide

Then start it:

lilbee self-check    # ~90 MB download; one inference and one embedding; prints "SELF-CHECK PASSED"
lilbee               # the terminal app; pick your models on first run

Pick a model that fits your machine from the catalog, and you're chatting. The usage guide covers the rest: TUI screens, slash commands, CLI, HTTP server, MCP, env vars and config.toml.

The bundled builds use your GPU through Vulkan or Metal. NVIDIA and AMD cards get faster CUDA and ROCm builds. The install guide also covers older CPUs, pip and uv, and hardware requirements.

How lilbee compares

lilbee sits between the desktop runners that get one model chatting (Ollama, LM Studio) and vLLM, the server that pushes one model to many users. It places chat, embedding, vision and reranking together across the GPUs in the machine, and spreads indexing across every card.

The closest project is AnythingLLM, an all-in-one app for chat with your documents. It ships as an Electron desktop app or a Docker server; lilbee is one headless executable. AnythingLLM sends telemetry unless you turn it off; lilbee sends none.

Full comparison: lilbee vs AnythingLLM, LM Studio, Ollama and vLLM
lilbeeAnythingLLMLM StudioOllamavLLM
Primary focuslocal search, chat, and serving across your GPUsall-in-one app for chat with your documents, and agentsdesktop app to run and chat with modelslocal model runner with a growing ecosystemhigh-throughput GPU serving
How it shipsone headless executableElectron desktop app or Docker serverdesktop appapp or archive with its runtimesPython package
Runs local models✓✓ built-in engine (Lemonade, llama.cpp)✓✓✓
Search your own files, with citations✓ full RAG pipeline, inline per-line citations✓ workspace RAG with source citationsper-session doc attachment (RAG, document-level citation)——
Published retrieval benchmark✓ MS MARCO————
Chat, embedding, vision, rerank as one managed fleet✓ all four, coordinatedchat, embedding and a native reranker, set up one by onechat, embed, vision (no rerank), loaded individuallychat, embed, vision (no rerank), several loaded per GPUeach supported, but one model per server
Multi-GPU model placement✓ VRAM-aware tensor-splitnot documented✓ GPU selection + tensor parallelism (CUDA)✓ auto multi-GPU offload✓ tensor + pipeline parallel
Indexing spread across every GPU✓ an embedding and OCR replica per GPU, load-balanced————
Web crawler built in✓ whole sites, concurrent, saved as markdowndepth 1 to 5, 20 pages by default, saved as plain text———
Long-term memory (opt-in)✓ opt-in✓———
InterfacesTUI, CLI, MCP server, REST, Python, Obsidian GUIdesktop GUI, web UI, REST API, chat widget, MCP clientdesktop GUI, lms CLI, Python + TS SDKs, REST API, MCP clientdesktop GUI, CLI, REST API, Python/JS libsAPI server
Use your existing Ollama / LM Studio / cloud as a backend✓ how✓ 30+ providers———

First start

The first launch unpacks the bundle once and loads the model, with progress in the answer bubble. Every launch after that opens to chat in a couple of seconds.

Very first launch

First launch: a one-time unpack bar, chat opens, the first answer shows the engine loading in its bubble, then streams

Every launch after

Every later launch: chat opens in about two seconds and the answer follows
Very first launchEvery launch after
Chat on screen15 to 20s, one-time unpack2 to 3s
First answer10 to 20s while the engine loadsthe same, or instant with Keep engine warm inside the idle window

Measured with a small chat model (Qwen3 0.6B). Answers after the first run at model speed. Bigger models take longer to load, and the bubble shows real progress while the weights load. The usage guide explains the engine lifecycle.

What you can do with it

A library of your own files

Point lilbee at a folder of PDFs, notes, ebooks or code. It builds a library you can search and talk to, with citations that click back to the source line. A shelf of appliance manuals, a field's research papers, your company's wiki: whatever you give it.

https://github.com/user-attachments/assets/73903a5c-9c0a-42a8-9ffd-bdf34f719c29

Ask something with a real answer at stake and you get the answer, not a paraphrase of the question. Here lilbee reads the towing section of a car manual and cites the page, so you can check it. The panel on the right is the GPU doing the work.

https://github.com/user-attachments/assets/284c316c-85f8-46d1-9531-59476f0db9f7

Offline copies of websites

Point lilbee at a docs site, a wiki or an API reference. It fetches the pages, converts them to markdown and adds them to your library. You can search that copy offline, even after the site changes or goes down.

https://github.com/user-attachments/assets/8380c49b-cc65-43ae-83d4-ba9e3aa84af4

Turn on recursive crawling and lilbee follows the links. Watch the page count climb, then ask one question that draws on the whole site.

https://github.com/user-attachments/assets/0c7fbed2-9b40-4976-9856-1720c4f9ffb0

Documents, code, and scanned images

  • Documents (PDFs, Office files, ebooks, HTML, 120+ file types) go through Xberg with heading-aware chunking, so each chunk keeps its section.
  • Code goes through tree-sitter across 300+ languages, so chunks are functions and classes, not arbitrary line ranges.
  • Scans and photos go through OCR in 100+ languages: Tesseract for plain text (set LILBEE_OCR_LANGUAGE, for example eng+deu), or a local or remote vision model that keeps tables and layout as markdown.

Search returns pieces that make sense on their own, not fragments cut through an argument or a function signature.

Tested GPUs and backends

Every backend reports hardware differently, so lilbee checks each one on real silicon: CUDA from an RTX 3090 up to an H200 and eight A100s at once, Vulkan on NVIDIA and Intel, ROCm on an AMD Instinct MI300X, Metal on Apple silicon, and a CPU-only host. Tested GPUs lists every machine and what each run settled. Send captures from hardware the table does not list.

Supported models

lilbee's engine is llama.cpp, so lilbee runs what llama.cpp runs: any GGUF model built on one of the architectures below. The list comes from the bundled engine itself and grows with every engine update.

All 168 supported model architectures. Click to expand.
afmoeapertusarceearctic
arwkv7baichuanbailingmoebailingmoe2
bailingmoe3beambertbitnet
bloomchameleonchatglmclef
clipclover_moecodeshellcogvlm
cohere2cohere2moecommand-rdbrx
decideepseekdeepseek2deepseek2-ocr
deepseek32deepseek4deepseek41dflash
dots1dots3notedreameagle3
ernie4_5ernie4_5-moeeurobertexaone
exaone-moeexaone4falconfalcon-h1
flintgemmagemma-embeddinggemma-embedding2
gemma2gemma3gemma3ngemma4
gemma4-assistantglm-dsaglm4glm4moe
glm5-nextgpt-ossgpt2gptj
gptneoxgranitegranite_swagranitehybrid
granitemoegraniteswitchgrokgrovemoe
hrm_texthunyuan-densehunyuan-moehunyuan_vl
hy_v3hy_v4internlm2jais
jais2jambajina-bert-v2jina-bert-v3
k2-horizonkimi-k3kimi-linearkolibri1
lagunalfm2lfm2moelfm3
limitelladallada-moellama
llama-embedllama4maincodermaion-coder
mambamamba2maplemellum
mimo2minicpmminicpm3minimax-01
minimax-m2minimax-m3mistral-large4mistral3
mistral4modern-bertmptmuse-glimmer
muse-sparknanbeigenemotronnemotron_h
nemotron_h_moeneo-bertnomic-bertnomic-bert-moe
olmoolmo2olmoeopenelm
orionpaddleocrpangu-embeddedphi2
phi3phimoeplamoplamo2
plamo3plmpocketttsqwen
qwen2qwen2moeqwen2vlqwen3
qwen35qwen35moeqwen3moeqwen3next
qwen3ttsqwen3vlqwen3vlmoeqwen4exp
refactrnd1rwkv6rwkv6qwen2
rwkv7seed_osssensenova_u1smallthinker
smollm3spark2_5stablelmstarcoder
starcoder2step35t5t5encoder
talkievllm-decision2wavtokenizer-decxverse

One representative per family also runs the full pipeline end to end on real GPUs; the models, method and results are in tested models. Browse the catalog, search Hugging Face, and pull a model without leaving the terminal.

https://github.com/user-attachments/assets/993a63d4-9468-4a55-b9ed-e4b1ae1ed235

Already running Ollama or LM Studio? Keep them.

Your Ollama and LM Studio models show up in the same pickers as lilbee's own, labeled by where they run. lilbee runs them but never pulls or deletes them, so their lifecycle stays in the app you already use. On a pip or uv install this needs the [providers] extra; the bundled builds include it. These reels run chat and embedding on the other manager's models, picked from the catalog's Library tab. Watch them with captions: Ollama, LM Studio.

https://github.com/user-attachments/assets/52635a74-b69f-42df-b427-3c8f8499323f

https://github.com/user-attachments/assets/13ec8b12-f931-46ac-a500-8a7940d1a2bd

See when a model won't load before you download it

Hugging Face has thousands of GGUFs, and brand-new architectures take time to reach the bundled llama.cpp. lilbee tags the models it can't run and refuses the download unless you confirm an override. You don't wait through a multi-GB pull to hit "unsupported architecture".

https://github.com/user-attachments/assets/b42effc3-a7f6-4391-904c-3ac897712172

Cloud models, when you want them

Add an API key and point any role at a cloud model from the same catalog. The TUI shows a warning while a cloud model is on. Your files and the index stay local; only your question and the snippets that answer it go to the model.

Agents

lilbee serves your coding agents two ways, both local: it runs the models they talk to, and it answers their searches with cited snippets from your library.

Launch your coding agent on local models

One command sets up your agent on lilbee's local models:

lilbee launch opencode    # or: hermes, pi, claude

Each launch warms a model and opens the agent pointed at it. No API keys, no provider setup, and nothing leaves your machine, except a check of any provider API key you have set. Agent models lists the models verified for tool calling, and how the QA harness measures it.

  • opencode and hermes: lilbee registers itself as a provider and an MCP server in the agent's own config, and leaves the rest of your setup intact.
  • Claude Code: lilbee serves an Anthropic-style API and points the session at it through the environment. Claude Code's settings stay untouched.
  • pi: lilbee writes nothing into pi's config. It starts pi with lilbee's pi extension and the lilbee-mcp skill for that session only. Tested with pi 1.5.0; pi needs Node 22.19 or newer.

One model serves as many agents as you want to run. Here, four agents work at once on one local model, each in its own worktree, reading and searching this repository through lilbee.

https://github.com/user-attachments/assets/5f3fd1a4-f946-4008-bfd8-600142785327

Qwen3 Coder Next, 45GB across three RTX 4090s: four agents on one model, 138 tokens a second warm.

https://github.com/user-attachments/assets/510a1691-4289-4d98-b749-7522c1f28559

Gemma 4 26B is a thinking model, and lilbee streams its reasoning as visible text.

https://github.com/user-attachments/assets/06dbf829-1e1e-4a1f-9ca2-32aa65086f13

Qwen3.6 27B on the same four tasks: each agent states what it expects, then reads the code to check itself.

https://github.com/user-attachments/assets/46ce5440-ee9d-4420-a881-031a1ccccec8

And it scales up: Devstral 2 123B, 70GB across two A100 80GB cards, one agent at the model's full 14 tokens a second.

It tunes itself, too. Tell a small local model to widen lilbee's search when a first result comes back thin, and the second pass returns full function bodies with file:line citations. A more capable model does the same from a prompt like "improve your search results." The lilbee-mcp skill teaches your model to retry with a larger top_k on the call, without changing any saved setting.

https://github.com/user-attachments/assets/7bfec600-4c06-4a2f-8f77-be7e92f4f33f

A reference for AI agents

Feed lilbee your project docs, dependency source and API docs. Over MCP, your agent reads the actual code, cites file and line, and says when the answer isn't in your library. This works with cloud agents too: only the query and the returned snippets reach the model.

The lilbee-mcp skill is the single entry point. It teaches the search, cite and long-operation workflow, over MCP or the lilbee --json CLI, and points to drop-in AGENTS.md and worker-subagent starters under examples/agent-integration/. Agents can also tune lilbee's settings on the fly with lilbee_settings_set. The install table has one command each for Claude Code, opencode, pi and Hermes, and the plain MCP form for any other agent.

Run a model bigger than one card

When a model won't fit on one GPU, lilbee spreads it across the ones you have. It sizes each role's memory with gguf-parser, keeps headroom on every card, and tensor-splits the chat model across the fewest GPUs that fit. The embedder, reranker and vision models sit alongside it behind a load-balancing router. It's automatic. Here a 70B runs across three consumer cards and answers a mechanic's question from a car manual, with the page cited.

https://github.com/user-attachments/assets/2a2232e6-d8ce-4302-92e4-6467f4fb1bee

To place it by hand, the placement editor pins each role to the cards you pick and previews the fit before anything loads, and applies it live. If a layout can't fit, it tells you the exact shortfall.

TUI

Run lilbee with no arguments for the terminal app: streaming chat with clickable citations, a model bar with searchable pickers and a Search/Chat toggle, a Task Center for background jobs, and screens for the catalog, settings and wiki.

https://github.com/user-attachments/assets/ab4c5847-2261-421d-91a0-e3838498901c

Ctrl+P opens the command palette, ? or F1 shows the keybindings, and /help lists the slash commands. Every action is in one of those three.

https://github.com/user-attachments/assets/7c4f1096-44a4-40b5-b511-0f6496c520c5

Conversations are kept. Reopen an earlier one and it comes back with its history and citations. Fork after any answer to try another follow-up; the original stays as it was. Export a chat as markdown with its sources. In the chat, use /fork and /export-chat; on the command line, lilbee sessions fork and lilbee sessions export; both also work over HTTP. See Sessions.

https://github.com/user-attachments/assets/3ee7fb50-b983-4761-807c-2f024bbc3756

Tell it something about yourself and it remembers, across conversations.

https://github.com/user-attachments/assets/08a69c31-d74f-4e0a-97b6-340dc195848c

Every setting is editable in the app, and the first run opens the model catalog to get you started.

https://github.com/user-attachments/assets/a578dfd1-61a5-4008-b9bf-e94539003b6e

https://github.com/user-attachments/assets/702975d8-5c1f-4fa7-92a6-bf594ef9d2e3

Every reel on this page, plus the extras that don't fit here, is at lilbee.sh/tutorial with long-form captions. The tape sources are in demos-src/ on the gh-pages branch.

HTTP server and Obsidian

The HTTP server exposes search (with SSE streaming), documents, crawling, models and settings. See the REST API reference and the usage guide.

The Obsidian plugin is a GUI on top of it. It starts the HTTP server in the background, and every citation opens a Source Preview scrolled to the exact spot. It is an official Obsidian community plugin: install it from Settings → Community plugins inside Obsidian. The plugin README has setup.

Keep the HTTP server warm as a service

Only the HTTP server benefits from a daemon; the TUI, CLI and MCP server start on demand. Pull a chat and an embedding model first. Each recipe serves on 127.0.0.1:42697.

PlatformCommand
macOS (Homebrew)brew services start lilbee
Linux (Arch / AUR)systemctl --user enable --now lilbee (on a headless server, also loginctl enable-linger $USER)
NixOSImport lilbee.nixosModules.lilbee, set services.lilbee.enable = true;

Supported formats

Xberg reads the documents and tree-sitter splits the code. lilbee follows Xberg's format list, so support grows as Xberg adds formats.

Format table

lilbee ingests 126 file extensions through Xberg and 306 programming languages through tree-sitter.

FormatExtensionsRequires
PDF.pdfnone; scanned pages need Tesseract or a vision model
Office.doc, .docm, .docx, .dot, .dotm, .dotx, .fodg, .hwp, .hwpx, .key, .numbers, .odp, .ods, .odt, .pages, .pot, .potm, .potx, .pps, .ppsx, .ppt, .pptm, .pptx, .rtf, .wp, .wp5, .wp6, .wpd, .xla, .xlam, .xls, .xlsb, .xlsm, .xlsx, .xlt, .xltm, .xltxnone
eBook.epub, .fb2none
Images (OCR).avcs, .avif, .bmp, .gif, .heic, .heics, .heif, .heifs, .hif, .j2c, .j2k, .jb2, .jbig2, .jp2, .jpc, .jpeg, .jpg, .jpg2, .pbm, .pgm, .png, .pnm, .ppm, .tif, .tiff, .webpTesseract or a vision model
Notebooks.ipynb, .qmd, .rmdnone
Bibliographies.bib, .enw, .nbib, .risnone
Email.eml, .msg, .pstnone
Data.csv, .db, .dbf, .geojson, .gpkg, .gpkx, .json, .jsonl, .kml, .ndjson, .sqlite, .sqlite3, .toml, .tsv, .xml, .yaml, .ymlnone
Text and markup.adoc, .asciidoc, .commonmark, .dbk, .dj, .djot, .docbook, .docbook4, .docbook5, .doctags, .htm, .html, .jats, .latex, .markdown, .md, .mdx, .nxml, .opml, .org, .rst, .tex, .txt, .typ, .typst, .vtt, .xht, .xhtmlnone
Archives.7z, .gz, .tar, .tgz, .zip (each file inside is indexed as its own document, named archive.zip/file.pdf)none
Code.py, .js, .ts, .go, .rs, .java, .c, .cpp, .rb and 306 languages via tree-sitter (AST-aware chunking)none

See the usage guide for OCR setup.

Wiki

lilbee reads your library and writes a wiki about it: one page per concept or entity, not per document. A subject that recurs earns its own page, cited from the source that mentions it most and cross-linked with [[wiki link]]; synthesis pages cover what spans several sources. Every section is checked against the source text before it publishes, and lower-confidence pages wait in a drafts/ queue for review. Open a page that doesn't exist yet and lilbee writes it from your sources, then links it into the rest.

https://github.com/user-attachments/assets/3ba1478e-86b0-4a90-aba1-99384b4f92fb

See the usage guide for commands, and how the wiki is validated for the evidence.

How the wiki compares to STORM, GraphRAG and DeepWiki-Open
Capabilitylilbee wikiSTORMGraphRAGDeepWiki-Open
Builds a wiki from your own private documents (PDFs, notes)✓partial¹✓— (code repos)²
Runs fully local, no cloud account required✓✓✓³✓ (Ollama)
Every generated claim carries a citation with a quoted excerpt✓⁴———⁵
Citations mechanically verified against the source text before publishing✓———
Quality gate (faithfulness score) that quarantines failing pages✓———
Human review queue for gated pages: diff, accept, reject✓———
Detects stale citations when a source document changes✓——⁶—
Archives pages when their sources are deleted✓———
Drift protection: a rewrite above threshold never silently replaces a reviewed page✓———
Wiki pages feed back into search alongside your documents✓—✓—
Never generates without an explicit action (auto-update strictly opt-in)✓n/an/an/a
Multi-perspective research and outline planning before writing—✓—partial⁷
Entity relationship graph with hierarchical topic communitiespartial⁸—✓—
Researches topics on the live web while writing—✓——
Web UI (self-hosted)—✓ (demo)—✓

¹ STORM's retrievers are web search engines; its VectorRM grounds on a custom corpus, but documents must be pre-converted to CSV and indexed into Qdrant. No PDF or note ingestion in the repo. ² A local folder of .md/.txt files works via repo_type=local, but there is no PDF support and the prompts assume a codebase. ³ Any OpenAI-compatible local endpoint works; the config validator requires a placeholder api_key value. ⁴ Claims are cited with quoted excerpts or explicitly marked [*inference*]; lint flags any unmarked claim. ⁵ The page prompt instructs per-claim file:line citations, but nothing verifies them and no excerpt is quoted. ⁶ Incremental indexing exists, but old community reports are kept verbatim; nothing flags a stale page. ⁷ An LLM structure-planning step produces the page outline before writing; no multi-perspective research. ⁸ lilbee's optional [graph] extra builds a concept co-occurrence graph (PMI-weighted) with flat Leiden communities, usable as the wiki synthesis clusterer; no typed entity relations or hierarchical communities.

Built on

lilbee stands on a stack of established open-source projects, all bundled into one install:

lilbee stands on a stack of established open-source projects, all bundled into one install:

  • Xberg parses 120+ file types with heading-aware chunking.
  • llama.cpp is the local model runtime: lilbee bundles its llama-server and starts it for you, so every chat, embedding, vision, and reranker call goes through it. llama-swap keeps a server per role resident together behind one endpoint, and gguf-parser estimates each model's memory footprint so lilbee loads what fits. Without llama.cpp there is no lilbee.
  • Hugging Face Hub (via huggingface_hub) hosts the model catalog and handles every download. Search, browse, and pull all route through it.
  • liter-llm connects to hosted and local model providers: OpenAI, Anthropic, Gemini, Ollama, LM Studio and others.
  • LanceDB is the embedded vector store.
  • tree-sitter (via tree-sitter-language-pack) chunks code across 300+ languages.
  • crawlberg crawls the web, and Playwright installs its headless Chromium; Tesseract is the OCR fallback when no vision model is set.
  • Textual draws the terminal; Litestar runs the HTTP server.
  • MCP Python SDK is the agent surface; Typer is the CLI; Pydantic is the config + validation backbone.
  • Nuitka compiles the whole thing into the standalone single-file binary, bundling its own Python runtime so there is nothing to install and nothing to compile.

Docs

FAQ

Does my data leave my machine? No. Your files stay on disk and search runs locally. A cloud model is used only when you pick one.

Will a model fit my GPU? lilbee reads the GGUF file and your devices and estimates fit before you download, and splits large models across multiple GPUs. More at lilbee.sh/gpu.

Can my coding agent use it? Yes, over MCP. The agent reads your real code and docs before answering, cited to the file and line. More at lilbee.sh/mcp.

Support

lilbee is built and maintained by one person. If it is useful to you, you can chip in via PayPal. Bug reports and pull requests help just as much.

License

MIT. See LICENSE.

NPM
lilbee
Install Command
npm install lilbee
Runtime: npx