# minimal-llm-ui is a Next.js chat window in front of Ollama on port 11434

> A React and Tailwind front end for local models that keeps conversation context in memory so you can switch models mid-answer, stores history in a local database, and templates prompts with parameters. The Ollama base URL is a NEXT_PUBLIC variable, which decides who can see it.

**richawo/minimal-llm-ui** — Minimalistic UI for Ollama LMs - This powerful react interface for LLMs drastically improves the chatbot experience and works offline. 

- Repository: https://github.com/richawo/minimal-llm-ui
- Stars: 357 · Forks: 61
- Language: TypeScript
- License: MIT
- Published: 2026-09-15 · Updated: 2026-09-15 · Language: en
- Canonical page: https://hysenlabs.com/projects/richawo-minimal-llm-ui

## Ollama answers on 11434, the app answers on 3000, and one variable decides which host

Two processes, two ports, one line of configuration between them.

The model runs first.

```bash
ollama serve
```

That serves Ollama at http://localhost:11434/, and ollama run with a model name is the alternative that starts it for you. The application is a Next.js project, so it installs and starts the same way any of them does.

```bash
npm install
npm run dev
```

The dev server then answers at http://localhost:3000. From that point the browser is talking to a React and Tailwind interface while every model call goes to Ollama on 11434.

The connection between the two is a single environment variable, and .env.example contains exactly one line.

```json
NEXT_PUBLIC_OLLAMA_BASEURL=
```

If you leave it empty the base URL defaults to http://localhost:11434, which is right when both run on your machine. If Ollama lives on another host or device, copy .env.example to .env.local and set the variable, and the interface follows.

That variable name is the detail worth pausing on. The NEXT_PUBLIC_ prefix is what Next.js uses for values it inlines into the client bundle, so the address of your Ollama instance is not a server-side secret. It ships to the browser, and therefore to anyone who can load the page. That is fine for a tool on your own laptop and is the wrong shape for anything you publish.

## Mid-conversation model switching works because the context sits in memory, not in a file

The feature that distinguishes this from a plain chat page is switching models without losing the thread, and it has one implementation cause.

Context is stored in memory for efficient model switching. The conversation history you can revisit is a separate thing, saved in a local database. Those are two stores, and the in-memory one is what makes the switch seamless: the prompt history is already in the application, so pointing the next turn at a different model is a change of destination rather than a change of session.

The trade is honest and worth stating. Memory-backed context does not survive a page reload, and it is scoped to the running server process. A conversation you care about has to be saved before you lose it, and the feature list draws that line by promising history and promising memory as separate things.

Model toggling works even mid-conversation, which is the part that makes experimenting with models practical rather than annoying. You can start a reasoning problem on one model, move the next turn to another, and keep asking without re-establishing context.

The other two features are smaller and concrete. Prompt templating saves prompts as parameter-driven templates, which is the difference between reusing a prompt and copying it. The command menu surfaces those saved prompts, and, as the to-do list notes, it cannot yet edit or delete them.

## The setup guide stops to check node -v, and the floor is 14.0.1

Step four of the getting-started list is a version check, which is unusual to see written out and suggests the project has been bitten by it.

```bash
node -v
npm install -g n
n 20.0.9
node -v
```

The check is whether your Node is at least 14.0.1, and the escape hatch is the n version manager installed globally through npm, then used to install a specific version, then verified. Nothing about this is project-specific; it is the generic repair path for an old runtime, included inline.

The order of the steps matters more than any of them. Install Ollama and start it, because the application has nothing to talk to until 11434 answers. Then work from the root of the project. Then npm install. Then, optionally, point the base URL somewhere else. Then npm run dev.

The optional step is the one most people on a laptop skip and most people with Ollama on a second machine need. Nothing else in the setup is required.

There is no database to provision and no container to start, which is a real difference from the heavier local-LLM stacks: the local database holding conversation history needs no setup step of its own.

## langchain is pinned at 0.0.167 while next sits on 14, and there is no test script

package.json is a snapshot of two different eras of frontend tooling, and the pins are the interesting part.

The application layer is current enough: next at ^14.0.0, react and react-dom at ^18, tailwindcss at ^3.3.3, typescript at ^5, ai at ^2.2.16, react-markdown at ^9 with remark-gfm at ^4, react-syntax-highlighter for code blocks, framer-motion for animation, and clsx with tailwind-merge for class handling.

The model layer is not. langchain is pinned to ^0.0.167, which is a pre-1.0 release from a period when the JavaScript package still exposed the old chain-based API, and it sits next to ai at ^2.2.16, a newer streaming-oriented SDK. Two LLM abstraction layers in one dependency list is either a migration in progress or a leftover, and nothing in the README says which.

One more mismatch is visible: eslint-config-next is held at 13.5.5 while next itself is on 14. A lint config one major behind the framework it lints is the kind of thing that keeps working until it does not.

The scripts are dev, build, start and lint. There is no test script, and the repository has no test directory, which is worth knowing before you plan to contribute changes to the model-switching path.

## The to-do list names what it cannot do yet, starting with images and message editing

The roadmap is short enough to quote and specific enough to plan around.

Missing: an edit icon for user messages, image uploads for multimodal models, conversation summarisation, visualisations, a desktop app conversion, and a command menu that can edit and delete existing prompts.

Two of those matter more than they look. No image uploads means the multimodal models Ollama can serve are unusable through this interface, which narrows the audience to text-only work. No message editing means you cannot fix a prompt in place, which is the single most common thing people want from a chat UI once they have used one for an afternoon.

The prompt command menu is a partial feature rather than an absent one, and partial features are more confusing: the prompts are there and reachable, but changing one means editing a file by hand.

The desktop-app item is the one to read as a statement of intent. It sits in the same list as the summaries and the charts, which tells you this project sees itself as a browser application rather than as a desktop client, and that the browser is where the missing capabilities are going to be built.

Everything on that list is unimplemented, so the honest feature summary for a reader is: text chat, mid-conversation model switching, saved history, prompt templates and a custom endpoint.

## The troubleshooting section is one sentence, and the sponsor line is longer than it

The documentation has one structural gap and one structural quirk, and both are visible in the file itself.

The troubleshooting section reads, in full, that if you encounter any issues, feel free to reach out. There is no entry for a connection refused to 11434, no entry for a model that loads but produces nothing, and no entry for the blank page you get when NEXT_PUBLIC_OLLAMA_BASEURL points somewhere unreachable. For a two-process application where the most common failure is that the two processes are not talking, that is the section a reader needs most and gets least.

The quirk is the sponsorship. The README carries a sponsor section for yaps.ai, described as a collection of local AI tools in a single app covering dictation, screen reading, speech generation, translations, meeting notes and transcription, all running offline. It sits above the licence and is longer than the installation notes, which is a fair thing to know when you are deciding how much of the setup documentation to trust.

The rest of the repository is conventional: .eslintrc.json alongside prettier.config.js with prettier-plugin-tailwindcss, tailwind.config.ts, next.config.js, postcss.config.js, tsconfig.json, a committed package-lock.json, assets/ and public/ for static files, src/ for the application, and a sweep.yaml.

Licensing is MIT with the text in the LICENSE file. The package is marked private at version 0.1.0, there are no GitHub releases, and the last push was on 2026-08-24.

## Conclusion

Adopt minimal-llm-ui if you already run Ollama locally and want a chat window with model switching and saved history in about twenty lines of setup, and you are comfortable running the Next.js dev server on your own machine. Do not adopt it for shared or hosted use: the base URL is a NEXT_PUBLIC_ variable baked into the client bundle, so anything you expose this to hands out the address of your Ollama instance. Verify three things first: that your Node version is at least 14.0.1, that NEXT_PUBLIC_OLLAMA_BASEURL points at the host where Ollama is actually listening when it is not localhost, and that the features you need are not still on the to-do list, since image uploads, message editing, conversation summaries and prompt deletion are all listed as outstanding. The licence is MIT, the package version is 0.1.0, and the last push was on 2026-08-24.

## FAQ

### How do I run minimal-llm-ui locally?

Start Ollama first, with ollama serve or ollama run and a model name, so it answers at http://localhost:11434. Then run npm install and npm run dev in the project root, and open http://localhost:3000.

### How do I point minimal-llm-ui at Ollama on another machine?

Copy .env.example to .env.local and set NEXT_PUBLIC_OLLAMA_BASEURL to the address of the host running Ollama. Leaving it empty defaults the base URL to http://localhost:11434.

### Why does switching models in minimal-llm-ui not lose the conversation?

Context is kept in memory in the application rather than read back per model, which is what lets a switch happen even mid-conversation. Conversation history that should survive a reload is saved separately in a local database.

### What version of Node.js does minimal-llm-ui need?

The setup notes check with node -v and ask for at least 14.0.1. If yours is older, the documented path installs the n version manager with npm install -g n and installs a specific version such as n 20.0.9.

## Sources

- [Issues](https://github.com/richawo/minimal-llm-ui/issues)
- [License: MIT](https://github.com/richawo/minimal-llm-ui/blob/main/LICENSE)
- [README](https://github.com/richawo/minimal-llm-ui/blob/main/README.md)
- [richawo/minimal-llm-ui on GitHub](https://github.com/richawo/minimal-llm-ui)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/richawo-minimal-llm-ui