AMC WebUI: a Gemini-first console that keeps your chats in IndexedDB

What AMC WebUI actually is, and who it is built for

The repository describes AMC WebUI as an All-in-one Model Console WebUI built on React 18, with Google Gemini's native capabilities as the primary path and an OpenAI-compatible standard chat mode as a secondary one. The audience is narrow and specific: a developer or power user who already holds a Gemini API key, wants Thinking traces, the Live API, the Files API, Deep Search, Google Search grounding, code execution and image generation behind one interface, and does not want to run a database.

The Local-First claim is the design centre. Chat data is stored in the browser's IndexedDB by default, so a static deployment on Pages or a CDN needs no persistence backend. The repository also supports a two-container deployment where a Node API service holds the Gemini key and proxies requests, which the README presents as the self-hosted option. Those are two different trust models sharing one codebase, and the project does not pretend otherwise.

The name is not expanded anywhere in the README. The only search question Google returns for this project is "What does AMC stand for in software?", which suggests the abbreviation is not well established in public usage. Treat AMC as the project's own label rather than a defined acronym.

Two request paths that stay deliberately separate

The architecture splits into a Gemini native mode and an OpenAI-compatible mode, and the split is enforced rather than cosmetic. Each mode keeps its own API key, its own base URL and its own model list. The README states explicitly that the OpenAI-compatible mode does not overwrite Gemini native configuration, and that the two sets of keys are stored separately.

The compatible path posts to `POST {Base URL}/chat/completions`. You supply the root, for example `https://api.openai.com/v1`, and the application appends the rest. Streaming and non-streaming responses are both supported, along with system prompts, `temperature` and `top_p`. What it does not carry is the Gemini toolchain: the README is direct that Gemini-exclusive capabilities remain on the native path. If you switch to the compatible mode expecting Live API or code execution to follow, they will not.

In the Docker layout the routing becomes concrete. The `web` container reverse-proxies `/api/*` to the `api` container, which serves `/api/gemini/*` for native requests, `/api/openai/*` for third-party compatible endpoints, and terminates the WebSocket upgrade on `/api/live` to bridge it to the Gemini Live endpoint. The `.env.example` exposes `ENABLE_LIVE_WS_PROXY`, defaulting to true, and `LIVE_WS_IDLE_TIMEOUT_MS`, defaulting to 300000. That idle timeout is worth noticing: a long, quiet Live session can be cut by the proxy rather than by the model.

Installing AMC WebUI and running a first Gemini chat

The README gives two installation routes. The standard development route recommends Node.js 26, with a `.nvmrc` in the repository and CI on the same major version; the minimum is Node.js 24, and the Docker images build on `node:24-slim`. The `engines` field in `package.json` is `>=24 <27` and `engine-strict` is enabled, so an install on Node 27 or Node 23 will fail outright rather than warn. Run `nvm use` first if you are unsure which version is active.

Clone, install and start the dev server:

# Clone and install
git clone https://github.com/yeahhe365/AMC-WebUI.git
cd AMC-WebUI
npm ci
npm run dev

The dev server listens on `http://localhost:5175`. Open it, then go to Settings, then API configuration, and paste your Gemini API key. Nothing else is required for a first chat.

If you would rather not type the key into the interface on every fresh browser profile, the README documents a root-level `.env.local` for frontend development only:

GEMINI_API_KEY=your_api_key_here
VITE_OPENAI_API_KEY=your_openai_compatible_key_here

To try the OpenAI-compatible path instead, switch API mode to OpenAI compatible in Settings, then API configuration, fill in the key (or rely on `VITE_OPENAI_API_KEY`), set the base URL to something like `https://api.openai.com/v1`, and edit the model list under Settings, then Models. The README also lists `https://generativelanguage.googleapis.com/v1beta/openai` as a Gemini-side compatible endpoint.

For the self-hosted route, build both bundles and bring up Compose:

npm run build:docker
docker compose up -d --build

The default entry point is `http://localhost:8080`. Note the ordering constraint the README states: the `web` image packages the `dist/` directory produced on the host, so any change to frontend or API code requires `npm run build:docker` before `docker compose up -d --build`. Skipping the build step means the container serves stale assets.

Where AMC WebUI is the wrong tool

The README contains an unusually blunt security boundary, and it should be read before anything else. The `web + api` proxy is positioned as a trusted, self-hosted deployment. In the default BYOK mode the browser's own API key is used for requests, and the README states that this is not sufficient on its own as an unauthenticated multi-user API gateway on the public internet. Opening it to the public requires authentication, quotas and rate limiting, abuse protection, audit logging and tenant isolation, none of which the project claims to ship.

There is a related trap in `SERVER_KEY_PRIORITY`. It defaults to false, meaning the browser key wins and the server key is only a fallback. If you set it to true, the server key takes priority across all three chains (Gemini, Live and third-party). That is a meaningful change in who pays and who is accountable, and it is a single boolean in `.env`.

The third-party routing has its own constraint. `THIRD_PARTY_ROUTES` takes a JSON object mapping provider IDs to `{ baseUrl, apiKey }`, and the `.env.example` comment restricts it to https and non-private hosts. That is a guard against using the proxy to reach internal services, not a general-purpose egress filter.

One more boundary sits on the Gemini side. The README's Robotics migration notice states that `gemini-robotics-er-2-preview` and similar endpoints require an API key that already has a restriction configured in AI Studio; an unrestricted key returns `403 Forbidden`. The model constant is centralised as `ROBOTICS_MODEL` in `src/constants/modelConfiguration.ts`. The README also suggests `thinking_level` default to `medium` for latency, reserving `high` for high-precision spatial tasks.

How the browser-side tooling compares to a server-hosted console

The closest alternative in spirit is a self-hosted chat front end such as LibreChat or Open WebUI, which keep conversations in a server-side database and treat the browser as a thin client. That difference drives almost everything else. A server-hosted console gives you accounts, shared history and a single place to hold credentials, and it inherits the operational cost of a database, migrations and backups.

AMC WebUI inverts that. History lives in IndexedDB, so there is nothing to back up on the server and nothing to leak from it, but your conversations are also tied to one browser profile. The README covers import and export of chat records, plus session grouping and full-text search across titles and content, which is the mitigation for that lock-in. It does not describe server-side sync of that data across devices.

The multi-tab story is more considered than most browser-only tools. The README states that cross-tab synchronisation uses BroadcastChannel, with Web Locks API guarding IndexedDB writes so concurrent tabs do not corrupt state. That is the right primitive for the problem, and it is the kind of detail that separates a browser-first design from a browser-only one.

The local Python sandbox is the other clear divergence. It runs on Pyodide compiled to WebAssembly, preloads numpy, pandas and matplotlib, detects dependencies and installs packages such as scipy or scikit-learn on demand, and captures matplotlib output. A server-hosted console would simply run Python on the host with full system access. The WASM sandbox trades that reach for isolation and zero setup, and the README frames it as a sandbox rather than a general execution environment.

Maintenance cadence, licence and the cost of upgrading

The repository is not archived, and the last push was on 2026-08-27. The release history shows v1.16.0 on 2026-08-22, v1.17.0 on 2026-08-23 and v1.18.0 on 2026-08-27, so the project was shipping in close succession through late August. The `package.json` version reads 1.21.0, ahead of the most recent release listed. That gap between the manifest version and the published release tag is worth checking against the releases page before you pin a version.

The licence is MIT, which permits commercial and private use and modification, and requires the copyright notice and permission notice to be preserved in copies or substantial portions. That is the standard obligation and it is stated here as a fact about the licence text, not as legal advice; if you redistribute a modified build, have your own counsel read the terms.

Upgrade cost is dominated by the Node version window rather than by API churn. `engines` is `>=24 <27` with `engine-strict` enabled, so a CI runner or developer machine outside that range fails at install time. The Docker images pin `node:24-slim`, and the README notes the CI main workflow uses the same major as the recommended Node 26. If you build the `web` image yourself, remember that it packages the host-generated `dist/`, so container rebuilds and frontend rebuilds are two steps, not one. The repository also ships `pnpm-lock.yaml` and declares `[email protected]` as the package manager while the README's installation instructions use `npm ci`; pick one and be consistent across your own tooling.

Editorial conclusion

Adopt AMC WebUI if you want one browser console for Gemini's native capabilities and are content with BYOK keys held in the browser. Do not adopt it as a public multi-user gateway: the README states the web + api proxy is scoped to trusted self-hosted deployment and says it is not sufficient without authentication, quotas, abuse protection, audit and tenant isolation. Before deploying, confirm your Node version satisfies the engines field (>=24 <27), check whether SERVER_KEY_PRIORITY should stay false, and decide if THIRD_PARTY_ROUTES should be set at all.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes