AxonHub is a production-grade, multi-provider LLM API gateway that routes, transforms, and manages requests to a wide range of AI providers (OpenAI, Anthropic, Gemini, DeepSeek, xAI, and 60+ others). It provides a unified API surface for chat completions, embeddings, moderations, audio, images, and video generation, with sophisticated features like load balancing (latency-aware, weighted round-robin, circuit breaker), per-channel rate limiting, provider quota enforcement, streaming, and reasoning token handling. The backend is written in Go using Gin, Ent ORM, gqlgen, and Uber Fx for dependency injection, supporting PostgreSQL, MySQL, and SQLite with automatic migration. The frontend is a comprehensive React/TypeScript SPA (Vite, TanStack Router/Query, Tailwind, shadcn/ui) that provides administration of channels, models, API keys, users, roles, projects, and system settings. It includes analytics dashboards, request tracing, usage logs, and OIDC SSO. The system is designed for multi-tenancy with fine-grained RBAC (scope-based permissions) and privacy policies enforced at the Ent ORM layer. Deployment is supported via Docker, Docker Compose, and Helm charts. The codebase exhibits strong engineering practices: extensive unit and integration tests (including race-condition tests and E2E Playwright tests), pipeline middleware for request transformation, generic caching abstractions, stream processing utilities, and a Zanzibar-inspired authorization framework. While there are minor issues (duplicate utility packages, a typo in a folder name, and some frontend boilerplate repetition), the overall architecture is clean, modular, and well-documented. The project is actively maintained with frequent commits, issue triage, and a clear release process.
CLIProxyAPI is a sophisticated Go-based proxy/gateway service that acts as an intermediary between clients and multiple AI service providers (OpenAI, Claude, Gemini, Codex, xAI/Grok, etc.). It handles authentication, request/response translation, routing, and management of AI API interactions. The system features a modular architecture with distinct layers for server handling, authentication, execution, translation, plugins, and configuration. It provides both REST and WebSocket interfaces, includes a terminal UI for interactive management, and offers extensibility through a plugin system. The codebase demonstrates strong engineering practices with comprehensive testing, clear separation of concerns, and reusable components.
Higress is a cloud-native, AI-native API gateway built on Istio and Envoy. In production, it operates as a Kubernetes ingress controller, an AI/LLM proxy gateway, and a Wasm plugin host. The system ingests Kubernetes resource definitions (Ingress, Gateway API, custom CRDs like WasmPlugin, Http2Rpc, McpBridge) and translates them into Envoy xDS configurations, managing the full lifecycle of gateway routes, policies, and plugins. It provides a rich set of Wasm plugins (Go, Rust, C++, AssemblyScript) for authentication, rate limiting, request/response transformation, AI proxy (with 15+ LLM providers), semantic caching, RAG, MCP server hosting, and security (WAF, bot detection, IP restriction). The architecture is microservices-oriented: a control plane (Go-based ingress controller) manages Kubernetes resources and pushes config to Envoy data planes; a CLI tool (hgctl) handles installation, plugin development, and debugging; and a plugin release pipeline manages OCI image distribution with provenance verification. External dependencies include Kubernetes (client-go, controller-runtime), Istio (pilot, networking APIs), Envoy (Go filter API), and various AI/vector DB providers (OpenAI, Milvus, Pinecone, etc.).
Kong is a cloud-native, platform-agnostic API gateway built on OpenResty/Nginx. It provides traffic management, security, observability, and AI/LLM proxying capabilities through a plugin architecture. The system supports traditional, DB-less, and hybrid deployment modes, with an Admin API for configuration and Kong Manager for GUI-based management. Key features include load balancing, authentication, rate limiting, request/response transformation, and extensive observability integrations.
free-claude-code is a local proxy and developer tool that connects coding agents (Claude Code and similar harnesses) to OpenAI-compatible AI providers. It is a Python package (`free_claude_code`) with a CLI, a local API server, an admin web UI, and a substantial configuration subsystem. The system abstracts over a dozen AI providers (including NVIDIA NIM, Cloudflare, HuggingFace, and others) with provider-specific workarounds for tool parameter aliasing, thinking templates, and reasoning replay. It persists sessions, messages, and model metadata in SQLite, manages a tree-based conversation model with Telegram platform support, and renders transcripts with segment-based truncation and subagent state management. The repo is a shipped developer tool with installer/update scripts, GitHub issue templates, dependabot config, and a diagnostic `fcc-doctor` command; it is not a research or data project.
ccNexus is a desktop application (built with Wails v2, Go backend + web frontend) and a headless server that acts as a smart proxy for multiple AI API endpoints, including Claude, OpenAI Chat, OpenAI Responses, and Gemini. It manages endpoint rotation with automatic failover, credential token pools (API keys, access tokens, refresh tokens), and real-time format conversion between the different API protocols. The system provides a full-featured GUI for managing endpoints, viewing usage statistics, configuring backup/restore (WebDAV, local, S3), launching Claude Code or Codex CLI terminals, and applying visual themes. A separate web UI is available for headless deployments via Docker. The architecture follows a layered design: a proxy layer handles request routing, authentication, and streaming response transformation; a transformer layer converts between API formats using a registry of converters; a storage layer persists endpoints, credentials, and stats in SQLite; and a service layer orchestrates higher-level operations like backup, updates, and terminal launching. The codebase demonstrates strong engineering practices including thread-safe configuration, adapter patterns for storage abstraction, SSE for real-time stats, and comprehensive contract tests. Notable features include zero-cost endpoint testing, incremental stats updates, and a credential lifecycle management system with rate limit tracking and automatic cooldown. While primarily an application, ccNexus includes some data-oriented components such as token counting, usage statistics aggregation, and credential rate limit parsing. However, these serve the operational needs of the proxy rather than constituting a data research pipeline. The project is actively maintained with a responsive issue tracker and regular releases.
Kiro Account Manager is a Tauri-v2 desktop application (Rust + React/TypeScript) that manages multiple Kiro IDE accounts with smart switching, quota monitoring, token refresh, and machine-ID rotation to avoid multi-account association. It also ships a fully featured local HTTP gateway (Kiro2API) that exposes managed accounts via OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages APIs, with load balancing, model mapping, prompt filtering, response caching, and streaming. Additionally, the app provides a configuration surface for Kiro IDE settings, MCP servers, custom agents, skills, steering rules, hooks, and powers. It supports multiple authentication providers (Google, GitHub, AWS Builder ID, IAM Identity Center) and integrates with the Kiro CLI SQLite database for account import. The architecture follows a clean separation—Rust backend handles all business logic via Tauri IPC commands, while the React frontend uses Radix-based UI components and context-based state management. Despite its broad feature set, the codebase demonstrates professional engineering practices with extensive testing in both Rust and TypeScript, though some modules are monolithic and contain hardcoded constants tied to Kiro-specific APIs.
Antigravity-Manager is a professional-grade desktop application (Tauri + React + Rust) that serves as an AI account manager and local proxy gateway. It manages multiple AI service accounts (Google Gemini, Anthropic Claude, OpenAI) by handling OAuth token lifecycle, device fingerprinting, quota tracking (5-hour rolling and 7-day weekly buckets), and subscription tier management (Free/Pro/Ultra). The built-in reverse proxy (Axum HTTP server) translates between different AI provider protocols (OpenAI, Anthropic, Gemini), supports streaming, handles rate limiting with adaptive retry, and provides intelligent request routing with account failover. It also syncs its configuration to popular AI CLI tools (Claude Code, OpenCode, Hermes, etc.) and includes a comprehensive monitoring dashboard, IP security filtering (CIDR blacklist/whitelist), user token management, and a warmup scheduler to prevent quota decay. The application runs as a Tauri desktop app with optional headless/Docker mode for containerized deployment.