What is a self-assembling graph database?
A graph database stores things and the relationships between them. A self-assembling graph database writes those things and relationships itself, from your documents, and keeps them current. This page explains what a graph database is, why building one from documents has been expensive, and what Spyndel does differently.
What a graph database is
A graph database stores data as nodes, the things, and edges, the relationships between them, with properties on both. A relational database keeps relationships implicit in keys and rebuilds them with joins. A graph database stores each relationship directly, so following connections stays cheap however many hops you take.
Nodes
The entities: a person, a part, a regulation, a requirement. Each carries properties, such as a name, a date or the page it came from.
Edges
The relationships: cites, depends on, supersedes, is about the same thing as. Edges carry properties too, such as a confidence score or how often the edge has proved useful.
Queries
Graph query languages ask for patterns and paths: everything two hops from here, the documents that share the most connections, the shortest route between two requirements.
That model fits anything where the relationships matter as much as the records: supply chains, fraud rings, networks of people, and libraries of technical documents, where every requirement relates to others across hundreds of files.
Why building one from documents has been expensive
A graph database stores a graph. It does not write one. For a library of documents, somebody has to decide what the nodes and edges are, extract them from every page, load them, and keep them current as documents arrive and change. There have been two ways to do that.
By hand: a conventional graph database
You design the schema, write the extraction and loading code, and own the result. The graph is exactly as good as the effort you put in, and it goes stale the moment a new revision lands. For structured data this is ordinary database work. For thousands of PDFs it is a project of its own.
By LLM: the GraphRAG approach
Newer tools send every chunk of every document to a large language model and ask it to extract entities and relationships. That removes the schema work, but the bill arrives per page, every time you add or reprocess documents, and your documents leave your network to be read. Building a graph of 100 documents this way cost $91 to $133 in our measurement, against $0.68 for Spyndel. See the measurement
What self-assembling means
Spyndel is a graph database with the writer built in. Give it documents and it produces the graph: the nodes, the edges and the structure above them. Nothing to model, no loaders to write, and no LLM reading pages.
Statements become nodes
Every requirement, specification and fact in a document becomes a statement node that keeps its document, page, section and surrounding text. Documents, topics and categories are nodes too.
Topics are discovered, not declared
Statements about the same subject are grouped into topics, and topics into categories, found in your content and named in plain language. That is the schema, and it comes from the documents rather than from you.
Connections are verified edges
Statements in different documents that say the same thing are linked. Every candidate link is checked before it is written, so statements that merely look alike are rejected, and every link that passes carries a calibrated confidence score. The checks run on your own hardware, with no LLM and no tokens.
It stays current
A new document connects into everything already there in seconds to minutes. When enough new material has arrived, Spyndel reorganizes the whole graph in the background and reuses the checks it has already done.
It learns from use, and from you
Answers record which connections they relied on. Those rank higher next time, and connections that never help fade at the next reorganization. When search misses, a reviewer's correction fixes it at once and carries to new wordings of the question; the graph itself is never rewritten.
verified connections in a graph of 1,717 public NRC documents, built from scratch in 76 minutes on one GPU
in AI spend to build a graph of 100 documents, all on optional topic names and summaries, against $91–$133 for the LLM-built graph tools we tested
to reorganize the 1,717-document graph after new documents arrive
A graph you can query
Self-assembling does not mean opaque. The graph Spyndel writes is a real graph with a schema you can inspect, and three ways in.
Silk queries
A read-only console with familiar graph-query syntax: match patterns, count connections, find paths, and draw any result as an explorable graph.
// documents sharing the most verified
// connections with a given document
MATCH (d:Document {name: $name})
-[:HAS_STATEMENT]->(:Statement)
-[r:SIMILAR_TO]-(:Statement)
<-[:HAS_STATEMENT]-(o:Document)
WHERE o <> d
RETURN o.name, count(r) AS connections
ORDER BY connections DESC LIMIT 10An MCP endpoint
Claude, ChatGPT and other assistants connect through the Model Context Protocol to search the graph, walk connections hop by hop, and fetch attribution ready to cite: document, page, section and the surrounding text.
The app and the API
Add documents over HTTPS with a personal token. People browse categories, topics and statements, explore concept and document maps, and ask questions whose answers cite checked statements.
Spyndel against the alternatives
Four ways to put a library of documents to work, and who does the work in each.
| Spyndel | Conventional graph database | LLM-built knowledge graph | Vector database | |
|---|---|---|---|---|
| Who designs the schema | Nobody: topics and categories are discovered from the documents | You | The LLM, prompt by prompt | Nobody: there is no structure |
| Who writes the nodes and edges | Spyndel, from the documents | Your loaders | An LLM, page by page | Embeddings only; no edges |
| LLM cost to load 100 documents | $0.68 optional names and summaries | None, but the extraction is yours to build | $91–$133 measured | $0 |
| Where documents go to be connected | Nowhere: your own hardware | Through your pipeline | To the AI provider | Nowhere, and nothing is connected |
| Provenance on every node | Document, page, section, surrounding text | Whatever you load | Whatever the LLM kept | The chunk |
| Edges checked, with a confidence score | Yes, every one | As good as your loader | Extracted by an LLM, not separately checked | None |
| Stays current as documents arrive | Connects on arrival, reorganizes in the background | Rerun your pipeline | Another LLM pass, billed per page | Re-embed |
| How you query it | Silk graph patterns, MCP, API | Cypher, Gremlin, GQL and others | Depends on the store underneath | Similarity search |
| Learns from use and from corrections | Yes | No | No | No |
Costs measured on 100 public NRC documents in October 2026 with each tool's default settings. A conventional graph database is not in the benchmark: it stores the graph you give it, so there is nothing comparable to measure. All measurements
An honest guide
Each of these is the right tool for something. The question is where your knowledge lives.
- Use a conventional graph database when your data is already structured: customers, transactions, parts, permissions. You know the schema, you control the sources, and the database's job is to store and query it fast. Spyndel is not that.
- Use an LLM-built knowledge graph when you need the kind of entity extraction a large language model is good at, your library is small or static, and the per-page cost is acceptable.
- Use Spyndel when the knowledge is in documents: regulations, standards, specifications, procedures, reports. It writes the graph itself, keeps it current, cites every statement to its page, runs on your own hardware, and the Community Edition is free.
Questions people ask
Is Spyndel a graph database?
Yes. Spyndel stores statements, documents, topics and categories as nodes and verified connections as edges, each with properties such as a confidence score, and you query it with graph patterns in Silk, through MCP or through the API. What makes it different is that it writes the graph itself from your documents.
Do I need Neo4j or another database to run it?
No. Spyndel includes its own graph store. The Community Edition is a single install that runs on your own machine or server.
Does Spyndel use an LLM to build the graph?
No LLM makes the connections. Spyndel's own compact models find and check every connection on your hardware, so no tokens are spent on them. An AI provider of your choice is used only for optional topic names and document summaries, and to write the answers in Ask.
What documents can it read?
PDFs, Word files, web pages, spreadsheets and plain text: reports, standards, specifications, procedures, regulations and papers. Every statement keeps its document, page and section.
Can I query it like a graph database?
Yes. Silk, Spyndel's read-only query console, uses familiar graph-query syntax to match patterns, count connections and find paths, and can draw any result as an explorable graph. AI assistants reach the same graph through the MCP endpoint.
How large a library can it hold?
The live demo holds 1,717 public NRC documents with 209,884 statements and 392,371 verified connections. The Community Edition is limited to 250 documents and 5 users; Enterprise removes the limits and adds multi-GPU processing for large libraries.
Where does my data go?
Nowhere, to build the graph: it is built on your own hardware. Only if you set up an AI provider for Ask are questions and the relevant statements sent to that provider.
Is it free?
The Community Edition is free to download and runs on your own machine. Enterprise is priced to your deployment.
See a self-assembling graph database on a real library
The live demo holds 1,717 public NRC documents. Or download the Community Edition and build a graph from your own.