FastAPI is a modern, high-performance Python web framework for building APIs with automatic OpenAPI documentation. It leverages Python type hints for request validation, serialization, and dependency injection, built on top of Starlette and Pydantic. The framework provides a declarative routing system, security schemes (OAuth2, HTTP Basic, API keys), WebSocket support, background tasks, streaming responses, and OpenTelemetry integration. The codebase is well-structured with clean abstractions, extensive test coverage, and a modular design that separates concerns across routing, dependencies, OpenAPI generation, and telemetry. It is actively maintained with frequent releases and a large community.
Unsloth is a full-stack, local-first AI platform for fine-tuning and inference of large language models (LLMs), diffusion models, and audio models. It consists of two primary components: (1) the core `unsloth` Python library, which provides highly optimized LoRA/QLoRA/RL training with custom Triton kernels, and (2) the Unsloth Studio application, a Tauri desktop app with a React frontend (TanStack Router, Zustand) and a FastAPI backend (SQLite, structlog). The platform enables users to discover models from the Hugging Face Hub, download and manage them locally, run inference with chat, image/video generation, and RAG, fine-tune with a visual recipe editor, and export in multiple formats (GGUF, NVFP4). It also integrates external LLM providers (OpenAI, Anthropic, Ollama) and supports agentic tool loops via MCP and Codex transports. The codebase is extensively tested with both unit tests and source-level contract tests, and includes cross-platform desktop installers for Windows, macOS, and Linux.
Headroom is a context optimization layer for LLM applications that reduces token usage by 50-90% through intelligent compression, caching, and memory systems. It provides a transparent proxy between LLM clients (like Claude Code, Cursor, etc.) and LLM providers (Anthropic, OpenAI, etc.), implementing CCR (Compress-Cache-Retrieve) for lossless compression with retrieval capability. The system features a hybrid polyglot architecture with a Rust-based high-performance proxy core, Python ecosystem for extensibility, and TypeScript SDK. Key capabilities include agent wrapping, cross-agent memory using Qdrant/Neo4j, observability through metrics and dashboard, and a learning system that analyzes interaction patterns to generate optimization rules. Deployment options include Docker, system services, and direct execution.
Frigate is a production-grade, full-stack Network Video Recorder (NVR) with real-time AI object detection. It ingests IP camera streams, performs motion detection, object detection (via TFLite/ONNX/OpenVINO/TensorRT on CPU/GPU/NPU), tracking, and recording. The backend is Python with FastAPI, Peewee ORM, and ZMQ-based inter-process communication. The frontend is a React/TypeScript single-page application with live views, timeline review, config editing, and GenAI enrichments (face recognition, license plates, semantic search, chat). It supports hardware acceleration across a wide range of devices (Coral, Intel iGPU, NVIDIA Jetson, Hailo, Rockchip NPU, etc.) and integrates deeply with Home Assistant. While primarily an application, it contains substantial data/research components including ML model runners, embedding pipelines, and post-processing logic for classification and transcription.
Rembg is a production-grade tool for removing image backgrounds, usable as a Python library, CLI, HTTP server, or Docker container. It wraps multiple ONNX-based segmentation models (U2Net, BiRefNet, SAM, BRIA-RMBG, etc.) and provides several cutout strategies: naive, alpha matting, color decontamination, and ViTMatte refinement. The architecture is modular: a session abstraction handles model download and inference, while the `remove()` function in `rembg/bg.py` orchestrates preprocessing, mask prediction, and post-processing. The CLI offers subcommands for single files (`i`), batch processing (`p`), HTTP serving (`s`), binary stream input (`b`), model download (`d`), and legacy migration (`m`). The HTTP server uses FastAPI with a Gradio UI and includes security measures like DNS rebinding protection. The codebase is well-tested, with synthetic fixtures for color decontamination and integration tests using perceptual hashing. It demonstrates strong engineering practices: idempotent migration, session caching, and careful handling of edge cases like oversized uploads and failed alpha matting convergence.
Django Ninja is a Python library that provides a FastAPI-inspired, type-hint-driven framework for building REST APIs on top of Django. It leverages Pydantic v2 for request validation and serialization, and automatically generates OpenAPI 3.0 schemas with interactive Swagger UI and Redoc documentation. The library offers a decorator-based API definition (e.g., @api.get, @router.post), supports sync and async views, and includes built-in support for authentication (API keys, HTTP Basic/Bearer, Django session), throttling, pagination (limit-offset, page-number, cursor), filtering (declarative FilterSchema), file uploads, streaming responses (SSE, JSONL), and CSRF protection. It integrates deeply with Django's ORM through ModelSchema and create_schema, and provides a TestClient for fast, serverless testing. The architecture is modular: NinjaAPI is the central application class, Router groups endpoints with nested routing and auth inheritance, and Operation handles the request lifecycle (auth, throttle, validation, response). The codebase is well-structured, extensively tested (100% coverage target), and actively maintained with broad compatibility across Python 3.7–3.14 and Django 3.1–6.1. It is a mature, production-ready framework used by multiple companies.
Gradio is a full-stack Python library and web framework for rapidly creating interactive web UIs for machine learning models, APIs, or any Python function. It provides a high-level Interface class for simple demos, a flexible Blocks API for custom layouts and event-driven apps, and a ChatInterface for chatbot applications. The backend is built on FastAPI and Uvicorn, serving both a REST API and WebSocket-based streaming. The frontend is a Svelte 5 / TypeScript application with per-component packages, a SvelteKit SSR app, and a standalone SPA that can be embedded via a custom HTML element. The library includes a rich component library (30+ input/output widgets), layout primitives (Row, Column, Tabs, Accordion, Sidebar), theming support, internationalization, and a CLI for development, deployment, and custom component creation. It also provides official Python and JavaScript client libraries for programmatic access to Gradio apps, and supports MCP (Model Context Protocol) for tool/resource integration. The repository contains over 100 runnable demos covering a wide range of ML use cases (image classification, text generation, speech recognition, object detection, chatbots, etc.), many of which integrate with Hugging Face models and datasets. While primarily an application framework, the extensive demo collection and focus on ML model visualization give it a secondary data/research character.
LightRAG is a production-ready Retrieval-Augmented Generation (RAG) framework that combines knowledge graph construction with vector-based retrieval. The system implements a dual-layer architecture managing both knowledge graphs (entities, relationships) and vector embeddings, enabling both local (entity-focused) and global (theme-focused) query modes plus hybrid combinations. It provides a FastAPI-based REST server with an embedded React WebUI, supporting 10+ LLM providers (OpenAI, Azure, Anthropic, Gemini, Ollama, Bedrock, etc.), 8+ vector/graph storage backends (PostgreSQL+pgvector/AGE, Neo4j, Milvus, Qdrant, Redis, MongoDB, OpenSearch, FAISS, NanoVectorDB), and a multimodal document parsing pipeline integrating MinerU and Docling for PDF/Office documents with tables, equations, and images. The codebase demonstrates strong engineering practices: async-first architecture with configurable concurrency controls, role-specific LLM configuration (EXTRACT, QUERY, KEYWORDS, VLM), atomic file operations for crash-safe persistence, comprehensive test coverage (300+ tests), and production deployment artifacts (Docker, Kubernetes/Helm, systemd). The parser layer is particularly well-designed with a registry-based engine dispatch (native docx/markdown, MinerU, Docling) producing a unified sidecar format. Recent additions include reranking support, asymmetric embeddings, document deletion with KG regeneration, and RAGAS/Langfuse integration for evaluation and observability.
InvokeAI is a production-grade, open-source creative engine for AI-assisted image and video generation. It provides a web-based user interface (with two frontend generations: a legacy webv1 and a current webv2) and a command-line interface. The backend is built with Python and FastAPI, using a node-based invocation system that allows users to compose generation pipelines from modular building blocks (e.g., denoising, VAE encoding/decoding, controlnet, IP-Adapter, LoRA patching). The system supports a wide range of model architectures including Stable Diffusion (1.5, 2.0, XL, 3.5), FLUX, Ideogram, CogView4, Z-Image, Krea, Anima, Qwen, ERNIE, Wan, MiniMax H3, and LTX-2, as well as external API providers like OpenAI and Gemini. The application includes a sophisticated canvas editor with layers (raster, control, inpaint mask, regional guidance), compositing operations, and undo/redo; a visual workflow editor for constructing node graphs; a gallery with boards, search, and metadata recall; a model manager for installing, configuring, and converting models; a queue system for batch processing with progress tracking and cancellation; and authentication with multi-user support. Persistence is handled via SQLite (with a custom migration system) or external MySQL/MariaDB. The frontend is built with React, Chakra UI, and nanostores/Redux for state management, with extensive internationalization scaffolding. While primarily an application, the repository contains significant research-oriented code for model architecture definitions, quantization (bitsandbytes, GGUF, SDNQ), custom PyTorch module autocasting, and image processing pipelines (Canny, depth estimation, face detection, segment anything, upscaling). The codebase demonstrates high engineering craftsmanship with abstract service layers, registry patterns, and a node-based architecture that cleanly separates concerns. However, it carries maintenance complexity from two parallel frontend codebases, vendored dependencies, and a large migration chain.
Piccolo is an async-first Python ORM and query builder targeting PostgreSQL, SQLite, and CockroachDB. It provides a declarative table definition system, automatic schema migrations, a CLI for project scaffolding, user authentication, fixture dump/load, and Pydantic model generation. The codebase is well-structured with clean abstractions (column types, query delegates, engine abstraction, migration auto-generation) and an extensive test suite covering multiple database backends. It is actively maintained with frequent releases and supports recent Python and database versions.
starlette-admin is a comprehensive admin interface library for Starlette and FastAPI applications, providing auto-generated CRUD views with search, sorting, filtering, inline editing, batch actions, import/export, and a widget-based dashboard system. It is designed as an ASGI middleware that mounts onto a Starlette app, using Jinja2 templating, itsdangerous for cookie signing, and python-multipart for file uploads. The architecture is backend-agnostic: the core defines abstract interfaces for model views, fields, filters, storage, and authentication, while optional ORM integrations (SQLAlchemy, SQLModel, Beanie, MongoEngine, Tortoise) provide concrete implementations. The library also includes a plugin and theme system, internationalization (Babel), CSRF protection, flash messages, and a full event lifecycle for audit and custom logic. It is a pure application library—no data research or analytics components.
This repository is the official FastAPI full-stack template, providing a production-ready starter for full-stack web applications. It consists of a FastAPI backend (Python 3.14, SQLModel ORM, PostgreSQL, Alembic migrations) and a React frontend (TypeScript, Vite, TanStack Router/Query, Tailwind CSS, shadcn/ui). The template ships with complete authentication (JWT, password hashing with Argon2/Bcrypt, password recovery via email), user and item CRUD, role-based access control, and a responsive dashboard UI. Deployment is handled via Docker Compose with Traefik, and the project includes comprehensive CI/CD pipelines for testing (pytest, Playwright) and deployment (FastAPI Cloud or self-hosted). While it is a template, the code is structured for immediate extension and includes many reusable patterns such as generic CRUD utilities, email templates written in React Email, and auto-generated OpenAPI client code for the frontend. The repository is not a data research project; it is a pure application template with no data pipelines, notebooks, or ML components. It is actively maintained, with frequent commits and a strong community following.
OGX (formerly Llama Stack) is a production-grade, open-source AI inference platform that provides a drop-in replacement for the OpenAI API. It is a multi-provider API gateway supporting chat completions, embeddings, the Responses API (agentic turns with tool use), vector stores, file processing, conversations, prompts, skills, and connectors. The system is built on a clean provider plugin architecture where inline (built-in) and remote providers (30+ including Anthropic, Bedrock, Gemini, Ollama, vLLM, NVIDIA) are registered via ProviderSpec and dynamically routed. The FastAPI server auto-discovers API protocols and generates routes with telemetry (OpenTelemetry), authentication, multi-tenancy, and ABAC access control. The repository includes a Next.js admin UI, a Python CLI, OpenAPI-generated client SDKs (Python, TypeScript), benchmarking tools (RAG eval, vertical scaling), and comprehensive integration tests with recording/replay. It is designed for self-hosted or cloud deployment with Kubernetes and Docker support.
Nebula is a local-first security assessment workbench designed for penetration testing and red teaming operations. It functions as a desktop application built with a Tauri shell (Rust) wrapping a React/TypeScript frontend and a Python FastAPI backend sidecar. The system manages security engagements, scope policies, evidence collection, and AI-assisted analysis, emphasizing operator control, auditability, and data privacy through local-first execution and content-addressed artifact storage. The architecture follows a sidecar pattern where the Python Core service handles database operations (SQLite with Alembic), containerized command execution (Kali Linux via Docker/Podman), and AI provider integration. The frontend manages the UI state and terminal sessions via WebSocket. Key data flows involve user actions triggering API calls that validate against scope policies before executing commands in isolated containers, with all outputs stored as immutable artifacts for evidence integrity. The codebase demonstrates strong engineering practices with extensive test coverage (Pytest, Vitest, Playwright), a robust diagnostic system with secret redaction, and a policy engine for deterministic scope enforcement. It supports multiple AI providers and includes features for knowledge indexing, mission orchestration, and report generation. The project is actively maintained with recent commits and zero security alerts, though it is currently in alpha release.
Vigil is an open-source AI SOC (Security Operations Center) platform that orchestrates autonomous threat hunting, incident response, and case management through a multi-agent architecture. The system ingests security findings from SIEMs (Splunk, Elastic, Azure Sentinel), EDRs (CrowdStrike, Microsoft Defender), and other sources via Kafka or webhooks, then uses LLM-driven agents (hunt, root_cause, adjudicate, investigate, compose, chat) to analyze, enrich, and respond. A TypeScript agent layer with event-sourced ledgers and budget enforcement runs investigations, while a Python daemon handles polling, deduplication, and orchestration. The platform exposes its own tools via MCP (Model Context Protocol) and integrates with 30+ external security tools through a descriptor-based plugin system. The frontend is a React SPA with a setup wizard, dashboards, and case management UI. Deployment is via Docker Compose or Helm, with PostgreSQL, Redis, and optional Kafka as backing services.
This is a full-stack web application that converts screenshots, images, text descriptions, and video recordings into functional code—primarily HTML with Tailwind CSS, but also supports React, Vue, Bootstrap, and Ionic stacks. The backend is a FastAPI server with a WebSocket-based streaming architecture. It orchestrates multiple AI models (OpenAI, Anthropic, Gemini) through a modular provider abstraction layer, using an agent system with tools such as create_file, edit_file, generate_images, extract_assets, and screenshot_preview. The frontend is built with React, Zustand for state management, Tailwind CSS, and shadcn/ui components. Users can upload images, paste URLs, type descriptions, import existing code, or record screen videos. Generated code is presented with live preview (desktop/mobile), version history (commits and variants), design system management, and an interactive select-and-edit mode for making targeted updates. The application also includes a sophisticated evaluation infrastructure for benchmarking different models and prompts, with agent run logging, cost tracking, and prompt reports that help developers compare outputs across configurations. Although primarily an application, the extensive eval system gives it a hybrid character with data-research elements.
Windows Copilot API is an unofficial Python library and OpenAI-compatible HTTP server that bridges the consumer Microsoft Copilot chat service. It uses a pure-HTTP driver with curl_cffi to impersonate Chrome and speak Copilot's WebSocket protocol, handling authentication, proof-of-work challenges, and Cloudflare Turnstile clearance in-process. A Playwright-based browser module enables interactive sign-in and scheduled clearance refresh. The server wraps the library behind FastAPI endpoints exposing /v1/chat/completions and /v1/models with full streaming support, rate limiting, and concurrency serialization to cope with Copilot's single-account constraints. Notable features include transparent token refresh, conversation persistence, and a diagnostic tool for session debugging. The codebase is well-structured, with clear separation of concerns across protocol constants, challenge solvers, models, and drivers. It demonstrates advanced reverse-engineering and browser-emulation skills.
Comet is a production-grade Stremio add-on (and Kodi plugin) that functions as a high-performance torrent and debrid streaming proxy. It aggregates torrent metadata from 15+ indexers (Torrentio, Jackett, Prowlarr, Nyaa, DMM, etc.), caches results intelligently, and optionally shares discovered metadata across a custom P2P network (CometNet). The architecture is a FastAPI web server with multiple background workers for proactive scraping, metadata enrichment (TMDB, Kitsu, Cinemeta), debrid account syncing, and automated DMM hashlist ingestion. It provides a built-in streaming proxy with per-IP bandwidth controls, an admin dashboard for monitoring and control, and integrates with Prowlarr/Radarr/Sonarr via Torznab. The codebase is well-structured with comprehensive test coverage, Pydantic validation throughout, async-first patterns, and a clean scraper abstraction layer. It is actively maintained with frequent commits and a mature feature set, though the CometNet P2P component remains experimental and some external scrapers may be fragile due to Cloudflare protections.
This repository is a production-grade, AI-powered stock analysis platform for CN, HK, US, JP, KR, and TW markets. In production it runs a scheduled analysis pipeline that fetches market data from multiple providers (akshare, yfinance, tushare, efinance, futu, etc.) with priority-based fallback, feeds the data to LLM backends via LiteLLM, generates structured decision reports, and pushes them through 15+ notification channels (WeChat, Feishu, DingTalk, Telegram, email, Discord, Slack, etc.). It also exposes a FastAPI REST API, a React/TypeScript web dashboard, an Electron desktop client, and bot integrations for Feishu/DingTalk/Discord. The system includes agent-based chat with tool use, screening, backtesting, alerts, portfolio management, decision-signal tracking, and market review capabilities.
Voicebox is a local-first, open-source desktop application for AI voice cloning, text-to-speech (TTS), speech-to-text (STT), and dictation. It provides a full voice I/O stack that runs entirely on the user's machine, supporting multiple TTS engines (Qwen3-TTS, Chatterbox, Kokoro, TADA, LuxTTS, etc.) with zero-shot voice cloning from short audio samples. The application is built as a Tauri v2 desktop shell (Rust) wrapping a React/TypeScript frontend and a Python FastAPI backend with SQLite storage. Key features include global dictation with auto-paste, voice profile management with effects chains, a multi-track story editor, MCP server integration for AI agents, and GPU acceleration (CUDA, ROCm, MLX, DirectML). The architecture follows a service-oriented pattern with a backend factory for pluggable TTS/STT engines, SSE-based progress streaming, and a platform abstraction layer for cross-platform compatibility. The codebase is well-structured with extensive documentation, CI/CD pipelines, and a large community.