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.
This is the official Gemini CLI by Google, a terminal-based AI assistant that brings Gemini models to the command line. It is a large TypeScript monorepo with packages for the CLI (interactive UI built on Ink/React), core agent logic (context management, tool execution, routing, policy enforcement), SDK for programmatic agent sessions, A2A server for agent-to-agent communication, and supporting tooling (devtools, test utilities, caretaker agent for automated issue triage). The CLI supports slash commands, extensions (hooks, MCP servers, themes), skills, sandboxed execution, multiple authentication methods (OAuth, API key, Vertex AI), and rich terminal features like themes, keybindings, and mouse support. It includes an extensive evaluation framework for behavioral testing of agent capabilities. The architecture is modular with clear separation between UI, core agent loop, and extensibility layers, though the monorepo size introduces some coupling and test fragility.
TranslateBooksWithLLMs is a full-stack web application for translating eBooks (EPUB, DOCX, TXT, SRT) using multiple LLM providers (Ollama, OpenAI, Gemini, Mistral, DeepSeek, Poe, OpenRouter, NVIDIA NIM, LiteLLM). The architecture is a Flask server with Socket.IO for real-time progress streaming, a JavaScript SPA frontend with i18n support across 7 locales, and a SQLite-based checkpoint/resume system for interrupted translations. The core pipeline extracts content with HTML/XML placeholder preservation, chunks text using tiktoken-aware splitting, translates via configurable LLM providers with multi-phase fallback (LLM → token alignment → original), and reconstructs the output file. Additional features include glossary management with NER-based term suggestion, style extraction from source text, TTS generation via Edge-TTS and Chatterbox, and a comprehensive benchmark framework for evaluating translation quality across 35+ languages. The codebase demonstrates strong engineering with clean abstractions (adapter pattern for formats, factory pattern for LLM providers, generic orchestrator for translation pipeline), extensive testing (unit, integration, characterization with golden snapshots, e2e), and several genuinely reusable components. Notable patterns include a token-aware chunker with exact reassembly, an API key pool with round-robin rotation on 429 responses, an ordered concurrent executor that preserves chunk ordering, a retry manager with exponential backoff and circuit breaker, and a placeholder system for preserving HTML/XML structure during LLM translation. The benchmark subsystem and prompt optimization tool are supporting features that add research value but are secondary to the core application purpose.
LangExtract is a Python library for extracting structured information (entities, relationships) from unstructured text using large language models (LLMs). It provides a production-grade pipeline: chunking long documents, building prompts with few-shot examples, invoking LLMs (Gemini, OpenAI, Ollama, or custom providers), parsing and fuzzy-aligning the output to source text, and generating interactive HTML visualizations. The architecture is modular with a plugin system for providers, a schema system for output constraints, and a resolver for alignment. It includes comprehensive tests, benchmarks, and CI/CD. The library is actively maintained with a clear deprecation path for v2.0.0. Notable strengths are the provider plugin system, fuzzy alignment algorithms, and format handling. Weaknesses include some deprecation debt and complex alignment code.
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.
This repository implements a fully autonomous pipeline that generates, produces, and uploads educational YouTube videos daily. It uses the Gemini 2.5 Flash API to create lesson scripts and curricula, gTTS for narration, Pexels for background imagery, and MoviePy/Pillow for video rendering. The pipeline runs on a GitHub Actions cron schedule, requiring no manual intervention. It produces both a long-form lesson video and a YouTube Short, uploads them with custom thumbnails, and updates the content plan repository. The code is well-structured for its purpose, with proper error handling, retry logic for TTS rate limits, and credential management for YouTube OAuth. While not a reusable library, it demonstrates good software engineering practices for a CI/CD-based content generation system.
Antigravity Manager is an Electron desktop application that serves as a multi-account manager and local API proxy gateway for AI models (Google Gemini, Claude, OpenAI-compatible). It allows users to pool multiple Google Cloud accounts, automatically rotates between them based on real-time quota and rate limits, and exposes a local proxy server that translates between OpenAI, Anthropic, and Gemini API protocols. The application handles OAuth token lifecycle, credential storage across OS keychains and encrypted files, and includes a React UI for account management, quota monitoring, and configuration. Architecturally, the app is a monolith with three major layers: an Electron main process that bootstraps a NestJS server (Fastify), a React renderer with TanStack Router and shadcn/ui, and a Python CLI for headless account operations. The proxy gateway is the most complex module, with controllers for OpenAI chat completions, Anthropic messages, Gemini models, batch jobs, file uploads, and WebSocket-based Responses API. Credential management is handled through a multi-provider master key system with migration paths, atomic file writes, and SQLite persistence via Drizzle ORM. The codebase also includes device identity profile manipulation (fingerprint spoofing) gated by environment variables, and binary patching of the agy CLI executable. The codebase demonstrates strong engineering practices with extensive Vitest unit tests (250+ test files), Playwright e2e tests, Zod schema validation at IPC boundaries, and structured error handling. However, it also carries risks: hardcoded model aliases and Google API endpoints, fragile binary patching logic, and a large surface area of credential storage strategies that may drift as OS APIs evolve. The repo is actively maintained with frequent commits and CI pipelines, but the complex fallback chains and security-sensitive code require careful ongoing maintenance.
This repository is a serverless web application that serves as a playground and API proxy for Google's Gemini Multimodal Live API. It provides a client-side interface for real-time text, audio, video, and screen-sharing interactions with the Gemini model. Crucially, it includes a backend proxy layer (deployable on Cloudflare Workers or Deno) that converts the native Gemini WebSocket/REST API into an OpenAI-compatible format, enabling integration with third-party clients like ChatBox or Cursor. The architecture is split between a static frontend (vanilla JS) and a lightweight serverless proxy that handles authentication, protocol translation, and streaming logic.
gcli2api is a FastAPI-based API proxy/gateway that converts between multiple AI model API formats (OpenAI, Google Gemini, Anthropic Claude) and two private backend services: GeminiCLI and Antigravity. It provides a web control panel for managing OAuth credentials across pluggable storage backends (SQLite, PostgreSQL, MongoDB), with automatic credential rotation, retry logic, and streaming support. The system also includes anti-truncation and fake streaming modes for handling long responses or models without native streaming. It is designed for users who need a unified, multi-account interface to Google's Gemini and related services, with a focus on reliability and credential pooling. The frontend is a static HTML/JS control panel that supports credential upload, batch operations, real-time logs via WebSocket, and configuration hot-reload.
GeminiProChat is a minimal web UI for interacting with Google's Gemini Pro API. It is built as a server-side rendered application using Astro with SolidJS for interactive components. The application provides a chat interface where users can send messages and receive streaming responses from the Gemini model. It supports features like system role settings, temperature control, message history persistence, password protection, and PWA capabilities. The architecture consists of Astro pages (index, password), API endpoints (auth, generate), and SolidJS components for the chat generator, message rendering with markdown and code highlighting, and a theme toggle with view transitions. External dependencies include the Google Generative AI SDK (patched to use v1beta API), markdown-it for rendering, and Zag.js for slider components. The application can be deployed on Vercel, Netlify, Railway, Zeabur, or via Docker, with environment variables for API key, base URL, password, and model name.
DemoGPT is an open-source Python framework that provides two core capabilities: (1) an automatic Streamlit application generator that converts natural language descriptions into complete, runnable Streamlit apps through a multi-stage LLM pipeline (planning, task decomposition, code generation, assembly), and (2) the DemoGPT AgentHub, a modular library for building AI agents with built-in tools (web search, code execution, Wikipedia, weather, etc.), two agent types (ToolCallingAgent for single-step tasks, ReactAgent for multi-step reasoning), and a RAG (Retrieval Augmented Generation) system supporting Chroma, FAISS, and Pinecone vector stores. The codebase is primarily a library/application hybrid, with the Streamlit app acting as both a user interface and a demonstration of the generation pipeline. The architecture separates concerns into chains, prompts, task definitions, and controllers, but many components are tightly coupled to the specific generation pipeline. The AgentHub portion is more modular and reusable. Technical drift is medium: the code uses deprecated LangChain APIs (LLMChain, Chain.run), hardcodes older models like gpt-3.5-turbo-16k in some generated code, and has a broad dependency range. Maintenance appears active with recent commits and responsive issue triage, but the codebase would benefit from modernizing to LangChain's new LCEL syntax and updating default models.
The repository is a simple Flask web application demonstrating interaction with the Google Gemini API for text and multimodal chat. It provides a UI for sending text messages and uploading images, maintaining a chat session via the Gemini API and streaming responses using Server-Sent Events. The architecture is monolithic with backend logic in app.py, served frontend static files, and a single HTML template. Key endpoints include '/' for the main page, '/upload' for file handling, '/chat' for message reception, and '/stream' for response streaming. While functional for demonstration, the application relies on global variables for state management (chat session, pending message, pending image), making it unsuitable for production multi-threaded environments without modification. The code is straightforward and serves as an educational starting point for Gemini API integration, but lacks reusable components due to tight coupling and simplicity-focused design. Dependencies are current, and the repository shows recent maintenance activity.