CoordiNode 开源图原生混合检索引擎，单条查询混合图遍历、向量相似度与 BM25

The graph-native hybrid retrieval engine for AI and GraphRAG. A graph database, a vector database and a full-text search engine, running as one transactional engine with one query language.

Built in Rust. Zero GC. Single binary. OpenCypher-compatible. Clustering included in the open-source edition.

• One query mixes graph traversal, vector similarity and BM25 text relevance, planned and executed as one pipeline.
• One snapshot: MVCC snapshot isolation across edges, embeddings and the text index, so a retrieval never reads a half-applied write.
• One binary: no JVM, no C dependencies, no separate router. The same executable runs standalone or as a Raft-replicated cluster.

Quick start

Run the latest release from the container registry:

docker run -d --name coordinode \
  -p 7080:7080 -p 7081:7081 -p 7084:7084 \
  -v coordinode-data:/data \
  ghcr.io/structured-world/coordinode:latest
curl http://localhost:7084/health

Or install a package from the latest release: RPMs for Fedora 42 to 44, DEBs for Debian and Ubuntu, and static binaries for linux-amd64 and linux-arm64.

From source (Rust 1.90+; the toolchain is pinned in rust-toolchain.toml):

git clone https://github.com/structured-world/coordinode.git
cd coordinode
cargo build --release
./target/release/coordinode serve --addr [::]:7080

# Optional CJK full-text analyzers
cargo build --release --features cjk-zh,cjk-ja,cjk-ko

Ports: 7080 gRPC, 7081 REST/JSON, 7084 metrics and health. The Quick Start guide goes from an empty database to a hybrid query in five minutes.

One query, three modalities

Traverse a knowledge graph, filter by semantic similarity, rank by text match, all inside one transaction:

MATCH (topic:Concept {name: "machine learning"})-[:RELATED_TO*1..3]->(related)
MATCH (related)<-[:ABOUT]-(doc:Document)
WHERE vector_distance(doc.embedding, $question_vector) < 0.4
  AND text_match(doc.body, "transformer attention mechanism")
RETURN doc.title,
       vector_distance(doc.embedding, $question_vector) AS relevance,
       text_score(doc.body, "transformer attention mechanism") AS text_rank
ORDER BY relevance LIMIT 10

Across a split stack (graph database, vector store, search cluster) this is three round trips and a join in application code, with retrieval quality bounded by the least-fresh copy. Here it is one query, planned and costed as a whole, inside one snapshot.

Who it is for, and where it stops

Use CoordiNode today for

• GraphRAG and knowledge retrieval: traverse a knowledge graph, filter by embedding similarity, rank by text relevance, in one statement.
• Fraud detection and threat intelligence: shared-device graphs with behavioural embedding similarity; attack patterns correlated across MITRE ATT&CK with vector and text search over indicators.
• Recommendations and social discovery: social-graph traversal plus semantic similarity to user preferences, with edge properties (ratings, timestamps) filterable in the same query.
• Replacing a multi-database stack (graph + vector + search) with a single binary and a single transaction model.

Not yet, if you need

• A drop-in replacement for a mature Neo4j Enterprise deployment, or APOC procedures, Neo4j Browser/Bloom, GDS.
• The Bolt protocol for existing Neo4j drivers. gRPC and REST are available now; Bolt and GraphQL are planned.
• A cluster with years of production mileage. Raft replication, follower reads and mTLS ship today and are covered by a fault-injection suite, but the deployment history is short.
• Vector indexes larger than memory. At 1M vectors of 384 dimensions that is roughly 1.5 GB before compression; SQ8 and RaBitQ bring it down substantially in exchange for a rerank pass.
• Horizontal sharding. The Community Edition replicates the full dataset to every node, which is the right shape until a dataset outgrows one machine; sharding is an Enterprise feature.

Example queries for each use case

Fraud ring detection

MATCH (suspect:Account {flagged: true})-[:SHARES_DEVICE*1..3]-(connected:Account)
WHERE vector_distance(suspect.tx_embedding, connected.tx_embedding) < 0.15
  AND connected.flagged = false
RETURN connected.id, connected.holder_name,
       vector_distance(suspect.tx_embedding, connected.tx_embedding) AS similarity
ORDER BY similarity LIMIT 50

Semantic recommendation

MATCH (me:User {id: $userId})-[:FOLLOWS*1..2]->(friend)
MATCH (friend)-[:PURCHASED]->(item:Product)
WHERE NOT (me)-[:PURCHASED]->(item)
  AND vector_distance(item.embedding, $user_taste_vector) < 0.3
RETURN DISTINCT item.name, item.category,
       vector_distance(item.embedding, $user_taste_vector) AS match_score
ORDER BY match_score LIMIT 20

Threat intelligence

MATCH (malware:Indicator {hash: $sample_hash})-[:USES]->(technique:AttackTechnique)
MATCH (technique)<-[:USES]-(similar:Indicator)
WHERE vector_distance(similar.behavior_embedding, malware.behavior_embedding) < 0.2
  AND text_match(similar.description, $ioc_keywords)
RETURN similar.name, technique.mitre_id,
       vector_distance(similar.behavior_embedding, malware.behavior_embedding) AS similarity
ORDER BY similarity LIMIT 25

Feature status

Syntax for every extension above is in the Cypher extensions reference.

What makes CoordiNode different

Other engines combine some of these. What CoordiNode optimises for is the combination holding under one transaction, one planner and one storage engine:

• One planner over all three modalities. A compound WHERE mixing traversal, vector distance and text match is split into one pipeline and costed as a whole, not executed as three lookups joined by your application.
• One snapshot. Graph edges, embeddings and the text index move together under MVCC snapshot isolation.
• Vector search over relationships as well as nodes, integrated with traversal and transactional execution.
• Rust with no garbage collector. Tail latency is a design constraint, not a tuning exercise: no JVM pauses, no stop-the-world.
• Pure Rust with no FFI. cargo build produces the whole engine, compression and TLS included. No OpenSSL, no C storage engine, nothing to reconcile with your base image.
• AGPL-3.0 with clustering included. Replication is not held back for a paid tier.
• Operations answered in-engine: entity resolution, document promotion and demotion, and triggers are native clauses, not plugins that break once you cluster.

For measured comparisons rather than claims, see the benchmarks: CoordiNode and the systems it is compared against run on the same host, results are JSON-recorded with a hardware fingerprint and commit SHA, and CoordiNode's numbers are regenerated by CI on every push.

Coming from Neo4j? The compatibility matrix lists clause by clause what carries over, what is spelled differently, and what is missing.

Python SDK

pip install coordinode                               # gRPC client
pip install coordinode-embedded                      # in-process engine, no server
pip install langchain-coordinode                     # LangChain GraphStore
pip install llama-index-graph-stores-coordinode      # LlamaIndex PropertyGraphStore

Source: structured-world/coordinode-python.

Architecture

                    ┌─────────────────────────────────────────┐
  gRPC :7080 ──────▶│                                         │
  REST :7081 ──────▶│           CoordiNode Server             │
  Metrics :7084 ───▶│                                         │
                    │         (single Rust binary)            │
                    │                                         │
                    ├─────────────────────────────────────────┤
                    │  OpenCypher Parser + Query Planner      │
                    │  ┌──────┐ ┌──────┐ ┌───────┐ ┌───────┐  │
                    │  │Graph │ │Vector│ │  FTS  │ │Spatial│  │
                    │  │Engine│ │ HNSW │ │Tantivy│ │  S2   │  │
                    │  └──┬───┘ └──┬───┘ └──┬────┘ └───┬───┘  │
                    │     └────────┴────────┴──────────┘      │
                    │           LSM Storage Engine            │
                    └─────────────────────────────────────────┘

20 Rust crates, about 232K lines of code. A multi-node deployment runs the same binary on every node: replication and routing are built in, with no separate router or coordinator process to operate.

Documentation

• Quick Start: from zero to a hybrid query in five minutes
• Guide: concepts, deployment, operations
• Cypher extensions: vector, full-text, spatial, time-travel and encrypted-search syntax
• Neo4j compatibility: clause-by-clause matrix
• Configuration: every tunable, its default, and whether it needs a restart
• Embedded mode: the engine as a library, with no server process
• Benchmarks: per-modality results, reproducible, same hardware for every system

Contributing

Bug reports, features and documentation are welcome; see CONTRIBUTING.md. Before a first pull request, contributors sign the Structured World Contributor License Agreement once; the CLA status on the pull request updates by itself. Security issues go to the address in SECURITY.md.

License

Copyright (C) 2026 Dmitry Prudnikov.

CoordiNode Community Edition is licensed under AGPL-3.0-only: genuine open source with SaaS protection. See LICENSE and COPYRIGHT.

What your program links to talk to the server is Apache-2.0: the wire definitions (proto) and the Rust driver (crates/coordinode-client). Connecting to CoordiNode puts no licence condition on your application.

The same code base is also available under a commercial licence as the Enterprise Edition (horizontal sharding, multi-tenancy, CRUSH placement, geo-distribution), for deployments that cannot meet the AGPL terms. Contact: enterprise@sw.foundation. The commercial licence never narrows the Community Edition: everything published here stays under AGPL-3.0-only, in full.

Support the project

CoordiNode is developed by Dmitry Prudnikov and contributors. Donations go directly to the maintainer and fund development time.

If you believe graph + vector + text should live in one engine under a genuine open-source license, you can support the work:

USDT (TRC-20), maintainer's personal wallet: TFDsezHa1cBkoeZT5q2T49Wp66K8t2DmdA

Sponsorship accelerates: the Bolt protocol so existing Neo4j drivers connect unchanged, SQL over the same engine, and hardening the cluster path that shipped in this release.