{"slug": "aurora-ai-gateway-fork-for-multi-ip-setups-55x-faster-than-litellm", "title": "Aurora: AI gateway fork for multi-IP setups, 55x faster than LiteLLM", "summary": "A developer known as entitybtw has released Aurora, a self-hosted AI gateway fork of aurorallm/aurora that claims to be 55x faster than LiteLLM and supports 14 provider types with OpenAI and Anthropic compatibility. The fork adds a redesigned dashboard, provider CRUD, fallback chains, provider pools, and a Session Hub, all managed via UI with persistence across restarts. The project is written in Go, licensed under Apache 2.0, and is available as a Docker image `entbtw/aurora`.", "body_md": "**One API for every AI provider. Self-hosted. No vendor lock-in.**\n\n14 provider types • OpenAI & Anthropic compatible • Go • Apache 2.0 • Built for raw speed\n\nFull guides, written for this fork.\n\n| Guide | What it covers | \n|---|---|\n| [Getting Started](/entitybtw/aurora/blob/main/documentation/GETTING_STARTED.md) | first run, build, config, basic usage, OpenAI-compatible client | \n| [Deployment](/entitybtw/aurora/blob/main/documentation/DEPLOYMENT.md) | Docker / Docker Compose, persistent state files, multi-IP host networking | \n| [Multi-account pools](/entitybtw/aurora/blob/main/documentation/MULTI_ACCOUNT.md) | end-to-end: load-balanced accounts with distinct, stable client identities | \n| [Session Hub](/entitybtw/aurora/blob/main/documentation/SESSION_HUB.md) | header transformation & session mapping engine, header modes, API reference, dashboard | \n| [Docker image](/entitybtw/aurora/blob/main/documentation/DOCKER_PUSH.md) | published image `entbtw/aurora` , tags, how to build & publish | \n\n**Quick deploy:**\n\n```\ndocker pull entbtw/aurora:latest\ndocker run -d --name aurora -p 8080:8080 -e AURORA_MASTER_KEY=\"your-secure-key\" entbtw/aurora:latest\n```\n\nSee [Deployment](/entitybtw/aurora/blob/main/documentation/DEPLOYMENT.md) for production (persistent config & state, `network_mode: host` for multi-IP).\n\nDashboard-driven operations — no more `.env`-only workflows for the things you change most. Everything below is managed from the UI and **persists across restarts**.\n\n**Warning:** This fork contains custom features not present in the original [aurorallm/aurora](https://github.com/aurorallm/aurora). Some features (dashboard redesign, session hub, UI enhancements) were vibecoded and may contain rough edges. Designed for advanced API integration workflows — use at your own discretion.\n\n- **Redesigned dashboard** — full**Catppuccin** theme, mobile-responsive, compact/touch-friendly layout, clean auth/logo/sidebar, shared`SearchInput` fix in audit logs & usage.\n- **Provider CRUD** — manage providers from the UI (base URL, API key, models, type). Per-provider`bind_ip` ,`pool_only` , runtime enable/disable, live rename, duplicate protection. Status shows if a key is set**without exposing it** . OpenRouter list is now an**allowlist** ;**vLLM** type added to the dashboard (was`.env` -only).\n- **Custom User-Agent** — set a custom`User-Agent` header per provider for upstream attribution (e.g. OpenRouter recommends this for credits).\n- **Auto-fetch models toggle** — disable automatic`/models` discovery per provider to use only explicitly configured model lists.\n- **Fallback chains** — edit rules in the UI, applied at**runtime** ; callable by name, exposed in`/v1/models` , order preserved on toggle/edit/delete.\n- **Provider pools** — create/edit/delete with member selection and**weighted / round-robin** strategies; health-aware members,`pool_only` models, live registry rebuild.\n- **Response headers** — configurable`X-Actual-Provider` /`X-Actual-Model` /`X-Requested` /`X-Fallback-Chain` , per-header toggles, custom headers, success/error/always modes, emitted on`429` /`401` .\n- **Persistence** — state saved to`configs/provider-overrides.json` ,`configs/pool-overrides.json` ,`configs/fallback.json` (env-overridable); Docker volumes keep it across recreation.\n- **Session Hub** — header transformation engine with per-provider/pool session mapping, inbound→outbound unique ID generation, disk persistence with live toggle, and pool-aware binding via UI (see[Session Hub](#session-hub) below).\n\nAurora sits between your app and LLM providers. Your app sends requests using the standard OpenAI or Anthropic SDK — Aurora routes them to whichever provider you've configured. One format handles everything — you dont need to worry about provider-specific formats.\n\n```\n# Before: hardcoded provider\nclient = OpenAI(base_url=\"https://api.openai.com/v1\", api_key=\"sk-...\")\n\n# After: Aurora Gateway\nclient = OpenAI(base_url=\"http://localhost:8080/v1\", api_key=\"your-aurora-key\")\n```\n\nNo SDK changes. No format changes. Just swap the `base_url`.\n\n- **14 provider types** — OpenAI, Anthropic, Gemini, Groq, DeepSeek, OpenRouter, xAI, Z.ai, MiniMax, Azure OpenAI, Oracle, Ollama, vLLM, Jina\n- **Auto-discovery** — set an API key as an env var, restart, provider + all its models appear automatically\n- **Auto-fetch toggle** — disable per-provider model auto-discovery to use only explicitly configured model lists\n- **Custom User-Agent** — set a custom`User-Agent` header per provider for upstream attribution or branding\n- **Provider pools** — group multiple keys/endpoints, load-balance with round-robin or weighted distribution, health-aware failover\n- **Model aliases** — rename/remap any model to a custom identifier across the entire gateway\n- **Model overrides** — enable or disable specific models per user path, persisted via dashboard or`user_pricing.yaml`\n- **Fallback** — automatic failover on 5xx/429, or manual rules (from config or external JSON) mapping failed provider+model to backups\n- **Resilience** — exponential backoff with jitter, circuit breaker per provider (closed → open → half-open), per-provider override of global retry/circuit-breaker settings\n- **Multiple instances** — run`OPENAI_EAST_API_KEY` and`OPENAI_WEST_API_KEY` as separate providers\n- **Custom base URLs** — override any provider's endpoint (corporate proxies, regional endpoints)\n- **Passthrough** —`/p/{provider}/*` for full upstream API access (not just chat completions); filter which provider types get passthrough routes\n- **Config-driven workflows** — per-request routing, caching, guardrail, audit, usage, budget, and fallback behavior controlled by persisted workflow documents\n\n- **OpenAI-compatible** —`/v1/chat/completions` ,`/v1/embeddings` ,`/v1/rerank` ,`/v1/models` ,`/v1/files` ,`/v1/batches`\n- **Responses API** —`/v1/responses` with full CRUD, cancel, input items, compact\n- **Anthropic-compatible** —`/v1/messages` ,`/v1/messages/count_tokens` (native Anthropic wire format); optional dedicated ingress at`/v1/messages`\n- **Streaming** — SSE streaming for all endpoints, preserved end-to-end\n- **Keep-only-aliases mode** — hide raw provider models from`/v1/models` and expose only aliased names\n- **Configured provider models mode** —`fallback` (add listed models to auto-discovered) or`allowlist` (only serve explicitly listed models)\n\n- **Exact cache** — SHA-256 hash match on request, Redis-backed, async writes\n- **Semantic cache** — vector similarity with configurable threshold, supports Qdrant, pgvector, Pinecone, Weaviate\n- **Prompt cache** — forwards`cache_control` to Anthropic/OpenAI/Gemini native prompt caching; configurable modes (`auto` ,`manual` ,`off` ), component toggles, and minimum token threshold\n- **Model registry cache** — local filesystem + Redis, offline-safe; supports vendored JSON snapshots with per-field user pricing overrides\n\n- **Master key** — top-level gateway auth\n- **Managed API keys** — scoped, rate-limited, per-key model authorization, usage stats\n- **Rate limiting** — per-key rate limiting backed by in-memory or Redis\n- **PII redaction** — email, phone, SSN, credit card detection and masking\n- **Prompt injection blocking** — detects and blocks injection attempts\n- **System prompt protection** — inject, override, or decorate system prompts\n- **Regex blocking** — custom pattern matching with block or sanitize actions\n- **Length limits** — character/token count enforcement on requests\n- **LLM-based altering** — guardrail that rewrites message content via an auxiliary LLM call (anonymization, custom prompts)\n- **Guardrail direction & ordering** — run before provider dispatch (`input` ), after response (`output` ), or both; same-order guardrails run in parallel\n- **Batch guardrails** — apply configured guardrails to inline items in`/v1/batches` requests\n\n- **Audit logging** — full request/response capture, buffered writes, configurable retention (body/header logging, buffer size, flush interval), live SSE stream\n- **Usage analytics** — per-model token counting, cost tracking, daily aggregation by model/user-path, pricing recalculation action\n- **Prometheus metrics** —`aurora_requests_total` ,`aurora_request_duration_seconds` ,`aurora_requests_in_flight` , plus gateway phase timing\n- **Admin dashboard** — React SPA built into the Go binary (Catppuccin, fully mobile-responsive): full provider CRUD, fallback chains, provider pools, response-header config, plus models, aliases, guardrails, cache, usage, audit, auth keys, workflows, console, playground\n- **pprof endpoints** — Go runtime profiling at`/debug/pprof/*` (heap, goroutine, mutex, block, threadcreate)\n- **Structured logging** — configurable format (JSON/text), level (debug/info/warn/error), source info, service metadata\n\n- **Token saver** — policy-driven output compression (profiles: concise, caveman, ultra, wenyan); scoped to specific models/providers via include/exclude filters; configurable on-error behavior (allow/block)\n- **Pricing management** — per-model pricing overrides, recalculation, import/export\n- **Usage budgets** — per-key usage tracking and limits, per-request budget enforcement via workflow feature flags\n\n- **Single binary** —`docker pull entbtw/aurora` (this fork) or run from source with Go\n- **CLI** — run from source, or drive via config files + the dashboard\n- **CLI tools API** — admin REST endpoints for CLI configuration sync, gated separately\n- **Swagger docs** —`/swagger/index.html` (build-tag gated)\n- **Config profiles** — pre-built configs for local, local-power, and team deployments\n- **3-layer config** — code defaults → config.yaml → env vars (env vars win)\n\nHeader transformation engine for API integration workflows where upstream services require unique client identifiers per account.\n\n- **Per-provider/pool binding** — attach transformation rules to specific providers, pools, fallbacks, or all targets (`*` )\n- **6 header modes** —`map` (stable inbound→outbound per provider),`generate` (fresh ID each request),`passthrough` ,`static` ,`random_from_list` ,`remove`\n- **Pool-aware** — rules bound to a pool automatically apply to all member providers\n- **Inbound header forwarding** — client session headers are forwarded through the translation layer so`map` mode works even when the provider path drops arbitrary inbound headers\n- **Lock-free hot path** —`Apply()` is a single atomic map read; benchmarked at ~495 ns/op (negligible)\n- **Persistent or in-memory** — toggled live via API or dashboard (`PUT /admin/api/v1/sessionhub/storage {\"mode\":\"disk\"}` )\n- **Dashboard UI** — Settings → Session Hub: binding overview from live server targets (pools/providers), add rule by selecting target, live mapping viewer, storage toggle\n\n1. Client sends request to Aurora (e.g. with `x-opencode-session: ses_abc123` )\n2. Gateway intercepts the inbound session header and stores it in request context\n3. Request is routed to a pool member (e.g. `opencode-zen` →`vllm-zen-backup` )\n4. Provider's outbound `headerSetter` fires: session hub applies rules for that provider/pool\n5. `map` mode: inbound`ses_abc123` → unique outbound`ses_xR4f8k2m...` per provider (stable, deduplicated)\n6. `generate` mode: fresh random`ses_...` per request (always unique)\n7. Additional headers (`x-opencode-client` ,`user-agent` ) are injected per rule\n8. Outbound request goes to upstream with transformed headers\n\nRules are persisted in `configs/session-hub-rules.yaml` (gitignored). Live edits via API or dashboard are auto-saved.\n\n```\nenabled: true\nmapping_storage: disk          # \"memory\" or \"disk\"\nproviders:\n  opencode-zen:                # matches pool name or provider name\n    enabled: true\n    headers:\n      - name: x-opencode-session\n        mode: map              # stable inbound→outbound per provider\n        prefix: \"ses_\"\n        length: 28\n      - name: x-opencode-client\n        mode: static\n        value: cli\n      - name: user-agent\n        mode: static\n        value: \"opencode/1.18.26 ai-sdk/openai/2.0.0 runtime/bun/1.0.0\"\n```\n\n| Method | Endpoint | Description | \n|---|---|---|\n| `GET` | `/admin/api/v1/sessionhub/status` | Stats + `storage_mode` | \n| `GET` | `/admin/api/v1/sessionhub/providers` | List bound rules | \n| `POST` | `/admin/api/v1/sessionhub/providers` | Create rule | \n| `PUT` | `/admin/api/v1/sessionhub/providers/:name` | Update rule | \n| `DELETE` | `/admin/api/v1/sessionhub/providers/:name` | Delete rule | \n| `GET` | `/admin/api/v1/sessionhub/mappings` | List live mappings | \n| `DELETE` | `/admin/api/v1/sessionhub/mappings` | Clear all mappings | \n| `PUT` | `/admin/api/v1/sessionhub/storage` | Toggle `memory` /`disk` | \n| `POST` | `/admin/api/v1/sessionhub/apply` | Test transform | \n\n| Mode | Behavior | \n|---|---|\n| `map` | First request generates unique outbound value per provider; subsequent requests with same inbound reuse it | \n| `generate` | Fresh random value every request | \n| `passthrough` | Original value forwarded unchanged | \n| `static` | Fixed value (set `value:` ) | \n| `random_from_list` | Random pick from `values:` list | \n| `remove` | Strip header entirely | \n\nStart routing AI traffic in 60 seconds.\n\n**Recommended — Docker (published image):**\n\n```\ndocker pull entbtw/aurora:latest\ndocker run -d --name aurora -p 8080:8080 -e AURORA_MASTER_KEY=\"your-secure-key\" entbtw/aurora:latest\n```\n\nFull examples below. For production (persistent state, multi-IP) see the [Deployment guide](/entitybtw/aurora/blob/main/documentation/DEPLOYMENT.md).\n\nThe quickest way to configure providers from scratch is the dashboard: **[http://localhost:8080/admin/dashboard](http://localhost:8080/admin/dashboard) → Providers → Add provider**. For env-var driven setups:\n\n## Linux / macOS\n\n```\nAURORA_MASTER_KEY=your-secure-key \\\n  OPENAI_API_KEY=sk-... \\\n  ANTHROPIC_API_KEY=sk-ant-... \\\n  GEMINI_API_KEY=... \\\n  GROQ_API_KEY=gsk_... \\\n  DEEPSEEK_API_KEY=... \\\n  OPENROUTER_API_KEY=... \\\n  XAI_API_KEY=... \\\n  ZAI_API_KEY=... \\\n  MINIMAX_API_KEY=... \\\n  AZURE_API_KEY=... \\\n  ORACLE_API_KEY=... \\\n  OLLAMA_API_KEY=... \\\n  VLLM_API_KEY=... \\\n  JINA_API_KEY=... \\\n  LOGGING_ENABLED=true \\\n  METRICS_ENABLED=true \\\n  GUARDRAILS_ENABLED=true \\\n  TOKEN_SAVER_ENABLED=true \\\n  aurora\n```\n\n## Windows PowerShell\n\n```\n$env:AURORA_MASTER_KEY=\"your-secure-key\"; `\n$env:OPENAI_API_KEY=\"sk-...\"; `\n$env:ANTHROPIC_API_KEY=\"sk-ant-...\"; `\n$env:GEMINI_API_KEY=\"...\"; `\n$env:GROQ_API_KEY=\"gsk_...\"; `\n$env:DEEPSEEK_API_KEY=\"...\"; `\n$env:OPENROUTER_API_KEY=\"...\"; `\n$env:XAI_API_KEY=\"...\"; `\n$env:ZAI_API_KEY=\"...\"; `\n$env:MINIMAX_API_KEY=\"...\"; `\n$env:AZURE_API_KEY=\"...\"; `\n$env:ORACLE_API_KEY=\"...\"; `\n$env:OLLAMA_API_KEY=\"...\"; `\n$env:VLLM_API_KEY=\"...\"; `\n$env:JINA_API_KEY=\"...\"; `\n$env:LOGGING_ENABLED=\"true\"; `\n$env:METRICS_ENABLED=\"true\"; `\n$env:GUARDRAILS_ENABLED=\"true\"; `\n$env:TOKEN_SAVER_ENABLED=\"true\"; `\naurora\n```\n\n## Windows CMD\n\n```\nset AURORA_MASTER_KEY=your-secure-key ^\n  && set OPENAI_API_KEY=sk-... ^\n  && set ANTHROPIC_API_KEY=sk-ant-... ^\n  && set GEMINI_API_KEY=... ^\n  && set GROQ_API_KEY=gsk_... ^\n  && set DEEPSEEK_API_KEY=... ^\n  && set OPENROUTER_API_KEY=... ^\n  && set XAI_API_KEY=... ^\n  && set ZAI_API_KEY=... ^\n  && set MINIMAX_API_KEY=... ^\n  && set AZURE_API_KEY=... ^\n  && set ORACLE_API_KEY=... ^\n  && set OLLAMA_API_KEY=... ^\n  && set VLLM_API_KEY=... ^\n  && set JINA_API_KEY=... ^\n  && set LOGGING_ENABLED=true ^\n  && set METRICS_ENABLED=true ^\n  && set GUARDRAILS_ENABLED=true ^\n  && set TOKEN_SAVER_ENABLED=true ^\n  && aurora\n```\n\nPublished image: **`entbtw/aurora`** · tags `latest`, `v1.0.0`.\n\n```\ndocker pull entbtw/aurora:latest\ndocker run -d --name aurora -p 8080:8080 \\\n  -e AURORA_MASTER_KEY=\"your-secure-key\" \\\n  -e OPENAI_API_KEY=\"sk-...\" \\\n  -e ANTHROPIC_API_KEY=\"sk-ant-...\" \\\n  -e GEMINI_API_KEY=\"...\" \\\n  -e GROQ_API_KEY=\"gsk_...\" \\\n  -e DEEPSEEK_API_KEY=\"...\" \\\n  -e OPENROUTER_API_KEY=\"...\" \\\n  -e XAI_API_KEY=\"...\" \\\n  -e ZAI_API_KEY=\"...\" \\\n  -e MINIMAX_API_KEY=\"...\" \\\n  -e AZURE_API_KEY=\"...\" \\\n  -e ORACLE_API_KEY=\"...\" \\\n  -e OLLAMA_API_KEY=\"...\" \\\n  -e VLLM_API_KEY=\"...\" \\\n  -e JINA_API_KEY=\"...\" \\\n  -e LOGGING_ENABLED=true \\\n  -e METRICS_ENABLED=true \\\n  -e GUARDRAILS_ENABLED=true \\\n  -e TOKEN_SAVER_ENABLED=true \\\n  entbtw/aurora:latest\n```\n\nFor production setups (persistent config/state, multi-IP host networking) see the [Deployment guide](/entitybtw/aurora/blob/main/documentation/DEPLOYMENT.md).\n\nAfter starting, confirm the gateway is up and the dashboard loads:\n\n```\n# Health check\ncurl -s http://localhost:8080/health\n\n# Dashboard\nopen http://localhost:8080/admin/dashboard\n\n# Session Hub status (should show storage_mode: disk or memory)\ncurl -s http://localhost:8080/admin/api/v1/sessionhub/status \\\n  -H \"Authorization: Bearer your-master-key\"\n```\n\nIf health returns `{\"status\":\"ok\"}` — the gateway is running. Now add a provider via the dashboard or env vars, then test a model call:\n\n```\n# OpenAI format\ncurl http://localhost:8080/v1/chat/completions \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer your-master-key\" \\\n  -d '{\"model\":\"groq/llama-4-scout-17b-16e-instruct\",\"messages\":[{\"role\":\"user\",\"content\":\"Hello!\"}]}'\n\n# Anthropic format with streaming\ncurl http://localhost:8080/v1/messages \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer your-master-key\" \\\n  -H \"anthropic-version: 2023-06-01\" \\\n  -d '{\n    \"model\": \"anthropic/claude-sonnet-5-20260630\",\n    \"max_tokens\": 1024,\n    \"stream\": true,\n    \"messages\": [{\"role\": \"user\", \"content\": \"Hello!\"}]\n  }'\n\n# Embeddings\ncurl http://localhost:8080/v1/embeddings \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer your-master-key\" \\\n  -d '{\"model\":\"openai/text-embedding-3-small\",\"input\":\"Hello world\"}'\n\n# Reranking (Jina)\ncurl http://localhost:8080/v1/rerank \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer your-master-key\" \\\n  -d '{\"model\":\"jina/jina-reranker-v2-base-multilingual\",\"query\":\"test\",\"documents\":[\"doc1\",\"doc2\"]}'\n```\n\nDashboard: `http://localhost:8080/admin/dashboard`\n\n**Docs (this fork):** [Getting Started](/entitybtw/aurora/blob/main/documentation/GETTING_STARTED.md) · [Deployment](/entitybtw/aurora/blob/main/documentation/DEPLOYMENT.md) · [Session Hub](/entitybtw/aurora/blob/main/documentation/SESSION_HUB.md) · [Docker image](/entitybtw/aurora/blob/main/documentation/DOCKER_PUSH.md)\n\n**Source:** [github.com/entitybtw/aurora](https://github.com/entitybtw/aurora) · **Image:** [hub.docker.com/r/entbtw/aurora](https://hub.docker.com/r/entbtw/aurora)\n\nBase project (upstream): [aurorallm/aurora](https://github.com/aurorallm/aurora) · [aurorallm.online/docs](https://aurorallm.online/docs)\n\nProviders are **auto-discovered from environment variables**. Set any provider's `_API_KEY` and restart — the provider and its default models appear automatically.\n\n**Security note:** The env var names below are documentation references. Actual secrets go into your **`.env` file** (in `.gitignore`) or your **deployment secrets manager** — never commit them.\n\n| Provider | Env var | Default base URL | Requires base URL | API key required | Default models | \n|---|---|---|---|---|---|\n| OpenAI | `OPENAI_API_KEY` | `https://api.openai.com/v1` | No | Yes | `gpt-5.6-sol` ,`gpt-5.6-luna` | \n| Anthropic | `ANTHROPIC_API_KEY` | `https://api.anthropic.com/v1` | No | Yes | `claude-sonnet-5` ,`claude-fable-5` | \n| Google Gemini | `GEMINI_API_KEY` | `https://generativelanguage.googleapis.com/v1beta/openai` | No | Yes | `gemini-3.1-pro` ,`gemini-3.5-flash` | \n| Groq | `GROQ_API_KEY` | `https://api.groq.com/openai/v1` | No | Yes | `llama-4-scout-17b` ,`llama-4-maverick-17b` ,`qwen3-32b` | \n| DeepSeek | `DEEPSEEK_API_KEY` | `https://api.deepseek.com` | No | Yes | `deepseek-v4-pro` ,`deepseek-v4-flash` | \n| OpenRouter | `OPENROUTER_API_KEY` | `https://openrouter.ai/api/v1` | No | Yes | 300+ models | \n| xAI (Grok) | `XAI_API_KEY` | `https://api.x.ai/v1` | No | Yes | `grok-4.5` ,`grok-4.3` | \n| Z.ai | `ZAI_API_KEY` | `https://api.z.ai/api/paas/v4` | No | Yes | `glm-5.2` | \n| MiniMax | `MINIMAX_API_KEY` | `https://api.minimax.io/v1` | No | Yes | `minimax-m3` | \n| Azure OpenAI | `AZURE_API_KEY` | — | **Yes** | Yes | Your deployments | \n| Oracle | `ORACLE_API_KEY` | — | **Yes** | Yes | `cohere.command-r-plus` | \n| Ollama | `OLLAMA_API_KEY` | `http://localhost:11434/v1` | No | **No** (optional) | Any local model | \n| vLLM | `VLLM_API_KEY` | `http://localhost:8000/v1` | No | **No** (optional) | Any served model | \n| Jina (reranker) | `JINA_API_KEY` | — | **Yes** | Yes | `jina-embeddings-v3` | \n\nEvery provider supports `*_MODELS` to override auto-discovered models:\n\n```\nOPENAI_MODELS=gpt-5.6-sol,gpt-5.6-terra,gpt-5.6-luna\n```\n\nCustom base URL:\n\n```\nOPENAI_BASE_URL=https://my-corp-openai-proxy.example.com/v1\n```\n\nYAML provider config supports additional options:\n\n```\nproviders:\n  openai:\n    type: openai\n    api_key: \"${OPENAI_API_KEY}\"\n    base_url: \"https://api.openai.com/v1\"\n    # Custom User-Agent header for upstream attribution\n    user_agent: \"MyApp/1.0\"\n    # Disable auto-fetching models from /models endpoint (use only configured list)\n    auto_fetch_models: false\n    models:\n      - gpt-4o\n      - gpt-4o-mini\n```\n\nMultiple instances of the same provider (underscores become hyphens in the provider name):\n\n```\nOPENAI_EAST_API_KEY=sk-...     # → provider: openai-east\nOPENAI_WEST_API_KEY=sk-...     # → provider: openai-west\n```\n\nAzure requires API version:\n\n```\nAZURE_API_VERSION=2024-10-21\n```\n\nOpenRouter extras:\n\n```\nOPENROUTER_SITE_URL=https://github.com/entitybtw/aurora\nOPENROUTER_APP_NAME=Aurora Gateway\n```\n\nThe gateway loads settings in this priority order (later wins):\n\n```\ncode defaults → config.yaml → .env / environment variables\n```\n\nGenerated by `aurora init`, every section of `config.yaml` is documented inline:\n\n| Section | What it controls | \n|---|---|\n| `server` | Port, base path, master key, passthrough, Anthropic ingress | \n| `admin` | Dashboard API and UI | \n| `models` | Discovery, overrides, allowlisting | \n| `storage` | SQLite (default), PostgreSQL, or MongoDB | \n| `logging` | Audit logging of requests/responses | \n| `usage` | Token tracking, pricing, retention | \n| `metrics` | Prometheus endpoint | \n| `guardrails` | Content safety filters | \n| `cache` | Model cache, response cache (exact + semantic) | \n| `combos` | Multi-model combo definitions | \n| `token_saver` | Output compression | \n| `fallback` | Provider failover rules | \n| `resilience` | Retry + circuit breaker | \n| `workflows` | Policy-based request routing | \n\nPre-built configs in `configs/editions/`:\n\n| Profile | File | Use case | \n|---|---|---|\n| OSS | `oss.env.example` | Minimal local — SQLite, no Redis | \n| OSS Local Power | `oss.local-power.env.example` | SQLite + Redis exact cache | \n| OSS Team | `oss.team.env.example` | Postgres + Redis + Qdrant — full team deployment | \n\n```\nexport AURORA_CONFIG_PATH=configs/editions/oss.team.example.yaml\n```\n\n## Server & Security\n\n| Env var | Default | Description | \n|---|---|---|\n| `PORT` | `8080` | HTTP listening port | \n| `BASE_PATH` | `/` | URL path prefix to mount under | \n| `AURORA_MASTER_KEY` | `\"\"` | Master API key for auth | \n| `BODY_SIZE_LIMIT` | `10M` | Max request body size | \n| `SWAGGER_ENABLED` | `false` | Enable Swagger UI at `/swagger/index.html` | \n| `PPROF_ENABLED` | `false` | Enable pprof at `/debug/pprof/` | \n| `ENABLE_PASSTHROUGH_ROUTES` | `true` | Provider-native passthrough at `/p/{provider}` | \n| `ALLOW_PASSTHROUGH_V1_ALIAS` | `true` | Allow `/p/{provider}/v1/...` alias routes | \n| `ENABLED_PASSTHROUGH_PROVIDERS` | `openai,anthropic,openrouter,zai,vllm` | Provider types for passthrough | \n| `ENABLE_ANTHROPIC_INGRESS` | `false` | Expose `/v1/messages` for native Anthropic clients | \n| `DISABLE_REQUEST_LOGGING` | `false` | Turn off request logging | \n| `DISABLE_REQUEST_BODY_SNAPSHOT` | `false` | Don't snapshot request bodies | \n| `DISABLE_PASSTHROUGH_SEMANTIC_ENRICHMENT` | `false` | Disable semantic enrichment on passthrough | \n\n## HTTP Client & Proxy\n\n| Env var | Default | Description | \n|---|---|---|\n| `HTTP_TIMEOUT` | `600` | Upstream request timeout (seconds) | \n| `HTTP_RESPONSE_HEADER_TIMEOUT` | `600` | Timeout for upstream response headers | \n| `HTTP_PROXY` | — | HTTP proxy URL for upstream calls | \n| `HTTPS_PROXY` | — | HTTPS proxy URL | \n| `NO_PROXY` | — | Hosts to exclude from proxy | \n\n## Storage\n\n| Env var | Default | Description | \n|---|---|---|\n| `STORAGE_TYPE` | `sqlite` | Backend: `sqlite` ,`postgresql` , or`mongodb` | \n| `SQLITE_PATH` | `data/aurora.db` | SQLite database file path | \n| `POSTGRES_URL` | — | PostgreSQL connection string | \n| `POSTGRES_MAX_CONNS` | `10` | PostgreSQL connection pool max | \n| `MONGODB_URL` | — | MongoDB connection string | \n| `MONGODB_DATABASE` | `aurora` | MongoDB database name | \n\n## Model Registry\n\n| Env var | Default | Description | \n|---|---|---|\n| `MODEL_LIST_URL` | `https://raw.githubusercontent.com/aurorallm/aurora/refs/heads/main/docs-assets/assets/models.json` | External model metadata registry | \n| `MODEL_LIST_LOCAL_PATH` | `data/models.local.json` | Local model registry snapshot path | \n| `MODEL_LIST_USER_OVERRIDES_PATH` | `data/user_pricing.yaml` | User pricing override file | \n| `MODELS_ENABLED_BY_DEFAULT` | `true` | Default enabled state for provider models | \n| `MODEL_OVERRIDES_ENABLED` | `true` | Allow per-model overrides | \n| `KEEP_ONLY_ALIASES_AT_MODELS_ENDPOINT` | `false` | Hide provider models, show only aliases | \n| `CONFIGURED_PROVIDER_MODELS_MODE` | `fallback` | `fallback` or`allowlist` | \n\n## Caching\n\n**Model cache:**\n\n| Env var | Default | Description | \n|---|---|---|\n| `CACHE_REFRESH_INTERVAL` | `3600` | Model registry cache refresh (seconds) | \n| `AURORA_CACHE_DIR` | `.cache` | Local filesystem cache directory | \n| `REDIS_URL` | — | Redis connection URL (enables Redis-backed model cache) | \n| `REDIS_KEY_MODELS` | `aurora:models` | Redis key for model cache | \n| `REDIS_TTL_MODELS` | `86400` | Redis model cache TTL (seconds) | \n\n**Response cache (exact match):**\n\n| Env var | Default | Description | \n|---|---|---|\n| `RESPONSE_CACHE_SIMPLE_ENABLED` | `false` | Enable Redis exact-response cache | \n| `REDIS_KEY_RESPONSES` | `aurora:response:` | Redis key prefix for responses | \n| `REDIS_TTL_RESPONSES` | `3600` | Response cache TTL (seconds) | \n\n**Semantic cache (vector similarity):**\n\n| Env var | Default | Description | \n|---|---|---|\n| `SEMANTIC_CACHE_ENABLED` | `false` | Enable semantic cache | \n| `SEMANTIC_CACHE_THRESHOLD` | `0.92` | Similarity threshold (0-1) | \n| `SEMANTIC_CACHE_PROMPT_SIMILARITY` | `0.90` | Prompt similarity threshold | \n| `SEMANTIC_CACHE_TTL` | `3600` | Entry TTL (seconds) | \n| `SEMANTIC_CACHE_MAX_CONV_MESSAGES` | `3` | Recent conversation messages to embed | \n| `SEMANTIC_CACHE_EXCLUDE_SYSTEM_PROMPT` | `false` | Exclude system prompt from cache key | \n| `SEMANTIC_CACHE_EMBEDDER_PROVIDER` | `openai` | Embedder provider name | \n| `SEMANTIC_CACHE_EMBEDDER_MODEL` | `text-embedding-3-small` | Embedder model | \n| `SEMANTIC_CACHE_VECTOR_STORE_TYPE` | `qdrant` | Backend: `qdrant` ,`pgvector` ,`pinecone` ,`weaviate` | \n| `SEMANTIC_CACHE_QDRANT_URL` | `http://localhost:6333` | Qdrant URL | \n| `SEMANTIC_CACHE_QDRANT_COLLECTION` | `aurora_semantic` | Qdrant collection name | \n| `SEMANTIC_CACHE_QDRANT_API_KEY` | — | Qdrant API key | \n| `SEMANTIC_CACHE_PGVECTOR_URL` | — | pgvector connection string | \n| `SEMANTIC_CACHE_PGVECTOR_TABLE` | `aurora_semantic_cache` | pgvector table name | \n| `SEMANTIC_CACHE_PGVECTOR_DIMENSION` | `1536` | pgvector embedding dimension | \n| `SEMANTIC_CACHE_PINECONE_HOST` | — | Pinecone host URL | \n| `SEMANTIC_CACHE_PINECONE_API_KEY` | — | Pinecone API key | \n| `SEMANTIC_CACHE_PINECONE_NAMESPACE` | — | Pinecone namespace | \n| `SEMANTIC_CACHE_PINECONE_DIMENSION` | `1536` | Pinecone embedding dimension | \n| `SEMANTIC_CACHE_WEAVIATE_URL` | — | Weaviate URL | \n| `SEMANTIC_CACHE_WEAVIATE_CLASS` | `AuroraSemanticCache` | Weaviate class name | \n| `SEMANTIC_CACHE_WEAVIATE_API_KEY` | — | Weaviate API key | \n\n## Audit Logging\n\n| Env var | Default | Description | \n|---|---|---|\n| `LOGGING_ENABLED` | `false` | Enable audit log to storage | \n| `LOGGING_LOG_BODIES` | `true` | Log request/response bodies | \n| `LOGGING_LOG_HEADERS` | `true` | Log headers (sensitive headers redacted) | \n| `LOGGING_ONLY_MODEL_INTERACTIONS` | `true` | Skip health/metrics/admin endpoints | \n| `LOGGING_BUFFER_SIZE` | `1000` | In-memory queue capacity | \n| `LOGGING_FLUSH_INTERVAL` | `5` | Flush interval (seconds) | \n| `LOGGING_RETENTION_DAYS` | `30` | Auto-delete after N days (0 = forever) | \n\n## Usage Tracking\n\n| Env var | Default | Description | \n|---|---|---|\n| `USAGE_ENABLED` | `true` | Enable token usage tracking | \n| `USAGE_PRICING_RECALCULATION_ENABLED` | `true` | Allow admin pricing recalculation | \n| `ENFORCE_RETURNING_USAGE_DATA` | `true` | Add `stream_options.include_usage=true` to streaming requests | \n| `USAGE_BUFFER_SIZE` | `1000` | In-memory queue capacity | \n| `USAGE_FLUSH_INTERVAL` | `5` | Flush interval (seconds) | \n| `USAGE_RETENTION_DAYS` | `90` | Auto-delete after N days (0 = forever) | \n\n## Guardrails\n\n| Env var | Default | Description | \n|---|---|---|\n| `GUARDRAILS_ENABLED` | `false` | Enable content safety filters globally | \n| `ENABLE_GUARDRAILS_FOR_BATCH_PROCESSING` | `false` | Apply guardrails to `/v1/batches` items | \n\n## Metrics\n\n| Env var | Default | Description | \n|---|---|---|\n| `METRICS_ENABLED` | `false` | Enable Prometheus `/metrics` endpoint | \n| `METRICS_ENDPOINT` | `/metrics` | Metrics endpoint path | \n\n## Token Saver\n\n| Env var | Default | Description | \n|---|---|---|\n| `TOKEN_SAVER_ENABLED` | `false` | Enable output compression | \n| `TOKEN_SAVER_ENDPOINTS` | `chat_completions` | Endpoints to apply it to | \n| `TOKEN_SAVER_APPLY_STREAMING` | `true` | Apply to streaming responses | \n| `TOKEN_SAVER_OUTPUT_ENABLED` | `false` | Enable output style/profile | \n| `TOKEN_SAVER_OUTPUT_PROFILE` | `concise` | Profile: `concise` ,`caveman` ,`ultra` ,`wenyan` | \n| `TOKEN_SAVER_MODELS_INCLUDE` | — | Models to include (comma-separated) | \n| `TOKEN_SAVER_MODELS_EXCLUDE` | — | Models to exclude | \n| `TOKEN_SAVER_PROVIDERS_INCLUDE` | — | Providers to include | \n| `TOKEN_SAVER_PROVIDERS_EXCLUDE` | — | Providers to exclude | \n| `TOKEN_SAVER_ON_ERROR` | `allow` | Behavior on error: `allow` or`block` | \n| `TOKEN_SAVER_EMIT_HEADERS` | `true` | Emit token-saver headers in response | \n| `TOKEN_SAVER_AUDIT_ENABLED` | `true` | Log token-saver actions | \n\n## Resilience\n\n| Env var | Default | Description | \n|---|---|---|\n| `RETRY_MAX_RETRIES` | `3` | Upstream retry count | \n| `RETRY_INITIAL_BACKOFF` | `1s` | Initial backoff duration | \n| `RETRY_MAX_BACKOFF` | `30s` | Maximum backoff duration | \n| `RETRY_BACKOFF_FACTOR` | `2.0` | Exponential backoff multiplier | \n| `RETRY_JITTER_FACTOR` | `0.1` | Random jitter fraction | \n| `CIRCUIT_BREAKER_FAILURE_THRESHOLD` | `5` | Failures before circuit opens | \n| `CIRCUIT_BREAKER_SUCCESS_THRESHOLD` | `2` | Successes before circuit closes | \n| `CIRCUIT_BREAKER_TIMEOUT` | `30s` | Time before half-open retry | \n\n## Fallback\n\n| Env var | Default | Description | \n|---|---|---|\n| `FEATURE_FALLBACK_MODE` | `manual` | Fallback mode: `auto` ,`manual` , or`off` | \n| `FALLBACK_MANUAL_RULES_PATH` | — | Path to manual fallback rules JSON | \n\n## Admin & Features\n\n| Env var | Default | Description | \n|---|---|---|\n| `ADMIN_ENDPOINTS_ENABLED` | `true` | Enable `/admin/api/v1/*` REST endpoints | \n| `ADMIN_UI_ENABLED` | `true` | Enable `/admin/dashboard` UI | \n| `COMBOS_ENABLED` | `true` | Enable combo model calls | \n| `CLI_TOOLS_ENABLED` | `true` | Enable CLI tools integration | \n| `CLI_TOOLS_APPLY_ENABLED` | `false` | Allow admin/API to apply tool changes | \n| `WORKFLOW_REFRESH_INTERVAL` | `1m` | Workflow refresh interval from storage | \n| `EDITION` | — | Edition identifier (Enterprise use) | \n\n## Config file path\n\n| Env var | Default | Description | \n|---|---|---|\n| `AURORA_CONFIG_PATH` | `configs/config.yaml` | Override path to config YAML | \n\nRun the built binary directly (from source: `go build -o aurora ./apps/aurora`, then `./aurora`). The npm `iaurora` wrapper is the upstream package and isn't republished by this fork.\n\n| Command | Description | \n|---|---|\n| `aurora` | Start the gateway server (default port 8080) | \n| `aurora init` | Scaffold `config.yaml` ,`.env` ,`data/` in current directory | \n| `aurora models sync` | Download upstream model registry to local file | \n| `aurora models diff` | Show pricing diff between upstream and local snapshot | \n| `aurora models show` | Print effective pricing for a model after merging overrides | \n| `aurora -version` | Print version information | \n| `aurora -help` | Show all CLI options and config reference | \n| `aurora -help-json` | Dump env var schema as JSON | \n\n```\naurora/\n├── apps/              # Application entrypoints\n├── internal/          # Core packages (providers, gateway, storage, guardrails, etc.)\n├── dashboard-ui/      # React admin dashboard (Vite)\n├── configs/           # Configuration profiles and examples\n├── documentation/     # Markdown docs (Getting Started, Deployment, Session Hub, Docker)\n├── docs-assets/       # Images, models.json, assets\n├── monitoring/        # Prometheus + Grafana configs\n├── bench-results/     # Benchmark data\n├── release/           # Release scripts\n└── scripts/           # Build and utility scripts\n```\n\nThis project is licensed under the Apache 2.0 License — see the [LICENSE](/entitybtw/aurora/blob/main/LICENSE) file for details.\n\nCommunity fork of [Aurora](https://github.com/aurorallm/aurora). Session Hub features and multi-account integration built by [entitybtw](https://github.com/entitybtw/aurora). The upstream project is built by the Aurora team.", "url": "https://wpnews.pro/news/aurora-ai-gateway-fork-for-multi-ip-setups-55x-faster-than-litellm", "canonical_source": "https://github.com/entitybtw/aurora", "published_at": "2026-09-08 13:03:44+00:00", "updated_at": "2026-09-08 13:28:57.133332+00:00", "lang": "en", "topics": ["ai-infrastructure", "developer-tools", "ai-products"], "entities": ["entitybtw", "Aurora", "aurorallm/aurora", "LiteLLM", "OpenAI", "Anthropic", "Go", "Docker"], "alternates": {"html": "https://wpnews.pro/news/aurora-ai-gateway-fork-for-multi-ip-setups-55x-faster-than-litellm", "markdown": "https://wpnews.pro/news/aurora-ai-gateway-fork-for-multi-ip-setups-55x-faster-than-litellm.md", "text": "https://wpnews.pro/news/aurora-ai-gateway-fork-for-multi-ip-setups-55x-faster-than-litellm.txt", "jsonld": "https://wpnews.pro/news/aurora-ai-gateway-fork-for-multi-ip-setups-55x-faster-than-litellm.jsonld"}}