Your friendly, blazing-fast, self-hostable AI gateway.

You use AI coding tools — Claude Code, Cursor, Cline, or honestly anything that talks to OpenAI or Anthropic. And you know the headaches: a drawer full of API keys, rate limits that hit at the worst time, and a token bill that keeps creeping up.

KeiRouter is the smart middleman that makes all of that someone else's problem. Point your tools at one local endpoint and let it handle the boring stuff — routing each request to the right model, failing over the moment a provider taps out, caching repeat questions, and squeezing oversized prompts down before they ever cost you a token.

Oh, and it's written in Go. So it sips memory (~20 MB), boots instantly, ships as a single binary, and comes with a dashboard that's actually nice to look at. ✨

Heads up: KeiRouter is under active development. Peek at Architecture to see what's wired up today.

• Highlights
• Quick Start
  • Prerequisites
  • Pick your install
  • First login
  • Connect your tools
• Token Savings
• Smart Routing (Chains)
• Beyond Chat
• Connect via OAuth
• Plans & Budgets
• Rate Limiting
• Guardrails
• Branding & White-Label
• CLI Tools Auto-Config
• Usage Portal
• Supported Providers
• Configuration
• Architecture
• Security
• Development & Contributing
• License

Routing & reliability

• 🔀 One endpoint, every provider — Your apps speak OpenAI or Anthropic; KeiRouter quietly translates to whatever you actually want to use.
• 🛡️ Never stop coding — Provider down? Rate limited? Fallback chains keep you moving like nothing happened.
• ⚡ Semantic cache — Ask the same thing twice and the embedding-powered cache hands it back instantly, for a glorious $0.00.

Cost control

• 💸 Five token savers — Two on the way in, three on the way out, all on a live savings dashboard. Details in Token Savings.
• 💰 Budget engine — Per-key or per-org USD and token hard limits, with an auto-cutoff so surprise bills stay fictional.
• 🚦 Rate limiting — Per-key RPM, TPM, and concurrency caps via global defaults or reusable plans.
• 📋 Plans & templates — Set the rules once, slap them on any key.

Safety & governance

• 🛡️ Guardrails — PII, prompt-injection, toxicity, topics, and bias detectors layered global → provider → model → chain → key, with mid-stream output scanning and a fully-offline mode.
• 🔐 Locked down by default — AES-256-GCM envelope encryption for credentials, a password-gated dashboard, HMAC sessions, and SSRF protection on outbound calls.

Operations & UX

• 📊 See everything — Quota tracker, provider breakdowns, live key monitoring, TTFT metrics, and per-key summaries.
• 🎨 White-label it — Rebrand the dashboard and portal with your own name, logo, and palette.
• 🛠️ Skills & CLI auto-config — Built-in skills plus copy-paste configs for 12+ coding tools.
• 🌐 Usage portal — A no-admin-needed view so teammates can track their own usage and savings.

Grab whichever path matches what's already on your machine — no need to install things you won't use:

brew tap mydisha/keirouter https://github.com/mydisha/keirouter
brew install keirouter

keirouter -bootstrap   # mint your first API key (printed once — don't blink)
keirouter start        # fire up the server on :20180

curl -fsSL https://raw.githubusercontent.com/mydisha/keirouter/main/scripts/quickstart.sh | bash

curl -fsSL https://raw.githubusercontent.com/mydisha/keirouter/main/scripts/install.sh | bash -s -- --docker

git clone https://github.com/mydisha/keirouter.git
cd keirouter
cp .env.example .env       # set KEIROUTER_MASTER_KEY before going to prod
docker compose up -d --build

irm https://raw.githubusercontent.com/mydisha/keirouter/main/scripts/install.ps1 | iex

keirouter -bootstrap   # mint your first API key (printed once)
keirouter start        # start the server on :20180

It'll nudge you to change that password the second you log in (please do 🙏). Allergic to UIs? Mint a key straight from the terminal:

keirouter -bootstrap   # prints a kr_ key, once

In your AI tool of choice (Cursor, Claude Code, Cline, you name it), set:

• Base URL: http://localhost:20180/v1
• API Key: the kr_ key from the dashboard or -bootstrap
• Model: a provider model like openai/gpt-4o, or the name of a fallback chain you cooked up

That's it. You're routing.

Every request runs through a deterministic token-saving pipeline before it gets translated to the provider's format — so the savings work the same no matter which provider you land on. There are five savers, each independently toggleable from Settings → Token Saving, and a dashboard that shows you exactly how much you clawed back.

Terse and Caveman both inject a system directive, so they're mutually exclusive — pick one. Ponytail happily layers on top of either.

Pipeline order: normalizer → RTK → Headroom → Terse / Caveman → Ponytail → provider translation.

Headroom is its own open-source compression proxy. KeiRouter just calls its /v1/compress endpoint, so you spin it up locally first. One gotcha worth shouting about: the headroom CLI lives in the Python package — the npm package is a library only, so npm install -g headroom-ai will leave you staring at command not found. Don't say we didn't warn you. 😉

# The clean way: pipx isolates the CLI and sorts out your PATH (needs Python 3.10+)
pipx install "headroom-ai[all]"
pipx ensurepath               # puts headroom on your PATH — then restart your shell

headroom proxy --port 8787    # start the proxy
headroom doctor               # make sure it's actually happy

On Ubuntu and pip is fighting you (PEP 668 blocks global installs)? Go --user and make sure ~/.local/bin is on your PATH:

pip install --user "headroom-ai[all]"
export PATH="$HOME/.local/bin:$PATH"   # drop this in ~/.zshrc or ~/.bashrc

Then over in Settings → Token Saving → Headroom: flip it on, set the Proxy URL to http://localhost:8787, and hit Test connection to confirm the handshake. Green check? You're golden.

Why bet on one model when you can have a backup plan? Build a chain in the dashboard. Say you name one coding:

1. openai/gpt-4o — your first pick
2. deepseek/deepseek-chat — steps in if the first one rate-limits or face-plants

Then just set your app's model to chain:coding (or plain coding) and let KeiRouter sweat the failover.

Chat completions are just the start. KeiRouter proxies the whole buffet:

Copy-pasting API keys gets old fast. Connect providers straight from the Connections page with OAuth — sign in once, and KeiRouter quietly refreshes your tokens in the background.

Plans are reusable budget policies you can stamp onto any API key — write the rules once, apply them everywhere. Each plan covers:

• Spend limit — USD cap (micro-dollar precision, because pennies add up)
• Token limit — max token usage
• RPM / TPM / Concurrency limits — per assigned key (0 = unlimited)
• Reset period — daily, weekly, monthly, or total
• Allowed models — wildcard patterns like claude-*, gpt-4* (empty = everything's fair game)
• Alert threshold — get pinged at 1–100% of budget
• Hard cutoff — block requests when the budget's gone, or just track and let it ride

Every tenant gets a default plan out of the box. Manage them on the Plans page and assign them in Keys settings.

Keep your gateway (and your upstream quotas) from getting hammered with per-key RPM, TPM, and concurrency caps. For a single-instance setup, the in-memory limiter is all you need:

limits:
  enabled: true
  backend: memory
  default_rpm: 600
  default_tpm: 200000
  default_concurrency: 50
  window: 1m
  cleanup_interval: 1m

Those defaults only apply to keys without a plan. The moment a key has one, the plan's rpm_limit, tpm_limit, and concurrency_limit take over (0 = unlimited).

A built-in content-safety layer runs detectors against every request and response. Policies stack global → provider → model → chain → API key and merge at request time, so the most specific rule wins.

• Actions: log_only, warn, mask (rewrite it), or block (refuse it). Strictest action across detectors wins.
• PII strategies: redact, replace, mask, hash, anonymize, or block.
• Streaming-safe: a sliding 256-char buffer scans assistant output as it streams and pulls the plug mid-sentence if something leaks.
• Observability: every decision shows up in Audit Logs (live via SSE); Prometheus serves keirouter_guardrail_decisions_total and keirouter_guardrail_eval_seconds at /metrics.
• Compliance: a per-tenant allow_external_engines flag forces every detector offline; KEIROUTER_GUARDRAILS__AUDIT_RETENTION_DAYS controls retention; the test endpoint is capped at 10 req/min.

Starter templates ship in the dashboard's "From template" picker (Indonesia PII · Strict safety · Compliance audit · Public chatbot · Alerts-only), and you can export/import policies as a JSON bundle.

Want NER-based PII detection (PERSON, LOCATION, full multilingual)? Spin up the optional Presidio sidecar:

docker compose -f compose.yaml -f compose.postgres.yaml -f compose.presidio.yaml up -d

Then flip any PII policy's engine to presidio in the dashboard.

Rebrand the admin dashboard and the public Usage Portal from Settings → Branding:

• App name — swap "KeiRouter" for your own
• Logo & favicon URLs — your SVG/PNG, your vibe
• Tagline — the line on the portal login screen
• Color palette — sage-terra, ocean, midnight, and friends

The CLI Tools page spits out ready-to-paste config snippets for the usual suspects:

Claude Code · Cursor · Cline · GitHub Copilot · DeepSeek · KiloCode · OpenCode · OpenClaw · Hermes · JCode · Droid · CodeBuddy

Copy, paste into your tool's config, done.

A dedicated, no-admin-required view at /portal where teammates keep an eye on their own usage — quota and spend, token usage over time, compression savings, and plan limits. All it asks for is the API key. No keys to the kingdom required.

🧠 LLM / Chat

🎨 Media & Search

Out of the box, KeiRouter runs on an embedded SQLite database — zero config, zero fuss. Running it for a team? Switch to PostgreSQL: copy config.example.yaml and run with -config, or use environment variables like KEIROUTER_SERVER__PORT=8080. Docker/Coolify examples are in deploy/README.md.

Curious what happens after you hit send? Here's the life of a request:

1. Gateway — takes your HTTP request and figures out the dialect (OpenAI, Anthropic, Gemini, …).
2. Guardrails (inbound) — runs PII / injection / toxicity / topics detectors; block → refuse, mask → rewrite the prompt on the spot.
3. Pipeline — runs the token savers (RTK → Headroom → Terse/Caveman → Ponytail) and checks your budget.
4. Dispatch — picks the best provider account and juggles fallbacks.
5. Connector & Transform — calls the provider, then translates the answer back into your tool's format.
6. Guardrails (outbound) — scans the response (or each stream chunk) for leaked PII, bias, or toxicity; block → cancel, mask → rewrite.
7. Meter — logs token usage and savings so the dashboard has something pretty to show.

• The admin API (/api/*) only listens to localhost by default. Exposing it? Put it behind a reverse proxy and set a stable master_key.
• Guard your master key with your life — it's the root of trust for every encrypted credential.
• Credentials sit behind AES-256-GCM envelope encryption; the dashboard uses password auth + HMAC session cookies; outbound requests get SSRF protection.

Found a security issue? Please follow SECURITY.md instead of opening a public issue. 🙏

make setup   # first time: installs deps + starts backend (:20180) and dashboard (:5180)
make dev     # after that: just start the servers
make test    # run the backend test suite
make build   # build the backend binary + frontend assets

PRs and ideas are always welcome — start with CONTRIBUTING.md.

MIT — see LICENSE. Go build something cool. 🛠️