A self-hosted web UI for your language models, written in Python.
Talks to anything that speaks the OpenAI API. Themed after Middle-earth.

---

Lembas is the Elvish waybread — one bite sustains a traveller for a day's march. The capitals hide what it runs on: LLeMbas.

Why this exists

Most self-hosted LLM front-ends are large JavaScript applications with a Python API bolted underneath. LLeMbas is the other way round: server-rendered Python, with htmx and a little Alpine for interactivity. There is no package.json, no bundler, no build step, and nothing is fetched from a CDN at runtime. Clone it, pip install -e ., run it.

Features

Working now

• Chats — streaming replies, Markdown with server-side syntax highlighting, copy and regenerate, automatic chat titles. Chats are created when you send the first message, so an abandoned one never clutters the sidebar
• System prompts — instance-wide, per-model and per-chat, with the most specific winning outright
• Reasoning display — thinking streams into its own collapsible block (closed by default), labelled with how long it took, and is never replayed as context
• Live Markdown — formatting appears as the model writes, not at the end
• Stop and rewind — cut a reply short and keep what arrived, or edit an earlier message and run the conversation on from there
• Replies keep running in the background — navigate away, open another chat, close the tab; a green dot and a notification tell you when it lands
• Attachments — drag, paste or pick images, PDFs and text files. Images are downscaled and sent to vision models; PDF and text content is extracted and put in the prompt
• Folders — arbitrarily nested, delete a folder without losing the chats inside it
• Web search — offered to the model as a tool it calls when a question needs it. DuckDuckGo out of the box (no account, no key), or point it at your own SearXNG, or Firecrawl. The sources stay in the transcript
• Your own tools — describe an HTTP call in the admin area (a schema, a URL template, a secret) and a model can make it. Or add an MCP server by URL and its tools appear beside the built-in ones. Both restrictable to groups, and neither can be pointed at your own network unless you say so
• Agent chats — start a chat as an Agent instead, pointed at one of your own SSH connections and a directory on it, and a model can read files, write files and run commands there. Nothing ever runs on the machine LLeMbas itself is on. What it may do without asking is a mode you set and can change mid-conversation: Manual shows you everything first, Edit writes freely but asks before commands, Auto asks about nothing, and Plan reads freely, changes nothing, and finishes by proposing steps you can carry out with one button. Adding a host shows you its fingerprint before anything is sent to it
• A terminal beside the chat — the same connection, a real shell, opened and closed like any panel. It survives closing the panel and reloading the page, so a build keeps running; the model cannot see it, and a button hands it the output you choose
• It can ask you things — a model that needs a decision can stop and put a few questions on one card, with answers to pick from and a box to write your own. In any chat, not only an agent one
• Speech in and out — dictate a message and have replies read aloud, against any OpenAI-compatible audio endpoint (whisper.cpp, Speaches, Kokoro…). Each person picks their own voice
• A library — four places a model can reach for. Knowledge: documents, images and web pages you collect, grouped into named bases so a chat can be pointed at just the right one, searched before the web. Notes: longer things it writes down and finds again later. Memory: short facts about you, in front of it on every turn. Skills: saved procedures it can follow, and write. All of it visible and editable by you, and shareable with a group or a person, read-only
• Installable — add it to a phone home screen or a desktop launcher and it runs in its own window
• OpenAI connections — point at OpenAI, LM Studio, vLLM, llama.cpp, llama-swap, Ollama or OpenRouter; models are discovered and cached
• Model settings — searchable, filterable list with a page per model: ordering, pinned models, an instance default and a per-user default, custom names, descriptions and images. Scales to hundreds of models
• Users, groups & permissions — per-group grants that union rather than override, and model access restricted to chosen groups
• Accounts — first account becomes the administrator, argon2 password hashing, revocable server-side sessions, self-service password change, admin-managed accounts
• Admin settings — open or close registration from the UI, stored in the database and effective immediately
• Two themes — Moria (dark) and Shire (light), switchable per user

Planned

Image generation · OCR for scanned PDFs · semantic search in the library.

See PLAN.md for what is built, what is not, and why.

Quick start

git clone https://git.houmeres.sk/Houmeres/LLeMbas.git
cd LLeMbas

python -m venv .venv && . .venv/bin/activate
pip install -e ".[dev,search,ssh]"   # search: DuckDuckGo. ssh: agent chats.
                                     # Drop either if you do not want it

cp .env.example .env
lembas secret-key           # paste the result into LEMBAS_SECRET_KEY

lembas serve                # http://127.0.0.1:8080

Open the address and create the first account — it becomes the administrator. Then go to Admin → Connections and add an endpoint. For a local runner that is usually http://localhost:1234/v1 with no API key. Press Test & refresh and its models appear in the chat model picker.

The vendored browser libraries (htmx, Alpine) are committed, so no network access is needed to run. To re-fetch or bump them: python scripts/fetch_vendor.py --update.

Web search

Admin → Web search. DuckDuckGo needs nothing beyond the search extra above. SearXNG needs its JSON format enabled — add - json under search.formats in its settings.yml, or every search fails. Firecrawl needs an API key.

Search is offered to the model as a tool, so it decides when a question needs looking up. It is only offered to models marked tools under Admin → Models: an endpoint without tool support rejects the whole request rather than ignoring the extra field, so the flag is a real switch and not a hint.

Audio

Admin → Audio. Two endpoints, because they are usually two servers:

	Speaks	Example
Dictation	POST /v1/audio/transcriptions	whisper.cpp's whisper-server, Speaches, faster-whisper-server
Read aloud	POST /v1/audio/speech	Kokoro-FastAPI, OpenAI

If the speech endpoint also answers GET /v1/audio/voices the voice list is read from it, and each person can pick their own under Settings → Audio. Recorded audio is passed straight through and never written to disk.

The microphone needs HTTPS or localhost. Browsers do not grant it over plain HTTP, so a LAN install without TLS will not offer dictation.

Agent chats

Admin → Agents to turn the feature on, then Connections in the sidebar to add a machine. Three things have to line up before an agent chat can start: the feature enabled, the Run commands permission, and a model flagged Agent execution. All three are off by default, on purpose.

Nothing an agent does runs on the machine LLeMbas is on. Commands go to a host you name over SSH, which means the containment is that host — a container built for the job is a very different thing from a key to a server you care about, and LLeMbas cannot tell them apart. A throwaway container is the intended shape:

docker run -d --name agent-box -p 127.0.0.1:2222:22 <an sshd image>

Adding a connection does not connect to it. Check shows you the host's fingerprint with nothing sent — not your username, not your key — and only accepting pins it. If that host later answers with a different key, it is refused rather than quietly trusted.

Then start a chat with the Agent toggle, pick the connection and a directory, and choose a mode. The mode is in the chat header and changes at any time:

	Reads	Writes files	Runs commands
Manual	asks	asks	asks
Edit	free	free	asks
Auto	free	free	free
Plan	free	asks	asks

The mode is enforced in the reply loop, not written into the prompt: everything a model reads — a web page, a README, the last command's output — is untrusted, and a rule that lives only in a system message is one a poisoned file can argue with. In Auto, nothing stands between that and a command running.

Plan finishes by proposing steps, with a button that carries them out — which switches to Edit, never Auto, because the plan was written under a mode where every command still asked.

The terminal

An agent chat has a Terminal button in its header, which opens a real shell on that chat's connection, in its directory, beside the conversation. It needs the Open a terminal permission, which is off by default.

The modes above do not apply to it. They exist because a model reads pages, files and command output it did not write; you hold the credential and could open the same shell with an ssh client, so nothing you type is queued for your own approval. The model cannot see the panel either — the button in its header puts the selection, or the last of the output, into the message box, where you read it before it goes anywhere.

The shell is not tied to the panel. Close it and a build carries on; come back, or reload, and you reattach with the scrollback. Two tabs share one shell, and the smaller window decides the size. It ends when nobody has watched it and nothing has been typed for a while, when the chat is deleted, when the connection is disabled or deleted, or when LLeMbas restarts — a deploy cuts off whatever was running, and the panel says so rather than quietly opening a fresh shell that has lost your working directory.

Nothing typed here is in the transcript and nothing is logged but the opening and the closing. If you are running this over plain http, note that the session cookie is not marked secure so a LAN install works at all — with a terminal switched on, that is worth a certificate.

The library

Sidebar → Library, and Settings → Memory. Nothing is on by default for a model: give it the tools it should have under Admin → Models, where tools decides whether a tool list may be sent at all and the built-in tools are chosen one by one.

Knowledge is organised into bases — one per subject, project or client. A chat with no base attached searches everything you have; tick some in the chat's settings panel and it searches only those. Sharing happens at the base: share it and everything in it comes too, read-only.

Search is SQLite's FTS5 — keyword matching with BM25 ranking, no embedding service to run and nothing that stops working offline. It will not match a paraphrase, so a line of description on a document is worth writing.

Saving a link makes your server fetch a URL. Addresses on your own machine and network are refused unless an administrator opts in under Admin → Web search, because the address can come from a model and the server can reach things your browser cannot.

Installing as an app

Open it in a browser and use Install (Chromium) or Share → Add to Home Screen (iOS). This also needs HTTPS or localhost — service workers are unavailable over plain HTTP, and without one there is nothing to install.

There is no offline mode beyond a page saying so. Everything is rendered by your server, so a cached conversation would be a snapshot that silently went stale.

Configuration

All variables are prefixed LEMBAS_ and can live in .env. See .env.example for the annotated list.

Variable	Default	Purpose
LEMBAS_SECRET_KEY	generated	Signs sessions and encrypts stored API keys. Set this. A generated key changes every restart, signing everyone out and making stored API keys unreadable.
LEMBAS_DATA_DIR	./data	SQLite database and uploads.
LEMBAS_HOST / LEMBAS_PORT	127.0.0.1 / 8080	Bind address.
LEMBAS_ALLOW_SIGNUP	true	Whether new users may register themselves — the initial value only. Once set under Admin → General the stored setting wins. The first account is always an admin regardless.
LEMBAS_DEFAULT_THEME	moria	moria (dark) or shire (light).
LEMBAS_SESSION_TTL	2592000	Session lifetime in seconds.
LEMBAS_REQUEST_TIMEOUT	300	Seconds to wait on an upstream model.

Commands

lembas serve          # run the server
lembas info           # where data lives, what is configured
lembas secret-key     # generate a value for LEMBAS_SECRET_KEY
lembas create-admin   # create or promote an administrator

How it fits together

Browser  ──form POST──▶  FastAPI  ──▶  SQLite
   ▲                        │
   │                        └──httpx──▶  any OpenAI-compatible endpoint
   └──── server-sent events ◀───────────────┘   (streamed reply)

Sending a message stores the turn and returns two HTML fragments: the user's bubble and an empty assistant bubble carrying an sse-connect. That opens a server-sent event stream which appends tokens as they arrive, then replaces the whole bubble with the finished, Markdown-rendered version. Rendering and highlighting happen in Python, so the streamed and final views cannot disagree.

src/lembas/
  api/         routes: auth, chats, folders, admin, pages
  db/models/   SQLAlchemy schema
  security/    password hashing, sessions
  services/    llm client, chat orchestration, markdown, crypto, sse
  web/         Jinja templates and static assets
assets/        SVG artwork masters
scripts/       artwork generator, vendored-JS fetcher
deploy/        systemd unit and nginx vhost for a real install

Development

pytest                              # test suite
ruff check .                        # lint
python scripts/build_artwork.py     # regenerate the SVG artwork
python scripts/fetch_vendor.py      # verify vendored JS against the lockfile

There is no Alembic. The schema is SQLite-only and synchronised at startup: missing tables and missing columns are added automatically, so adding a field to a model needs nothing but a restart. Renames, drops and retypes are still manual — see CLAUDE.md.

Artwork

The logo, favicon and banner are original vector work, generated by scripts/build_artwork.py so the mallorn leaf stays identical across every size it appears at. The wordmark is Source Serif 4 (SIL OFL 1.1) converted to outlines — a README banner cannot load a webfont, and <text> would render in whatever serif the reader happens to have.

Licence

GPL-3.0.

A note on the theme

This is an independent hobby project, themed as an affectionate nod to J.R.R. Tolkien's world. It is not affiliated with, endorsed by, or connected to the Tolkien Estate, Middle-earth Enterprises, or any related rights holder. All artwork here is original.