GraphRAG is a Microsoft Research project that implements a graph-based retrieval-augmented generation (RAG) system. It extracts structured knowledge (entities, relationships, claims) from unstructured text using LLMs, builds a hierarchical knowledge graph via Leiden community detection, generates community summaries, and supports multiple query strategies: local search (entity-centric), global search (map-reduce over community reports), DRIFT search (iterative multi-hop), and basic vector search. The system is designed as a Python library with a CLI (Typer) and a public API, plus a Streamlit demo app for comparing search modes. It provides extensive configuration via YAML/JSON with environment variable substitution, and supports multiple backends for storage (file, Azure Blob, CosmosDB), caching (SQLite, JSON, memory), vector stores (LanceDB, Azure AI Search, CosmosDB), and LLM providers (OpenAI, Azure OpenAI, LiteLLM). The codebase is organized as a monorepo with eight sub-packages (graphrag, graphrag-llm, graphrag-storage, graphrag-vectors, graphrag-cache, graphrag-input, graphrag-chunking, graphrag-common), each with its own pyproject.toml and versioning. The project is explicitly in maintenance mode, accepting only bug fixes and dependency updates, with no new features planned. Despite this, the architecture is well-structured with clean abstractions, factory patterns, middleware pipelines, and a composable design that makes many components reusable in other projects.
Tabby is a self-hosted AI coding assistant that provides code completion, chat, and code search capabilities through multiple interfaces: a web dashboard (Next.js/React), IDE plugins (VS Code, IntelliJ, Eclipse, Vim), and a Language Server Protocol (LSP) agent. The backend is primarily written in Rust, using Axum for HTTP services, Tantivy for indexing, and llama.cpp for local model inference. It supports enterprise features like SSO (OAuth, LDAP), team management, access policies, and background job scheduling for repository indexing, web crawling, and third-party integration (GitHub/GitLab). The system is designed to be self-contained, running without external cloud dependencies, and can operate on consumer-grade GPUs. The architecture follows a monorepo pattern with Rust crates for core services (inference, indexing, git operations, download) and TypeScript/JavaScript for the agent and UI. The web dashboard uses GraphQL (Juniper) for API communication, while IDE plugins communicate via LSP. Data flows include: code completion requests from editors → agent → backend model server → response with postprocessing; chat queries → retrieval-augmented generation (RAG) pipeline using indexed code and documentation; and background jobs for syncing repositories, crawling web docs, and indexing commits/issues/PRs. External dependencies include SQLite (via SQLx), llama.cpp, tree-sitter, and various cloud provider APIs for OAuth. The codebase demonstrates strong engineering practices with modular design, extensive testing (unit tests, golden tests), and reusable patterns such as a background job abstraction, config merging system, and a postprocessing pipeline for code completions. However, the polyglot nature (Rust, TypeScript, Java, Kotlin) and multiple client implementations introduce maintenance complexity and potential drift. The repository is actively maintained with frequent releases and a large community (33k+ stars).
Kotaemon is a production-grade Retrieval-Augmented Generation (RAG) application for chatting with documents. It provides a full-stack Gradio web UI with user management, document indexing (PDF, DOCX, HTML, images, web URLs), hybrid retrieval (vector + full-text), reranking, and multi-step reasoning pipelines (simple QA, question decomposition, ReWOO agent). The architecture is a monolith split into two Python libraries: `kotaemon` (core components: embeddings, LLMs, indices, storages, loaders, agents) and `ktem` (application layer: UI pages, reasoning pipelines, database models, settings). It supports multiple LLM providers (OpenAI, Azure, Anthropic, Gemini, Cohere, Ollama, LlamaCpp), embedding models, vector stores (Chroma, LanceDB, Milvus, Qdrant), and document stores. The system is highly configurable via environment variables and a settings UI. While primarily an application, it includes data/research elements such as document loaders, OCR pipelines, graph-based indexing (GraphRAG, LightRAG, NanoGraphRAG), and a training dataset for question rephrasing.
CADAM is a production-grade, open-source web application that converts natural language descriptions into fully parametric 3D CAD models. It operates in two primary modes: parametric (generating OpenSCAD code via an AI agent that can iterate with live previews) and creative (producing 3D meshes via external providers like Meshy and Tripo). The application is built with React 19, TypeScript, TanStack Start, Vite, and Tailwind CSS, with a Supabase backend for authentication, database, and file storage. AI integration spans multiple providers (Anthropic, OpenAI, Google, xAI, and others) via the Vercel AI SDK, and the generated OpenSCAD code is compiled in-browser using a vendored WebAssembly build of OpenSCAD. The system includes a token-based billing model, real-time preview updates, parameter editing, and export to STL, OBJ, GLB, and other formats. Although primarily an application, the benchmarks directory serves as a research record of the quality of generated parametric models, covering complex assemblies like a V8 engine and turbofan.
SuperAgentX is a modular, open-source multi-agent AI framework designed for orchestrating autonomous agents that plan, act, and execute real-world workflows. It supports 100+ LLM providers (OpenAI, Azure, Gemini, Claude, Bedrock, Ollama, LiteLLM) and 10,000+ MCP tools via the Model Context Protocol. The architecture centers on `AgentXPipe` pipelines that sequence or parallelize agents, each composed of an `Engine` that wraps an LLM client and a set of tool handlers. Handlers are defined using a `@tool` decorator pattern that auto-generates LLM function schemas. The framework includes built-in human-in-the-loop approval channels (console, Slack, Teams), persistent memory with SQLite and vector stores (Chroma, OpenSearch), full observability via OpenTelemetry and SQL-based telemetry, and a CLI for project scaffolding. It also features a production-grade browser automation engine based on Playwright for tasks where APIs are unavailable.
BettaFish (微舆) is a multi-agent public opinion analysis system that automates the end-to-end process of gathering, analyzing, and reporting on public sentiment across 30+ Chinese social media platforms. The system is built around four specialized agents: QueryEngine (news breadth search via Tavily), MediaEngine (multimodal search via Bocha), InsightEngine (database mining via SQLAlchemy), and ReportEngine (template-based report generation with intermediate representation and HTML/PDF/Markdown rendering). A ForumEngine coordinates agent collaboration through log monitoring and LLM-generated moderator comments. The architecture is a monolithic Flask application that manages multiple Streamlit sub-applications and CLI tools, with a separate MindSpider crawler subsystem for data collection. While primarily an application, it includes significant data/research components such as sentiment analysis model training scripts (BERT, GPT-2, Qwen3, traditional ML), a Weibo sentiment dataset, and data pipeline scripts. The system relies heavily on external LLM APIs (OpenAI-compatible), search APIs (Tavily, Bocha, Anspire), and system dependencies (Playwright, WeasyPrint). The codebase demonstrates solid engineering with reusable patterns like robust JSON parsing, chart validation/repair, and a hardened GitHub Actions star-history script, but suffers from significant code duplication across engines and tight coupling to external APIs.
Made With ML is an educational data science project that implements an end-to-end ML pipeline for classifying GitHub repositories into categories (NLP, computer vision, MLOps, other) based on their titles and descriptions. The core data lineage flows from raw CSV datasets (dataset.csv, holdout.csv) through text cleaning, tokenization via SciBERT, and stratified splitting into train/val/test sets, followed by distributed training with PyTorch and Ray Train, hyperparameter tuning via HyperOpt, evaluation with slice-based metrics using Snorkel, and serving through a FastAPI/Ray Serve deployment. The project demonstrates MLOps patterns including MLflow experiment tracking, data validation with Great Expectations, behavioral model testing, and CI/CD via GitHub Actions with Anyscale for cloud execution. The codebase is well-structured with clear separation of concerns across data.py, train.py, tune.py, evaluate.py, predict.py, serve.py, models.py, and utils.py. It includes comprehensive tests at the code, data, and model levels. However, the project shows signs of staleness with pinned dependencies from 2023 (Ray 2.7.0, transformers 4.28.1, torch 2.0.0) that have known security vulnerabilities and compatibility issues with current Python versions. The data pipeline components—particularly the CustomPreprocessor, stratified splitting, and text cleaning—are genuinely reusable patterns. The evaluation framework with slice-based metrics and behavioral tests (invariance, directional expectations, minimum functionality) represents solid ML engineering practice. The deployment configuration is tightly coupled to Anyscale's proprietary platform, limiting portability.
This repository is a comprehensive collection of examples, tutorials, and applications demonstrating how to use LanceDB (a vector database) for various AI/ML applications. It showcases patterns for retrieval-augmented generation (RAG), multimodal search, chatbots, recommendation systems, and AI agents. The repository contains both Python and JavaScript/TypeScript implementations, with many examples featuring web interfaces using Streamlit, Gradio, or React. While it serves as a valuable resource for learning LanceDB integration patterns, the quality varies across examples, and some content is marked as archived.
This repository is a comprehensive, educational collection of 42+ Jupyter notebooks and runnable scripts demonstrating a wide array of Retrieval-Augmented Generation (RAG) techniques. It is primarily a data_research and educational resource, not a deployable application or library. The codebase serves as a practical cookbook for engineers and researchers, covering the full RAG stack from basic chunking and retrieval (e.g., simple RAG, BM25) to advanced methods like GraphRAG, Self-RAG, HyDE, RAPTOR, and agentic RAG. It also includes a dedicated evaluation framework with notebooks and reusable scripts for measuring faithfulness, relevance, and correctness using tools like DeepEval and custom LLM judges. The architecture is modular, with a shared helper_functions.py providing common utilities for PDF loading, embedding, and retrieval, and an evaluation/ module offering reusable evaluation pipelines. The runnable scripts in all_rag_techniques_runnable_scripts/ provide cleaner, class-based implementations of the techniques that are more suitable for integration into other projects than the notebooks themselves. While the code is well-structured for an educational project and demonstrates high craftsmanship in its reusable components, it is not designed for production deployment. Reproducibility is limited by the lack of a pinned dependency file and reliance on external API keys. The repository is actively maintained and highly influential (29k+ stars), making it a valuable reference for anyone building or evaluating RAG systems.
AgentFlow is a framework for building and training agentic LLM systems using reinforcement learning, specifically Flow-GRPO (Flow-based Group Refined Policy Optimization). It provides a modular architecture with four core roles—Planner, Executor, Verifier, and Generator—that coordinate via evolving memory and tool calls over multiple turns. The system supports both inference (via a Solver) and distributed RL training (via a Trainer/Client/Server architecture built on verl, vLLM, and Ray). It includes a multi-provider LLM engine abstraction (OpenAI, Anthropic, Gemini, DeepSeek, etc.), a tool system with metadata-driven discovery, and instrumentation for tracing and reward collection. The repository is heavily research-oriented, with benchmark datasets (AIME24, GPQA, GAIA, HotPotQA, etc.) and training pipelines for optimizing agent planners. While primarily an application framework, it has strong data/research components, making it a hybrid project with a focus on reproducible agentic reasoning experiments.
The Prompt Engineering Guide is a comprehensive, multilingual documentation site built with Next.js and Nextra that serves as an educational resource for prompt engineering with large language models. While the site itself is a web application, its core value lies in the extensive collection of tutorials, technique explanations, model-specific guides, and research summaries that constitute a structured knowledge base on effective LLM prompting. The repository includes interactive Jupyter notebooks that demonstrate practical applications of techniques like PAL, RAG, and ReAct, alongside hundreds of MDX pages covering topics from basic prompting to advanced agent building. Content is available in numerous languages, reflecting a commitment to global accessibility. The site features custom UI components for enhanced usability, such as announcement bars, course promotions, and copy-to-clipboard functionality, but these serve primarily to facilitate access to the educational content. Despite being actively maintained, the guide faces challenges typical of rapidly evolving fields: content requires frequent updates to keep pace with new LLM releases and research findings, and the multilingual nature increases the risk of translation drift. External links to papers, videos, and tools may also become stale over time. Nevertheless, the repository remains a valuable reference for practitioners and researchers seeking to understand and apply prompt engineering principles.
Hyper-RAG is a hypergraph-driven Retrieval-Augmented Generation (RAG) system designed to reduce LLM hallucinations by modeling beyond-pairwise correlations in domain knowledge. The repository provides both a Python library (`hyperrag`) and a full-stack web application with a FastAPI backend and React frontend. The core innovation is the use of hypergraphs to represent complex relationships among entities, outperforming traditional graph-based RAG methods like Graph RAG and Light RAG. The system supports multiple query modes: hyper (full hypergraph), hyper-lite, graph, naive, and direct LLM, with streaming responses. Architecture: The Python library (`hyperrag/`) implements the RAG pipeline: text chunking, entity extraction via LLM, hypergraph construction, vector embedding storage (NanoVectorDB), and query execution. The web UI (`web-ui/`) consists of a FastAPI backend (`main.py`) exposing REST endpoints for file upload, database CRUD, and HyperRAG queries, plus a React frontend with Ant Design and Graphin for interactive chat, hypergraph visualization, and settings management. Docker Compose orchestrates the frontend, backend, and Nginx reverse proxy. Key entry points: `hyperrag/hyperrag.py` (HyperRAG class), `service_api.py` (standalone API), `web-ui/backend/main.py` (FastAPI app). External dependencies include OpenAI/Azure/Bedrock LLM APIs, NanoVectorDB, tenacity, aiofiles, and various Python packages. The system is configurable via `config_temp.py` and `settings.json`. Data flows: Raw text (uploaded or provided) is chunked, entities and relationships are extracted via LLM, hyperedges are constructed, and embeddings are stored. Queries are processed by selecting relevant hyperedges and entities, constructing a context, and generating a response. The system caches LLM responses and supports real-time logging via WebSocket during embedding.
This repository is a vast curated collection of over 100 open-source AI agent application templates and tutorials, spanning multiple frameworks (Agno, Google ADK, OpenAI SDK, LangGraph, CopilotKit, CrewAI) and deployment patterns (Streamlit, Next.js, FastAPI, CLI). It serves as a living portfolio of AI agent patterns: single-agent assistants, multi-agent teams, generative UI (CopilotKit + AG-UI), RAG pipelines with various vector stores (Qdrant, Chroma, LanceDB, FAISS), voice agents, always-on scheduled agents, and agent skills (code analysis, dependency health). The architecture is a monorepo of independent sub-projects, each with its own requirements, entry point, and often a README. External dependencies are heavy: nearly every app requires API keys for LLMs (OpenAI, Google, Groq, Together) and tools (Tavily, Firecrawl, SerpAPI, E2B), plus optional services (PostgreSQL, Qdrant, ElevenLabs). While the codebase is not a single integrated application, it provides a rich set of reference implementations for developers building AI agents.
This repository is a curated collection of 93+ production-ready AI engineering projects, spanning beginner to advanced levels. It serves as a practical resource for building AI applications, with a strong emphasis on agent orchestration (CrewAI, AutoGen, OpenAI Swarm), Retrieval-Augmented Generation (RAG) pipelines, Model Context Protocol (MCP) servers, and LLM evaluation frameworks. The dominant character is application development: most projects are deployable apps using Streamlit, Next.js, FastAPI, or as standalone MCP servers. Notable sub-projects include a full visual workflow builder (open-agent-builder) with Convex backend, a multi-modal RAG pipeline (notebook-lm-clone), and a comprehensive audio analysis toolkit. While primarily application-focused, the repository also contains data/research elements such as model fine-tuning scripts (GRPO, DPO, SFT), synthetic data generation (SDV), and LLM comparison dashboards with Opik/DeepEval evaluation. The codebase is heterogeneous in quality: some projects exhibit clean architecture and reusable patterns, while others are simple demos with boilerplate code and hardcoded dependencies. Overall, it is an excellent educational resource for AI engineers seeking practical, runnable examples, but not a single cohesive product.
This repository is a curated list of papers, datasets, and code repositories for multi-turn interactions with large language models, accompanied by a static website that serves as a companion to a survey paper published in Transactions on Machine Learning Research (TMLR) 2026. The website includes sections on tasks (instruction following and conversational engagement), improvement methods, open challenges, and a searchable benchmark explorer. The repository also includes a script for processing survey data from Excel files and the README, though this script is not required to run the website.
This repository is the companion code for the O'Reilly book 'Hands-On Large Language Models' by Jay Alammar and Maarten Grootendorst. It provides 12 chapters of Jupyter notebooks covering fundamental and advanced LLM topics including tokenization, embeddings, text classification, clustering, prompt engineering, semantic search, multimodal models, fine-tuning, and generation. All notebooks are designed to run on Google Colab with free GPU resources and rely heavily on Hugging Face libraries (transformers, datasets, sentence-transformers, TRL) and external APIs (OpenAI, Cohere). The code is educational in nature, with clear step-by-step explanations and visualizations. While it is not a production application or a novel research pipeline, it serves as a high-quality, reproducible tutorial resource for practitioners learning LLM workflows. The repository includes pinned dependencies, Conda environment setup, and local installation guides, making it relatively easy to reproduce in a controlled environment, though API keys are required for some sections.
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.
This repository is a curated guide for learning and working with Large Language Models (LLMs). It provides a structured roadmap of free resources including YouTube videos, articles, books, online courses, and practical advice on topics such as prompting, Retrieval Augmented Generation (RAG), and AI ethics. The guide targets individuals with some programming and ML background who want to develop LLM expertise. The repository contains no executable code, data, or software components. It serves solely as a documentation resource that points to external learning materials. Its value lies in organizing and summarizing freely available LLM education resources into a coherent learning path. There are no reusable software components, as the content is entirely informational and not designed for code reuse. Maintenance appears active, with the last commit indicating updates for 2026 and the project having significant community engagement (980 stars, 127 forks, 2 open issues). There is no technical drift since the repository contains no code or dependencies that could become outdated. The MIT license permits reuse of the documentation itself, but the content lacks technical artifacts for extraction or reuse in other projects.
This repository is a literature survey on recent advances in large language model benchmarks against data contamination, specifically the transition from static to dynamic evaluation. It contains a single README.md file that lists and categorizes numerous research papers, benchmarks, and methods. There is no executable code, data pipelines, notebooks, or any software artifacts. The repository serves as a curated reference list and taxonomy for researchers, but offers no reusable code or data assets. It is not a functional application or a data research project with ETL or model training components.