pgGraph is a PostgreSQL extension written in Rust (via pgrx) that adds high-performance graph query capabilities directly into PostgreSQL. It allows users to model graphs by registering existing relational tables as nodes and edges, building a compressed sparse row (CSR) adjacency index for sub-millisecond traversals, shortest paths, and connected components. The extension exposes SQL functions (`graph.traverse`, `graph.shortest_path`, `graph.search`, `graph.gql`, `graph.cypher`) and supports both openCypher and a subset of GQL for querying property graphs. It integrates deeply with PostgreSQL security (row-level security, multi-tenancy, ACLs), provides resource governance (memory, disk, work unit budgets), and includes a durable projection layer with atomic manifests, delta segments, compaction, and crash recovery. The codebase is structured as a pgrx extension with a Rust core, SQL bootstrap scripts, background workers for build/maintenance jobs, and an extensive test suite including fuzz targets, property-based tests, and heavy integration tests for concurrency, crash recovery, and performance gates.
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.
Apache AGE is a PostgreSQL extension that adds graph database capabilities, implementing the openCypher query language. It allows users to create, query, and manipulate property graphs (vertices and edges) directly within PostgreSQL, leveraging the database's transactional guarantees, security, and indexing. The extension provides a custom data type (agtype) for graph entities, a Cypher-to-SQL parser, and custom scan executors for efficient graph operations. It includes a comprehensive test suite, multi-language client drivers (Go, Java, Node.js, Python), and integration with NetworkX for graph analysis. The architecture is tightly integrated with PostgreSQL internals through hooks, custom nodes, and memory management, making it a production-grade graph database solution for PostgreSQL users.
Infrahub is a full-stack infrastructure data management platform that provides a unified data model for network, cloud, and infrastructure resources. It features schema-first graph-based data modeling (using Neo4j), version control for data via branching and proposed changes, automation through generators and transforms, and integration capabilities via APIs, webhooks, and SDKs. The backend is built with Python/FastAPI, Prefect for workflow orchestration, and uses Neo4j as the primary graph database. The frontend is a React/TypeScript application with TanStack Query and Jotai for state management. The system supports IPAM, diff computation, artifact generation, and role-based access control, targeting infrastructure teams seeking repeatable, validated workflows for infrastructure as a service.
The OpenCog AtomSpace is a hypergraph-based knowledge representation system serving as the core component for Artificial General Intelligence (AGI) research. It provides an in-memory database for storing immutable, uniquely-typed atoms (nodes and links) with mutable key-value stores attached for dynamic data. The system supports executable graphs through the Atomese language, features a sophisticated pattern matching and query engine, includes type inheritance and intersection capabilities, and offers multi-language bindings (Scheme, Python). Architecture-wise, it follows a modular design with clear separation between atom management, value systems, execution frameworks, and query processing. The codebase demonstrates strong engineering practices with factory patterns, handle-based memory management, and thread-safe frame stacks for evaluation contexts.
This is a full-stack application (FastAPI backend, React frontend) that builds knowledge graphs from unstructured data using LLMs. It ingests documents from local files, S3, GCS, web pages, YouTube, and Wikipedia, chunks them, extracts entities and relationships via LangChain's LLMGraphTransformer, and stores the graph in Neo4j. The system provides a chatbot interface with multiple retrieval modes (vector, graph, hybrid, fulltext, community search), post-processing capabilities (community detection, duplicate merging, vector indexes), and RAGAS-based evaluation metrics. The architecture is a monolithic backend with a single FastAPI app and a React SPA frontend, orchestrated via Docker Compose. External dependencies include Neo4j, multiple LLM providers (OpenAI, Gemini, Anthropic, etc.), and optional cloud storage integrations. The codebase is actively maintained with recent commits and issue triage, and shows low technical drift despite some aspirational model names and minor duplication.
Cognee is an open-source AI memory platform that enables agents and applications to build, store, and query persistent knowledge graphs from documents, code, and conversations. The system provides a Python SDK, a FastAPI REST API, a CLI, a Next.js frontend, and an MCP server for agent integration. Core operations include ingesting data (remember), extracting entities and relationships via LLMs or GLiNER (cognify), retrieving context (recall), and self-improvement loops (improve). The architecture is modular with adapter/registry patterns for graph databases (Ladybug, Neo4j, Turso), vector stores (LanceDB, PGVector), LLM providers (LiteLLM, OpenAI, Anthropic, Ollama), and integrations (Slack, GitHub, Google Drive). The frontend provides a dashboard for dataset management, knowledge graph visualization, and business analytics. The project also includes an evaluation framework for benchmarking retrieval strategies against standard datasets like HotpotQA and BEAM. While production-grade in many areas, some components are marked as demo-quality or have cloud-only stubs.
ArcadeDB is a high-performance, multi-model database system supporting graph, document, key-value, time-series, vector, and full-text data models. It exposes multiple query languages (SQL, Cypher, Gremlin, GraphQL) and wire protocols (HTTP, Bolt, PostgreSQL, MongoDB, gRPC). The architecture is modular: a core engine (storage, indexing, query execution) with pluggable server plugins for protocols, replication (Raft-based HA), and observability. It features advanced indexing (LSM-tree, hash, vector quantization, sparse vectors, full-text BM25), time-series with PromQL and downsampling, and graph analytical views with CSR compression. Python bindings allow embedded use. The codebase demonstrates strong engineering with extensive use of interfaces, design patterns, comprehensive test coverage (including issue-specific regression tests), and automated CI/CD with performance benchmarks. It is actively maintained with low technical debt and a clean architecture.
Graphiti is a Python library and server framework for building temporal knowledge graphs that serve as persistent memory for AI agents. It ingests unstructured text episodes (messages, transcripts, JSON), uses LLMs to extract entities and relationships with bi-temporal validity windows, deduplicates against existing graph data, and provides hybrid search (semantic + BM25 + graph traversal) with configurable reranking. The codebase is structured around a clean driver abstraction (Neo4j, FalkorDB, Kuzu, Neptune) with per-provider operations classes, a prompt library supporting versioning and overrides, and a multi-provider LLM/embedder/cross-encoder client system. It is primarily an application library, though it includes evaluation infrastructure and research-grade deduplication algorithms (MinHash/LSH).
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.
OrientDB is a multi-model NoSQL database management system supporting document, graph, object, and relational data models within a single engine. It provides ACID transactions, a SQL-like query language, distributed clustering with automatic sharding and replication, full-text and spatial indexing via Lucene, and a Gremlin graph traversal API. The system is implemented in Java and organized into modular components: a core storage engine with pluggable index structures (SB-Tree, hash, Lucene), a binary client-server protocol, an HTTP REST API, and a web-based administration studio (AngularJS). It includes enterprise features such as backup/restore, metrics monitoring, and security auditing. The architecture follows a plugin-based server model, allowing extensions for authentication, indexing, and custom commands. External dependencies include Dropwizard Metrics, Lucene, Gremlin/TinkerPop, and various compression libraries.
KubeHound is a security analysis tool for Kubernetes clusters that automatically models and computes attack paths. It collects Kubernetes resources (pods, roles, bindings, endpoints, nodes) via a live API or offline dump, transforms them into a property graph stored in JanusGraph (with MongoDB as an intermediate store), and computes privilege escalation and lateral movement paths mapped to MITRE ATT&CK techniques. The system exposes a CLI for local analysis and a gRPC API (KHaaS) for service-oriented deployments, with optional Jupyter notebooks for querying the graph using a custom Gremlin DSL. The architecture is modular: a collector abstraction handles rate-limited streaming from the Kubernetes API; an ingestion pipeline converts raw objects into normalized store models and graph vertices/edges; an edge registry defines over 20 attack types (e.g., PodExec, TokenSteal, ContainerEscape); and a graph builder executes Gremlin traversals to connect vertices into paths. Storage layers use asynchronous writers with micro-batching for high throughput, and an in-memory cache deduplicates identities and roles. Telemetry (Datadog APM, metrics, logs) is integrated throughout. While primarily an application, the repository includes experimental research components (exp/khaudit) for audit reports and MITRE Attack Flow conversion, plus Jupyter notebooks for interactive graph queries, giving it a hybrid character. The codebase demonstrates strong engineering practices: provider interfaces, test mocking, worker pools, retry logic, and comprehensive system tests against real Kind clusters. However, some areas (large cluster optimizations, experimental code, deprecated flags) indicate ongoing evolution and minor technical debt.
GQLAlchemy is a Python library and Object Graph Mapper (OGM) for the Memgraph graph database, with secondary support for Neo4j. It provides a fluent Cypher query builder, declarative node/relationship models (Pydantic v2-based), and full lifecycle management of graph database instances (Docker/binary), streams (Kafka, Pulsar), triggers, and high-availability routing. The library also includes a rich set of transformations for bidirectional conversion between Memgraph/Neo4j and popular graph machine learning frameworks (NetworkX, DGL, PyG, TF-GNN), as well as tabular data import (CSV, Parquet, ORC, Feather) from local filesystem, S3, and Azure Blob Storage. While primarily a software library for building graph applications, it has strong data research capabilities through its graph ML translators and ETL importers, making it a hybrid tool suited for both production graph apps and data science pipelines. The codebase is well-tested (unit and integration tests), has comprehensive CI/CD, and follows a modular architecture with abstract base classes for extensibility. However, some modules are large (e.g., monolithic query builders), and optional dependencies (PyTorch, DGL, TF-GNN, PyArrow) increase maintenance surface, with a medium level of technical drift due to some deprecated Pydantic v1 patterns and skipped tests.
LeanKG is a Go-based knowledge graph engine for AI-assisted development. It indexes source code from multi-language repositories into a graph of elements (functions, types, classes) and relationships (calls, imports, implements), stored in SQLite or PostgreSQL with optional vector embeddings for semantic search. The system provides a CLI, REST API, MCP (Model Context Protocol) server, and a React web UI (force-directed graph, file tree, code panel). Core capabilities include incremental indexing with three-signal change detection, a four-tier query ladder (cold/exact/fuzzy/semantic), impact analysis with blast radius, organizational knowledge management (incidents, notes, env reports), ontology matching, federation across servers, and token-budgeted compression for AI tool integration. The architecture is modular: the store backend interface supports SQLite and PostgreSQL with a shared migration ledger; indexing uses regex extractors for 40+ languages with an optional tree-sitter CGO tier; embeddings use a provider abstraction (OpenAI-compatible, llama.cpp sidecar, deterministic). The codebase is well-structured with extensive tests, hermetic test patterns, and deterministic output design. Notable reusability includes the compress package (shell output, git diff), auth token system, store abstraction pattern, and A/B benchmarking harness.
This repository is the official Java client for Nebula Graph, a distributed graph database. It provides connectivity to Nebula Graph's graph, meta, and storage services through Thrift-based RPC. The client supports connection pooling, session management, SSL/TLS encryption, and HTTP/2 transport. Key features include load balancing across database nodes, automatic reconnection, and type-safe wrappers for Nebula's data types (values, vertices, edges, paths, geospatial). The architecture separates concerns into graph client (query execution), meta client (schema/cluster management), and storage client (direct data access). Examples demonstrate usage patterns for session pooling, SSL configuration, and storage scanning.
This repository is neo4rs, a production-grade asynchronous Rust driver for the Neo4j graph database. It implements the Bolt binary protocol (versions 4.x with partial 5.x support) and provides a complete client library for querying, transaction management, connection pooling, cluster routing, and serialization of Neo4j's rich data types (nodes, relationships, paths, temporal and spatial values). The architecture is modular: a connection layer handles TCP/TLS handshakes and chunked message framing; a PackStream serializer/deserializer converts between Rust types and the Bolt wire format; a routing module manages cluster membership and load balancing; and a high-level API (Graph, Session, Txn, RowStream) offers async query execution with automatic retry on transient errors. The codebase includes two parallel Bolt protocol implementations—a legacy one and a newer feature-gated version—which introduces maintenance overhead. Despite this, the project is actively maintained with extensive integration tests against multiple Neo4j versions and a robust CI pipeline. The library is suitable for any Rust application that needs to interact with Neo4j, offering both a high-level ergonomic API and low-level control over the protocol.
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 contains the Virtuoso Open-Source multi-model database server, primarily written in C, with extensive client libraries in Java, C#, and PHP. In production, it functions as a relational database, RDF triple store, SPARQL query endpoint, XML processor, and application server (VSPX). The architecture is a monolithic server process with plugin extensions for hosting languages (CLR, Java, PHP) and connectivity via ODBC, JDBC, OLE DB, and ADO.NET. Key entry points include the Virtuoso server binary (built from libsrc/Wi/ and libsrc/Dk/), ODBC driver (binsrc/virtodbc/), JDBC Type 4 driver (libsrc/JDBCDriverType4/), and .NET client (binsrc/VirtuosoClient.Net/). Data flows include SQL parsing and execution via the Wi module, RDF/SPARQL query processing, and WebDAV/HTTP file management through the built-in web server. External dependencies include PCRE, zlib, HTML Tidy (libsrc/Tidy/), and curl. The repository also contains a suite of web applications (ODS) for blogging, bookmarks, calendar, wiki, etc., built on a common SQL-based framework, and a comprehensive test suite covering performance benchmarks (BSBM, LUBM, TPC-D/H). Despite its breadth, the codebase shows signs of age: multiple duplicate Jena driver versions, a legacy Ajax toolkit (OAT), and hardcoded paths in test scripts. It remains actively maintained with regular commits and issue triage.
Aaia is a security analysis tool for AWS IAM and Organizations that visualizes identity and access relationships in a Neo4j graph database. It collects AWS data via CLI commands, stores it as JSON, and loads it into Neo4j for graph-based querying and auditing. The architecture consists of a modular Python application with separate components for data collection, loading into Neo4j, and custom auditing modules. Key entry points include the main Aaia.py script, the Aaia_aws_collector.sh shell script for data gathering, and specialized action/module handlers. The data flow moves from AWS CLI → JSON files → Neo4j graph → analysis results via Cypher queries or custom modules. The tool depends on Neo4j (v3.5.17 compatible), AWS CLI, and several Python packages for policy processing and Neo4j interaction.
This is the TigerGraph ecosystem repository, a large collection of tools, connectors, demos, benchmarks, and tutorials centered around the TigerGraph graph database platform. It is not a single application but an aggregation of community and in-house developed components. The dominant character is application: it includes production-grade ETL connectors (Spark DataSource V2, JDBC driver, Kafka Connect, Hadoop MapReduce), a multi-version GSQL CLI client, a Go-based REST API for remote GSQL management, a Kubernetes operator, and numerous demos showcasing graph analytics (PageRank, community detection, geospatial search, fraud detection, GraphRAG). There are also benchmarking suites (LDBC SNB) and sample data. The codebase exhibits high craftsmanship in the connector and client libraries, with robust retry logic, token management, streaming JSON parsing, and schema inference. However, it suffers from massive code duplication across GSQL client versions, incomplete JDBC driver implementations, hardcoded paths and credentials in demos, and outdated vendored libraries (Leaflet 0.7.7, moment-timezone 2016). Overall, it is a functional but uneven collection; the core connectors are reusable and well-engineered, while many demo scripts are fragile and require manual configuration.