PaperQA2 is an agentic retrieval-augmented generation (RAG) system for scientific literature. It answers questions by searching, indexing, and analyzing PDFs, text documents, and clinical trials using a multi-step agent workflow. The system integrates with multiple scholarly metadata providers (Crossref, Semantic Scholar, OpenAlex, Unpaywall) for DOI resolution, citation counts, retraction detection, and journal quality scoring. It supports multiple LLM backends via LiteLLM, pluggable PDF readers (pypdf, PyMuPDF, Docling, Nemotron), and vector stores (Numpy, Qdrant). The architecture is a Python library with a CLI (`pqa`), featuring a hierarchical Pydantic settings system, an agent framework with tool selection and memory, and a plugin-based document parsing pipeline. While primarily an application, it is research-backed with published benchmarks (LitQA2, LFRQA) and includes config presets for different quality/performance trade-offs.
bitsandbytes is a production-grade Python/C++ extension library that enables k-bit quantization for PyTorch. Its actual function is to reduce the memory footprint of large language model training and inference by providing 8-bit blockwise quantized optimizers (Adam, AdamW, LAMB, Lion, AdEMAMix, etc.), 4-bit NF4/FP4 quantized linear layers used by QLoRA, and LLM.int8()-style mixed-precision matmul with outlier separation. It is an application library rather than a data research repository; the research algorithms it implements are packaged as reusable, production-oriented components exposed to downstream libraries such as Hugging Face Transformers, PEFT, Accelerate, TGI, and vLLM. Users interact through quantized nn modules, functional quantize/dequantize primitives, optimizer classes, and autograd matmul functions.
AutoRAG is a production-grade, privacy-focused personal AI assistant and retrieval-augmented generation (RAG) agent. It provides a local-first search and answer engine that indexes federated datasources (Slack, Discord, KakaoTalk, GitHub, email, Obsidian, RSS, cloud drives, and more) via external CLI connectors, without migrating data. The system exposes a CLI, MCP server, TypeScript API, and a TUI (Pi interactive host), and powers a separate desktop Electron app. Its architecture is modular: a configurable agent (`AutoRAGAgent`) orchestrates multiple retrieval methods (BM25, semantic vectors, hybrid RRF, file-name search, web search), document parsing (PDF, DOCX, HWP, images via OCR), embedding (local Qwen3 model or external APIs), reranking (OpenRouter/Dazzi), and evidence judgment. A peer-to-peer layer (SimpleX) enables policy-controlled file sharing with injection and PII gates. The repository also contains a legacy Python codebase (`legacy/`) focused on automated RAG pipeline evaluation and QA dataset generation, which is in maintenance mode but still provides reusable metrics and pipeline components. This is a hybrid project where the dominant character is a modern TypeScript application, with significant data/research heritage in the legacy Python portion.
PPTAgent is an agentic PowerPoint generation system designed for integration with AI coding agents (Claude Code, Codex, OpenCode). It creates editable PowerPoint presentations from text briefs through a workflow involving HTML slide authoring, rendering, visual review (either multimodal or via external visual models), and PPTX export. The system features a dual-codepath architecture: 'deeppresenter/' as the current runtime with CLI, multi-agent orchestration, and MCP tool integration, and 'pptagent/' as the legacy core generation library still used for the MCP server entrypoint. Key capabilities include template-driven slide generation, visual quality validation, context management to prevent overflow, and support for optional document processing (MinerU) and search APIs. The skill-based architecture allows coding agents to invoke presentation generation as a tool while maintaining editable source artifacts.
This is the canonical implementation of OpenAI's Harmony response format, the structured prompt format used by the gpt-oss open-weight model series. The repository provides a high-performance Rust core for rendering conversations into token sequences and parsing model outputs back into structured messages. It supports multi-channel reasoning (analysis, commentary, final), tool/function calling with JSON Schema-defined parameters, structured outputs, and streaming incremental parsing. The library is packaged with first-class Python bindings via PyO3 and a JavaScript/WASM build for browser use. A Next.js demo visualizes the token-level rendering. The codebase demonstrates strong engineering: a custom BPE tokenizer (tiktoken) implementation in Rust, a streaming parser that gracefully handles partial UTF-8 sequences, and a JSON Schema-to-TypeScript converter for tool definitions. Tests are comprehensive with parity between Rust and Python test suites.
This repository is a production-grade application for building real-time voice agents, primarily designed as an educational course but structured for actual deployment. It implements a complete voice call center system capable of receiving and making phone calls via Twilio, transcribing speech using various STT models (Moonshine, Whisper, Faster Whisper), reasoning with LLMs (Groq), searching property data using Superlinked and Qdrant, and generating speech using TTS models (Kokoro, Orpheus). The architecture is a modular monolith built with FastAPI, utilizing Docker for containerization and RunPod for GPU-accelerated model inference. While the repository includes Jupyter notebooks for educational purposes (Lesson 1-4), the core value lies in the `src/realtime_phone_agents` package, which encapsulates the agent logic, avatar system, and infrastructure integrations. The code demonstrates high craftsmanship in handling async audio streaming, managing external API dependencies, and implementing a flexible avatar registry system. It is suitable for engineers looking to build voice AI applications or understand the integration of LLMs with real-time audio pipelines.
This repository is a high-performance React Native library (llama.rn) that enables on-device Large Language Model (LLM) inference on iOS and Android devices. It wraps the C++ llama.cpp core using JavaScript Interface (JSI) and TurboModules, allowing mobile applications to run GGUF-formatted models locally without cloud dependencies. The architecture consists of a TypeScript/JavaScript layer for the React Native interface, a C++ core for inference and model loading, and native modules for Android (Java/Kotlin) and iOS (Objective-C++). Key capabilities include hardware acceleration via Apple Metal and Qualcomm Hexagon DSP, multimodal support (vision/audio), parallel decoding, and structured output generation. The project includes a comprehensive example app demonstrating chat interfaces, model management, and benchmarking tools.
This is a production-grade, AI-powered code review automation tool that integrates with multiple version control systems (GitHub, GitLab, Bitbucket Cloud/Server, Azure DevOps, Gitea) and multiple LLM providers (OpenAI, Claude, Gemini, Ollama, Bedrock, OpenRouter, Azure OpenAI). The system is implemented as a Python async CLI application, packaged as a Docker image, and includes CI/CD integration templates for GitHub Actions, GitLab CI, Jenkins, Bitbucket Pipelines, and Azure Pipelines. Architecturally, it follows a clean layered design: a CLI layer (Typer) drives commands; a configuration layer (Pydantic Settings with multiple file/env sources) manages nested settings for LLM, VCS, agent, review, artifacts, and logging; a service layer orchestrates the review process through runners, gateways, and internal services (prompt building, diff analysis, policy enforcement, cost tracking, artifact persistence); and a client layer provides unified abstractions for VCS and LLM providers with provider-specific implementations. The tool supports multiple review modes: inline comments on specific code lines, summary comments on the entire PR, context review (full repository exploration via an optional agent loop), and reply to existing comments. The agent loop uses a ReAct pattern with tool execution (shell commands like `rg`, `cat`, `git`) to gather deeper context, with duplicate detection and context limits. A dry-run mode allows testing without posting to VCS. The system also includes a hook service for lifecycle events, cost tracking per request, and optional artifact saving of LLM interactions. Key strengths include extensive test coverage (unit tests with fake clients and fixtures), generic reusable components (HTTP client with retry, pagination helpers, diff parser, LLM output JSON parser, cost service), and a well-structured configuration system that supports discriminated unions for provider-specific settings. The codebase is actively maintained, uses modern Python async patterns, and demonstrates high craftsmanship in its abstraction layers and separation of concerns.
This repository is a Home Assistant custom component that adds OpenAI-compatible text-to-speech to a HA instance. It is distributed as an integration for HACS and registered as a config-flow service integration. In production it exposes TTS entities, an `openai_tts.say` service that announces text to media players with automatic volume save/restore and optional chimes, and an `openai_tts.set_api_key` service for credential rotation. The architecture is a HA integration split into focused modules: config flow and profile subentries, a streaming TTS engine, a sentence-level audio pipelining layer, an ffmpeg-based loudness pipeline, push-driven API health tracking, cache and validation logic, repairs, diagnostics, and a large announcement orchestration module. Provider support is driven by declarative presets for OpenAI, Mistral, Groq, Lemonfox, Kokoro, Chatterbox, and custom OpenAI-compatible endpoints, and the code intentionally modern-targets HA's streaming TTS contract rather than retaining legacy fallback paths.
The UTCP-MCP Bridge is a multi-language implementation that exposes Universal Tool Calling Protocol (UTCP) tools as Model Context Protocol (MCP) tools, enabling MCP clients like Claude Desktop to discover and call any UTCP-registered tool. The system consists of MCP servers (in Node.js/TypeScript, Python, Rust, and a web-based implementation) that initialize a UTCP client, register providers from configuration, and expose standard MCP tools for tool management (register/deregister manuals, call tools, search tools, list tools, get tool info, and get required variables). The architecture cleanly separates MCP server concerns from UTCP client operations, with each language implementation following similar patterns but idiomatic to its ecosystem. The bridge handles MCP specification nuances like proper content block preservation for binary data and provides dynamic provider management through REST APIs in the web UI.
This repository is the official companion code for the book *Build a Large Language Model (From Scratch)* by Sebastian Raschka (105k+ stars). It provides a step-by-step, educational implementation of GPT-2 and its modern variants (Llama 3, Qwen3, Gemma 3/4, Olmo3) entirely in PyTorch, organized by book chapters (2–7 plus appendices). The codebase is a mix of Jupyter notebooks for interactive learning and Python modules that form a reusable pip package (`llms-from-scratch`), accompanied by extensive CI/CD pipelines, unit tests, and performance analysis scripts. Architecturally, the core is a modular transformer library that includes tokenization (BPE, tiktoken, custom), multi-head attention with multiple variants (GQA, MLA, SWA, DSA, cross-layer KV sharing), feedforward blocks, normalization (LayerNorm, RMSNorm), and LoRA. The code supports pretraining from scratch, classification finetuning (spam, IMDB), instruction finetuning (with/without LoRA), and preference tuning (DPO). It can load pretrained weights from OpenAI, Hugging Face, and local checkpoints. The package exposes clean interfaces (`GPTModel`, `generate`, `train_model_simple`) and includes bonus materials for KV cache implementations, mixture-of-experts, memory estimators, and user interfaces (Chainlit). While primarily educational, the code exhibits production-quality patterns: isolated attention modules, configurable model architecture, well-structured training loops, and robust weight loading with shape validation. The repository is actively maintained with recent commits, cross-platform support (Linux, macOS, Windows), and a strong emphasis on reproducibility (fixed seeds, deterministic settings, environment definitions via pixi/uv/conda). Duplication exists across bonus notebooks and a few hardcoded paths, but the core package and test suite are well-coordinated.
JeecgBoot is an enterprise-grade low-code development platform that accelerates application delivery through AI-powered code generation, online form/report builders, and workflow integration. The backend is built on Spring Boot 3 with MyBatis-Plus, Shiro, and JWT, supporting both monolithic and microservice architectures (Spring Cloud, Nacos, Sentinel, XXL-Job). The frontend uses Vue 3 + TypeScript + Ant Design Vue with a rich component library including JVxeTable for editable grids and schema-driven forms. The platform provides comprehensive RBAC, multi-tenancy, dynamic data sources, data dictionaries, and third-party integrations (DingTalk, WeChat, Feishu). A dedicated AI module (airag) offers RAG knowledge bases, LLM chat, voice/image generation, and MCP plugin support. The codebase is actively maintained with frequent commits and a large community, though it contains some commented-out legacy code and hardcoded security values that represent minor technical debt.
changedetection.io is a self-hosted web application for monitoring web pages for content changes. It periodically fetches URLs, computes diffs (text, JSON, image, or stock/price), and sends notifications via 100+ channels (Apprise). The system is built on Flask with Socket.IO for real-time UI updates, a pluggable processor architecture (text_json_diff, restock_diff, image_ssim_diff), and an LLM integration layer (via litellm) for intelligent change summarization and intent-based filtering. It supports multiple fetcher backends (requests, Playwright, Selenium, Puppeteer), browser automation steps, RSS feeds, and a REST API with OpenAPI spec. Architecturally, it is a monolith with background workers: a priority queue (RecheckPriorityQueue) dispatches watch rechecks to async workers, which fetch content, run processors, and trigger notifications. The datastore is file-based JSON with atomic writes and schema migrations. The frontend uses jQuery, SCSS, and custom JavaScript for diff visualization, visual selectors, and real-time queue monitoring. The plugin system (pluggy) allows extending fetchers, processors, conditions, and UI elements. Key entry points include the CLI (changedetection.py), the Flask app factory (flask_app.py), the worker pool (worker_pool.py), and the notification service (notification_service.py). External dependencies include Playwright, Apprise, litellm, lxml, and various image processing libraries (OpenCV, libvips). The codebase is well-tested with over 120 test files covering security, integration, and unit tests.
BentoML is a machine-learning model serving framework and deployment platform. In production it lets developers define inference services via a decorator-based SDK (`@bentoml.service`, `@bentoml.api`), package those services into versioned "Bentos" with locked Python dependencies, and build OCI container images or deploy to Kubernetes, EC2, or BentoCloud. The serving layer supports both HTTP (Starlette/Uvicorn) and gRPC, with adaptive batching, model runners, Prometheus metrics, OpenTelemetry tracing, and pluggable monitoring. A comprehensive CLI (`bentoml serve/build/containerize/deploy`) is the primary operational surface, while the `_bentoml_sdk` and `_bentoml_impl` packages provide the user-facing and internal implementation layers respectively. Architecturally, the project separates concern into model registry, service definition, packaging, server workers, and cloud clients. Model artifacts are persisted in a versioned local store via framework adapters for PyTorch, TensorFlow, Transformers, ONNX, scikit-learn, MLflow, XGBoost, LightGBM, and others. Data flows from trained model artifacts into the registry, get referenced by service code, get bundled by `bentoml build` into self-contained Bento packages, and are served by Circus-managed worker processes. The core request path involves serialization, batching, resource allocation, and process supervision, all implemented in internal modules with generally clean abstractions. The repository is mid-migration from a legacy `bentoml.legacy.Service` API to a newer `_bentoml_sdk`, which creates visible duplication: two HTTP client stacks, multiple protobuf versions, and deprecation shims. This is a real maintenance cost but not a functional blocker; the modern SDK is actively developed, documented, and tested. The repo is clearly an application/framework rather than a data-research project; research-like artifacts are limited to test fixtures, training examples, and ML framework integration tests.
H2O LLM Studio is a web-based application for fine-tuning large language models (LLMs) without requiring coding experience. It provides a GUI built on H2O Wave and CLI tools for dataset import, experiment configuration, model training, evaluation, and export to Hugging Face Hub. The system supports multiple problem types including causal language modeling, classification, regression, sequence-to-sequence, and Direct Preference Optimization (DPO). The architecture centers around a Wave server handling both UI and backend logic, with distributed training capabilities via DeepSpeed. Key components include a configuration system using dataclasses, utilities for conversation chain handling, model loading abstractions, and factory patterns for training components.
This repository implements a deep research assistant web application that combines large language models (LLMs) with web search capabilities to generate comprehensive research reports. Built with Next.js 15, React, and Tailwind CSS, it features a client-side interface for topic input and research workflow management, backed by API routes that proxy requests to external AI and search services to protect API keys. The system orchestrates an iterative research process: planning sub-queries, executing parallel searches across multiple providers (Tavily, Firecrawl, Exa, etc.), analyzing results with auto-review cycles, and generating cited final reports. Key architectural elements include Zustand-based state management with localForage persistence, a Model Context Protocol (MCP) server for standardized tool/resource exposure, PWA support for offline installation, and modular components for knowledge base management, file parsing, and real-time progress streaming via Server-Sent Events (SSE).
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.
Tutel is a high-performance library for Mixture-of-Experts (MoE) in PyTorch, focused on both training and inference of large-scale sparsely-gated models. The codebase is organized into distinct layers: the core `MOELayer` configuration (gating, experts, dispatch), custom NCCL-based distributed communication primitives (`net.py`), JIT-compiled CUDA/ROCm kernels for routing and sparse operations, and utility modules for checkpoint resharding across different distributed topologies. Heavily exploited features include low-precision quantized inference (FP4, FP8, block quantization), fused Expert comunication via all-to-all collectives, and a experimental auto-paritioning solver for adaptive parallelism. The repository is dominated by software engineering artifacts (Python library design, C++/CUDA/ROCm extensions and binaries, structured examples) rather than research notebooks or analytic pipeline, but its origins include published papers (MLSys 2023) and active development for contemporary models such as DeepSeek, Qwen3, and Kimi.
gptstudio is an R package that integrates Large Language Models (LLMs) directly into the RStudio development environment. It functions as both a standalone Shiny application and a suite of RStudio add-ins. The core architecture relies on the {ellmer} package for LLM interactions, abstracting various providers (OpenAI, Anthropic, HuggingFace, etc.) through a unified S3 interface. Key features include a chat interface with conversation history, code commenting, and spelling/grammar checking add-ins. The package demonstrates strong engineering practices with comprehensive testing (shinytest2, testthat), modern UI theming (bslib), and support for streaming responses and audio input. It effectively bridges the gap between RStudio's IDE capabilities and external AI services.
KerasHub is a production-grade Keras 3 library providing pretrained model architectures, layers, tokenizers, metrics, and sampling utilities for NLP, vision, multimodal, and audio tasks. The codebase is organized around a consistent Backbone → Task → Preprocessor pattern, where each model family (e.g., BERT, Gemma, ViT, Whisper) defines a backbone, a preprocessor (tokenizer + optional media converter), and task-specific heads (CausalLM, ImageClassifier, etc.). All models expose a unified `from_preset()` API for loading pretrained weights hosted on Kaggle Models, and `save_to_preset()` for export. The library includes extensive checkpoint conversion tooling from HuggingFace and TIMM, export to HuggingFace format and OpenVINO, and integration with vLLM for serving. While predominantly an application library, it has strong data/research character through its pretrained weight infrastructure, benchmark scripts, and research-oriented architectures (e.g., FNet, RWKV7, BLIP-2).