tobocop2/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)

  

lilbee runs and manages your models: chat, embedding, vision, and rerank, placed across every GPU you have. It puts them to work as a search engine you can talk to, over your files, notes, code, and the web, where every answer cites the exact file and line. It crawls websites into your library, launches your coding agents on local models, and hands any MCP-aware agent cited answers from everything you've indexed. The same engine backs the Obsidian community plugin, so your vault gets all of it without a terminal. Ask in plain English. No containers, no networking, nothing else to install or set up.

It's all one program: no separate model server, vector database, or container to stand up. lilbee runs the models and keeps the index itself. Reach it as a terminal app, CLI, Model Context Protocol server, HTTP API, or Python library. Close it and it's gone, or run it as a service to keep it warm. Everything runs on your computer; it uses a cloud model only when you pick one.

Models are no different: lilbee has its own model manager and multi-GPU fleet, built on llama.cpp, so one executable does everything (browse Hugging Face, download a model, give it a role, run it on Metal / Vulkan / CUDA). You don't need Ollama or LM Studio at all: the model families lilbee runs are the architectures behind most of the 190,000+ GGUF repos on Hugging Face, verified per family on real GPUs. If you already use them, point lilbee at your existing setup and keep your models.

Tutorial reel: every demo on this page (and the extras) as a real video player at lilbee.sh/tutorial.

⚠️ Beta software

lilbee is in active beta development. Every release on PyPI is a pre-release; you must use --pre (or uv's --prerelease=allow) when installing. Interfaces, command names, and on-disk formats may shift between betas. Feedback, bug reports, and issues are very welcome; that's the whole point of the beta.

Latest pre-release (always): lilbee on PyPI →

---

• Quick start
• Tutorial reel (long-form videos)
• Highlights
• Why lilbee
• What you can do with it
• TUI
• Hardware requirements
• Install
• First start
• Agent integration
• HTTP Server · REST API reference
• Supported formats
• Experimental
• Built on

---

Quick start

Two recommended ways to use lilbee, depending on whether you're the one driving:

• Run lilbee for the full-screen terminal app. A welcome wizard picks a chat and embedding model, then you index files, search, and chat without leaving the TUI. The Settings screen exposes every retrieval knob (search depth, distance threshold, reranker, chunking) so you can tune lilbee to your library shape.
• Connect it to your agent over MCP. Any MCP-aware coding agent calls lilbee_search / lilbee_add and gets back cited snippets it can quote. Agents can also fine-tune lilbee on the fly via lilbee_settings_set. Drop in the lilbee-mcp skill and the agent reads the full surface: every tool, every retrieval knob, and when to widen for prose vs narrow for code. See Agent integration.

Retrieval defaults are sane, and every setting is tunable from the TUI, /set, MCP, env vars, or config.toml. The CLI and HTTP API cover scripting and headless runs. See the usage guide.

Highlights

• Answers cite the source line. Click a citation, jump to the file at the exact line; when the answer isn't in your library, lilbee says so instead of inventing one.
• It works, and the demos prove it. Every GIF and reel here is recorded live on real hardware, nothing staged, backed by 100% test coverage, full typing, and CI on macOS, Linux, and Windows.
• One command to running. Install, run lilbee, and a first-run wizard pulls a model and drops you into chat.
• Reads almost anything: 90+ formats and 150+ languages across documents, scanned pages, spreadsheets, ebooks, web pages, and source code.
• Chunks that stand on their own. Prose and code are split differently so each piece keeps its meaning, which is where most of the retrieval quality lives.
• A real search engine on top, ranking every result by how well it answers you, with 50+ tunable knobs and sane defaults.
• It brings and runs the models itself, on Metal, Vulkan, or CUDA, with no server to point at and no cloud account. Browse Hugging Face, pull a model, give it a role (chat, embedding, vision, rerank).
• A model too big for one card runs across all of them, sized with gguf-parser and tensor-split automatically, or pinned by hand. Run a model bigger than one card.
• Already on Ollama or LM Studio? Keep them. lilbee's own manager handles everything across the same model families they run, and their models also show up in the same pickers.
• One install, many surfaces: TUI, CLI, MCP server, REST API, and Python library, so your coding agent answers from your real files, with citations.
• Everything in one file, nothing to operate. The binary bundles the whole stack (search engine, crawler, MCP + HTTP servers, TUI, Python, llama.cpp) in ~290-420 MB, or ~0.6-1.2 GB with CUDA; it loads on demand and nothing stays running.
• Per-project libraries. One library for everything, or one per project.

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 does all of it in one install: it runs the models, processes your documents, crawls the web pages you point it at, and searches the lot with a real engine. 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 questions of it in the terminal.
• A reference layer for code. Point it at your project, dependencies, and API docs, and your coding agent answers from what's 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 and no provider to depend on; the cloud's there only when you want it.

How lilbee compares

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. One install gives you the whole stack in a single executable:

• A search engine over your files, with answers that cite the source line, not just a model to chat with.
• A managed fleet, chat, embedding, vision, and reranking, spread across every GPU in the machine behind a load-balancing router, not one model loaded at a time.
• Everything bundled: model manager, search engine, web crawler, MCP server for coding agents (native opencode and hermes), HTTP server, TUI, and Python, in one file.

It sits between two worlds: the desktop runners that get a model chatting on your machine (Ollama, LM Studio), and vLLM, the server you stand up to push one model to a cluster of users. lilbee runs models to do retrieval over your files, and scales that whole stack across every GPU in the machine, from one small file.

Full comparison table: lilbee vs Ollama, LM Studio, and vLLM. Click to expand.

Full comparison table

	lilbee	LM Studio	Ollama	vLLM
Primary focus	local search, chat, and serving across your GPUs	desktop app to run and chat with models	local model runner with a growing ecosystem	high-throughput GPU serving
Runs local models	✓	✓	✓	✓
Search your own files, with citations	✓ full RAG pipeline, inline per-line citations	per-session doc attachment (RAG, document-level citation)	—	—
Chat, embedding, vision, rerank as one managed fleet	✓ all four, coordinated	chat, embed, vision (no rerank), loaded individually	chat, embed, vision (no rerank), loaded individually	each supported, but one model per server
Multi-GPU model placement	✓ VRAM-aware tensor-split	✓ GPU selection + tensor parallelism (CUDA)	✓ auto multi-GPU offload	✓ tensor + pipeline parallel
Scales the whole stack, not just one model	✓ per-GPU replicas + load-balancing router	—	—	one model per server
Built for many-user throughput at scale	✓ a data-parallel replica per GPU, requests load-balanced	—	limited	✓ this is its job
Web crawler built in	✓ built in	—	—	—
Long-term memory (opt-in)	✓ opt-in	—	—	—
Interfaces	TUI, CLI, MCP, REST, Python, Obsidian GUI	desktop GUI, lms CLI, Python + TS SDKs, REST API, MCP client	desktop GUI, CLI, REST API, Python/JS libs	API server
Use your existing Ollama / LM Studio / cloud as a backend	✓ how	—	—	—

Of the four, lilbee is the only one built around retrieval, and the only one that scales the whole stack, chat, embedding, vision, and reranking, across every GPU in the machine behind a load-balancing router.

Install size by platform: one file that undercuts the others while doing more. Click to expand.

Install size (single-file download, models excluded)

Download sizes in decimal GB/MB (bytes ÷ 1000), measured from each project's own release artifacts, linked. lilbee and Ollama measured 2026-07-25 from their release APIs (lilbee v0.6.90b420.dev726, Ollama v0.32.4).

	macOS	Windows	Linux	What you get
lilbee (Metal / Vulkan, default)	317 MB	333 MB	478 MB	the whole stack: search engine, crawler, servers, TUI, model runner, fleet manager
lilbee (CUDA, opt-in for NVIDIA)	n/a	666 MB	1.25 GB	the same whole stack, with the faster CUDA runtime
lilbee (ROCm, opt-in for AMD)	n/a	n/a	854 MB*	the same whole stack, with the faster ROCm runtime
Ollama	181 MB	1.56 GB (CUDA bundled)	1.42 GB (CUDA bundled)	a model runner, fetches its runtimes separately
LM Studio	569 MB	617 MB	1.10 GB	a desktop app (Electron)
vLLM	n/a	n/a	multi-GB	a Python + CUDA serving engine

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

* ROCm is the one figure not yet from a release: it is the binary CI builds today, measured, and lands here unchanged at the first release that carries it.

Already on Ollama or LM Studio? lilbee runs on top of them. Prefer a GUI to the terminal? The Obsidian plugin maps lilbee's model manager and search to a visual interface inside your vault.

What you can do with it

A library of your own files

Point lilbee at a folder of PDFs, notes, ebooks, or code and it builds a searchable library, with citations that click back to the source line. The pattern works for anything you have a lot of text about: a shelf of appliance manuals, a field's research papers, a car's service manuals, your company's internal wiki. Whatever you give it becomes searchable, and you can talk to it.

Ask it something with a real answer at stake and you get the answer, not a paraphrase of the question. Here the trailer is too heavy for the car: lilbee says so, gives the weight it is rated for, and cites the page it read that on. The panel on the right is the GPU doing it, on this machine.

Launch your coding agent on local models

lilbee launch opencode and lilbee launch hermes set up lilbee's local models in your agent in one command. lilbee registers itself as a provider and an MCP server in the agent's own config, leaves your existing setup intact, warms a model, and opens the agent pointed at it. No API keys, no provider setup, and nothing leaves your machine. Tool-calling works across many GGUF families; docs/agent-models.md has the verified list and how the QA harness measures it.

These reels show each agent, launched on a local model, doing real work on lilbee's own source. opencode adds a lilbee launch status subcommand, runs it, and writes a test that passes; hermes does the same with lilbee launch list.

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 own model the pattern.

A reference for AI agents

Once configured, lilbee plugs into whatever agent you use, over MCP. Feed it your project's docs, your dependency source, your API docs, your design notes; the agent stops making up function names and instead reads the actual code, cites file and line, and says it doesn't know when the answer isn't in your library.

Your files, the search index, and the embeddings stay on your computer. The agent calls lilbee_search and gets back cited snippets. The demo below is lilbee talking to lilbee: an agent indexes lilbee's own source, then answers questions about how lilbee works with file:line citations.

Offline copies of websites

Install the [crawler] extra, point lilbee at a docs site, a wiki, or a vendor's API reference, and the pages get fetched, converted to markdown, and added to your library. From then on you can search or chat with that copy of the site offline, even after it changes or goes down.

Or crawl a whole site, not just one page. With recursive crawling on, lilbee follows the links and indexes the lot; watch the page count climb in the Task Center, then ask one question that synthesizes across the whole site.

Documents, code, and scanned images

lilbee splits indexing by what's being read:

• Prose and structured documents (PDFs, Office files, ebooks, HTML, 90+ formats) go through Kreuzberg with heading-aware chunking, so each chunk keeps its section context.
• Code goes through tree-sitter's AST-aware splitter across 150+ languages, so chunks map to functions, classes, and modules instead of arbitrary line ranges.
• Scanned PDFs and photos go through OCR: Tesseract for plain text, or a local / remote vision model that keeps tables and layout as markdown.

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

Pick and tune your models

Chat, embedding, vision, and reranking models are installed and switched from inside the terminal: browse the catalog, pull a model, pick a role. Retrieval and generation expose 50+ settings (chunk size, search strictness, reranker depth, and more), editable from the TUI, env vars, or a project-local config file. Sane defaults.

Tested GPUs and backends

Placement reads what the engine reports about your hardware, and every backend words that differently, so each is checked on real silicon rather than inferred from the last one. CUDA from an RTX 3090 up to H200, and up to eight A100s at once, Vulkan on NVIDIA and Intel, ROCm on an AMD Instinct MI300X, Metal on Apple Silicon, and a CPU-only host. docs/tested-gpus.md lists every machine and what each run settled. Captures from hardware not listed are welcome.

Tested model families

One representative per architecture family, pulled with lilbee model pull and run through the full pipeline (index, search, answer; OCR for vision) on consumer hardware. docs/tested-models.md has the details and method. Between them, these families are the architectures behind most of the 190,000+ GGUF model repos on Hugging Face: if a model's family is listed, its variants and quants are expected to work.

The family tables, per role. Click to expand.

Vision (all on a single 12 GB card, projector fetched by the pull itself):

Family	Projector type
LightOnOCR	lightonocr
Qwen2.5-VL	qwen2.5vl merger
Qwen3-VL	qwen3vl
Gemma 3	gemma3
SmolVLM2	idefics3
MiniCPM-V	resampler
InternVL3	internvl
LLaVA 1.6	mlp
Gemma 4	mixed vision+audio
dots.ocr	dots.ocr

Chat (one per memory-architecture class):

Class	Representative
Dense GQA	Llama 3.2
Dense	Qwen3
Sliding-window attention	Gemma 3
Multi-head latent attention	DeepSeek V2 Lite
Mixture of experts	OLMoE
Hybrid SSM	LFM2

Embedding:

Class	Representative
BERT encoder	all-MiniLM-L6-v2
nomic-bert	nomic-embed-text v1.5
Decoder-pooled	Qwen3-Embedding 0.6B
Decoder-pooled, large	Qwen3-Embedding 8B
XLM-RoBERTa	bge-m3

Rerank:

Class	Representative
Cross-encoder	bge-reranker-v2-m3
LLM reranker	Qwen3-Reranker 0.6B

Already running Ollama or LM Studio? Keep them.

Watch it: Ollama as the model manager and LM Studio as the model manager. Point lilbee at a running manager, index a PDF on camera, and get a cited answer back.

lilbee works with Ollama and LM Studio. Finding and running models for you is the default and simplest path (lilbee pulls them and runs them on Metal / Vulkan / CUDA, no server to stand up), but you don't have to adopt a new model manager to use lilbee.

• Point it at a running manager. Your models in Ollama or LM Studio show up in the same catalog and role pickers (chat, embedding, vision, rerank), labeled by where they run, alongside lilbee's own and any cloud models. Mix freely.
• They stay read-only. lilbee lists and runs them but never pulls or deletes them, so their lifecycle stays in the app you already use.
• On pip / uv, this needs the [litellm] extra (pip install --pre 'lilbee[litellm]'); the Homebrew, AUR, Nix, Docker, Flatpak, and Snap builds already include it. See Install.

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

Hugging Face has thousands of GGUFs, but the bundled llama.cpp only supports a subset of architectures and brand-new ones take time to reach the pinned runtime. lilbee tags incompatible models in the catalog and refuses the download (with an override confirm), so you don't wait through a multi-GB pull only to hit "unsupported architecture" at load.

Cloud models, when you want them

lilbee runs entirely on your machine by default. Two ways to use a cloud model when you want one:

• Bring your own key. Install the [litellm] extra, add an API key, then point any role (chat, embedding, vision, rerank) at a cloud model from the same catalog. The TUI shows a warning the whole time a cloud model is on.
• Pair lilbee with a cloud agent over MCP. Your files, the embeddings, and the index stay local. Any MCP-aware agent calls lilbee_search / lilbee_add and gets back cited snippets.

Either way, your files and the index stay on your computer. Only what you ask and the snippets needed to answer it get sent to the cloud model.

Run a model bigger than one card

When a chat model won't fit on a single 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, with the embedder, reranker, and vision models placed alongside it behind a load-balancing router. This is automatic: ask a question and the model loads split across your cards, answering from your own indexed source.

You can also place it by hand. The placement editor pins each role to the cards you choose, previews the fit before anything loads, and applies it live. Ask for a layout that can't fit and it tells you the exact shortfall instead of failing at load time.

TUI

lilbee (no args) launches a full Textual 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 model catalog, settings, the setup wizard, and the auto-built wiki. Type / for the command list; tab completion works everywhere.

Ctrl+P opens the Textual command palette, ? on an empty prompt (or F1 anywhere) toggles the keybinding cheat sheet, /help opens the slash-command catalog. Every action lilbee can take is reachable from one of those three.

Every GIF on this page (plus the extras that don't fit here) is at lilbee.sh/tutorial as an embedded video with long-form captions. Tape sources are in demos/. For commands and settings, see the usage guide.

Hardware requirements

Standalone mode runs entirely on your machine. No cloud required. Minimum: Apple Silicon Mac, or a 64-bit Intel/AMD CPU from 2013+ (older CPUs: On older CPUs), or an ARMv8 Linux box; 8 GB RAM, 2 GB disk.

Full platform and resource breakdown

Platform	Minimum	Recommended
macOS arm64	Apple Silicon (M1 or newer), macOS 11+	M-series Pro / Max / Ultra
Linux x86_64	64-bit Intel/AMD from 2013+ (x86-64-v3)	Modern Intel/AMD CPU + an NVIDIA, AMD, or Intel Arc GPU
Windows x86_64	64-bit Intel/AMD from 2013+ (x86-64-v3), Windows 10/11	Modern desktop / workstation CPU + GPU
Linux ARM64	ARMv8 NEON-capable (Raspberry Pi 4+, AWS Graviton, Ampere Altra)	Modern ARM server with 16+ GB RAM

Resource	Minimum	Recommended
RAM	8 GB	16 to 32 GB to keep several local models warm at once (chat + embed + rerank + vision); actual footprint scales with the sizes and quantizations you pick
GPU / Accelerator	none required (CPU-only works)	Apple Silicon (Metal) · NVIDIA / AMD / Intel Arc (Vulkan) · faster vendor builds with the runtime bundled: CUDA on NVIDIA, ROCm on AMD (see Install)
Disk	2 GB	10+ GB for multiple models

Install

Two routes, and the difference matters:

• Into your own Python with pip or uv (Python 3.11 to 3.14). Uses the Python and tooling you already have, picks the fastest CPU code path for your machine at runtime, and upgrades like any other package. Recommended if you have Python.
• A self-contained bundle: the standalone binary, or the Homebrew / AUR / Nix / Docker / Flatpak / Snap builds that wrap it. Nothing else to install. The trade-off is a single large download (it bundles its own Python runtime, llama.cpp, and the optional extras) and a small cold-start cost the first time it self-extracts. Recommended if you'd rather not deal with Python.

Have a discrete GPU? The default Vulkan build already uses it. There are faster vendor builds too: NVIDIA (CUDA) and AMD (ROCm).

No external services either way; lilbee downloads and runs models locally. Optional, for scanned-PDF / image OCR: Tesseract (brew install tesseract / apt install tesseract-ocr) or a GGUF vision model.

How	Command	Notes
pip	pip install --pre 'lilbee[engine]' --extra-index-url https://lilbee.sh/cpu/	Recommended. The default wheel runs on any x86_64 CPU with AVX2 (2013+; older CPUs: On older CPUs) and uses your GPU via Vulkan / Metal automatically. The engine extra is the bundled llama-server, published on lilbee.sh rather than PyPI, which is why the index is needed. Faster vendor builds: CUDA, ROCm.
uv	uv tool install --prerelease=allow lilbee	Same wheel as pip; fetches a Python for you if you need one.
Homebrew	brew tap tobocop2/lilbee && brew install lilbee	macOS arm64 / Linux x86_64. Bundled build; clears the macOS quarantine flag for you.
AUR	paru -S lilbee	Arch Linux. Wraps the Linux x86_64 binary; works with yay / pacaur / any helper.
Docker	docker run --rm -v lilbee-data:/home/lilbee/data ghcr.io/tobocop2/lilbee:latest --help	GHCR image, tagged by version and latest. Data lives at /home/lilbee/data. Mount a volume there. :cuda and :rocm tags carry the vendor builds.
Nix	nix run github:tobocop2/lilbee	NixOS, nix-darwin, or any host with nix. On Linux the flake bundles glibc, libgomp, and vulkan-loader so it runs on bare NixOS.
Flatpak	flatpak remote-add --if-not-exists lilbee https://tobocop2.github.io/flatpak-lilbee/lilbee.flatpakrepo && flatpak install lilbee io.github.tobocop2.lilbee	Linux x86_64, any distro with flatpak. Needs the Flathub remote for the runtime. Run with flatpak run io.github.tobocop2.lilbee (worth an alias); flatpak update picks up new releases. Data lives under ~/.var/app/io.github.tobocop2.lilbee/.
Snap	curl -LO https://github.com/tobocop2/lilbee/releases/latest/download/lilbee-linux-x86_64.snap && sudo snap install ./lilbee-linux-x86_64.snap --dangerous --classic	Linux x86_64. Sideloaded, so snapd flags it --dangerous (it just means unsigned) and it won't auto-update; rerun the same command to upgrade.
Scoop	scoop bucket add lilbee https://github.com/tobocop2/lilbee && scoop install lilbee	Windows x86_64. Installs the CUDA build on machines with a recent NVIDIA driver, otherwise the CPU build. scoop update lilbee upgrades.
Standalone binary	download for your platform →	One file, own Python runtime, no pip needed. Linux needs glibc 2.28+; the macOS / Windows builds are unsigned (xattr -d com.apple.quarantine ./lilbee-macos-arm64 if Gatekeeper blocks it).
From source	git clone https://github.com/tobocop2/lilbee && cd lilbee && uv sync && uv run lilbee	For hacking on it. Needs git and uv.

On NVIDIA hardware

The default Vulkan build works on NVIDIA cards, but there's a dedicated CUDA build that's faster on NVIDIA hardware and sidesteps the iGPU + dGPU Vulkan-loader crash on Windows.

CUDA install commands

	Command
pip	pip install --pre 'lilbee[engine]' --extra-index-url https://lilbee.sh/cu125/
uv	uv tool install --prerelease=allow lilbee --extra-index-url https://lilbee.sh/cu125/
Homebrew	brew install tobocop2/lilbee/lilbee-cuda
AUR	paru -S lilbee-cuda
Nix	nix run github:tobocop2/lilbee#lilbee-cuda
Scoop	scoop install lilbee (auto-picks the CUDA build when an NVIDIA driver is present)
Binary	lilbee-linux-x86_64-cu125 or lilbee-windows-x86_64-cu125.exe

Same lilbee command after install. The CUDA runtime is bundled; you only need the NVIDIA driver. Already have the regular lilbee installed? On AUR paru -S lilbee-cuda swaps it automatically; on Homebrew run brew uninstall lilbee first. Older driver? cu124 and cu121 ship via the matching wheel indexes and as direct-download Linux binaries on the release page.

On AMD hardware

The default Vulkan build works on AMD cards, and stays the fallback if ROCm isn't set up. There's also a dedicated ROCm build that's faster. It bundles the ROCm userspace, so you need only the amdgpu kernel driver.

ROCm install commands

	Command
pip	pip install --pre lilbee --extra-index-url https://lilbee.sh/rocm/
uv	uv tool install --prerelease=allow lilbee --extra-index-url https://lilbee.sh/rocm/
Homebrew	brew install tobocop2/lilbee/lilbee-rocm
AUR	paru -S lilbee-rocm
Nix	nix run github:tobocop2/lilbee#lilbee-rocm
Flatpak	flatpak install lilbee io.github.tobocop2.lilbee.rocm
Binary	lilbee-linux-x86_64-rocm

Same lilbee command after install. Linux only. Cards: MI100, MI200, MI300, MI350, RDNA2, RDNA3, RDNA3.5 APUs and RDNA4. ROCm 7 ships no GEMM kernels for the MI50, so it needs the Vulkan build. Largest of the three builds, since the ROCm userspace and per-card kernels ship inside it.

Then check it runs and pick a model:

lilbee self-check    # ~90 MB download; runs an inference + an embedding; "SELF-CHECK PASSED" on success
lilbee               # launch the terminal app; pick a chat + embedding model on the welcome screen

The usage guide covers the rest: TUI screens, slash commands, CLI, HTTP server, MCP, env vars, and config.toml.

On older CPUs (pre-AVX2)

Pre-2013 Intel or pre-Zen AMD CPUs lack AVX2, so the normal build crashes on launch. The lilbee-compat build runs on any x86-64 chip back to ~2008.

Install commands for every channel, and why it's needed

	Command
pip	pip install --pre lilbee 'lancedb==0.34.0+compat' --extra-index-url https://lilbee.sh/compat/
Homebrew	brew install tobocop2/lilbee/lilbee-compat
AUR	paru -S lilbee-compat
Nix	nix run github:tobocop2/lilbee#lilbee-compat
Scoop	scoop install lilbee-compat
Flatpak	flatpak install lilbee io.github.tobocop2.lilbee.compat
Snap	curl -LO https://github.com/tobocop2/lilbee/releases/latest/download/lilbee-compat-linux-x86_64.snap && sudo snap install ./lilbee-compat-linux-x86_64.snap --dangerous --classic
Binary	lilbee-compat-linux-x86_64 or lilbee-compat-windows-x86_64.exe

Same lilbee command after install. The crash is from lancedb's AVX2-compiled wheels; this build swaps in a lancedb fork that picks instructions at runtime. A 👍 or comment on the upstream lance PR helps it land.

Linux runtime requirements

The Linux x86_64 wheel and binary link the Vulkan loader at runtime. Most desktop distros (Ubuntu 22.04+, Pop!_OS, Mint) ship libvulkan1; bare Arch / Fedora / Alpine images don't, and lilbee self-check fails with cannot open shared object file: libvulkan.so.1. Install it once: sudo pacman -S vulkan-icd-loader (Arch / Manjaro), sudo dnf install vulkan-loader (Fedora, RHEL), or sudo apt-get install libvulkan1 (Debian, Ubuntu).

Optional extras

These only matter for a pip or uv install: add the name in brackets, e.g. pip install --pre 'lilbee[crawler,litellm]' (combine multiple, and --extra-index-url still works for CUDA). The standalone binary and the Homebrew / AUR / Nix / Docker / Flatpak / Snap builds already include all three. lilbee works without them either way.

Extra	What it adds
[crawler]	Index websites alongside your files: crawl a docs site or wiki to markdown, then search it offline.
[litellm]	Bridge to hosted model providers for chat, vision, or embeddings while other roles stay local. The TUI flags when a hosted role is active.
[graph]	Concept-graph search: extracts the ideas in your documents and uses how they relate to surface matches plain keyword search misses. No extra model calls.

See the full guide on optional extras for configuration.

First start

The very first launch does one-time work: the executable unpacks itself behind a progress bar, and the model loads before your first answer, shown live inside the answer bubble. Every launch after that opens straight to chat in a couple of seconds.

Very first launch	Every launch after

Measured with a small chat model (Qwen3 0.6B):

	Very first launch	Every launch after
Chat on screen	15 to 20s, one-time unpack	2 to 3s
First answer of the session	10 to 20s, the engine load plays in the bubble	the same, or instant with Keep engine warm
Answers after that	model speed	model speed

Bigger models load longer; the bubble shows real progress while weights are read. How the engine lifecycle works, and how to keep it warm so relaunches skip the load entirely, lives in the usage guide.

Agent integration

Drop the lilbee-mcp skill into .opencode/skills/ or .claude/skills/, register lilbee as an MCP server, and any MCP-aware coding agent can search your library, swap models, and tune retrieval. The skill is the single entry point: it documents every tool, the workflows the agent should follow, and points to drop-in AGENTS.md and worker-subagent starters under examples/agent-integration/.

The demos below use opencode with a cloud model. lilbee stays local; only the queries and the returned chunks go to the cloud model. To run the agent itself on a local model instead, see Launch your coding agent on local models above.

Live-indexing example: opencode (cloud model) indexes a Godot 4 pathfinding subset (~3s), then lilbee_search-es for AStarGrid2D and answers method-by-method against your local files.

It scales up. Pre-index Godot 4's full class reference (810 XMLs, 3449 chunks) and the same opencode + cloud setup writes a procedural level generator, every API call backed by a godot-classes/<Class>.xml:line citation; the side-by-side benchmark measured 4 hallucinated APIs without lilbee, 0 with.

HTTP Server

The HTTP server exposes a REST API any tool or GUI can hit: search (with SSE streaming), document lifecycle, crawling, model management, configuration. See the REST API reference and the usage guide for setup.

The Obsidian plugin is a GUI built on 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 then Community plugins inside Obsidian. The plugin README has setup.

Running as a service (optional)

For tools that talk to lilbee's HTTP REST API (the Obsidian plugin, custom GUIs, anything hitting /api/*), your OS launcher can keep the HTTP server warm so requests skip the cold-start.

Daemon setup per platform

This is the only lilbee surface that benefits from a daemon. The TUI, lilbee chat, the MCP server, and the rest of the CLI load on demand and exit when you close them. No always-on process to babysit.

Pull a chat and embedding model first; all recipes pin the server to 127.0.0.1:42697.

Platform	Command
macOS (Homebrew)	brew services start lilbee
Linux (Arch / AUR)	systemctl --user enable --now lilbee (add loginctl enable-linger $USER on headless servers)
NixOS	Import lilbee.nixosModules.lilbee, set services.lilbee.enable = true;

Supported formats

Text extraction powered by Kreuzberg, code chunking by tree-sitter. Structured formats (XML, JSON, CSV) get embedding-friendly preprocessing. This list is not exhaustive; Kreuzberg supports additional formats beyond what's listed here.

Format table

Format	Extensions	Requires
PDF	.pdf	none
Scanned PDF	.pdf (no extractable text)	Tesseract (auto, plain text), or a GGUF vision model via the native mtmd backend (recommended, preserves tables, headings, and layout as markdown)
Office	.docx, .xlsx, .pptx	none
eBook	.epub	none
Images (OCR)	.png, .jpg, .jpeg, .tiff, .bmp, .webp	Tesseract
Data	.csv, .tsv	none
Structured	.xml, .json, .jsonl, .yaml, .yml	none
Code	.py, .js, .ts, .go, .rs, .java and 150+ more via tree-sitter (AST-aware chunking)	none

See the usage guide for OCR setup and model benchmarks.

Experimental

Two opt-in features that work but are still finding their final shape: Wiki and semantic chunking. Click to expand.

Generation quality and retrieval behavior depend on your library, models, and knobs; expect to iterate. Feedback is welcome.

Wiki

lilbee analyzes the documents you've indexed and writes a wiki about them. Pages compound across sources: concepts and entities that show up repeatedly get their own page with citations from every source that mentions them. Sections are citation-verified before publish, and plain-text concept references are rewritten to [[wiki link]] form so graph-style markdown viewers can render the connections. Lower-confidence pages land in a drafts/ queue for review rather than publishing direct.

See the Wiki section of the usage guide for the full command list and configuration.

Semantic chunking

A semantic-chunking mode is available as an opt-in alternative to the default fixed-size chunker. It uses embedding similarity to find topic boundaries, so each chunk is one coherent thought instead of a fragment that cuts through an argument. The benefit shows up on prose-heavy collections like novels, essays, long-form research papers, or interview transcripts. The trade-off is roughly 9x more embedding calls during indexing.

See the Semantic chunking section of the usage guide for trade-offs and how to enable it.

Built on

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

• Kreuzberg parses 90+ document formats 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.
• LanceDB is the embedded vector store.
• tree-sitter (via tree-sitter-language-pack) chunks code across 150+ languages.
• crawl4ai and Playwright crawl the web; Tesseract is the OCR fallback when no vision model is set.
• LiteLLM bridges cloud model providers (the [litellm] optional extra).
• 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.

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

Having trouble? See TROUBLESHOOTING.md for log locations and common failures.

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.