This repository is a curated collection of Jupyter notebooks implementing core components of modern LLM architectures, intended for interview preparation. It covers attention mechanisms (MHA, GQA, MLA, KV-cache), normalization layers (LayerNorm, RMSNorm), functional components (RoPE, SwiGLU, LoRA, BPE, activation functions, cross-entropy, InfoNCE, sampling, quantization, SFT loss, tool calling parsing), and reinforcement learning losses (DPO, GRPO, DAPO, GSPO, KL divergence). Each notebook is a self-contained, minimal implementation of a specific algorithm, typically using PyTorch. The code is clean, concise, and well-commented, reflecting good engineering practices for educational purposes. While the repository is not a production application and lacks data pipelines, model training scripts, or continuous integration, it serves as a high-quality reference for understanding and reproducing the mathematical foundations of transformer-based language models. The hybrid nature lies in its focus on research-oriented ML components, but its structure is a pure code library rather than a data-driven research project.
This repository is a comprehensive data research project tracking the open-source Agentic AI ecosystem. It ingests data from GitHub (metadata, READMEs, stargazers), ClickHouse (OpenDigger OpenRank metrics), HuggingFace Hub (model metadata, downloads), and usage platforms like OpenRouter and ZenMux. The data is transformed through a series of Python scripts that enrich, classify, and score projects and models, producing weekly trend reports, landscape snapshots, case studies, and presentation materials. The core analytical framework uses OpenRank-based vitality scoring, a keyword taxonomy for project classification, and composite model rankings. Outputs include markdown reports, SVG charts, PPTX decks, and curated CSV datasets. While the repository is primarily a data analysis and reporting hub, it also contains agent skill definitions and change management workflows (OpenSpec), giving it a hybrid character. The codebase is actively maintained with weekly automated pipelines, but reproducibility is limited by hardcoded paths, missing Python dependency pinning, and reliance on external APIs with changing access patterns.
This repository is the LLM Inference Handbook, a comprehensive technical documentation site built with Docusaurus. It serves as an educational resource for engineers building, optimizing, and deploying LLM inference systems. The site covers inference fundamentals, model preparation, interaction patterns, optimization techniques (batching, KV cache, prefix caching, speculative decoding), kernel optimization (FlashAttention, GPU architecture), and infrastructure operations. It includes interactive React components such as GPU memory calculators, KV cache simulators, batching visualizers, and GPU execution visualizers that demonstrate concepts through live demos. The codebase is well-structured with TypeScript, CSS modules, a custom design system (DLS), and integration with Mantine UI. While primarily a documentation site, the interactive components are self-contained and could be extracted for reuse in other educational contexts. The handbook is framework-agnostic but has a strong emphasis on the Modular MAX ecosystem.
Pixel-Reasoner implements a two-stage training framework for Vision-Language Models (VLMs) to enable pixel-space reasoning. The system first performs instruction tuning on synthesized reasoning traces to familiarize models with visual operations (zoom-in, select-frame), then applies curiosity-driven reinforcement learning to balance exploration between pixel-space and textual reasoning. Targeting visual reasoning benchmarks (V* bench, TallyQA-Complex, InfographicsVQA, MVBench), it provides pre-trained models and evaluation scripts. The architecture combines adapted OpenRLHF components with custom VLM modules, Ray-based distributed training, and specialized data processors for multimodal input. Key entry points include training scripts (single/multi-node) and evaluation scripts, with data flowing from Hugging Face datasets through tokenization/image processing to PPO optimization loops.
This repository is an interactive educational resource (Jupyter notebooks) teaching prompt engineering for Anthropic's Claude LLM. It is not a software application or a data pipeline; it is a notebook collection, so it is classified as data_research by the notebook signal, but its 'data' is synthetic/demo content (animal names, user/product records, arithmetic operations, legal tax code excerpts) used to illustrate prompt patterns. The primary entry points are the notebooks themselves, with parallel implementations for the Anthropic direct API and AWS Bedrock (both boto3 and anthropic Bedrock clients). Lessons progress from basic prompt structure, clarity, system prompts, XML tags, few-shot examples, step-by-step thinking ('Precognition'), output formatting, avoiding hallucinations, to complex/industry use cases. The notebooks use get_completion wrappers around client.messages.create(...), %store magic to share variables, and a tool-use appendix that implements prompt-injected function calling via XML-like tags and regex parsing. Exercises include golden answers and rubric-based grading (e.g., summary quality scored 1-5). Reusable patterns include the tool-use prompt-injection function construct_successful_function_run_injection_prompt(invoke_results), system-prompt composition (general tool-use explanation + specific tool definitions), and a grader prompt pattern. However, the code is tightly coupled to notebook execution order, API details may drift, and duplicated content across anthropic/boto3 notebooks creates maintenance risk.
This repository is a comprehensive Chinese-language educational tutorial and codebase for Retrieval-Augmented Generation (RAG) systems, created by Datawhale. It systematically covers the full RAG stack from fundamentals (data loading, chunking, embeddings) to advanced techniques (hybrid search, query construction, Text2SQL, reranking, agentic RAG, and Graph RAG). The code is organized by chapter, with runnable Python scripts demonstrating each concept using popular frameworks like LangChain, LlamaIndex, and LangGraph, alongside vector databases (Milvus, FAISS) and graph databases (Neo4j). While primarily an educational resource, the repository contains several well-crafted, reusable components such as a minimal Text2SQL agent framework, a clean LangGraph-based agentic RAG pattern, and a custom ColBERT reranker. The practical application is a Chinese recipe Q&A system ('尝尝咸淡'), which serves as a consistent domain for demonstrating various RAG techniques. The codebase is hybrid in nature, blending structured educational content with functional demo applications. The repository is actively maintained with a large community following. However, users should be aware of technical drift risks including vendored model code, hardcoded API dependencies, and the presence of AI-generated code sections. The core value lies in its structured curriculum and reusable RAG patterns rather than as a production-ready system.
UFO (UI-Focused agent) and Galaxy constitute a multi-agent AI framework for automating GUI-based tasks across Windows, Linux, and mobile platforms. The system uses LLM-driven agents (AppAgent, HostAgent, ConstellationAgent) that interact with desktop applications via UI automation (UIA, COM) and execute distributed task workflows modeled as DAGs (task constellations). It includes a client-server architecture with WebSocket-based Agent Interaction Protocol (AIP), MCP tool servers, a configurable RAG knowledge substrate, and a Web UI (React+FastAPI) for real-time monitoring and control. The framework is primarily an application with strong research elements: it supports trajectory analysis, evaluation agents, demonstration learning, and configurable LLM backends (OpenAI, Claude, Gemini, DeepSeek, Ollama).
This repository is a collection of standalone examples demonstrating the MLX framework (Apple's machine learning framework for Apple Silicon). It covers a wide range of deep learning models including LLMs (Mistral, Mixtral, Llama, T5), image generation (Stable Diffusion, FLUX, CLIP), video generation (Wan2.1), audio (Whisper, MusicGen, EnCodec), segmentation (SAM), and more. Each example is self-contained with its own entry point (CLI or Python script), model conversion utilities, and often a training/fine-tuning script. The repository is primarily an application-focused showcase with some research elements (e.g., normalizing flows, GCN). Production entry points include `whisper/mlx_whisper/cli.py` for transcription, `flux/txt2image.py` for image generation, `video/wan2.1/txt2video.py` for video generation, and `lora/lora.py` for fine-tuning. All examples depend on the MLX library and often bundle conversion from PyTorch weights. The architecture is a flat collection of independent projects, not a unified framework, leading to some code duplication (e.g., T5 and EnCodec are copied into multiple directories). However, several components are well-crafted and reusable, notably the Whisper decoding pipeline, the LoRA adapter module, and the flow-matching samplers for diffusion models.
MiniMind-O is a research codebase for training and evaluating a small-scale (0.1B parameter) omni-modal language model that processes text, audio, and image inputs and generates text or streaming speech. The architecture uses a Thinker–Talker dual-path design with frozen external encoders (SenseVoice, SigLIP2, Mimi codec, CAM++) and trainable projectors, plus a Multi-Token Prediction (MTP) head for audio codec tokens. The repository includes a complete training pipeline (SFT with DDP, mixed precision, checkpointing), a comprehensive evaluation CLI, a Gradio web demo, and a real-time Flask WebSocket demo with VAD and ASR for near-duplex interaction. Data is stored in parquet format with pre-encoded audio codes, images, and speaker embeddings. The project is primarily research-oriented, aiming to provide a transparent, reproducible baseline for omni-modal models, but also includes application-like components for interactive demos.
This is a monorepo for an AI coding assistant called T1 Code (a fork of T3 Code). It provides a unified chat-based interface that integrates multiple AI providers (Codex, Claude, Cursor, OpenCode) via a server-side orchestration engine. The server uses Effect-TS for functional effects, SQLite for persistence, and WebSocket for real-time communication. Clients include a web app (React with TanStack Router), a terminal UI (Ink/React), and a desktop app (Electron). The system supports git operations, terminal integration, source control providers (GitHub, GitLab, Bitbucket, Azure DevOps), checkpointing/diff tracking, and text generation for commit messages, PRs, and branch names. The architecture follows an event-sourcing/CQRS pattern with a projection pipeline for read models. The codebase is well-structured with extensive test coverage and reusable Effect-based service layers, but relies on beta versions of Effect-TS and other libraries, which introduces some technical drift risk.
This repository is an educational tutorial series that teaches how to build a nanoGPT-like transformer language model from scratch using PyTorch. It consists of over 30 Jupyter notebooks (with both TODO exercises and answer keys) designed for Google Colab, covering topics from token embeddings and positional encodings to multi-head attention, transformer blocks, training loops, scaling experiments, and instruction tuning. The code is modular, with separate classes for each component (TokenEmbedding, PositionEmbedding, AttentionHead, MultiHeadAttention, FeedForward, TransformerBlock, VocabularyLogits, nanoGPT, DataLoader, Trainer, ModelConfig), making it a valuable learning resource. Training is demonstrated on the Shakespeare dataset and later on a sample of FineWeb-Edu, with experiments on model size, learning rate, and tokenization. While the repository is not a production data pipeline or deployable application, it exhibits strong data/research characteristics through its focus on model training, scaling laws, and loss analysis. The notebooks are well-structured for self-paced learning but rely on Colab-specific workflows and hardcoded data URLs, limiting portability.
Eidolon is an open-source framework for building, deploying, and managing multi-agent AI applications. It provides a Python SDK with abstractions for LLM integration (OpenAI, Anthropic, Mistral, Ollama, Azure), retrieval-augmented generation (RAG) pipelines, memory systems (vector stores, symbolic memory, file storage), and document processing (loaders, parsers, splitters). Agents are configured declaratively via YAML and can communicate with each other, use tools, and stream responses. The framework includes a Kubernetes operator for production deployment, a web UI built with Next.js and React for chatbot interaction and developer tooling, and a TypeScript client library. It also features built-in agent types like SimpleAgent, RetrieverAgent, SQLAgent, and a Tree-of-Thought agent, along with logic units for web search, browser automation, and API integration.
PandaWiki is a production-ready, self-hosted AI knowledge base and wiki platform. The actual codebase implements document management with versioned releases, RAG-based Q&A and search, AI-assisted document summarization and editing, multi-source content ingestion (URL, RSS, Sitemap, Notion, Feishu, DingTalk, Confluence, EPUB, Wiki.js, Yuque, Siyuan, etc.), a customizable public landing page builder, analytics, comments, contribution review, and multi-channel bot integrations for WeChat, WeCom, DingTalk, Feishu/Lark, and Discord. It is not a data research repository, but it contains substantial document-ingestion and analytics pipelines that feed the RAG system. The architecture is a full-stack monolith-style application split across a Go backend (Echo + GORM + PostgreSQL + Redis + MinIO/S3 + NATS JetStream), a React admin panel (Vite/MUI/Redux), a Next.js public site, and a pnpm workspace of shared UI/icon/theme packages. The Go backend follows a layered design with handlers, use cases, repositories, middleware, and dependency injection via generated Wire code. A standalone MQ consumer process handles async RAG document updates, crawler exports, and cron-driven statistics aggregation. The public app is served separately from the admin panel, with an embeddable widget and an H5 chat interface. In production, documents are imported through crawler tasks or direct upload, converted to HTML/Markdown, chunked, and upserted into a configurable vector/RAG service. User chat requests rewrite the query, retrieve ranked chunks, and stream LLM responses via SSE with citations. Statistics are rolled up hourly into PostgreSQL. Authentication supports local accounts, JWT sessions, GitHub OAuth, LDAP, CAS, and enterprise SSO. Feature availability is gated by commercial license editions, with a private pro submodule adding enterprise functionality.
XianyuAutoAgent is an AI-powered customer service bot for the Chinese second-hand marketplace platform Xianyu (闲鱼). It connects via WebSocket to Xianyu's messaging service, receives user messages, and generates intelligent replies using a Large Language Model (LLM) with multi-expert routing. The system features intent classification (price negotiation, technical support, general query), dynamic pricing negotiation with gradual concessions and adaptive LLM temperature, context-aware conversation management via SQLite, and a manual takeover mode. It handles authentication via cookies, token refresh, heartbeat, and captcha-triggered cookie re-entry. The bot operates as a long-running async process, suitable for deployment via Docker.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
TripStar is a full-stack, multi-agent AI travel planning platform. It uses a FastAPI backend with a modular agent system (trip planner, weather, hotel agents) orchestrated by a large language model, and a Vue 3 + TypeScript frontend with a dark glassmorphism UI. The backend provides REST APIs and WebSocket real-time status updates for asynchronous trip generation tasks. It integrates data from multiple sources: Xiaohongshu (via reverse-engineered signed API and SSR scraping), Google Maps, and AMap (with automatic fallback). The LLM extracts structured attractions from scraped text, plans itineraries, and repairs malformed JSON output. The system also includes user preference memory with weighted decay and TOP-K recall, a knowledge graph module, and export to image/PDF. The frontend features interactive maps, a budget panel, multi-city support, and a floating AI chat widget. The application is Dockerized with a multi-stage build and supports Chinese, English, and Japanese through i18n. The architecture is cleanly separated into backend services (agents, API routes, memory, map dispatcher, scraper), and frontend views (Home, Landing, Result, AIChat). The map dispatcher pattern provides a unified interface for geocoding and POI search across Google and AMap, and the memory manager implements a reusable preference-learning system. However, the codebase has technical debt: heavy reliance on Xiaohongshu's undocumented API (fragile), a monolithic 42k-token CSS file from Paper Kit 2 (2017) with deprecated techniques, and a complex ~2000-line Result.vue component. Dependencies are not fully locked, and the scraper's JavaScript signature engine may break with anti-bot updates. Overall, TripStar is a solid, functional application with several reusable patterns, but it carries moderate maintenance risks due to its external dependencies and some aging code. Note: This is a hybrid application with a strong data-crawling component (Xiaohongshu scraping and LLM extraction), but the dominant character is a production-ready web application with a clear user interface and API.
This is an 'awesome list' curation repository — the definitive index of the LangGraph/LangChain ecosystem — rather than a conventional software application. The core product is a ~30k-line README.md that maps the ecosystem into core frameworks (LangChain, LangGraph, Deep Agents, LangSmith, LangSmith Fleet, and integrations), official LangChain projects, and ~100 community projects organized across 20+ use-case categories (RAG, finance, web automation, coding agents, research, cybersecurity, workplace productivity, media, robotics, and more), plus learning resources, templates, case studies, and communities. Its practical function is as a discovery and evaluation map for engineers building stateful, tool-using AI agents: everything is categorized, linked, badged, and maintained under defined contribution quality gates. The only real code is scripts/repo-checks.mjs, a maintenance automation script that parses every GitHub URL from the README, queries the GitHub API for each repo's metadata, classifies repos as archived or stale (15-month staleness cutoff for community projects), writes a markdown check report, and fails CI when problems are found. This is orchestrated by three GitHub Actions workflows: awesome-lint/markdownlint on PRs, a monthly scheduled repo-health cron, and a stale-issue/PR bot. The package.json exposes npm scripts for these checks with Node >=20 as the engine. The repository is actively maintained (latest commit 2026-07-10), uses current GitHub Actions major versions (v6 checkout/setup-node, stale@v9), and follows a documented contribution process with a PR template enforcing category placement, alphabetical order, and non-archived/active-project requirements. For AI agents and engineers, the value is twofold: (1) it is a currently-maintained, comprehensively categorized starting point for discovering LangGraph/LangChain projects and patterns by domain — useful before writing any code; (2) the repo-checks script is a genuinely extractable pattern for anyone maintaining any markdown document containing GitHub links, since it is a self-contained, env-configurable health checker that requires minimal adaptation. It is as close to a 'productized' awesome list as exists in this space, with CI, lint enforcement, and automated freshness audits. Limitations: no unit tests for the maintenance script (its errors surface only monthly via cron), descriptions for some official projects are generic and low-signal, and there is no actual application or library code to reuse beyond the single maintenance script.
This repository provides a comprehensive toolkit for Chinese Llama-3 models, including base and instruction-tuned versions. It offers scripts for pre-training, fine-tuning, model merging, inference (via Hugging Face transformers, llama.cpp, Ollama, and OpenAI API-compatible server), and evaluation on standard benchmarks (CEval, CMMLU, MMLU, LongBench). The repository follows a modular architecture where each functionality is implemented in separate scripts under the scripts/ directory. Key entry points include training scripts (run_clm_pt_with_peft.py, run_clm_sft_with_peft.py), inference scripts (inference_hf.py, llama_cpp/chat.sh, openai_api_server.py), and evaluation scripts (ceval/eval.py, cmmlu/eval.py, etc.). The model supports LoRA adapters for efficient fine-tuning and provides merging utilities to combine base models with LoRA weights. The code demonstrates good practices in handling model quantization, PEFT integration, and multi-platform deployment.
This repository is a monorepo of self-contained demo applications showing how to build and deploy multi-agent AI systems using Docker Compose, Docker Model Runner, and the MCP Gateway. It contains 12+ independent examples spanning Google ADK, A2A, Agno, CrewAI, LangGraph, Langchaingo (Go), Spring AI, Akka, and a Next.js agent UI. Each subproject is a standalone composition with its own compose.yaml, Dockerfile, and README, designed to run with a single `docker compose up --build` after creating a `.mcp.env` file. The demos are reference architectures rather than a single product, emphasizing local LLM inference, MCP tool integration, and switching between local and cloud models via compose override files.
monkeSearch is a macOS-native file search tool that uses a local LLM to parse natural language queries into structured search parameters, then executes Spotlight searches via PyObjC. The system breaks queries into file type indicators (with specificity detection), temporal expressions, and residual keywords, converting them to NSPredicates using UTIs for file type matching and date comparisons for temporal filtering. It features a clean separation between LLM-based query parsing (query_gen.py) and Spotlight execution (parser.py), with the former being particularly well-engineered for reuse. The tool is designed for offline, agentic use with no cloud dependencies, targeting low-resource environments.