AISIX AI Gateway
The open-source, Rust-native AI gateway for LLMs and AI agents
One OpenAI-compatible API in front of every model. Route, govern, secure, cache, and
observe all your LLM and AI-agent traffic from a single control point — shipped as one
static binary with low per-request overhead. Run it in your infrastructure for free,
forever.
Built by the original creators of Apache APISIX.
Start free ·
Documentation ·
Quickstart ·
AISIX Cloud ·
Roadmap
AISIX AI Gateway is a Rust-native gateway that puts a single, OpenAI-compatible API in
front of every LLM provider — OpenAI, Anthropic, Google Gemini, AWS Bedrock, Azure OpenAI,
DeepSeek, and any OpenAI-compatible endpoint. It gives platform teams one place to route,
govern, secure, and observe LLM traffic, with first-class SSE streaming and low gateway
overhead.
It runs as a single static binary — low cold-start, lock-free config reads, and hot
configuration reloads with no restarts: declare resources in one resources.yaml and
reload on SIGHUP, or point the gateway at etcd for a multi-replica cluster. Run the
open-source gateway in your infrastructure, or connect it to
AISIX Cloud
for centralized management with team governance, budgets, audit, and a dashboard.
AISIX AI Gateway (this repo) is the open-source product. It runs without a control
plane using declarative configuration or etcd. When connected to
AISIX Cloud,
the same gateway serves as the data plane. AISIX Cloud adds a commercial control plane,
either hosted by API7 (Hybrid Cloud) or hosted by you in your infrastructure
(On-Premises). In both options, the gateway runs in your environment and calls
providers directly; live AI traffic does not pass through the control plane or API7.
The proxy API is identical throughout.
Talk to us about AISIX Cloud →
✨ Why AISIX
- One API, every model. Speak the OpenAI or Anthropic wire format in; the gateway
translates to whichever provider each model points at. Point an OpenAI or Claude SDK at
one
base_url and switch models without changing code.
- A real gateway, in Rust. Single static binary, low cold-start, lock-free config reads
on the hot path, native streaming.
- Open source, free forever. Apache-2.0 licensed and built to run in your
infrastructure. Choose AISIX Cloud when you want centralized management through a
control plane and dashboard.
- Production controls built in. Routing & failover, rate limits, guardrails, caching,
and observability ship in the box. (Budgets and spend caps are an AISIX Cloud feature —
the gateway enforces the control plane's decisions.)
🧩 Features — available today
Covered by 183 end-to-end scenario files (496 cases) that run against real gateway processes.
- OpenAI-compatible proxy (
:3000) — chat/completions, completions, responses,
embeddings, rerank, images/{generations,edits}, audio/{speech,transcriptions,translations},
videos (submit → poll → fetch), files, batches, fine_tuning/jobs, realtime,
GET /v1/models, plus a root-level /passthrough/:provider/* escape hatch. Native SSE streaming,
tool/function calling, JSON mode, vision/multimodal input, and reasoning-content support.
- Anthropic Messages API —
POST /v1/messages as a first-class route, working against
any configured upstream: requests and responses (including streaming) are translated
both ways when a model points at a non-Anthropic provider.
- Routing & failover — virtual/routing models with six strategies:
round_robin
(smooth weighted round-robin), consistent_hash (session affinity keyed by header /
cookie / API key / client IP), failover, plus metric-based least_cost,
least_latency, and least_busy. Per-target tiers (active/backup pools),
retry budgets, cooldowns, tag-conditional targets, and per-attempt timeouts.
🔌 Supported providers
AISIX dispatches through five native adapter families — distinct wire-protocol bridges,
not one generic relabel. Whatever the upstream protocol, the client-facing API stays
OpenAI-shaped.
| Adapter family | Reaches | Wire shape · auth |
|---|
openai | OpenAI + any OpenAI-compatible vendor — DeepSeek, Groq, Mistral, Together, Fireworks, Perplexity, vLLM, Ollama, or self-hosted OpenAI-compatible endpoints | OpenAI chat completions · Bearer |
anthropic | Anthropic Claude | Anthropic Messages · x-api-key |
bedrock | AWS Bedrock — Anthropic, Meta Llama, Mistral, Cohere, Amazon Titan/Nova, AI21 | Bedrock Converse + /invoke · SigV4 |
vertex | Google Vertex AI (Gemini) | Vertex :generateContent · OAuth2 |
azure-openai | Azure OpenAI | Azure deployments · api-key / Entra ID |
Plus specialized handling for vendor quirks (e.g. DeepSeek reasoning content) and dedicated
rerank / embeddings vendors (Cohere, Jina). Details in
adapter protocol families.
☁️ Open source vs AISIX Cloud
Same gateway binary, same proxy API — in every form the gateway runs in your environment.
AISIX Cloud adds a commercial control plane, either hosted by API7
(Hybrid Cloud) or hosted in your infrastructure (On-Premises).
| Open-source gateway (this repo) | AISIX Cloud (Hybrid Cloud or On-Premises) |
|---|
| Price | Free · Apache-2.0 · forever | Commercial — talk to us |
| Configuration | Declarative resources.yaml, or etcd for a cluster | Dashboard + Cloud Admin API, multi-environment |
| Tenancy | Single instance / namespace | Org → Team → Member → Environment |
| Provider keys | In the resources file as ${VAR} env references, or in etcd | Envelope-encrypted at rest, write-only, in-place rotation |
| Inbound auth | Caller keys (SHA-256 hashed, model allowlists, expiry), or OIDC/JWT bearers | Same, plus masked reveal, key ownership, and PATs |
| Budgets | — (rate and token limits only) | Per key / provider / env / org / team, hard-stop & alerts |
| RBAC | Admin key = read-only resource surface |
→ Want the AISIX Cloud control plane, governance, budgets, and dashboard?
Talk to API7 about
Hybrid Cloud or On-Premises, or book a demo.
🏗️ Architecture
A single Cargo workspace; the aisix-server crate builds one binary named aisix that
wires the crates together.
crates/
├── aisix-core Config, snapshot, resource model, resources.yaml source, errors
├── aisix-etcd Config provider + watch supervisor
├── aisix-gateway Hub & bridge, SSE parser, provider trait
├── aisix-proxy /v1/*, /mcp, /a2a handlers, routing, middleware
├── aisix-admin Read-only resource surface + playground + OpenAPI
├── aisix-provider-* openai · anthropic · azure-openai · bedrock · vertex
├── aisix-mcp MCP gateway — server registry, tool ACL, transports
├── aisix-a2a A2A agent gateway — agent cards, JSON-RPC bridge
├── aisix-ratelimit fixed-window + token accounting + concurrency (local | redis)
├── aisix-cache memory + redis backends
├── aisix-redis shared Redis connection for cache + rate limits
├── aisix-guardrails pre/post content-policy hooks
├── aisix-obs tracing, metrics, access log, exporters
└── aisix-server the `aisix` binary — bootstrap + CLI
🗺️ Roadmap
Highlights on the roadmap; tracked live in
issues:
- Semantic (embedding-similarity) response caching
- More observability sinks — Langsmith, Helicone, Slack alerts
- Prompt templates managed as gateway resources
- Llama-Guard as a guardrail provider
Shipped since this list was last written: the MCP gateway, the A2A agent gateway,
OIDC/JWT inbound auth, Redis-backed distributed rate limiting, and the Lakera, Presidio,
PII, and OpenAI Moderation guardrails — see Features above.
🛠️ Development
Prerequisites: the Rust toolchain pinned in rust-toolchain.toml. Docker is only needed
for the tests that exercise etcd, Redis, or provider emulators.
cargo check --workspace
cargo fmt --check
cargo clippy --workspace -- -D warnings
cargo test --workspace
# Coverage (matches the CI gate)
cargo llvm-cov --workspace --lcov --output-path lcov.info
# Run locally against a resources.yaml (no etcd needed). Copy the Quickstart's two files
# and change resources_file to the local path, e.g. resources_file: ./resources.yaml
cargo run -p aisix-server --bin aisix -- --config config.local.yaml
# Check a resources file without starting a listener
cargo run -p aisix-server --bin aisix -- validate --resources resources.yaml
💬 Community
If AISIX is useful to you, a ⭐ helps other engineers find it.
📄 License
Apache 2.0.