Lilbee

Run and manage local AI models, and search everything you own with them, all in one program.

Project site  ·  Tutorial reels  ·  PyPI  ·  Obsidian plugin  ·  REST API

A batteries-included local search engine you can talk to: it runs the AI models, indexes your files and code, crawls the web, and plugs into your coding agent, so there's nothing else to install or set up. Ask in plain English; every answer cites the file and line.

It's all one program: no separate model server, [vector database](#built-on), 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). Battle-tested managers are always supported too. If you already use Ollama or LM Studio, point lilbee at your existing setup and skip its native model support if you prefer.

> 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](#quick-start)
• Tutorial reel (long-form videos)
• [Highlights](#highlights)
• [Why lilbee](#why-lilbee)
• [What you can do with it](#what-you-can-do-with-it)
• [TUI](#tui)
• [Hardware requirements](#hardware-requirements)
• [Install](#install)
• [Agent integration](#agent-integration)
• [HTTP Server](#http-server) · REST API reference
• [Supported formats](#supported-formats)
• [Experimental](#experimental)
• [Built on](#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](docs/agent-skills/lilbee-mcp/SKILL.md) 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](#agent-integration).

Defaults are sane for chatting with code, documentation, crawled sites, and long PDFs. Every retrieval setting is writable from the TUI Settings screen, the /set slash command, MCP lilbee_settings_set, or config.toml. When answers feel thin or noisy, the usual knobs are top_k, max_distance, or diversity_max_per_source.

CLI, the HTTP API, env vars, and config.toml are there for scripting, headless runs, and custom integrations. See the [usage guide](docs/usage.md).

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 tutorial reel here is recorded live on real hardware, nothing staged. Backed by 100% test coverage, full typing, and CI on macOS, Linux, and Windows.
• Up and running in one command. Install, run lilbee, and a first-run wizard pulls a model and drops you straight into chat.
• Reads almost anything you point it at. Documents, scanned pages, spreadsheets, ebooks, web pages, and source code: [90+ formats and 150+ languages](#supported-formats) in all. Whatever you give it becomes searchable.
• Splits it into pieces that stand on their own. [Prose and code are chunked differently](#documents-code-and-scanned-images), so each piece keeps its meaning instead of getting cut mid-thought. A search engine is only as good as the chunks underneath it, and this is where most of the quality lives.
• A sophisticated [search engine](docs/architecture.md#search-pipeline) on top, built on published research. It ranks every result by how well it answers you, so the best match comes back first. 50+ knobs to [tune from the Settings screen](docs/usage.md#settings-screen) or hand to your agent, with sane defaults if you'd rather not.
• It brings and runs the models itself. Browse Hugging Face, pull a model, give it a role (chat, embedding, vision, reranking); lilbee runs it on Metal, Vulkan, or CUDA. You never point it at a server you set up.
• Already on Ollama or LM Studio? Keep them. Managing models for you is the default, but lilbee also works with both, so you never have to switch model managers. Their models show up in the same catalog and role pickers, alongside lilbee's own.
• Your hardware, put to work. Your machine can do a lot more than you're using it for. lilbee runs local models on hardware you already own, no cloud account required.
• Per-project libraries. Keep one library for everything, or give each project its own.
• One install, many surfaces. TUI, CLI, [MCP server](#agent-integration), REST API, and Python library. Nothing to stand up.
• Everything in one file, nothing to operate. The standalone binary bundles the whole thing (search engine, web crawler, MCP server, HTTP server, terminal UI, Python, and llama.cpp) in 250-365 MB, or 600 MB+ with CUDA. No Docker, no vector database, no model server, nothing to keep running; it loads on demand. Comparable desktop AI apps (often Electron) ship hundreds of MB to several GB and do less.
• Works with your coding agent. Connect lilbee to your AI coding assistant and it answers from your actual files and code, with citations, instead of guessing. It can even adjust its own search as it works.

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](#built-on), crawls the web pages you point it at, and searches the lot with a real engine. Use it in the terminal, or connect it to your coding agent so it answers from your files with citations instead of guessing.

> 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. The same engine works two ways. It's an Encarta 99 you build over your files and saved web pages, that you read and ask questions of. And it's a reference layer for code: point it at your project, dependencies, and API docs, and your coding agent answers from what's there instead of guessing function names. Read it yourself, or have your agent read it for you.

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.

Already using an MCP-aware agent? Hand setup to it.

If you've already got an MCP-aware coding agent running, it can do the setup: browse the catalog, pull picks, assign them to the embedding / reranker / vision roles, and tune retrieval. No TUI, no config file, no restart. Agents already understand search engines, so the right knobs are obvious to them. See the [lilbee-mcp skill](docs/agent-skills/lilbee-mcp/SKILL.md) for the workflow and example prompts.

Opencode integration (coming)

Local-model opencode support is coming in #267, with tool-calling working across many GGUF families.

The demo shows a small local model (Qwen) given a specific instruction: when its first search comes back thin, widen lilbee's search settings and search again. The second pass returns the full function bodies with file:line citations. A more capable model would do the same from a higher-level prompt like "improve your search results." Read the [lilbee-mcp skill](docs/agent-skills/lilbee-mcp/SKILL.md) to teach 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.

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 the simplest path: lilbee pulls them, runs them on Metal / Vulkan / CUDA, and you never stand up a server. But you don't have to adopt a new model manager to use lilbee.

If your models already live in Ollama or LM Studio, point lilbee at the running endpoint and they appear in the same catalog and role pickers (chat, embedding, vision, rerank), labeled by where they run, alongside lilbee's own and any cloud models. They're read-only: lilbee lists and runs them but never pulls or deletes them, so their lifecycle stays in the app you already use. Mix freely.

On a pip or uv install, talking to Ollama or LM Studio needs the [litellm] extra (pip install --pre 'lilbee[litellm]'); the Homebrew, AUR, Nix, Docker, Flatpak, and Snap builds already include it. See [Install](#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.

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, ? 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/](demos). For commands and settings, see the [usage guide](docs/usage.md).

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](#on-older-cpus-pre-avx2)), 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 x8664 | 64-bit Intel/AMD from 2013+ (x86-64-v3) | Modern Intel/AMD CPU + an NVIDIA, AMD, or Intel Arc GPU | | Windows x8664 | 64-bit Intel/AMD from 2013+ (x86-64-v3), Windows 10/11

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: tobocop2
• Source: tobocop2/lilbee
• License: MIT
• Homepage: https://lilbee.sh

Install and usage instructions live in the source repository linked above.