A semantic graph database with time travel, branching, and verifiable data — built on W3C standards.

Fluree DB is a single binary that stores your data as an RDF knowledge graph, queryable with SPARQL, JSON-LD Query, Cypher, or GraphQL, with every commit immutably recorded so you can travel back to any prior state. It supports git-style branching and merging, signed and policy-gated transactions, SHACL validation, OWL/RDFS reasoning, and full-text and vector search — over local files or S3 — without bolting on external services.

• Semantic by default. Your data is RDF. IRIs, JSON-LD @context, named graphs, and typed values are first-class. Queries are SPARQL 1.1, the equivalent JSON-LD Query, or openCypher — all compiling to the same execution engine. A GraphQL endpoint sits on top, its schema derived from the data and its SHACL shapes.
• Property graphs and statement-level metadata. Attach properties to a relationship, not just a node — role and since on a worksFor edge, source and confidence on a claim — with RDF 1.2 / SPARQL 1.2 edge annotations. Labeled-property-graph edges, parallel relationships between the same two nodes, and RDF-star provenance all live on one surface, and plain triple queries are left undisturbed. See Edge annotations.
• Time travel. Every transaction is a commit on an immutable chain. Query the state of the graph at any past moment with a single t parameter — no snapshots to restore, no separate audit log to consult.
• Branching and merging. Create a branch off any commit, transact against it in isolation, then merge it back. Useful for staging changes, running what-if analyses, or maintaining environment-specific overlays.
• Verifiable data. Transactions and commits can be signed (JWS / W3C Verifiable Credentials). The commit chain is content-addressed, so any tampering is detectable. Pair it with policy enforcement to prove who changed what and when they were allowed to.
• Policy-based access control. Policies are written as graph data, evaluated per query and per transaction, and travel with the ledger — not bolted on at the API layer.
• Storage your way. Local filesystem for development, S3 + DynamoDB for production, and (experimentally, from the Rust API) IPFS for content-addressed distribution. The same ledger format works across all of them.
• Search built in. BM25 full-text indexing and HNSW vector search live alongside SPARQL — no separate search service to operate.
• Reasoning. OWL/RDFS inference and Datalog rules run inside the query engine, so derived facts are queryable without a materialization step.
• Embeddable. The same engine that powers the server runs as a Rust library, generic over storage and nameservice, and in-process from Python. Use it directly in your application or run it standalone over HTTP.

• New to Fluree? → Getting started
• Run the server → Quickstart: run the server
• Create a ledger and write data → Quickstart: create a ledger → Quickstart: write data
• Query data → Quickstart: query (JSON-LD, SPARQL, Cypher), or GraphQL for a schema derived from your data
• End-to-end walkthrough → Tutorial: search, time travel, branching, policies
• Coming from SQL? → Fluree for SQL developers
• Embedding in Rust? → Using Fluree as a Rust library
• Using Python? → Using Fluree from Python

• Concepts — ledgers, graph sources, IRIs, datatypes, edge annotations, time travel, policy, verifiable data, reasoning
• Guides (cookbooks) — query patterns, search, time travel, branching, policies, SHACL, edge annotations — task-oriented recipes
• CLI reference — every fluree command, flag by flag
• HTTP API — endpoints, headers, signed requests, error model
• Query — JSON-LD Query, SPARQL, Cypher, GraphQL, output formats, CONSTRUCT, explain plans, reasoning
• Transactions — insert, upsert, update, conditional updates, signed transactions
• Security and policy — authentication, encryption, commit signing, policy model
• Indexing and search — background indexing, BM25, vector search, geospatial
• Graph sources and integrations — Iceberg/Parquet, R2RML, BM25 graph source
• Operations — scaling and resilience, configuration, Docker, storage modes, telemetry, archive/restore
• Design — internals: query execution, storage traits, index format, nameservice
• Reference — glossary, vocabulary, OWL/RDFS support, crate map
• Troubleshooting — common errors, debugging queries, performance tracing
• Contributing — dev setup, tests, SPARQL compliance, releasing

The full table of contents is in the sidebar.

Fluree for AI and agents features for the AI use case — it ties together Agent JSON (token-efficient query output), the MCP server (Fluree as an agent tool), Fluree Memory, vector and full-text search as a RAG substrate, and reasoning.

Fluree Memory is persistent, searchable memory for AI coding assistants — built on Fluree DB and shipped in the same fluree binary. If you're here for the memory tooling, jump straight to the Memory docs.