lilbee

A local search engine for your vault, inside Obsidian.

Project site  ·  Tutorial reel  ·  Releases  ·  lilbee engine

This plugin runs lilbee against your vault and gives you chat, a web crawler that saves sites into your vault, an auto-generated wiki, click-to-source citations, and a model catalog, all inside Obsidian. It downloads and manages the lilbee server for you; nothing to install separately. Everything runs on your computer; cloud models are opt-in, per role.

Ask a question in plain English and lilbee answers from your vault, with citations that click straight back to the source line.

Tutorial reel: every recording on this page (and a few extras) as videos with longer notes at obsidian.lilbee.sh/tutorial.

Now in the Obsidian community plugin store

lilbee is an official community plugin: install it from Settings → Community plugins inside Obsidian, nothing else needed. Feedback, bug reports, and issues are very welcome.

Heads up: this downloads to your computer. lilbee is a local search engine with its own models, so the plugin fetches the lilbee server (a few hundred MB) on first launch and the models you pick from the catalog (a few hundred MB up to several GB each) when you choose them. It's all stored locally and runs on your machine.

• Highlights
• Tutorial reel (long-form videos)
• Why a local search engine for Obsidian
• What you can do with it
• Quick start
• Open the chat
• How it works
• Privacy & network use
• Updating the plugin
• Updating the server
• Documentation

Highlights

• Ask your vault in plain English. Type a question; get an answer with citations that click straight back to the source line.
• Verify in one click. Every citation opens a Source Preview scrolled to the exact spot: surrounding paragraphs visible, cited lines highlighted.
• Save websites into your vault. Crawl a single page or a whole docs site; the pages land in your vault as markdown notes you can search, chat with, and cite offline, even after the site changes or goes down.
• Reads more than markdown. PDFs, Office files, ebooks, CSV / TSV / JSON / YAML, 150+ programming languages, plus OCR for scans and photographed pages.
• Your models, your machine. Browse a built-in model catalog straight from Hugging Face Hub, pull one with a click, run it locally. No account needed.
• Already on Ollama or LM Studio? Keep them. lilbee manages models for you by default, but it also works with both, so you never have to switch model managers. Their models appear in the same pickers, alongside lilbee's own.
• Runs on your computer. Server, models, index, and vault all stay local; cloud models are opt-in per role, with a persistent indicator when one is active.
• An auto-generated wiki (experimental): linked markdown pages written from what you've indexed, citation-checked before publish, landing in your vault's graph alongside your own notes.

Why a local search engine for Obsidian

A vault is already a curated set of documents: notes you've taken, PDFs you've collected, scans you've filed away. That's exactly what a local search engine wants. This plugin points lilbee at your vault so a local model can reason over your library with retrieval-augmented generation (RAG) and answer with citations you click straight back to the source.

An Encarta 99 you build for yourself, from your own vault, shaped to your needs.

What you can do with it

A library of your vault

Point lilbee at your vault and it builds a searchable library from every note, PDF, ebook, and code file. The pattern works for any vault you've curated, a medical-textbook collection, a field's research papers, a company wiki: whatever it holds becomes searchable, and you can talk to it.

Add a single file from the right-click menu or the command palette, or run Sync vault to index everything at once. Background jobs (sync, crawl, wiki build, model downloads) run in a Task Center, so you can keep asking questions while they work.

Offline copies of websites, inside your vault

Watch it: crawl the web into your vault — fetch a Wikipedia page, then ask a cited question against the saved copy.

Crawl a docs site, a wiki, or a vendor's API reference and the pages land in your vault as ordinary markdown notes. Grab a single page or a whole site; whole-site crawls follow internal links, with depth and page caps when you want them. From then on you search or chat with that copy offline, with citations that click back to the saved page, even after the site changes or goes down.

Verify every answer at the source

Every citation in a chat reply or wiki page is a live link. Click it and a Source Preview opens, scrolled to the exact spot, surrounding paragraphs visible and cited lines highlighted; from there, open the full document or copy a deep link back. A confident answer with a footnote is only as good as the footnote, so the check is one click instead of a separate chore. This works for crawled web pages too: citations link back to the saved copy in your vault.

Ask for several things at once

Put more than one question in a single prompt and lilbee answers each from wherever it lives in your library, with a separate citation per fact.

Pick and tune your models

Chat, embedding, vision, and reranking are separate roles, each with its own model. The Model Catalog (command palette or chat toolbar) browses featured picks or searches Hugging Face Hub, shows each model's size and memory before you pull, and flags ones that won't run on your hardware. Defaults are sensible out of the gate; Settings exposes the retrieval and generation knobs when you want to go deeper, each with a reset.

Each role sits on the chat rail, so you can see what's active and switch it mid-conversation. Hover a pill to see what that role does.

Reranking, before and after

Reranking is an optional role that re-scores retrieved passages with a cross-encoder before the model answers. When the note that holds the answer is worded around the cause rather than your keywords, plain vector search can rank it too low to make the cut; reranking pulls it back into context. Here's the same question with reranking off, then on; the answer flips from wrong to right.

Already running Ollama or LM Studio? Keep them.

lilbee has its own model manager and multi-GPU fleet, built on llama.cpp. Downloading, running, and updating models for you is the default and the simplest path, with no second app to think about. Battle-tested managers are supported too, so you don't have to switch model managers to use lilbee.

If your models already live in Ollama or LM Studio, point lilbee at the running server and they show up right in the same Chat / Embed / Vision / Rerank pickers, next to lilbee's own models and any cloud models, each labeled by where it runs. You keep managing them in the app you already use; lilbee just uses them. Pick whichever fits how you already work, and mix all three freely.

Pick one of your Ollama models for embedding and another for chat from the catalog's Hosted tab, and the whole pipeline runs on Ollama:

The same flow works with LM Studio's local server:

Documents, code, and scanned images

Your vault is full of more than markdown. lilbee handles the rest:

• Prose and structured files (PDFs, Word / Excel / PowerPoint, ebooks, CSV / JSON / YAML) are split so each chunk keeps its section context.
• Code (150+ languages) is split along real functions and classes, not arbitrary line ranges.
• Scanned PDFs and photographed pages are read with OCR, including a local vision model that keeps tables and layout intact. (A per-vault toggle in Settings.)

Cloud models, when you want them

By default everything stays on your machine: server, models, index, vault. For a role where a cloud model genuinely helps (vision OCR, long-context summarization), Settings → Advanced lets you key in an API endpoint for that role only while the rest stay local. A persistent indicator shows whenever a cloud model is the active backend, so it's clear when chunks are leaving the machine.

With your own key, hosted frontier models appear under the catalog's Hosted tab too. Pick a free-tier Gemini model for chat, keep embedding local, and the answer comes from Gemini while still citing your own documents:

Experimental

Quick start

1. In Obsidian, open Settings → Community plugins → Browse, search for "lilbee", then Install and Enable. (Or start from the store listing.)
2. The Setup Wizard auto-launches. Pick a chat model and an embedding model from the featured grid, then run the initial sync.

The plugin downloads and manages the lilbee server automatically; nothing to install separately. The first launch fetches the right version for your platform and verifies it before starting. Wait for the status bar to show lilbee: ready, then open the chat.

Hardware note: the server runs on your CPU or GPU. A Mac with Apple Silicon (M1+) or a PC with an NVIDIA / AMD / Intel Arc GPU gives the best performance. 8 GB of RAM is the minimum; 16 to 32 GB is recommended. See lilbee's hardware requirements for the full table.

Open the chat

Once the status bar shows lilbee: ready:

The chat panel opens in the sidebar. From there you can ask questions, attach individual files, or run Sync vault (Cmd/Ctrl + P → "lilbee: Sync vault") to index everything at once. Every lilbee surface, the model catalog, the Task Center, chat, is reachable from the command palette.

How it works

The plugin runs lilbee in the background: on first launch it downloads the right version for your platform, starts it, and shuts it down when you close Obsidian. Your vault is what it searches; lilbee handles indexing, retrieval, generation, and the wiki, and the plugin is the interface on top.

Vaults on the same computer share one lilbee install and one model cache, so downloaded models are reused instead of fetched again, while each vault keeps its own isolated index.

One vault at a time. lilbee follows whichever vault you have open, re-targeting automatically when you switch, and each vault's index is saved and restored when you reopen it. (Advanced users can point the plugin at their own lilbee server from Settings → Connection.)

macOS users: the server binary is unsigned (Apple charges $99/year for signing). The plugin clears the quarantine flag automatically. If macOS still blocks it, go to System Settings → Privacy & Security and click Allow Anyway. See the lilbee source if you want to audit the build.

Updating the plugin

Obsidian handles plugin updates: Settings → Community plugins → Check for updates, then update lilbee like any other plugin.

Updating the server

The plugin tracks the installed lilbee server version. Go to Settings → lilbee → Check for updates. If a newer release is available the button changes to Update to vX.Y.Z: one click stops the running server, downloads the new version, verifies it, and restarts.

This updates only the lilbee server, never the plugin itself. The plugin's own code is updated through Obsidian like any other community plugin; the Check for updates button only manages the separate server it downloads. Each server download is checked against the SHA256 digest GitHub publishes for the release before it runs, so a corrupted or tampered download is discarded instead of executed.

Privacy & network use

Everything runs on your machine by default, and the plugin tells you when that changes. For transparency, here's exactly what it does and what leaves your computer:

• Managed or external server. The plugin talks to a local lilbee server over 127.0.0.1. In managed mode (the default) Obsidian runs the server for you so you can get going without installing or managing the executable yourself. It prompts before downloading the server, then starts it when Obsidian launches and stops it when you close Obsidian. In external mode you run lilbee serve yourself and point the plugin at it; in that mode the plugin downloads no executable.
• What it contacts, and why. GitHub: in managed mode, to download the lilbee server and check for updates. Hugging Face Hub: the model catalog you browse and pull models from. Nothing else, unless you opt into a cloud model below.
• Cloud models are opt-in, per role. By default chat, embedding, vision, and reranking all run locally. You can point a single role at your own API endpoint (Settings → Advanced); only that role's requests leave your machine, and a persistent indicator shows whenever a cloud model is active.
• No account, no telemetry. lilbee needs no account to run locally, and the plugin collects no analytics or usage data of any kind. Cloud models use an API key you enter yourself.
• Vault access. The plugin reads your vault to index it and, if you enable the wiki, writes generated pages into a vault folder you choose (default lilbee/). The server install and model cache live in Obsidian's app data folder, outside your vault.

Running a local server is unusual for an Obsidian plugin, so the automated store review flags a few capabilities. Here is exactly what each one does:

• Shell execution. In managed mode the plugin starts and stops the lilbee server executable it downloaded (and verified against GitHub's published SHA256). It runs nothing else, and external mode never spawns a process.
• Filesystem access outside the vault API. The server install, model cache, and index live in Obsidian's app data folder, so the plugin uses Node's fs to download, verify, and clean up those files. The only other paths it touches are ones you pick yourself in a save/open dialog when exporting or importing a dataset.
• Environment variables. Read only to locate the server's data folder (HOME/USERPROFILE, XDG_DATA_HOME, LOCALAPPDATA, and the LILBEE_DATA override). The plugin never reads your hostname or username, and nothing from your environment leaves your machine.
• Vault file listing. The plugin lists your vault's files to know what to index and to keep the index in sync as you edit. File contents go only to the local server.

Documentation

See Usage Guide for the full reference: every command, every setting, the chat toolbar, supported formats, troubleshooting, and advanced configuration. For the underlying engine (what it indexes, how retrieval works, model formats, hardware requirements), see lilbee.

License

MIT