The whole local AI stack in one executable. It runs and manages the models on every GPU you have. It answers questions about your files, your code, and the web, and it cites every answer. It crawls sites into your library, plugs into your coding agents, and backs the Obsidian plugin.
The built-in model manager browses Hugging Face, downloads models, gives each one a role, and runs them on your GPU: Metal, Vulkan, CUDA, or ROCm.
Private by default. Your files, the index, and every question and answer stay on your machine. No telemetry, no account. A cloud model runs only when you pick one.
It runs on your hardware. No Docker, no servers, no web stack to maintain. One file you run on demand.
see it work
Index lilbee's own README, ask "what is lilbee in one sentence?", and get a cited answer drawn straight from the source.
First run: a setup wizard pulls a chat model and an embedder, then drops you straight into chat.
A cold start, end to end: the one-time unpack behind the wordmark, chat on screen in seconds, and the first answer showing the engine load inside its own bubble.
One-minute sweep through every screen: setup wizard, chat with citations, model catalog, settings, task center, palette.
Streaming replies with clickable citations back to the file and line.
Resume a 240-message chat, watch it condense to fit the model, keep asking with citations.
/add <path> copies a file or folder into your library and indexes it; ask questions while it syncs.
/crawl <url> fetches a page into your library, then answers against it with a page citation.
Recursive crawl (depth 1) of a whole site: hundreds of Wikipedia pages indexed (fast-forwarded), then one multipart question synthesized across them, cited, with Qwen3-8B and a reranker.
Browse models on Hugging Face Hub, pull one live, switch a role without leaving the terminal.
Already running Ollama? Point lilbee at it. The catalog labels the model "ollama"; index the Crown Victoria manual on camera, then get a cited answer.
Same flow with LM Studio: lms ls shows the model, the catalog labels it "lm studio", and lilbee answers from the manual with a citation.
50+ settings: search depth, reranking, sampling, parsers. Sane defaults; tune the moment you want to.
Ctrl+P opens the command palette; /help opens the slash-command catalog. Every action is discoverable.
Four agents at once against a single local model, Qwen3 Coder Next, 45GB across three RTX 4090s at 138 tokens a second. Each works in its own clone of this repository through lilbee.
The same four tasks on Gemma 4 26B, a thinking model. lilbee streams its reasoning as visible text, so every pane shows the model working through the problem before it answers.
Qwen3.6 27B, also thinking out loud: each agent states what it expects, then reads the code to check itself.
Devstral 2 123B, 70GB across two A100 80GB cards. One agent gets the model's full 14 tokens a second; a model this size trades pane count for depth.
Tell lilbee a fact and a preference, then ask in a brand new conversation. The answer comes from memory, not from the transcript.
Browse a cited encyclopedia built from your own documents, then open a page that does not exist yet and watch lilbee write it on demand.
Automatic placement: lilbee spreads the models across every GPU on its own. The chat model is tensor-split across the cards; the embedder is copied to each. It then answers a grounded question while the per-card load bars move live.
Manual placement: press ctrl+g for the drawer, pin each role to the cards you want — split, copy, or a single pinned instance — preview the fit, then chat against that exact fleet.
install
Linux only. The default build uses Metal on macOS, Vulkan on Windows.
prebuilt bundle, built with Nuitka: its own Python interpreter and llama.cpp backend, nothing for you to compile . clears macOS quarantine for you . the [crawler] / [litellm] / [graph] extras are already included
package lilbee on the AUR . works with yay / pacaur / any helper . wraps the Linux x86_64 release binary, so the [crawler] / [litellm] / [graph] extras are already included
Linux only. The default build uses Metal on macOS, Vulkan on Windows.
no compat image; run the self-contained lilbee-compat binary instead.
image on the GitHub Container Registry . data lives at /home/lilbee/data, REST API on port 8000 . wraps the release binary, so the [crawler] / [litellm] / [graph] extras are already included
Linux only. The default build uses Metal on macOS, Vulkan on Windows.
flake at github:tobocop2/lilbee . wraps the release binary, so the [crawler] / [litellm] / [graph] extras are already included . on Linux it bundles glibc and the Vulkan loader via an FHS env so it runs on bare NixOS
run with flatpak run io.github.tobocop2.lilbee . plain lilbee command: alias lilbee='flatpak run io.github.tobocop2.lilbee' (append .cuda / .rocm / .compat for a vendor build)
needs the Flathub remote for the runtime . flatpak update picks up new releases . prefer one file? flatpak install ./lilbee.flatpakref, from the latest release
wraps the release binary, so the [crawler] / [litellm] / [graph] extras are already included
--dangerous just means sideloaded and unsigned . no auto-update: rerun the same command to upgrade . wraps the release binary, so the [crawler] / [litellm] / [graph] extras are already included
scoop install lilbee auto-installs the CUDA build when an NVIDIA driver is present.
Windows package manager . scoop update lilbee upgrades . wraps the release binary, so the [crawler] / [litellm] / [graph] extras are already included
Single self-contained binary, compiled with Nuitka. Bundles its own Python runtime and the [crawler] / [litellm] / [graph] extras. Click to download, or use the terminal one-liner.
unsigned: the macOS arm64 and Windows builds aren't code-signed. The macOS one-liner clears quarantine for you; Homebrew does the same. On Windows, SmartScreen may warn the first time.
older CPU on Windows also via scoop install lilbee-compat . CUDA cu124 / cu121 for older drivers on the releases page
driven via Vulkan by default; for the CUDA path use pip or the binary.
Linux only. Use the ROCm binary or the pip / uv ROCm index instead.
add --extra-index-url https://lilbee.sh/compat/ and pin lancedb==0.34.0+compat to your sync.
for hacking on it or contributing . needs git and uv
a small launcher, not a Node rewrite: on first run it reads your hardware, downloads the matching standalone build of the latest release, verifies it, and caches it.
picked for you. AMD ROCm, Apple Metal, and the AVX-baseline build are picked the same way; LILBEE_VARIANT=default forces the plain build.
needs Node 18+ . lilbee prepare downloads the build ahead of time . npx -y lilbee mcp runs the MCP server for agent hosts . wraps the release binary, so the [crawler] / [litellm] / [graph] extras are already included
for installing into a Python you manage. The [engine] extra ships from lilbee.sh, not PyPI, and the index picks the build: metal/ on Apple silicon, vulkan/ for other GPUs, cpu/ without one.
Linux only. The default build uses Metal on macOS, Vulkan on Windows.
no compat engine wheel exists: this installs lilbee without an engine, so use a bundled build instead, or point LILBEE_LLAMA_SERVER_PATH at your own llama-server.
needs Python 3.11+ . extras below, e.g. pip install --pre 'lilbee[engine,crawler,litellm]'
for installing into a Python you manage. The [engine] extra ships from lilbee.sh, not PyPI, and the index picks the build: metal/ on Apple silicon, vulkan/ for other GPUs, cpu/ without one.
Linux only. The default build uses Metal on macOS, Vulkan on Windows.
no compat engine wheel exists: this installs lilbee without an engine, so use a bundled build instead, or point LILBEE_LLAMA_SERVER_PATH at your own llama-server.
uv fetches a Python for you if needed . extras: uv tool install --prerelease=allow 'lilbee[engine,crawler]'
pip / uv install, add the name in brackets, e.g. 'lilbee[crawler,litellm]'. The binary, Homebrew, AUR, Nix, Docker, Flatpak, Snap, scoop, and npm builds bundle all three already. lilbee works without them.your hardware, put to work
lilbee runs local models on hardware you already own. No token budgets, no provider to depend on. The cloud is there when you want it.
one program
The model, the search through your files, and the chat run in one program. Run it when you want; close it when you're done. Nothing stays running, and no container stays alive. For a long-running server, use the command line.
- a model server, always running
- model files fetched by hand
- a vector database to stand up
- code to connect them
- a separate app for the interface
- often a container around it all
- the model runtime (llama.cpp) and the vector index (LanceDB) run inside lilbee
- use it as a terminal app, a CLI, an MCP server, a web API, or a Python library
- a built-in model catalog: browse and pull straight from Hugging Face Hub
- a scoped library per project, so each domain stays its own clean encyclopedia
- runs on a laptop or headless over a remote shell; move it between machines
what it does
runs local AI models itself
Browse Hugging Face, pull a model, assign it to a role. lilbee runs it on Metal, Vulkan, CUDA, or ROCm. You never point it at a server you set up.
a real retrieval pipeline (RAG)
A real search engine, built on published research. It ranks results by how well they answer you, so the best match comes back first. 50+ settings to tune.
search your files, code, and PDFs
Point it at a folder: your man pages, a pile of PDFs, your notes, a codebase. Then talk to them. Every answer names the file and line. Each project gets its own library.
chunked so it makes sense
Prose and code get chunked differently, so each piece keeps its meaning. A search engine is only as good as the chunks underneath it.
MCP server for your coding agent
Pair it with your favorite agent over MCP. It reads the real code and docs, cites the file and line, and says "I don't know" instead of guessing.
crawl websites for offline search
Crawl a docs site or a wiki into markdown and keep it. Search and chat with it offline, even after the site goes down.
scans & OCR
Old scans and photos go through OCR or a local vision model and come out as searchable markdown, layout intact.
remembers what you tell it
Turn on memory and lilbee keeps durable facts about you and how you like your answers. It recalls them in later conversations. Off by default, and it never leaks into your citations.
conversations that survive
Chats save automatically as plain files, no database. Press ctrl+o to pick a conversation back up. When one outgrows the model's context window, lilbee folds the older turns into notes it keeps reading.
a note on answers
Answers are only as good as the model you pick and the settings behind it. lilbee ships sane defaults and exposes 50+ settings you can tune: the search, the answers, how your files get read.
use it for
questions
What is lilbee?
lilbee is a local AI search engine. It runs the models, indexes your files, code, and crawled web pages, and answers your questions in plain English with a citation to the exact source. It is one program, with no separate model server or vector database to set up.
Is it really one program?
Yes. The model runtime (llama.cpp) and the vector index (LanceDB) run inside lilbee. You install one thing and reach it as a terminal app, a command-line tool, an MCP server, a web API, or a Python library.
Is lilbee a model manager? Do I need Ollama or LM Studio?
lilbee is a complete model manager on its own. It browses Hugging Face, downloads models, gives each one a role, and runs them on your GPU across Metal, Vulkan, CUDA, or ROCm, and it places large models across multiple GPUs. You do not need a separate model runner. If you already use Ollama or LM Studio, you can point lilbee at them instead.
Does my data leave my machine?
No. Your files stay on disk and search runs locally. lilbee uses a cloud model only when you pick one.
What can I search?
Files and markdown, code, PDFs, office documents, ebooks, and scanned images through OCR, plus whole websites you crawl into markdown. Over 150 file types.
go deeper
built on
Xberg · llama.cpp · llama-swap · gguf-parser · Hugging Face Hub · huggingface_hub · LanceDB · tree-sitter · tree-sitter-language-pack · crawl4ai · Playwright · Tesseract · LiteLLM · Textual · Litestar · MCP Python SDK · Typer · Pydantic · Nuitka