TavernAI-v1: the legacy TavernAI frontend for chat and storywriting

What TavernAI-v1 actually solves, and for whom

Running a local language model gives you a completion endpoint and a blank page. TavernAI-v1 is the page. It is a Node.js and Express application that serves a browser interface for character-based chat and story writing, and it talks to whichever generation backend you already have running. The README lists the targets: the Kobold series (KoboldAI, KoboldCpp and Horde), Oobabooga's Text Generation Web UI, OpenAI including ChatGPT and GPT-4, NovelAI, Claude and Ollama. That spread is the point. You pick a backend, and the same interface sits on top of it.

The intended user is someone self-hosting a model who wants more than a raw prompt box. The feature list covers character creation, an online character database, group chat with several characters at once, story mode, world info, message swiping, configurable generation settings, themes and backgrounds, message editing, and picture recognition through GPT and Claude. Group chat and world info are the two features that distinguish this from a generic chat wrapper: both require the frontend to assemble context before it sends anything to the model.

The README opens with a blunt statement: this is a legacy repository, and TavernAI 2 is available at a separate GitHub location. That single line should shape how you read everything else. The code is present, installable and MIT licensed, but the project's own documentation treats this repository as the earlier line rather than the recommended one.

How the Express server and config.conf fit together

The architecture visible in the repository is a conventional single-process web app. server.js is the entry point, listed in package.json under bin as TavernAI, and the Dockerfile ends with CMD ["node", "/home/node/app/server.js"]. Express serves the frontend from public/, and routes/ holds the server-side handlers. The browser never holds your API credentials; it sends requests to the local server, and the server forwards them to the backend you selected.

That forwarding is why the dependency list is heavier than a typical chat UI. needle, node-rest-client and follow-redirects handle outbound HTTP to remote APIs and to reverse proxies. multer handles uploads, and sharp plus webp-converter and the png-chunks family process images, which is what backs the character card import and the picture recognition features. csrf-csrf, cookie-parser, cors and ipaddr.js sit on the request side. sanitize-filename and serialize-javascript appear to guard file and data handling. None of this is exotic, but it means the install pulls native modules, and sharp in particular is the dependency most likely to fail on an unusual platform.

config.conf is the file you will actually touch. The docker-compose.yml mounts it into the container alongside public/, which tells you both are meant to persist outside the image:

yaml volumes: - "./public:/home/node/app/public" - "./config.conf:/home/node/app/config.conf"

Because public/ is mounted, characters, backgrounds and uploaded images survive a container rebuild. Because config.conf is mounted, your backend choice and generation defaults survive too. The README does not document the individual keys in config.conf, so treat the shipped file as the reference and change one value at a time.

Installing TavernAI-v1 and starting a first chat

The README gives two paths. On Windows you run Start.bat, on Linux you run start-linux.sh, and on other systems you install dependencies and start the server yourself. Node.js is a prerequisite; the README links specific installers, including v21.3.0 for Windows 10 and later and v20.2.0 for Windows 7 x64 SP1. During the Node.js install on Windows, the README asks you to tick "Additional Build-Tools" and answer Yes to All when the tools script runs. That step exists because of the native dependencies described above.

For the manual route, run these two commands from the project directory:

bash npm install node server.js

npm install resolves the dependency tree from package.json, which is where sharp and the image libraries come from. node server.js starts the Express process. The README does not state a default port in the installation section, but the Dockerfile contains EXPOSE 8000 and docker-compose.yml maps "8000:8000", so 8000 is the port the containerised build expects.

If you would rather not manage Node.js locally, the repository ships a Dockerfile and a compose file. From the project root:

bash docker compose up

The compose file builds from the local Dockerfile, names the container tavernai, publishes port 8000 and restarts unless stopped. Once the server is up, open the interface in a browser, create a character, and point the connection settings at your running backend. The README's KoboldAI and NovelAI setup guides live in the project wiki rather than in the README itself, so the exact connection fields for those two backends are documented there and not in the main file.

One practical note from the README's tips: if a reply stops mid-sentence, send the request again or type "continue". The README says this depends on the model, which is an honest way of saying continuation handling is a property of the backend rather than something the frontend can guarantee.

Where TavernAI-v1 is the wrong tool

The clearest limitation is stated by the project itself. The README calls this a legacy repository and links to TavernAI 2. If you are starting fresh and have no reason to pin to the older line, the project's own documentation is telling you which repository it considers current.

The second limitation is the release cadence. The most recent tagged release in the list is @1.5.4 from 2024-03-05, preceded by @1.5.3 on 2024-01-22 and @1.5.2 on 2023-11-12. The last push to the repository was on 2026-06-16, so work has happened since that release, but the published version numbers stop in early 2024. Anyone who deploys from a tag rather than from main is running code that is more than two years behind the branch tip, and the README does not describe what changed in between.

The third limitation is operational. The README does not document rollback, backup or migration of the data under public/, and it does not describe what happens to existing character files when the code changes. Since docker-compose.yml mounts public/ as a host directory, that directory is your state, and the documentation does not tell you how to move it between versions safely.

Finally, consider the threat model. The application proxies requests to remote APIs using credentials you supply, and it accepts image uploads that it processes with sharp, png-chunks and webp-converter. The README does not describe a hardening guide, an authentication layer for the web interface, or a supported deployment pattern for exposing the server beyond localhost. If you need the interface reachable from the open internet, this repository gives you no documented answer for that.

TavernAI-v1 against SillyTavern

The obvious comparison is SillyTavern, the frontend that grew out of this lineage. Both are browser-based chat frontends that sit between you and a generation backend, and both support local and remote backends. The difference in approach is in how each project positions itself. TavernAI-v1 is a single Express application with its own server.js, its own routes/ directory and its own config.conf, and it ships Start.bat, Start.ps1, start-linux.sh and a Dockerfile as first-class entry points. The README frames it as a downloadable application you run.

SillyTavern's documentation, by contrast, describes it as a frontend that installs and updates through its own launcher scripts, with the update path treated as part of the product. That is the practical distinction: if you want to run a fixed, self-contained build and never think about updating it, TavernAI-v1's model is simple. If you want the frontend to track upstream changes without you re-downloading a zip, that is a different design goal.

The second difference is backend coverage as documented here. TavernAI-v1's README names KoboldAI, KoboldCpp, Horde, Oobabooga's Text Generation Web UI, OpenAI, NovelAI, Claude and Ollama. If your backend is on that list, the integration is claimed to exist. If it is not, this repository gives you no plugin mechanism to add it, because the backend handling lives in routes/ rather than in a documented extension point. That is a real constraint, not a preference.

Maintenance, licensing and the cost of staying on this branch

The repository is MIT licensed, which permits commercial and private use, modification and redistribution provided the copyright notice and permission notice are retained. That is the most permissive common option, and it means forking is legally straightforward. It does not mean the project will help you: an MIT licence carries no warranty and no support obligation, and nothing in the README promises either. This is a description of the licence text, not legal advice; if you are redistributing a modified build, have someone qualified read the terms.

The maintenance picture is mixed and worth stating plainly. The repository is not archived, and the last push was on 2026-06-16, so the branch is not abandoned. But the release list ends at @1.5.4 from 2024-03-05, and the README labels the repository legacy and redirects to TavernAI 2. Those two facts together describe a project that still receives commits while its documented version history has stopped. Anyone planning to depend on it should decide whether they are tracking main or a tag, because the two are far apart.

Upgrade cost follows from that split. There are no release notes for anything after 1.5.4, and the README does not describe a migration procedure for the public/ directory. In practice that leaves you diffing the tree yourself between whatever commit you deployed and whatever you deploy next. The dependency list adds a second cost: sharp, webp-converter and the png-chunks packages are native or binary-adjacent, so an upgrade can require rebuilding them, and the README's instruction to install Node.js build tools is the reason. On a pinned Docker image this is contained; on a bare Node.js install it is where upgrades tend to break.

Editorial conclusion

TavernAI-v1 suits people who want a self-hosted character chat UI over a local KoboldCpp or Ollama endpoint, and who accept that this repository is labelled legacy. It is the wrong choice if you want the version the maintainers direct new users to, or if you need documented upgrade notes, since the release list stops at 1.5.4 from 2024-03-05. Before installing, check that your Node.js version matches what the README links, and read config.conf to see which backend settings your build expects.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. TavernAI/TavernAI-v1 on GitHub