Skip to content
Back to search

aisix

Open-source AI gateway for LLMs & AI agents, built in Rust. One OpenAI-compatible API for OpenAI, Anthropic, Gemini, Bedrock & more — routing, guardrails, caching, rate limits, observability.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/api7/aisix with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/api7/aisix'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/api7--aisix/badge.svg)](/listings/api7--aisix)

HTML

<a href="/listings/api7--aisix"><img src="/api/listings/api7--aisix/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

One container. No control plane, no database, no configuration store — the gateway reads every dynamic resource from one declarative `resources.yaml`.

# config.yaml
resources_file: /etc/aisix/resources.yaml
proxy:
  addr: "0.0.0.0:3000"
admin:
  enabled: false          # a declarative gateway needs no admin listener
observability:
  metrics:
    prometheus:
      enabled: true
      addr: "0.0.0.0:9090"
# resources.yaml
_format_version: "1"

provider_keys:
  - display_name: openai-main
    provider: openai
    api_key: ${OPENAI_API_KEY}        # interpolated from the environment

models:
  - display_name: my-model
    provider: openai
    model_name: gpt-4o-mini
    provider_key: openai-main

api_keys:
  - display_name: local-dev
    key_env: CALLER_API_KEY           # hashed at load; the plaintext is never stored
    allowed_models: ["my-model"]
export OPENAI_API_KEY="YOUR_PROVIDER_KEY"
export CALLER_API_KEY="YOUR_CALLER_KEY"

docker run -d --name aisix \
  -v "$(pwd)/config.yaml:/etc/aisix/config.yaml:ro" \
  -v "$(pwd)/resources.yaml:/etc/aisix/resources.yaml:ro" \
  -e OPENAI_API_KEY -e CALLER_API_KEY \
  -p 3000:3000 -p 127.0.0.1:9090:9090 \
  ghcr.io/api7/aisix:latest        # proxy → :3000, metrics + status → :9090
#                                  ^ the metrics/status listener is unauthenticated;
#                                    keep it on loopback or a private network

Then call the gateway exactly like OpenAI:

curl http://localhost:3000/v1/chat/completions \
  -H "Authorization: Bearer $CALLER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"my-model","messages":[{"role":"user","content":"hello"}]}'

Edit `resources.yaml` and send `SIGHUP` (`docker kill -s HUP aisix`) to apply changes with no restart — an invalid file is rejected whole and the last good configuration keeps serving. Check a file before booting with `aisix validate --resources resources.yaml`.

Full walkthrough: the [Gateway Quickstart](https://docs.api7.ai/ai-gateway/getting-started/gateway-quickstart) · every field: the [resources file reference](https://docs.api7.ai/ai-gateway/reference/resources-file). For a multi-replica cluster, point the gateway at etcd instead — `resources_file` and `etcd` are mutually exclusive.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 353 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. # AISIX OSS
  3. ### The open-source, Rust-native AI gateway for LLMs and AI agents
  4. **One OpenAI-compatible API in front of every model.** Route, govern, secure, cache, and
  5. observe all your LLM and AI-agent traffic from a single control point — shipped as one
  6. static binary with low per-request overhead. Run it in your infrastructure for free,
  7. forever.
  8. *Built by the original creators of [Apache APISIX](https://apisix.apache.org/).*
  9. [![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
  10. [![Built with Rust](https://img.shields.io/badge/Built%20with-Rust-orange.svg)](https://www.rust-lang.org/)
  11. [![Docs](https://img.shields.io/badge/docs-read-3aa757.svg)](https://docs.api7.ai/ai-gateway/)
  12. [![Discord](https://img.shields.io/badge/Discord-join-5865F2.svg)](https://discord.gg/dUmRZ7Rvf)
  13. [![Website](https://img.shields.io/badge/website-api7.ai-1a73e8.svg)](https://api7.ai/ai-gateway)
  14. [**Start free**](https://api7.ai/ai-gateway?utm_source=github&utm_medium=readme&utm_campaign=ai-gateway) ·
  15. [**Documentation**](https://docs.api7.ai/ai-gateway/) ·
  16. [**Quickstart**](https://docs.api7.ai/ai-gateway/getting-started/gateway-quickstart) ·
  17. [**AISIX Enterprise and AISIX Cloud**](https://api7.ai/ai-gateway?utm_source=github&utm_medium=readme&utm_campaign=cloud) ·
  18. [**Roadmap**](ROADMAP.md)
  19. <br>
  20. <img src="assets/aisix-architecture.svg" alt="AISIX OSS architecture — one OpenAI- or Anthropic-compatible API in front of OpenAI, Anthropic, Gemini/Vertex, Bedrock, Azure OpenAI, and DeepSeek, with API key auth, rate and token limits, guardrails, caching, routing and failover, and observability in between" width="100%">
  21. </div>
  22. ---
  23. **AISIX OSS** is the open-source product built around the Rust-native AISIX gateway. The
  24. gateway puts a single, OpenAI-compatible API in front of every LLM provider — OpenAI,
  25. Anthropic, Google Gemini, AWS Bedrock, Azure OpenAI, DeepSeek, and any OpenAI-compatible
  26. endpoint. It gives platform teams one place to route, govern, secure, and observe LLM
  27. traffic, with first-class SSE streaming and low gateway overhead.
  28. It runs as a **single static binary** — low cold-start, lock-free config reads, and hot
  29. configuration reloads with no restarts: declare resources in one `resources.yaml` and
  30. reload on `SIGHUP`, or point the gateway at etcd for a multi-replica cluster. Run the
  31. gateway in your infrastructure, or connect it to **AISIX Enterprise** or
  32. **[AISIX Cloud](https://api7.ai/ai-gateway?utm_source=github&utm_medium=readme&utm_campaign=cloud)**
  33. for centralized management with team governance, budgets, audit, and a dashboard.
  34. > **AISIX OSS (this repo)** is the open-source product. It runs without a control plane
  35. > using declarative configuration or etcd. The same gateway binary serves as the data
  36. > plane in the commercial products: customers host the control plane with **AISIX
  37. > Enterprise**, while API7 hosts it with **AISIX Cloud**. In all three products, the
  38. > gateway runs in your environment and calls providers directly; live AI traffic does not
  39. > pass through either control plane. The proxy API is identical throughout.
  40. > **[Talk to us about AISIX Enterprise or AISIX Cloud →](https://api7.ai/contact?utm_source=github&utm_medium=readme&utm_campaign=cloud)**
  41. ## ⚡ Quickstart
  42. One container. No control plane, no database, no configuration store — the gateway reads
  43. every dynamic resource from one declarative `resources.yaml`.
  44. ```yaml
  45. # config.yaml
  46. resources_file: /etc/aisix/resources.yaml
  47. proxy:
  48. addr: "0.0.0.0:3000"
  49. admin:
  50. enabled: false # a declarative gateway needs no admin listener
  51. observability:
  52. metrics:
  53. prometheus:
  54. enabled: true
  55. addr: "0.0.0.0:9090"
  56. ```
  57. ```yaml
  58. # resources.yaml — every entry is an id plus the resource's document
  59. _format_version: "2"
  60. provider_keys:
  61. - id: 0b6f3c1e-2f0a-4c5e-9d55-7d1a8b0c2e11
  62. display_name: openai-main
  63. provider: openai
  64. api_key: ${OPENAI_API_KEY} # interpolated from the environment
  65. models:
  66. - id: 6efd592d-a73b-573d-8e2c-e9e103692f92
  67. display_name: my-model
  68. provider: openai
  69. model_name: gpt-4o-mini
  70. provider_key_id: 0b6f3c1e-2f0a-4c5e-9d55-7d1a8b0c2e11
  71. api_keys:
  72. - id: 4a1c9e2b-7d3f-4b6a-8c5e-1f2a3b4c5d6e
  73. display_name: local-dev
  74. key_hash: ${CALLER_API_KEY_SHA256} # sha256 hex of the caller key; the plaintext is never stored
  75. allowed_model_ids: ["6efd592d-a73b-573d-8e2c-e9e103692f92"]
  76. ```
  77. ```bash
  78. export OPENAI_API_KEY="YOUR_PROVIDER_KEY"
  79. export CALLER_API_KEY="YOUR_CALLER_KEY"
  80. export CALLER_API_KEY_SHA256="$(printf %s "$CALLER_API_KEY" | sha256sum | cut -d' ' -f1)"
  81. docker run -d --name aisix \
  82. -v "$(pwd)/config.yaml:/etc/aisix/config.yaml:ro" \
  83. -v "$(pwd)/resources.yaml:/etc/aisix/resources.yaml:ro" \
  84. -e OPENAI_API_KEY -e CALLER_API_KEY_SHA256 \
  85. -p 3000:3000 -p 127.0.0.1:9090:9090 \
  86. ghcr.io/api7/aisix:latest # proxy → :3000, metrics + status → :9090
  87. # ^ the metrics/status listener is unauthenticated;
  88. # keep it on loopback or a private network
  89. ```
  90. Then call the gateway exactly like OpenAI:
  91. ```bash
  92. curl http://localhost:3000/v1/chat/completions \
  93. -H "Authorization: Bearer $CALLER_API_KEY" \
  94. -H "Content-Type: application/json" \
  95. -d '{"model":"my-model","messages":[{"role":"user","content":"hello"}]}'
  96. ```
  97. Edit `resources.yaml` and send `SIGHUP` (`docker kill -s HUP aisix`) to apply changes with
  98. no restart. The file is loaded exactly as etcd is: a resource that does not load is dropped
  99. and reported on `/status/config` while the rest serve, and a file that cannot be read at all
  100. keeps the last configuration serving. Check a file before booting with
  101. `aisix validate --resources resources.yaml`.
  102. Full walkthrough: the
  103. [Gateway Quickstart](https://docs.api7.ai/ai-gateway/getting-started/gateway-quickstart) ·
  104. every field: the [resources file reference](https://docs.api7.ai/ai-gateway/reference/resources-file)
  105. (still being updated for format `"2"`; each entry's fields are the resource's document, see
  106. [`schemas/resources/`](schemas/resources/)).
  107. For a multi-replica cluster, point the gateway at etcd instead — `resources_file` and
  108. `etcd` are mutually exclusive.
  109. ## ✨ Why AISIX
  110. - **One API, every model.** Speak the OpenAI *or* Anthropic wire format in; the gateway
  111. translates to whichever provider each model points at. Point an OpenAI or Claude SDK at
  112. one `base_url` and switch models without changing code.
  113. - **A real gateway, in Rust.** Single static binary, low cold-start, lock-free config reads
  114. on the hot path, native streaming.
  115. - **Open source, free forever.** Apache-2.0 licensed and built to run in your
  116. infrastructure. Choose AISIX Enterprise or AISIX Cloud when you want centralized
  117. management through a control plane and dashboard.
  118. - **Production controls built in.** Routing & failover, rate limits, guardrails, caching,
  119. and observability ship in the box. (Budgets and spend caps are AISIX Enterprise and
  120. AISIX Cloud features — the gateway enforces the control plane's decisions.)
  121. ## 🧩 Features — available today
  122. Covered by 183 end-to-end scenario files (496 cases) that run against real gateway processes.
  123. - **OpenAI-compatible proxy** (`:3000`) — `chat/completions`, `completions`, `responses`,
  124. `embeddings`, `rerank`, `images/{generations,edits}`, `audio/{speech,transcriptions,translations}`,
  125. `videos` (submit → poll → fetch), `files`, `batches`, `fine_tuning/jobs`, `realtime`,
  126. `GET /v1/models`, plus a root-level `/passthrough/:provider/*` escape hatch. Native SSE streaming,
  127. tool/function calling, JSON mode, vision/multimodal input, and reasoning-content support.
  128. - **Anthropic Messages API** — `POST /v1/messages` as a first-class route, working against
  129. **any** configured upstream: requests and responses (including streaming) are translated
  130. both ways when a model points at a non-Anthropic provider.
  131. - **Routing & failover** — virtual/routing models with six strategies: `round_robin`
  132. (smooth weighted round-robin), `consistent_hash` (session affinity keyed by header /
  133. cookie / API key / client IP), `failover`, plus metric-based `least_cost`,
  134. `least_latency`, and `least_busy`. Per-target `priority` tiers (active/backup pools),
  135. retry budgets, cooldowns, tag-conditional targets, and per-attempt timeouts.
  136. - **Ensemble models** — fan one request out to a panel of models concurrently, then have a
  137. judge model synthesize a single answer, with a minimum-successful-responses threshold.
  138. - **Semantic routing** — one virtual model that dispatches by the *meaning* of each
  139. request: it embeds the prompt, scores it against per-route example utterances, and routes
  140. to the best match (or a default). See the
  141. [semantic routing docs](https://docs.api7.ai/ai-gateway/routing/semantic-routing).
  142. - **Rate limiting & concurrency** — RPS/RPM/RPH/RPD + TPM/TPD + concurrency caps,
  143. AND-combined across caller keys, models, and policy scopes (`api_key` / `model` / `team` /
  144. `member` / `team_member`). Counters are per-process by default, or shared across replicas
  145. with the Redis backend.
  146. - **Guardrails** — content-policy enforcement on input and output, in-process or through a
  147. provider: keyword/regex, built-in PII detection and redaction, Presidio, Lakera, OpenAI
  148. Moderation, AWS Bedrock Guardrails, Azure AI Content Safety (Prompt Shield + text
  149. moderation), and two Alibaba Cloud services. A block returns `422 content_filter`;
  150. monitor mode records what would have happened without blocking.
  151. - **Caching** — exact-match response cache with per-policy TTL and model/key scope matchers;
  152. memory and Redis backends; cost-saved telemetry on every hit. Separately, **automatic
  153. prompt caching** can be enabled per direct Anthropic model to inject cache breakpoints, so
  154. callers get provider-side prompt discounts without changing their requests.
  155. - **MCP gateway** — front registered upstream MCP servers at `/mcp` with gateway-held
  156. credentials, per-server tool namespaces, and per-caller access. It serves every
  157. Streamable HTTP revision from `2025-03-26` through stateless `2026-07-28` without
  158. downstream sessions. Upstreams use `initialize` by default or `server/discover` with
  159. `protocol_version: "2026-07-28"`. CI runs the official MCP suite's applicable tools-only
  160. protocol scenarios. Also exposes a REST API as MCP tools from its OpenAPI description.
  161. - **A2A agent gateway** — front A2A (Agent-to-Agent) agents at `/a2a/:agent`, serving each
  162. agent's card with URLs rewritten to the gateway, over JSON-RPC 2.0.
  163. - **Inbound authentication** — caller API keys (SHA-256 hashed, model allowlists, expiry,
  164. rotation), or OIDC/JWT bearer tokens validated against registered providers (Entra ID,
  165. Okta, Google Workspace, or any OIDC issuer) with JWKS caching.
  166. - **Observability** — Prometheus `/metrics`, structured per-request access logs, usage
  167. events, OTLP/GenAI span export (Langfuse, Honeycomb, Grafana Cloud, or any OTLP receiver),
  168. plus dedicated Datadog and Aliyun SLS log exporters and object-storage (S3/GCS/Azure Blob)
  169. telemetry.
  170. - **Declarative configuration** — one `resources.yaml` carries all ten resource collections
  171. (provider keys, models, caller keys, guardrails, MCP servers, A2A agents, cache policies,
  172. observability exporters, rate-limit policies, OIDC providers) as the same documents the
  173. gateway reads from etcd, loaded by the same code. `aisix validate` checks a file offline;
  174. `SIGHUP` reloads it.
  175. - **Operational endpoints** — `/livez` and `/readyz` on the proxy listener; `/status/config`,
  176. `/status/ready`, `/status/models`, and Prometheus `/metrics` on a dedicated metrics
  177. listener (`:9090`). The admin listener (`:3001`) additionally serves a **read-only**
  178. resource surface, OpenAPI 3 with a Scalar UI, and a playground. Resources are managed
  179. declaratively — through the `resources_file` (reloaded on SIGHUP) or direct etcd
  180. writes — not through the admin listener; its former write endpoints were removed.
  181. ## 🔌 Supported providers
  182. AISIX dispatches through **five native adapter families** — distinct wire-protocol bridges,
  183. not one generic relabel. Whatever the upstream protocol, the client-facing API stays
  184. OpenAI-shaped.
  185. | Adapter family | Reaches | Wire shape · auth |
  186. |---|---|---|
  187. | `openai` | OpenAI **+ any OpenAI-compatible vendor** — DeepSeek, Groq, Mistral, Together, Fireworks, Perplexity, vLLM, Ollama, or self-hosted OpenAI-compatible endpoints | OpenAI chat completions · Bearer |
  188. | `anthropic` | Anthropic Claude | Anthropic Messages · `x-api-key` |
  189. | `bedrock` | AWS Bedrock — Anthropic, Meta Llama, Mistral, Cohere, Amazon Titan/Nova, AI21 | Bedrock Converse + `/invoke` · SigV4 |
  190. | `vertex` | Google Vertex AI (Gemini) | Vertex `:generateContent` · OAuth2 |
  191. | `azure-openai` | Azure OpenAI | Azure deployments · api-key / Entra ID |
  192. Plus specialized handling for vendor quirks (e.g. DeepSeek reasoning content) and dedicated
  193. **rerank / embeddings** vendors (Cohere, Jina). Details in
  194. [adapter protocol families](https://docs.api7.ai/ai-gateway/providers/adapters).
  195. ## ☁️ Choose an AISIX Product
  196. Same gateway binary, same proxy API — in every form the gateway runs in your environment.
  197. **AISIX Enterprise** adds a customer-hosted commercial control plane. **AISIX Cloud** adds
  198. an API7-hosted commercial control plane.
  199. <table>
  200. <tr>
  201. <td width="50%" valign="top">
  202. <img src="assets/console-overview.png" alt="AISIX Enterprise and AISIX Cloud overview — requests, latency p50/p99, error rate and cost today, with a 7-day request-and-cost trend and gateway health" width="100%"><br>
  203. <sub><b>Overview</b> — traffic, latency, error rate &amp; spend at a glance</sub>
  204. <br><br>
  205. <img src="assets/console-models.png" alt="AISIX Enterprise and AISIX Cloud models — alias an upstream LLM per provider with model IDs and per-model rate limits" width="100%"><br>
  206. <sub><b>Models</b> — one alias per upstream: OpenAI, Anthropic, Bedrock, DeepSeek…</sub>
  207. <br><br>
  208. <img src="assets/console-guardrails.png" alt="AISIX Enterprise and AISIX Cloud guardrails — pre-input and post-output content policies that block on violation" width="100%"><br>
  209. <sub><b>Guardrails</b> — pre-input &amp; post-output policies, block on violation</sub>
  210. </td>
  211. <td width="50%" valign="top">
  212. <img src="assets/console-playground.png" alt="AISIX Enterprise and AISIX Cloud playground — pick a model, set prompts, and read the response with live token and cost metering" width="100%"><br>
  213. <sub><b>Playground</b> — test any model with live token &amp; cost metering</sub>
  214. <br><br>
  215. <img src="assets/console-observability.png" alt="AISIX Enterprise and AISIX Cloud observability exporters — fan out telemetry to OTLP, Datadog and object storage, with per-target delivery health" width="100%"><br>
  216. <sub><b>Observability</b> — fan out traces &amp; logs to OTLP, Datadog, object storage</sub>
  217. <br><br>
  218. <img src="assets/console-budgets.png" alt="AISIX Enterprise and AISIX Cloud budgets — organization and per-environment spend caps with hard-stop and warn-only policies" width="100%"><br>
  219. <sub><b>Budgets</b> — hard-stop spend caps with warn-only tiers</sub>
  220. </td>
  221. </tr>
  222. </table>
  223. <p align="center">
  224. <em>The AISIX Enterprise and AISIX Cloud dashboard — overview metrics, multi-provider models, guardrails, budgets, and observability exporters across all your gateways.</em>
  225. <br><br>
  226. <a href="https://aisix-demo.api7.ai/"><b>▶ Try the live dashboard demo — aisix-demo.api7.ai</b></a>
  227. </p>
  228. | | AISIX OSS (this repo) | AISIX Enterprise | [AISIX Cloud](https://api7.ai/ai-gateway?utm_source=github&utm_medium=readme&utm_campaign=cloud) |
  229. |---|---|---|---|
  230. | License | Apache-2.0 | Commercial | Commercial |
  231. | Control plane | None | Customer-hosted | API7-hosted |
  232. | Configuration | Declarative `resources.yaml`, or etcd for a cluster | Dashboard + AISIX Cloud Admin API | Dashboard + AISIX Cloud Admin API |
  233. | Tenancy | Single instance / namespace | Organization-scoped environments, teams, and members | Organization-scoped environments, teams, and members |
  234. | Provider keys | `${VAR}` references in `resources.yaml`; plaintext credentials in etcd | Encrypted at rest; operator-triggered in-place rotation | Encrypted at rest; operator-triggered in-place rotation |
  235. | Budgets | — (rate and token limits only) | Per key, provider, environment, organization, and team | Per key, provider, environment, organization, and team |
  236. | RBAC and audit | Local admin key; no organization layer | Organization roles, invitations, and audit history | Organization roles, invitations, and audit history |
  237. | Operations | You operate the gateway | You operate the control plane and gateways | API7 operates the control plane; you operate gateways |
  238. → **Want centralized governance, budgets, and a dashboard?**
  239. **[Talk to API7](https://api7.ai/contact?utm_source=github&utm_medium=readme&utm_campaign=cloud)** about
  240. AISIX Enterprise or AISIX Cloud, or **[book a demo](https://api7.ai/contact?utm_source=github&utm_medium=readme&utm_campaign=demo)**.
  241. ## 🏗️ Architecture
  242. A single Cargo workspace; the `aisix-server` crate builds one binary named `aisix` that
  243. wires the crates together.
  244. ```text
  245. crates/
  246. ├── aisix-core Config, snapshot, resource model, errors
  247. ├── aisix-etcd Config providers (etcd, resources.yaml) + watch supervisor
  248. ├── aisix-gateway Hub & bridge, SSE parser, provider trait
  249. ├── aisix-proxy /v1/*, /mcp, /a2a handlers, routing, middleware
  250. ├── aisix-admin Read-only resource surface + playground + OpenAPI
  251. ├── aisix-provider-* openai · anthropic · azure-openai · bedrock · vertex
  252. ├── aisix-mcp MCP gateway — server registry, tool ACL, transports
  253. ├── aisix-a2a A2A agent gateway — agent cards, JSON-RPC bridge
  254. ├── aisix-ratelimit fixed-window + token accounting + concurrency (local | redis)
  255. ├── aisix-cache memory + redis backends
  256. ├── aisix-redis shared Redis connection for cache + rate limits
  257. ├── aisix-guardrails pre/post content-policy hooks
  258. ├── aisix-obs tracing, metrics, access log, exporters
  259. └── aisix-server the `aisix` binary — bootstrap + CLI
  260. ```
  261. ## 🗺️ Roadmap
  262. Highlights on the [roadmap](ROADMAP.md); tracked live in
  263. [issues](https://github.com/api7/aisix/issues):
  264. - Semantic (embedding-similarity) response caching
  265. - More observability sinks — Langsmith, Helicone, Slack alerts
  266. - Prompt templates managed as gateway resources
  267. - Llama-Guard as a guardrail provider
  268. Shipped since this list was last written: the MCP gateway, the A2A agent gateway,
  269. OIDC/JWT inbound auth, Redis-backed distributed rate limiting, and the Lakera, Presidio,
  270. PII, and OpenAI Moderation guardrails — see **Features** above.
  271. ## 🛠️ Development
  272. Prerequisites: the Rust toolchain pinned in `rust-toolchain.toml`. Docker is only needed
  273. for the tests that exercise etcd, Redis, or provider emulators.
  274. ```bash
  275. cargo check --workspace
  276. cargo fmt --check
  277. cargo clippy --workspace -- -D warnings
  278. cargo test --workspace
  279. # Coverage (matches the CI gate)
  280. cargo llvm-cov --workspace --lcov --output-path lcov.info
  281. # Run locally against a resources.yaml (no etcd needed). Copy the Quickstart's two files
  282. # and change resources_file to the local path, e.g. resources_file: ./resources.yaml
  283. cargo run -p aisix-server --bin aisix -- --config config.local.yaml
  284. # Check a resources file without starting a listener
  285. cargo run -p aisix-server --bin aisix -- validate --resources resources.yaml
  286. ```
  287. ## 💬 Community
  288. - **Discord** — [discord.gg/dUmRZ7Rvf](https://discord.gg/dUmRZ7Rvf)
  289. - **Issues & discussions** — [github.com/api7/aisix/issues](https://github.com/api7/aisix/issues)
  290. - **Contributing** — [CONTRIBUTING.md](CONTRIBUTING.md)
  291. - **Website** — [api7.ai/ai-gateway](https://api7.ai/ai-gateway?utm_source=github&utm_medium=readme)
  292. If AISIX is useful to you, a ⭐ helps other engineers find it.
  293. ## 📄 License
  294. [Apache 2.0](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.