# ClickGraph #### ClickGraph - A high-performance graph query engine for ClickHouse, written in Rust, with Neo4j ecosystem compatibility - Cypher and Bolt Protocol 5.8 support. Server mode is stateless (translates Cypher to ClickHouse SQL with no extra datastore); embedded mode runs in-process via chdb and is **read-write** as of v0.6.7 (`CREATE` / `SET` / `DELETE` / `REMOVE`). Reads also work in remote and sql_only modes. Exports query results to external destinations. Golang and Python bindings in addition to native Rust. New `cg` CLI tool supports agentic workflows. > **Note: ClickGraph dev release is at beta quality for view-based graph analytics applications. Kindly raise an issue if you encounter any problem.** > 🧊 **Meet DeltaGraph β€” ClickGraph's sibling for Databricks.** The same engine, the same Cypher, the same Bolt/Neo4j-Browser compatibility β€” but translating to Spark SQL and executing against a **Databricks SQL Warehouse** instead of ClickHouse. One codebase, two server binaries (`clickgraph` for ClickHouse, `deltagraph` for Databricks); pick the backend at runtime. See the [Docker quickstart](docs/deltagraph/DOCKER_QUICKSTART.md), the [build-from-source quickstart](docs/deltagraph/QUICKSTART.md), or [how the two are packaged](docs/deltagraph/PACKAGING.md). > πŸ“Š **Why warehouse- & lakehouse-native graph?** [**Read the positioning brief β†’**](https://genezhang.github.io/clickgraph/) β€” how ClickGraph & DeltaGraph compare to Neptune, Neo4j GDS, and lakehouse graph engines on scale, GraphRAG, and security graph at petabyte scale. `ClickGraph` provides three modes now: - Stateless service - Embedded mode with embedded `chDB` - Hybrid mode with remote querying and local storage See [motivation and rationale](docs/motivation.md). --- ## What's New in v0.6.8-dev β€” DeltaGraph preview 🧊 - **DeltaGraph is now packaged for preview.** The `deltagraph` server (Cypher β†’ Spark SQL β†’ Databricks SQL Warehouse) ships alongside `clickgraph` in the same Docker image (`genezhang/clickgraph`, selected via `--entrypoint /usr/local/bin/deltagraph`) and as its own `deltagraph-` release tarball on every platform. A user chooses the backend at **runtime** β€” run `clickgraph` (ClickHouse), run `deltagraph` (Databricks), run both side-by-side on different ports, or `clickgraph --databricks`. The Neo4j Browser demo is verified live end-to-end on **both** backends at full result parity, including a live Databricks free-tier warehouse. Start here: [Docker quickstart](docs/deltagraph/DOCKER_QUICKSTART.md) Β· [packaging & binary selection](docs/deltagraph/PACKAGING.md). - **`toString()` float fidelity (#1055)** β€” `toString(3.0)` now returns `"3.0"` (Neo4j semantics), not `"3"`, on both the ClickHouse and Databricks dialects. See [CHANGELOG.md](CHANGELOG.md).
DeltaGraph β€” full capability detail (dialect routing, surfaces, auth, what's pending) - **Cypher over Databricks SQL Warehouse** (opt-in `--features databricks`). A second SQL dialect alongside ClickHouse: Cypher is translated to Spark SQL locally and executed against a Databricks SQL Warehouse over the Statement Execution API. Dialect routing through `FunctionMapper` (`groupArray`β†’`collect_list`, `toInt64`β†’`bigint`, `Array(Int64)`β†’`ARRAY`, etc.), including variable-length paths and BFS shortestPath. PAT auth with `Debug` redaction. Surfaces: `Database::new_databricks(schema, DatabricksConfig)` in `clickgraph-embedded`, `Database::open_databricks` over the FFI for Go/Python, `cg --dialect databricks` for SQL emission *and* execution (env-only PAT), `cg schema discover --dialect databricks` for LLM-assisted YAML drafts off a live warehouse, optional top-level `catalog:` YAML field for schemas permanently tied to one Unity Catalog (env still wins), and a dedicated **`deltagraph` server binary** (HTTP + Bolt, defaults to Databricks). Manual walkthrough: [docs/deltagraph/QUICKSTART.md](docs/deltagraph/QUICKSTART.md). Docker quickstart: [docs/deltagraph/DOCKER_QUICKSTART.md](docs/deltagraph/DOCKER_QUICKSTART.md). Packaging & binary selection: [docs/deltagraph/PACKAGING.md](docs/deltagraph/PACKAGING.md). Plan: [docs/design/DELTAGRAPH_PLAN.md](docs/design/DELTAGRAPH_PLAN.md). Still pending: `MERGE`, OAuth M2M auth, full LDBC validation against a live warehouse, external-link result chunks.
## What's New in v0.6.7-dev - **Cypher writes in embedded mode** β€” `CREATE`, `SET`, `DELETE` / `DETACH DELETE`, and `REMOVE` against ClickGraph-managed (non-`source:`) tables. Translates to ClickHouse's lightweight `INSERT` / `UPDATE` / `DELETE` mutation path; tables created by ClickGraph automatically get `enable_block_number_column = 1, enable_block_offset_column = 1`. Per-node `id_generation` schema attribute (`uuid` default / `provided` / `snowflake`). Returns Neo4j-compatible counters (`nodes_created`, `properties_set`, `nodes_deleted`, `relationships_deleted`). Server / remote / sql_only modes reject writes before planning them (the embedded connection's executor check); `source:`-backed nodes/edges remain read-only. `MERGE`, relationship `CREATE`, `CREATE … RETURN`, edge-alias `DELETE r`, `SET a += {…}` map-merge, and `REMOVE a:Label` are not implemented yet β€” each is rejected with an explicit error rather than silently mis-rendering. See [docs/wiki/Cypher-Language-Reference.md](docs/wiki/Cypher-Language-Reference.md#write-clauses) for full syntax + caveats and [docs/design/embedded-writes.md](docs/design/embedded-writes.md) for the design. ## What's New in v0.6.6-dev - **`cg` CLI tool** β€” Agent/script-oriented CLI (`clickgraph-tool` crate). Translate and execute Cypher without a running server: `cg sql`, `cg validate`, `cg query`, `cg nl` (NLβ†’Cypher via LLM), `cg schema show/validate/discover/diff`. Config via `~/.config/cg/config.toml`. Designed for agentic callers, CI pipelines, and scripting. - **`embedded` feature now opt-in** β€” `clickgraph-embedded` compiles without chdb by default. New `Database::new_remote(schema, RemoteConfig)` constructor executes Cypher against external ClickHouse with no chdb dependency β€” useful for lightweight tooling and the `cg` CLI. - **Agent skills** β€” Three publishable skills for any agentic framework (Claude Code, LangChain, AutoGen, CrewAI, OpenAI function calling): `/cypher` (NLβ†’Cypherβ†’execute), `/graph-schema` (show schema), `/schema-discover` (generate schema YAML from ClickHouse via LLM). See [skills/README.md](skills/README.md). - **openCypher TCK** β€” 402/402 read scenarios passing (100%). Write scenarios are not yet imported from upstream openCypher TCK; v0.6.7 adds the Cypher write pipeline that will unblock them. ## What's New in v0.6.5-dev - **Hybrid remote query + local storage** β€” Execute Cypher against a remote ClickHouse cluster from embedded mode, store results locally in chdb for fast re-querying. `query_remote()`, `query_remote_graph()`, `store_subgraph()` β€” ideal for GraphRAG context enrichment. Available in Rust, Python, and Go. - **Embedded write API for GraphRAG** β€” `create_node()`, `create_edge()`, `upsert_node()` with batch variants. AI agents can extract entities from documents, store them as an in-process graph, and query with Cypher β€” all without a server. - **Kuzu API parity** β€” `Value::Date/Timestamp/UUID` types, query timing (`compiling_time`/`execution_time`), `Database::in_memory()`, `Connection::set_query_timeout()`, column type metadata, multi-format file import (CSV/Parquet/JSON). - **DataFrame output** β€” `result.get_as_df()` (Pandas), `result.get_as_arrow()` (PyArrow), `result.get_as_pl()` (Polars) for Python data science workflows. See [CHANGELOG.md](CHANGELOG.md) for complete release history. --- ## Features ### Core Capabilities - **Cypher-to-SQL Translation** - Industry-standard Cypher read syntax translated to optimized ClickHouse SQL - **Stateless Architecture** - Offloads all query execution to ClickHouse; no extra datastore required - **Embedded Mode** - In-process graph queries over Parquet/Iceberg/Delta/S3 via chdb; no ClickHouse server needed (`--features embedded`) - **Remote Mode** - Cypher translated locally, executed against external ClickHouse β€” no chdb required (`Database::new_remote`) - **DeltaGraph (Databricks SQL Warehouse)** - Cypher translated to Spark SQL locally and executed against a Databricks SQL Warehouse via the Statement Execution API. Opt-in `--features databricks`; ships the `deltagraph` server binary, `cg --dialect databricks`, `Database::new_databricks` (embedded Rust), and `Database::open_databricks` (FFI for Go/Python). See [docs/deltagraph/QUICKSTART.md](docs/deltagraph/QUICKSTART.md) (build from source) or [docs/deltagraph/DOCKER_QUICKSTART.md](docs/deltagraph/DOCKER_QUICKSTART.md) (Docker). - **LLM-powered schema discovery** - `cg schema discover` or `:discover` generates YAML schema from ClickHouse table metadata using Anthropic or OpenAI β€” no server needed - **Variable-Length Paths** - Recursive traversals with `*1..3` syntax using ClickHouse `WITH RECURSIVE` CTEs - **Path Functions** - `length(p)`, `nodes(p)`, `relationships(p)` for path analysis - **Parameterized Queries** - Neo4j-compatible `$param` syntax for SQL injection prevention - **Query Cache** - LRU caching with 10-100x speedup for repeated translations - **ClickHouse Functions** - Pass-through via `ch.function_name()` and `chagg.aggregate()` prefixes - **GraphRAG structured output** - `format: "Graph"` returns deduplicated nodes, edges, and stats for graph visualization and RAG pipelines - **GraphRAG write API** - `create_node()`, `create_edge()`, `upsert_node()` for in-process graph building (embedded mode) - **Hybrid remote + local** - Query remote ClickHouse, store subgraph locally in chdb for fast re-querying - **Query Metrics** - Phase-by-phase timing via HTTP headers and structured logging - **ClickHouse cluster load balancing** - `CLICKHOUSE_CLUSTER` env var auto-discovers and balances queries across cluster nodes - **openCypher TCK: 402/402 read scenarios passing (100%)** - 0 failures. Write feature files are not yet imported from upstream; v0.6.7 adds the Cypher write pipeline (`CREATE` / `SET` / `DELETE` / `REMOVE`) that will unblock them. - **LDBC SNB benchmark: 36/37 queries (97%)** - Near-complete Social Network Benchmark coverage. See [benchmark results](benchmarks/ldbc_snb/BENCHMARK_RESULTS.md) for performance data on sf0.003, sf1 and sf10 datasets ### Neo4j Ecosystem Compatibility - **Bolt Protocol v5.8** - Full Neo4j driver compatibility (cypher-shell, Neo4j Browser, graph-notebook) - **HTTP REST API** - Complete query execution with parameters and aggregations - **Multi-Schema Support** - Per-request schema selection via `USE` clause, session parameter, or default - **Authentication** - Multiple auth schemes including basic auth ### Agentic & AI Integration - **Agent skills** - `/cypher`, `/graph-schema`, `/schema-discover` for Claude Code, LangChain, AutoGen, CrewAI, and OpenAI function calling (see [skills/README.md](skills/README.md)) - **`cg` CLI** - Subprocess-friendly CLI for agentic callers; outputs clean text/JSON, no interactive prompts - **MCP compatibility** - `apoc.meta.schema()` and Neo4j schema procedures for MCP-based AI assistants - **DataFrame output** - `get_as_df()` (Pandas), `get_as_arrow()` (PyArrow), `get_as_pl()` (Polars) for Python data science ### View-Based Graph Model - **Zero Migration** - Map existing tables to graph format through YAML configuration - **Auto-Discovery** - `auto_discover_columns: true` queries ClickHouse metadata automatically - **Dynamic Schema Loading** - Runtime schema registration via `POST /schemas/load` - **Composite Node IDs** - Multi-column identity (e.g., `node_id: [tenant_id, user_id]`) --- ## How ClickGraph compares ClickGraph and DeltaGraph are **warehouse- and lakehouse-native** graph query engines: they translate Cypher to SQL and execute it **inside** ClickHouse or Databricks. They are stateless translators β€” they store nothing and add no compute of their own. This is a deliberately different point in the design space from a graph database, and it wins in some places and loses in others. Here is the honest map. **Where warehouse-native pushdown wins** - **No data movement.** Your existing tables β€” including FK-edge and denormalized layouts β€” *are* the graph, mapped via YAML. Nothing is imported, copied, or flattened, so relationships already encoded in your schema are preserved rather than collapsed to primitive node/edge pairs. - **No second compute engine.** 100% of execution is pushed down to the warehouse you already run, secure, and pay for. There is no separate graph engine to size, scale, or bill β€” unlike engines that deploy their own distributed compute layer beside your data. - **No in-memory scale ceiling.** The graph-analytics engines are in-memory by design: Neo4j GDS runs algorithms in heap (β‰ˆ90% of one machine's RAM), and Amazon Neptune Analytics holds the whole graph in memory (~1 TiB at its max capacity). ClickGraph's ceiling is the warehouse's β€” petabyte-native. At 100s of TB–PB, the data often physically cannot be loaded into the engine that would analyze it. - **Freshness.** Query where fresh data already lands (ClickHouse ingests millions of rows/sec) β€” zero ingestion lag, because there is no ingestion step. - **Graph algorithms in-place.** PageRank (`CALL pagerank(...)`) and shortest path (`shortestPath` / `allShortestPaths`) run as generated SQL over your warehouse tables β€” no export to a separate engine. - **Inspectable.** `sql_only` mode returns the exact generated SQL, so you can see precisely what runs on your warehouse β€” no black box. **Where a native graph database still wins β€” use one when:** - You need **very deep, tight-loop iterative graph algorithms** at small scale where an in-memory adjacency representation is decisively faster. ClickGraph *does* support graph algorithms β€” **PageRank** (`CALL pagerank(...)`, translated to iterated SQL) and **shortest path** (`shortestPath` / `allShortestPaths`, compiled to BFS recursive CTEs) ship today β€” but like any warehouse feature they carry a scale profile: iterative execution over very large graphs is bounded by the warehouse's recursive/iterative performance, not vectorized scans. For heavy, repeated whole-graph analytics (e.g. community detection over a resident in-memory graph), a dedicated GDS/cuGraph/TigerGraph engine on a snapshot can be the better tool. (Pushing more of the iterated-`JOIN`+`GROUP BY`-over-a-semiring family further inside SQL is an active optimization direction.) - You need **deep OLTP-style traversal** (10-hop, millisecond, per request). The columnar scan model isn't that shape. - Your data is small enough (GB–low TB) that in-memory adjacency is a clean win with no scale concern. **Query-shape note.** Pattern-matching + filtering + aggregation and *bounded* traversal push down and scale with the warehouse β€” this is the shape of most real "graph analytics" (fraud rings, lineage, recommendations, security graph). Exact fixed-hop paths already compile to MPP-parallel joins; unbounded transitive closure uses recursive CTEs (row-iterative on ClickHouse today, and expensive for any engine at PB scale). For the full breakdown with sources, GraphRAG, and security-graph-at-scale: **[the positioning brief β†’](https://genezhang.github.io/clickgraph/)** --- ## Architecture ClickGraph service runs as a lightweight stateless query translator alongside ClickHouse: ```mermaid flowchart LR Clients["Graph Clients

HTTP/REST
Bolt Protocol
(Neo4j tools)"] ClickGraph["ClickGraph

Cypher -> SQL
Translator

:7475 (HTTP)
:7687 (Bolt)"] ClickHouse["ClickHouse

Columnar Storage
Query Engine"] Clients -->|Cypher| ClickGraph ClickGraph -->|SQL| ClickHouse ClickHouse -->|Results| ClickGraph ClickGraph -->|Results| Clients style ClickGraph fill:#e1f5ff,stroke:#0288d1,stroke-width:3px style ClickHouse fill:#fff3e0,stroke:#f57c00,stroke-width:3px style Clients fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px ``` **Three-tier architecture:** Graph clients -> ClickGraph translator -> ClickHouse database --- ## Quick Start **New to ClickGraph?** See the **[Getting Started Guide](docs/getting-started.md)** for a complete walkthrough. ### Option 0: Pre-built Binaries Download the latest release from [GitHub Releases](https://github.com/genezhang/clickgraph/releases/latest). Assets are gzipped tarballs (`.tar.gz` on Linux/macOS, `.zip` on Windows) named `-`, where `` is one of `linux-amd64`, `macos-amd64`, `macos-arm64`, `win-amd64`: ```bash # ClickGraph server (ClickHouse backend) curl -L https://github.com/genezhang/clickgraph/releases/latest/download/clickgraph-linux-amd64.tar.gz \ | tar -xz && chmod +x clickgraph # DeltaGraph server (Databricks backend) β€” same Cypher/Bolt, Spark SQL dialect curl -L https://github.com/genezhang/clickgraph/releases/latest/download/deltagraph-linux-amd64.tar.gz \ | tar -xz && chmod +x deltagraph # cg CLI tool (agent/scripting use) curl -L https://github.com/genezhang/clickgraph/releases/latest/download/cg-linux-amd64.tar.gz \ | tar -xz && chmod +x cg ``` ### Option 1: Docker (Recommended) ```bash # Pull the latest image docker pull genezhang/clickgraph:latest # Start ClickHouse only docker-compose up -d clickhouse-service # Run ClickGraph from Docker Hub image docker run -d \ --name clickgraph \ --network clickgraph_default \ -p 7475:7475 \ -p 7687:7687 \ -e CLICKHOUSE_URL="http://clickhouse-service:8123" \ -e CLICKHOUSE_USER="test_user" \ -e CLICKHOUSE_PASSWORD="test_pass" \ -e GRAPH_CONFIG_PATH="/app/schemas/social_benchmark.yaml" \ -v $(pwd)/benchmarks/social_network/schemas:/app/schemas:ro \ genezhang/clickgraph:latest ``` Or use docker-compose (uses published image by default): ```bash docker-compose up -d ``` ### Option 2: Build from Source ```bash # Prerequisites: Rust toolchain (1.85+) and Docker for ClickHouse # 1. Clone and start ClickHouse git clone https://github.com/genezhang/clickgraph cd clickgraph docker-compose up -d clickhouse-service # 2. Build and run cargo build --release export CLICKHOUSE_URL="http://localhost:8123" export CLICKHOUSE_USER="test_user" export CLICKHOUSE_PASSWORD="test_pass" export GRAPH_CONFIG_PATH="./benchmarks/social_network/schemas/social_benchmark.yaml" cargo run --bin clickgraph ``` > `GRAPH_CONFIG_PATH` is required. It tells ClickGraph how to map ClickHouse tables to graph nodes and edges. ### Test Your Setup ```bash # HTTP API curl -X POST http://localhost:7475/query \ -H "Content-Type: application/json" \ -d '{"query": "MATCH (u:User) RETURN u.full_name LIMIT 5"}' # Bolt protocol (cypher-shell, Neo4j Browser, or any Neo4j driver) # (cypher-shell needs the server started with --neo4j-compat-mode) cypher-shell -a bolt://localhost:7687 -u neo4j -p password ``` ### Visualize with Neo4j Browser Run the included demo for interactive graph visualization: ```bash cd demos/neo4j-browser && bash setup.sh ``` Then open http://localhost:7474 and connect to `bolt://localhost:7687`. See [demos/neo4j-browser/README.md](https://github.com/genezhang/clickgraph/blob/main/demos/neo4j-browser/README.md) for details. ### AI Assistant Integration **Agent skills** β€” drop-in skills for Claude Code and other agentic frameworks, backed by the `cg` CLI (no MCP server needed): ```bash # Install for Claude Code mkdir -p .claude/commands curl -L https://raw.githubusercontent.com/genezhang/clickgraph/main/skills/cypher.md \ -o .claude/commands/cypher.md curl -L https://raw.githubusercontent.com/genezhang/clickgraph/main/skills/graph-schema.md \ -o .claude/commands/graph-schema.md # Then in Claude Code: # /cypher find users with more than 10 followers # /graph-schema ``` See **[skills/README.md](skills/README.md)** for installation across Claude Code, LangChain, AutoGen, CrewAI, and OpenAI function calling. **MCP server** β€” for frameworks requiring the MCP protocol, ClickGraph implements `apoc.meta.schema()` and Neo4j-compatible schema procedures, compatible with [`@anthropic-ai/mcp-server-neo4j`](https://www.npmjs.com/package/@anthropic-ai/mcp-server-neo4j) and [`@neo4j/mcp-neo4j`](https://www.npmjs.com/package/@neo4j/mcp-neo4j). See the **[MCP Setup Guide](https://github.com/genezhang/clickgraph/blob/main/docs/wiki/AI-Assistant-Integration-MCP.md)** for configuration details. ### CLI Tools **`cg` β€” agent/script CLI** (no server needed): ```bash cargo build --release -p clickgraph-tool # Translate Cypher β†’ SQL ./target/release/cg --schema schema.yaml sql "MATCH (u:User) RETURN u.name LIMIT 5" # Execute against ClickHouse ./target/release/cg --schema schema.yaml --clickhouse http://localhost:8123 \ query "MATCH (u:User)-[:FOLLOWS]->(f) RETURN f.name LIMIT 5" # NL β†’ Cypher (requires ANTHROPIC_API_KEY or OPENAI_API_KEY) ./target/release/cg --schema schema.yaml nl "find users with more than 10 followers" ``` **`clickgraph-client` β€” interactive REPL** (connects to a running server): ```bash cargo build --release -p clickgraph-client ./target/release/clickgraph-client # connects to http://localhost:7475 ``` --- ## Schema Configuration Map your tables to a graph with YAML: ```yaml views: - name: social_network nodes: - label: user table: users database: mydb node_id: user_id property_mappings: name: full_name edges: - type: follows table: user_follows database: mydb from_node: user to_node: user from_id: follower_id to_id: followed_id ``` ```cypher MATCH (u:user)-[:follows]->(friend:user) WHERE u.name = 'Alice' RETURN friend.name ``` --- ## Documentation - **[Getting Started](docs/getting-started.md)** - Setup walkthrough and first queries - **[Features Overview](docs/features.md)** - Comprehensive feature list - **[API Documentation](docs/api.md)** - HTTP REST API and Bolt protocol - **[Configuration Guide](docs/configuration.md)** - Server configuration and CLI options - **[Wiki](https://github.com/genezhang/clickgraph/blob/main/docs/wiki/)** - Comprehensive guides: [Cypher Reference](https://github.com/genezhang/clickgraph/blob/main/docs/wiki/Cypher-Language-Reference.md), [Schema Basics](https://github.com/genezhang/clickgraph/blob/main/docs/wiki/Schema-Basics.md), [Graph-Notebook](https://github.com/genezhang/clickgraph/blob/main/docs/wiki/Graph-Notebook-Compatibility.md), [Neo4j Tools](https://github.com/genezhang/clickgraph/blob/main/docs/wiki/Neo4j-Tools-Integration.md) - **[Examples](examples/)** - [Quick Start](examples/quick-start.md) | [E-commerce Analytics](examples/ecommerce-analytics.md) - **[Dev Quick Start](DEV_QUICK_START.md)** - 30-second workflow for contributors --- ## Development Status **Current Version**: v0.6.6-dev ### Test Coverage - **Rust Unit Tests**: 1,601 passing (100%) - **Integration Tests**: 3,068 passing (108 environment-dependent) - **openCypher TCK**: 402/402 read scenarios passing (100%), 0 failures - **LDBC SNB**: 36/37 queries passing (97%) - **Benchmarks**: 14/14 passing (100%) - **E2E Tests**: Bolt 4/4, Cache 5/5 (100%) ### Known Limitations - **Cypher writes β€” embedded mode only**: `CREATE`, `SET`, `DELETE`, `REMOVE` work in embedded mode against ClickGraph-managed tables (v0.6.7+). Server / remote / sql_only modes reject writes; `source:`-backed nodes/edges remain read-only. `MERGE` is planned for v0.7.x. See [Known Issues #2 / #3](KNOWN_ISSUES.md) for the full list of unsupported write combinations. - **Anonymous Nodes**: Use named nodes for better SQL generation See [STATUS.md](STATUS.md) and [KNOWN_ISSUES.md](KNOWN_ISSUES.md) for details. ## Roadmap | Phase | Version | Status | |-------|---------|--------| | Phase 1 | v0.4.0 | Complete - Query cache, parameters, Bolt protocol | | Phase 2 | v0.5.0 | Complete - Multi-tenancy, RBAC, auto-schema discovery | | Phase 2.5-2.6 | v0.5.2-v0.5.3 | Complete - Schema variations, Cypher functions | | Phase 3 | v0.6.3 | Complete - WITH redesign, GraphRAG, LDBC SNB, MCP | | Phase 4 | v0.6.x | Next - user-requested features, advanced optimizations | See [ROADMAP.md](ROADMAP.md) for detailed feature tracking. ## Contributing Contributions welcome! See [DEV_QUICK_START.md](DEV_QUICK_START.md) to get started and [DEVELOPMENT_PROCESS.md](DEVELOPMENT_PROCESS.md) for the full workflow. ## License ClickGraph is licensed under the Apache License, Version 2.0. See the LICENSE file for details. This project is developed on a forked repo of [Brahmand](https://github.com/darshanDevrai/brahmand) with zero-ETL view-based graph querying, Neo4j ecosystem compatibility and enterprise deployment capabilities.