Skip to content

Features

IndentiaDB bundles capabilities that would normally require six separate systems into a single ACID-compliant engine. This section documents every major feature area in depth.

Feature Overview

Feature Description Page
Enterprise Search BM25 full-text indexing with an Elasticsearch-compatible API on port 9200, hybrid BM25+vector search with Bayesian fusion, opt-in SPARQL search joins for RAG, and access-controlled search with audit logging Enterprise Search
Governed commits Signed policy decisions, object version checks, atomic evidence, and stored receipts Governed commits
Workspaces and use cases Shared retrieval scopes that retain source-document ACLs Workspaces
Context graphs Evidence slices, bounded context assembly, and retraction Context graphs
Vector Search & RAG In-memory HNSW/IVF and disk-backed DiskIVF (100M+ vectors, 194× RAM reduction via scalar quantization, SOAR boundary recall), SurrealQL and SPARQL vector operators, hybrid text+vector queries, stored-value filtering, Vector K-NN in LPG, and a complete RAG pipeline with Knowledge Graph provenance Vector Search
Graph Algorithms 35 graph algorithms over the LPG projection: community detection (Louvain, Label Propagation), centrality (PageRank, Betweenness, Eigenvector), structural (SCC, bridges, cliques), paths (Dijkstra, A*, Bellman-Ford, k-shortest), flow (Dinic), and more — all via POST /algo/:name Graph Algorithms
Logic Programming (Locy) Datalog-with-Cypher-syntax rule engine: recursive rules, transitive closure, stratified negation, IS-reference joins, and FOLD aggregations — evaluated bottom-up to fixpoint over the LPG Locy Reference
Live Queries LIVE SELECT over WebSocket, DEFINE EVENT triggers, a REST-based SPARQL alerting engine, Rust live-query API with triple-level filtering, and AI agent patterns (inbox, task queue, pub/sub, event sourcing) Live Queries
Federated Queries SPARQL SERVICE clause, SERVICE SILENT fault-tolerant federation, R2RML virtual graphs mapping SQL databases to RDF, and a source registry supporting local, HTTP, and relational sources Federation
Semantic Inference RDFS/OWL forward-chaining materialization with incremental updates, rdfs:subClassOf / rdfs:subPropertyOf / owl:sameAs / owl:equivalentClass support, and configurable per-query inference toggle Inference
Bitemporal Time-Travel Dual-timeline queries (transaction time + valid time), TEMPORAL AS OF, TEMPORAL BETWEEN, and a configurable purge policy for regulatory retention compliance Bitemporal
Geospatial 60-bit geospatial encoding, WKT parsing, GeoSPARQL functions (geof:distance, geof:buffer, geof:within), nearest-neighbour queries, and distance joins Geospatial
Holonic Four-Graph Layer Native Cagle/Koestler holon layer (Interior / Boundary / Context / Meta) on named graphs. SHACL shapes act as formal membranes; /holonic/* routes are opt-in via config with startup guards against cluster mode. Dedicated authz middleware enforces Read for GET and Write for POST; anonymous calls rejected when authn is configured. Holonic
Scale & Sharding Bounded ingest with auto-compaction, streaming projection bootstrap, cross-node scatter-gather and shuffle joins over a dedicated distributed query service, and (experimental) tenant-spread sharding — the roadmap to 250M documents Scale & Sharding
Performance & Benchmarks The igbench SPARQL 1.1/1.2 benchmark harness and the query-engine overhaul: constant-time point lookups (~10 µs), 16,000× faster property paths, real-cardinality join planning, fused top-k — all with bit-identical results Performance

Cross-Cutting Feature Matrix

Capability SPARQL SurrealQL ES API LPG / Algo Locy Cypher
Full-text search ql:contains-word @@ operator match query — — —
Vector similarity vec:approxNearCosine <\|> operator knn field VectorKnn — —
Hybrid search ql:contains-word + vec:approxNear Combined knn + match — — —
Graph algorithms — — — 35 via /algo/:name — —
Logic programming — — — — Recursive rules —
Pattern matching BGP + SPARQL ->edge-> — Traverse MATCH MATCH
Write/mutate SPARQL UPDATE CRUD _bulk — — CREATE/MERGE
Aggregation GROUP BY Inline aggs — FOLD count()/sum()
Live queries Via WebSocket/events LIVE SELECT — — — —
Inference inference = true — — — Derived rules —
Bitemporal TEMPORAL AS OF — — — — —
Federation SERVICE clause SPARQL() call — — — —
Geospatial geof:distance geo::distance geo_distance filter — — —
ACL filtering Transparent Transparent Transparent Transparent Transparent Transparent

Where to Go Next

  • If you are building a search application or replacing Elasticsearch: start with Enterprise Search.
  • If you are building a RAG pipeline or AI application: start with Vector Search. For corpora above ~500K vectors, see the DiskIVF section.
  • If you need graph analytics (community detection, centrality, path analysis): start with Graph Algorithms.
  • If you need recursive inference or logic rules over graph data: start with Locy.
  • If you need real-time dashboards or event-driven automation: start with Live Queries.
  • If you are federating multiple data sources: start with Federation.
  • If you need regulatory audit trails or historical reporting: start with Bitemporal.
  • For security configuration (authentication, authorization, ACL): see the Security section.