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.
This repository is a Serverless Framework plugin that enables deploying Python WSGI applications (Flask, Django, Pyramid, etc.) to AWS Lambda via API Gateway or ALB. It automatically converts API Gateway events (v1, v2) and ALB requests into WSGI environ dictionaries, invokes the application, and transforms the response back into the appropriate Lambda proxy format. The plugin also provides a local development server (`sls wsgi serve`), automated dependency packaging from `requirements.txt`, and remote execution commands for Python code, shell commands, Django management commands, and Flask CLI commands. The codebase is split into a Node.js plugin (`index.js`) that hooks into Serverless lifecycle events (packaging, deployment, invoke local) and a set of Python modules (`serverless_wsgi.py`, `wsgi_handler.py`, `serve.py`, `requirements.py`) that handle the actual WSGI conversion, local serving, and dependency installation. The core WSGI adapter (`serverless_wsgi.py`) is a standalone, reusable library that can be used independently of the Serverless framework for any Lambda function needing to handle API Gateway events. The plugin is well-tested with both JavaScript and Python test suites, and follows a clean, modular architecture.
Apache ServiceComb Java Chassis is a production-grade microservices SDK for Java, providing a comprehensive framework for building, registering, discovering, and governing distributed services. It supports multiple programming models (Spring MVC, JAX-RS, POJO) and transport protocols (REST over Vert.x/Servlet, custom binary Highway, WebSocket). The architecture is modular: a core engine (SCBEngine, Invocation) orchestrates filter chains for consumer, provider, and edge roles; pluggable service registries (ServiceCenter, Consul, ZooKeeper, Nacos, etcd, lightweight) handle discovery and registration; governance modules (circuit breaker, retry, rate limiting, bulkhead, fault injection) are policy-driven via Resilience4j; and Swagger/OpenAPI generators automatically produce API contracts from Java annotations. Dynamic configuration is supported through multiple sources (config-center, Kie, Apollo, etcd) with priority-based injection and hot-reloading. External dependencies include Spring Boot, Vert.x, Jackson, Guava, Resilience4j, Zipkin, and Micrometer. In production, a typical data flow begins with a consumer invocation (via RestTemplate, Invoker.createProxy, or RpcReference) that passes through a consumer filter chain (load balancing, retry, circuit breaker), then a transport layer (REST or Highway) to the provider, which processes the request through a provider filter chain (rate limiting, validation, business logic) and returns a response. The framework handles service registration at startup, periodic heartbeats, and instance cache updates via discovery events. Edge/gateway services can apply custom authentication and routing filters. The codebase is large (3355 files) but well-organized into modules: core, transports, providers, governance, swagger, service-registry, clients, foundations, and demos. It demonstrates strong engineering practices: extensive use of SPI for extensibility, filter chain pattern for middleware, event bus for decoupled lifecycle events, and priority-based configuration management. However, the sheer number of demo modules and multiple registry implementations introduces maintenance overhead, and some legacy patterns (LegacyPropertyFactory, JMockit in tests) indicate areas of technical drift.
This repository implements an OpenAI-compatible REST API proxy for Amazon Bedrock, enabling applications built for OpenAI SDKs to seamlessly use Bedrock foundation models without code changes. The FastAPI-based service translates standard OpenAI API calls (chat completions, embeddings, models listing) into Amazon Bedrock runtime invocations and returns responses in OpenAI-compatible format. The architecture supports two deployment options: Lambda with API Gateway (serverless, cost-effective) or Fargate with ALB (lowest latency, no cold starts). Key features include streaming responses via SSE, tool/function calling, multimodal inputs, prompt caching for Claude/Nova models, reasoning mode for Claude 3.7 and DeepSeek R1, and interleaved thinking for Claude 4 models. Infrastructure is managed via CloudFormation templates with proper IAM roles and Secrets Manager integration for API key authentication. The codebase demonstrates solid engineering practices with clean separation of concerns, proper error handling, and comprehensive feature support. However, the absence of test files and limited documentation reduce overall quality. The project is actively maintained with recent commits and up-to-date dependencies.
NyaProxy is a lightweight API gateway/proxy service built with FastAPI and Uvicorn that manages authentication, credential rotation, load balancing, rate limiting, and observability for HTTP APIs. It acts as an intermediary between clients and upstream services, injecting credentials, enforcing quotas, and providing features like retry logic, key quarantine, and request/response transformation. The system includes a web dashboard for monitoring traffic, metrics, and queue status, and exposes Prometheus metrics for external monitoring. The architecture follows a modular design with separate concerns: core proxy logic (queue-first request handling), traffic management (load balancing and rate limiting), configuration management (using Nacho for layered config and schema validation), services (metrics, state persistence), and a dashboard interface. Requests are processed via a priority queue with worker pools, enabling prioritization of retries and high-priority requests. State persistence saves rate limit windows and key cooldowns to disk using SHA256-hashed keys to avoid storing secrets, allowing survival across restarts. Key entry points include the CLI (`python -m nya` or `nyaproxy` script) and the main application factory in `nya/server/app.py`. The system relies on dependencies like FastAPI, Uvicorn, Pydantic, Nacho, and the Prometheus client, with explicit version pins in `pyproject.toml` and regular updates shown in the changelog. The codebase demonstrates strong engineering practices including comprehensive test coverage (unit and end-to-end), secure secret handling, and clean separation of concerns.
WSO2 API Manager is an enterprise-grade API management platform. In production, it provides API publishing, a developer portal, a gateway for request mediation/security enforcement (authentication, rate limiting, threat protection), a key manager (OAuth2, JWT, API keys), and a traffic manager for analytics and throttling. The architecture is modular, with deployable profiles (all-in-one, control-plane, gateway, traffic-manager) built on the WSO2 Carbon kernel with Apache Synapse mediation. The codebase is primarily Java/Maven with Python-based recommendation engine components, extensive integration tests (both legacy TestNG and a modern Cucumber/Testcontainers parallel framework), and sample scenarios. Key entry points include REST APIs (Publisher, Developer Portal, Admin, Gateway), startup scripts (api-manager.sh), and deployment configuration (deployment.toml). External dependencies include WSO2 Identity Server for key management, databases (H2/PostgreSQL), MongoDB for recommendations, and various protocols (REST, GraphQL, WebSocket, SSE, WebSub, SOAP, MCP).
The Kong OIDC plugin is an OpenID Connect Relying Party (RP) implementation for the Kong API gateway. It authenticates users against an OpenID Connect Provider using the Authorization Code flow and supports token introspection for Bearer tokens. The plugin maintains user sessions and adds headers (X-Userinfo, X-Access-Token, X-ID-Token) to the upstream request for use by backend services. The plugin follows a modular architecture with separate modules for handling the main logic (handler.lua), request filtering (filter.lua), session configuration (session.lua), and utility functions (utils.lua). It relies on the `lua-resty-openidc` library for the core OIDC protocol handling. Key features include configurable session storage (client-side cookie or server-side via shared memory, memcache, or Redis), caching of discovery documents and access tokens, and support for both authentication and token introspection modes. Note: This repository is not maintained and is not recommended for use in production, as indicated in the README. The last commit history shows no recent activity, and dependencies are outdated relative to current Kong and OIDC library versions.
BlossomGateway is a custom API gateway built on Netty, supporting HTTP and Dubbo protocols. It uses Nacos for service registration and configuration, Redis for distributed rate limiting, and provides a pluggable filter chain for routing, load balancing (random, round-robin, weighted, consistent hash), authentication (JWT), gray release, flow control (Guava/Redis), circuit breaking (Hystrix), monitoring (Prometheus), and mocking. The gateway core is a Netty server that processes incoming HTTP requests, creates a GatewayContext, and runs through a chain of filters before routing to backend services. It also includes a client SDK (BlossomGateway-Client) for downstream services to register themselves. Additionally, the repository contains a separate custom RPC framework (BlossomRPC) with its own protocol, serialization, and dynamic proxy, which appears to be experimental/educational. The project is structured as a multi-module Maven project with clear separation of concerns. However, the codebase shows signs of being a learning project with many TODOs, hardcoded values, and personal promotional content, indicating it may not be production-ready.
APIMyLlama is a Node.js application that serves as a proxy and management layer for the Ollama API. It provides an endpoint (/generate) to interact with LLMs using API keys, which are managed via a command-line interface. The application includes features such as API key generation, validation, rate limiting, webhook notifications, and dynamic configuration of server port and Ollama URL. The architecture is monolithic, leveraging Express for HTTP handling, SQLite for persistence, and a custom CLI for administrative tasks. Key components include rate limiting middleware and a webhook notification system, which demonstrate common patterns in API management. However, the project suffers from dependency issues where the version constraints for axios and express are set to versions (>=1.13.5 and >=5.2.1) that are not currently available, preventing installation with the latest stable packages. This indicates a lack of maintenance in terms of dependency updates, despite recent commits.
This repository implements an API Gateway based on Openresty and NGINX with LuaJIT for high-performance request processing. The system provides service discovery via Marathon integration, API key validation, HMAC/OAuth authentication, rate limiting, request/response transformation, and metrics collection. Architecture-wise, it uses a modular design with NGINX configuration files defining request processing phases, Lua modules for extensible functionality (validation, tracking, metrics), and external dependencies for service discovery (Marathon), caching (Redis), and metrics reporting (StatsD). Key entry points include the health-check endpoint (/health-check), metrics endpoint (/api-gateway-stats), and admin API (/tracking/* on port 5000). The gateway processes client requests through validation phases, proxies them to backend services, collects metrics throughout, and returns responses while supporting dynamic configuration reloading and remote config sync from S3.