Fluree DB - A graph database for data that matters.

Temporal, verifiable, standards-compliant, git-like branching and merging, and optimized for AI agents. Integrated vector, text and geo search, and fine-grained access control with no external dependencies.

RDF 1.1 / 1.2, Open Cypher Preview, SPARQL and JSON-LD query (includes history query and other Fluree feature extensions).

Billions of graph facts on commodity hardware. Over 2M facts/second bulk import. Benchmark leader, 10.4x faster than next database. On the full 21.5-billion-triple Wikidata dump, all 850/850 WGPB graph-pattern queries complete with a 43 ms geometric mean.

Fluree Memory — is part of the Fluree DB CLI. Persistent, searchable memory for AI coding assistants. Give Claude Code, Cursor, and other AI tools long-term project memory: facts, decisions, and preferences persist across sessions in a Fluree ledger you control — scoped per-repo or per-user, shareable via git.

Install

Cloud / Serverless — Run in a dedicated serverless stack at no cost (usage limited), spin up dedicated servers on demand as needed. Interact seamlessly with local fluree CLI (install instructions below).

Docker — pre-configured HTTP server, ready to accept queries on port 8090. Best for trying out the API or running Fluree as a service.

docker run -p 8090:8090 fluree/server:latest

Homebrew, shell installer, or Windows PowerShell — installs the fluree binary that bundles both the CLI and the embedded server (fluree server run).

# Homebrew (macOS / Linux)
brew install fluree/tap/fluree

# Shell installer (macOS / Linux)
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/fluree/db/releases/latest/download/fluree-db-cli-installer.sh | sh

# Windows (PowerShell)
irm https://github.com/fluree/db/releases/latest/download/fluree-db-cli-installer.ps1 | iex

Pre-built binaries and the changelog for every release are on the GitHub Releases page.

Zero to graph in 60 seconds

fluree init
fluree create movies

fluree insert '
@prefix schema: <http://schema.org/> .
@prefix ex:     <http://example.org/> .

ex:blade-runner  a schema:Movie ;
  schema:name        "Blade Runner" ;
  schema:dateCreated "1982-06-25"^^<http://www.w3.org/2001/XMLSchema#date> ;
  schema:director    ex:ridley-scott .

ex:ridley-scott  a schema:Person ;
  schema:name "Ridley Scott" .

ex:alien  a schema:Movie ;
  schema:name        "Alien" ;
  schema:dateCreated "1979-05-25"^^<http://www.w3.org/2001/XMLSchema#date> ;
  schema:director    ex:ridley-scott .
'

fluree query --format table 'SELECT ?title ?date WHERE {
  ?movie a <http://schema.org/Movie> ;
         <http://schema.org/name> ?title ;
         <http://schema.org/dateCreated> ?date .
} ORDER BY ?date'

┌──────────────┬────────────┐
│ title        │ date       │
├──────────────┼────────────┤
│ Alien        │ 1979-05-25 │
│ Blade Runner │ 1982-06-25 │
└──────────────┴────────────┘

That's a SPARQL query. The same query in JSON-LD:

fluree query --jsonld '{
  "@context": { "schema": "http://schema.org/" },
  "select": ["?title", "?date"],
  "where": [
    { "@id": "?movie", "@type": "schema:Movie",
      "schema:name": "?title", "schema:dateCreated": "?date" }
  ],
  "orderBy": "?date"
}'

Both languages access the same engine — same features, same performance.

Now update the data and query the past:

# Give every Ridley Scott movie a genre
fluree update '
PREFIX schema: <http://schema.org/>
PREFIX ex:     <http://example.org/>
INSERT { ?movie schema:genre "sci-fi" }
WHERE  { ?movie schema:director ex:ridley-scott }
'

# What did the data look like before that update?
fluree query --at 1 'SELECT ?title ?genre WHERE {
  ?movie a <http://schema.org/Movie> ;
         <http://schema.org/name> ?title .
  OPTIONAL { ?movie <http://schema.org/genre> ?genre }
}'
# → Blade Runner (no genre), Alien (no genre)

# And now?
fluree query 'SELECT ?title ?genre WHERE {
  ?movie a <http://schema.org/Movie> ;
         <http://schema.org/name> ?title .
  OPTIONAL { ?movie <http://schema.org/genre> ?genre }
}'
# → Blade Runner "sci-fi", Alien "sci-fi"

Every change is preserved. Query any point in history by transaction number, ISO timestamp, or commit ID.

What makes Fluree different

Time travel

Every transaction is immutable. Query data as it existed at any point in time — by transaction number, ISO-8601 timestamp, or content-addressed commit ID. No special tables, no slowly-changing dimensions. It's built into the storage model.

fluree query --at 2024-06-15T00:00:00Z 'SELECT * WHERE { ?s ?p ?o }'

Property graphs & edge annotations

Attach properties to a relationship, not just a node — a role and since date on a worksFor edge, a source and confidence on a claim. Fluree implements the RDF 1.2 / SPARQL 1.2 annotation syntax, so you get labeled-property-graph edges, parallel relationships between the same two nodes, and RDF-star statement-level provenance on a single surface. Plain triple queries are left untouched — annotations only change cardinality when you ask for them.

# Attach metadata to the edge itself, not to Alice or Acme
INSERT DATA {
  ex:alice ex:worksFor ex:acme {| ex:role "Engineer" ; ex:since 2024 |} .
}

# Match the edge and its metadata together
SELECT ?role ?since WHERE {
  ex:alice ex:worksFor ex:acme {| ex:role ?role ; ex:since ?since |} .
}

Integrated search

BM25 full-text search and HNSW vector similarity are built into the query engine — not bolted-on external services. Search results participate in joins, filters, and aggregations like any other graph pattern.

{
  "@context": { "ex": "http://example.org/" },
  "from": "mydb:main",
  "where": [
    { "@id": "?doc", "ex:title": "?title" },
    ["bind", "?score", "(fulltext ?title \"knowledge graph\")"]
  ],
  "select": ["?doc", "?title", "?score"],
  "orderBy": [["desc", "?score"]],
  "limit": 10
}

Git-like data management

Branch, rebase, merge, push, pull — the same workflow developers already use for code, applied to data. Fork a dataset to experiment without affecting production. Merge when ready. Rebase to catch up with upstream changes. Every branch has its own independent commit history.

fluree branch create experiment
fluree use mydb:experiment
# ... make changes safely ...
fluree branch rebase experiment    # catch up with main
fluree branch merge experiment     # fast-forward merge into main
fluree branch drop experiment      # clean up

Triple-level access control

Policies are data in the ledger, enforced at query and transaction time. Users see only what they're authorized to see — not rows, not tables, individual facts. No application-layer filtering required.

Reasoning and inference

RDFS subclass/subproperty reasoning, OWL 2 RL forward-chaining, and user-defined Datalog rules. The database infers facts you didn't explicitly store.

Standards-first

Full SPARQL 1.1 with zero compliance failures against the W3C test suite. Native JSON-LD for idiomatic JSON APIs. Both query languages access the same engine with the same capabilities — time travel, policies, graph sources, and all.

Also worth knowing

• SHACL validation — declarative shape constraints enforced at transaction time, with violations reported per-target, per-property.
• OWL ontology imports — pull external vocabularies into a ledger via f:schemaSource + owl:imports, materialized at commit time.
• Apache Iceberg / R2RML — query Parquet warehouses and relational stores as first-class graph sources alongside native Fluree data.

Use it your way

CLI — Explore data, script pipelines, manage ledgers from the terminal.

fluree query -f report.rq --format csv > output.csv

HTTP Server — Run fluree server for a production API with OIDC auth, content negotiation, and OpenTelemetry.

fluree server run
curl -X POST http://localhost:8090/v1/fluree/query?ledger=mydb:main \
  -H "Content-Type: application/sparql-query" \
  -d 'SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10'

Rust library — Embed Fluree directly in your application. No server process needed.

let fluree = FlureeBuilder::memory().build_memory();
fluree.create_ledger("mydb").await?;

let result = fluree.graph("mydb:main")
    .query()
    .sparql("SELECT ?s WHERE { ?s a <http://schema.org/Person> }")
    .execute()
    .await?;

MCP server — Expose Fluree to AI assistants over the Model Context Protocol.

fluree mcp serve            # stdio transport for Claude Desktop, Cursor, etc.

Capabilities

Documentation

For documentation and more information, visit labs.flur.ee/docs.

For AI agents

The published docs are available as LLM-readable text following the llms.txt convention:

• Curated index: https://fluree.github.io/db/llms.txt
• Full corpus: https://fluree.github.io/db/llms-full.txt

License

Licensed under the Business Source License 1.1, with a Change Date to Apache License 2.0 as specified in that file.