PandoraAI: a Nuxt 3 chat client that keeps every conversation in local storage

What PandoraAI actually is, and who it is built for

PandoraAI is a web chat client, not a model gateway. The README describes it as "a web chat client powered by node-chatgpt-api", and the repository is a Nuxt 3 application written in Vue 3. That split matters: the client renders conversations, manages presets and talks HTTP to an API server that you run yourself. The README says you may use it with other API server implementations "as long as the endpoints are compatible", so the coupling is to a request shape rather than to one binary.

The audience is people who already self-host the API layer. If you have node-chatgpt-api running and want a browser front end for it, PandoraAI gives you a client dropdown, per-client presets and a chat surface. The README lists support for what node-chatgpt-api supports, naming gpt-3.5-turbo, text-davinci-003, ChatGPT and Bing. It is not aimed at someone who wants to paste an OpenAI key into a hosted page and start typing; there is no hosted version described in the README, and the setup path assumes you control a server.

How the client, the API server and local storage fit together

The data flow is short. The browser loads the Nuxt app, which reads its configuration from an environment variable named API_BASE_URL, and sends chat requests to that base URL. Responses arrive as server-sent events: the dependency list includes @microsoft/fetch-event-source, which is the library used for streaming event sources over fetch rather than the browser's built-in EventSource. That is consistent with a streaming chat UI, and it is the main reason a plain reverse proxy in front of the API server has to leave the response unbuffered.

The state layer is Pinia, with @pinia/nuxt wiring it into Nuxt. Chat history and presets are kept in the browser's local storage, which the README states directly: "Everything is stored in local storage, so you can use this client without an account, and it can be imported or exported to other devices." That sentence carries both the appeal and the constraint. There is no server-side database to back up, and there is also no shared history between two browsers unless someone exports and imports it by hand.

Rendering is conventional for a chat app: marked for Markdown, highlight.js for code blocks, and isomorphic-dompurify to sanitize the HTML that comes out of the model. That last piece is worth noting because model output is untrusted input in a browser context. The repository also carries a Dockerfile and an .env.example, and the top-level entries include app.vue, components/, stores/, nuxt.config.js and tailwind.config.js, which is the layout you would expect from a small Nuxt 3 project rather than a monorepo.

Installing PandoraAI and getting a first reply

The README gives a two-part setup: install the client, then point it at a running API server. Start with the client dependencies. The README shows yarn, npm and pnpm variants; the npm one is below, and it installs the Nuxt 3 toolchain along with the runtime dependencies such as pinia, marked and highlight.js.

npm install

Next you need node-chatgpt-api's API server running. The README links to that project's API server section rather than repeating the steps, so the exact command lives there, not in this repository. Once it is up, copy the example environment file and set the base URL to wherever that server listens.

cp .env.example .env

API_BASE_URL=http://localhost:3000

That value is the one shipped in .env.example. If your API server runs on a different port or host, this is the line to change. Then start the development server, which the README says listens on http://localhost:3000.

npm run dev

Open the client and you should see the chat interface with a client dropdown. Pick a client or a preset and send a message; the reply streams in through the event-source fetch. For a production bundle the README gives npm run build followed by npm run preview to check it locally. One troubleshooting note comes straight from the README: if you pull the latest changes and get an empty white page, run nuxi upgrade --force and then npm run dev again.

The repository also ships a Dockerfile if you would rather not install Node locally. It is short and worth reading before you rely on it: it is based on node:16-alpine, copies the working directory, copies .env, runs npm install, exposes 3000 and 24678, and starts with npm run dev.

FROM node:16-alpine
WORKDIR /app
COPY . .
COPY .env .
RUN npm install
EXPOSE 3000 24678
CMD ["npm", "run", "dev"]

Two things stand out. The image runs the development server rather than a production build, and it copies .env into the image, which means your API base URL is baked into a layer. For a local trial that is fine. For anything long-lived, treat the Dockerfile as a starting point rather than a deployment recipe.

Where PandoraAI stops being the right tool

The local-storage model is the sharpest limitation. Conversations live in one browser profile. Two people cannot share a thread, a support team cannot audit what was asked, and clearing site data removes history. The README frames this positively, and for a single user on one machine it is a reasonable trade, but it rules out any multi-user deployment without adding a persistence layer that the project does not provide.

PandoraAI is also not a standalone chat app. It renders and stores; it does not talk to a model provider by itself. If the API server is down or the endpoints are not compatible, the client has nothing to say. The README is explicit that compatibility is the requirement, and it does not document a fallback mode, a mock server or an offline state. There is no rollback or migration story for local-storage schema changes either; the README documents export and import for moving data between devices, and nothing about what happens to stored presets when the stored format changes.

Finally, this is a client with no retrieved releases and a last push on 2026-05-29. The repository is not archived, but the README does not describe a release process, versioned artifacts or a changelog, so you are tracking the main branch. That is a real cost for anyone who wants a pinned version they can reproduce later.

How it differs from LibreChat and other self-hosted chat UIs

The obvious comparison is a self-hosted chat UI that bundles its own backend and database. LibreChat is the clearest example: it ships a server, a database and provider configuration in one deployment, so a single compose file can give you accounts, persisted conversations and provider keys managed server-side. PandoraAI takes the opposite approach. It keeps the UI thin, pushes all provider handling into node-chatgpt-api, and keeps user state in the browser.

The practical difference shows up in three places. Setup: LibreChat is one stack, PandoraAI is two processes plus an environment variable. Persistence: LibreChat stores conversations server-side, PandoraAI stores them per browser. Scope: LibreChat aims to be the whole application, while PandoraAI is explicitly a client that can point at any compatible endpoint. If you already run node-chatgpt-api for other reasons, PandoraAI is a small addition. If you are starting from nothing, you are choosing to maintain two services instead of one, and the second service is the one that holds your API credentials.

Licence, maintenance and what upgrades cost you

PandoraAI is MIT licensed, and the LICENSE file sits at the top level of the repository. MIT is permissive: it allows use, modification and redistribution with the copyright notice and permission notice retained. That is a statement about the licence text, not legal advice; if you redistribute the client inside a product, check how the notice is preserved and how node-chatgpt-api, which is a separate project with its own licence, is handled alongside it.

Upgrade cost is dominated by the front-end toolchain. package.json pins the Nuxt line at ^3.5.2, Vue is forced to latest through an overrides block, and the dev dependencies include eslint, tailwind and the PWA module. That combination means a fresh npm install can pull newer Vue than the rest of the tree was written against, which is exactly the class of drift the README's white-page note points at: run nuxi upgrade --force when the app breaks after pulling. Expect periodic dependency work rather than a stable pinned set.

There is no release history in the repository, so there is no upgrade path to follow other than pulling main and rebuilding. The last push was on 2026-05-29. For a personal client that is workable. For a team, it means owning the fork.

Editorial conclusion

Adopt PandoraAI if you already run node-chatgpt-api or a compatible endpoint and you want a browser client whose presets and history never leave the device, and you accept that the API server is a separate deployment you maintain. Skip it if you want a single install that talks to a model provider directly, or if several people need to share one conversation history, since everything lives in local storage per browser. Before committing, run the API server, set API_BASE_URL in .env, and confirm the client can list clients and stream a reply; also check whether the Dockerfile's npm run dev path fits your deployment, because it is the only container recipe in the repository.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. waylaidwanderer/PandoraAI on GitHub