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.
FalkorDB is a graph database implemented as a Redis module, written in Rust. It supports the Cypher query language and uses sparse matrices and GraphBLAS/LAGraph for efficient graph operations. The system features MVCC for concurrency control, a batch-oriented query execution engine, and pluggable indexing (including native FalkorDB index for range, full-text, and vector search). Key architectural layers include the Redis module interface, query parser/planner, runtime operators, and storage backend. The codebase demonstrates strong modularity and includes several reusable patterns such as copy-on-write for MVCC, a storage backend seam, thread-local string interning, batched result emission, and a pipeline of query optimization passes.
Graphify is a CLI tool and library that extracts structural and semantic knowledge graphs from source code across 36+ programming languages. It parses files using tree-sitter grammars, builds a graph of nodes (functions, classes, modules, etc.) and edges (calls, imports, inheritance, etc.), performs community detection via Leiden/Louvain, and generates reports, wikis, and exports to formats like Obsidian, Neo4j, and FalkorDB. The system integrates with AI coding assistants through an MCP server (stdio/HTTP), skill files (SKILL.md, CLAUDE.md), and git hooks for automatic graph updates. Key entry points include `graphify extract`, `graphify query`, `graphify serve`, and `graphify install`. External dependencies include tree-sitter grammars, LLM APIs (OpenAI, Anthropic, Gemini, Ollama), and optional databases. The architecture is modular: per-language extractors in `graphify/extractors/`, graph assembly in `build.py`, clustering in `cluster.py`, and export in `export.py`. The codebase demonstrates strong engineering practices with extensive tests, atomic file writes, security validation (SSRF, path traversal), and cross-platform support.
MiroFish is a full-stack web application that implements a swarm intelligence prediction engine. It ingests real-world documents (PDF, Markdown, TXT), extracts seed information via LLM-driven ontology generation, builds a knowledge graph using Zep Cloud, and then generates agent profiles and simulation configurations for the OASIS multi-agent simulation framework. The system runs dual-platform simulations (Twitter-like and Reddit-like) to model social evolution and produce predictive reports through a ReACT-based report agent that queries the knowledge graph and interviews simulated agents. The frontend is a Vue 3 SPA with a 5-step wizard guiding users through graph building, environment setup, simulation execution, report generation, and deep interaction with agents. The architecture follows a monolith-with-subprocesses pattern: a Flask backend serves REST APIs for graph management, simulation lifecycle, and report generation, while simulation subprocesses run independently and communicate via a file-based IPC protocol. The system relies heavily on external services: an OpenAI-compatible LLM API for generation tasks, Zep Cloud for persistent graph storage and retrieval, and the OASIS simulation engine. The codebase is well-structured with clear separation into API routes, service modules, utility functions, and frontend components. It includes comprehensive i18n support (7 locales), Docker deployment, and CI/CD via GitHub Actions. While primarily an application, MiroFish has strong data/research characteristics: its core value proposition is predictive simulation driven by LLM-generated ontologies and agent profiles, and it uses GraphRAG techniques for report generation. The repository includes standalone scripts for star history tracking and validation, but these are auxiliary to the main application. The code demonstrates good engineering practices with reusable utilities (LLM client with retry, Zep pagination, file parser, retry decorators) and a consistent pattern for asynchronous task management and polling.
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.
VeritasGraph is a comprehensive, governed GraphRAG and agent framework for building enterprise-grade knowledge graphs with verifiable attribution. The repository contains a core Python library (VeritasReason) for knowledge graph construction, semantic extraction, reasoning, provenance tracking, and export, along with multiple domain-specific applications: a HIPAA-safe clinical knowledge graph pipeline (clinical-kg), a floorplan extraction and validation web app (floorplan-kg), a municipality incident reporting chatbot, and a Model Context Protocol (MCP) server for IDE integration. The architecture is modular, with a plugin-based method registry pattern, unified configuration management, and a pipeline orchestration engine. While the primary character is an application framework, it also includes research-oriented components such as clinical benchmarks (MedKG-Signal) and evaluation suites, making it a hybrid project with a strong application focus.
This repository is a full-stack application for building knowledge graphs from unstructured data using Large Language Models (LLMs). The backend, built with FastAPI and LangChain, ingests documents from multiple sources (local files, web pages, YouTube, Wikipedia, S3, GCS), chunks them, and uses an LLM to extract entities and relationships, which are stored in a Neo4j graph database. The frontend, a React/TypeScript application, provides a user interface for uploading files, configuring extraction (schema, LLM model, chunking), visualizing the resulting graph, and interacting with the data through a retrieval-augmented generation (RAG) chatbot with multiple retrieval modes (vector, graph, fulltext, hybrid). The system includes post-processing features like community detection, deduplication, and orphan node cleanup, as well as token usage tracking and evaluation metrics (RAGAS). While primarily an application with a web UI, it also contains experimental notebooks (GraphRAG, chunk size evaluation) that serve a data research purpose, making it a hybrid codebase with a dominant application character.
This repository implements a full-stack AI-powered food recommendation application called 'δ»ε€©εδ»δΉ' (What to eat today). The system combines a Next.js frontend with a Python Flask backend that uses a GraphRAG (Retrieval-Augmented Generation) architecture leveraging Neo4j for graph-based recipe relationships and Milvus for vector similarity search. Users interact via a chat interface to receive personalized recipe recommendations with step-by-step cooking instructions. The application includes a comprehensive recipe knowledge base in markdown format, Docker-based deployment orchestration, and a modular RAG pipeline with intelligent query routing and session management.
This repository is an educational collection of minimal, from-scratch implementations of core LLM and generative AI systems, maintained by DataWhale. It is not a single production application; rather, it is a set of self-contained 'Tiny' sub-projects covering a small LLM trained on TinyStories, a RAG pipeline, a ReAct agent, an LLM evaluation harness, a DDPM diffusion model, a Transformer, a GraphRAG system, and an image-based RAG pipeline. Each sub-project has its own README, requirements, and runnable code or notebooks, with heavy Chinese-language comments explaining the underlying theory. The code is intentionally simple and readable rather than production-hardened, and it serves as a teaching resource for understanding how these systems work internally.