Concept graph primer
Concept graphs · Living primer

Created by Benjamin J Brey, CFA

Chief Strategist, SeKondBrain.ai

b@sekondbrain.ai

A concept graph is a spreadsheet with arrows. Here is how to build one.

One construction pipeline, one worked example, and 90 vetted how-tos, each linked to the step it teaches. Refreshed weekly since 26 Aug 2026.

90Sources
7Pipeline steps
43Sites
13Weekly updates
01 · The library as a concept graph

Everything we have read, as one graph.

Every how-to in the library, the site that publishes it, the pipeline step that teaches it, the ideas and tools it names, and the weekly note that first recorded it. Drag, zoom, hover to see neighbours, or click a source to open it.

205Nodes
656Edges
8Node types
Drag nodes · scroll to zoom · click for details
Ontology termspublishedBy joins a source to its site. mentions joins a step to the sources its section links, and a source or step to the terms it names. recordedFrom joins a source to the weekly note that first recorded it.
Plain labels“next step” and the dotted loop come from the pipeline diagram. “follows” chains the weekly notes; “updated” joins a note to the steps it says it changed; “keyword” joins the Ask vs Search node to the memory-retrieval keywords its sources name.
How it was builtRead straight from the source table, the primer and the twelve weekly notes. A term is linked only where its name appears in the text; nothing is inferred.

Terms are matched on each source’s catalogue entry (title and note), not the full page, so a source can teach more than its links show. The full graph is also available as kg_library_graph.json.

02 · The idea

Spreadsheets, with arrows.

A concept graph is a spreadsheet with arrows.

Each row is a thing you care about: an issuer, a bond, a fund. Each column is a fact about that thing: a name, a coupon, a CUSIP. The extra piece, the part a table cannot say cleanly, is a named arrow from one row to another: this issuer issued that bond; that bond is held by this fund.

Why concept graph? It is SeKondBrain’s take on the knowledge graph: facts organised around persistent, versioned concepts, each fact carrying its time, its source and how certain it is (what the Concept-Grounded Attention paper calls a Concept Lifecycle Model). Everything below works for any knowledge graph, and most of the outside guides it links still use that name.

Those arrows are first-class. You can follow them, count them, and ask questions that hop two or three rows without a pile of joins. Every page this primer leans on is listed with a date in the source library (77 keepers). This week’s changes are in 2026-W47, which folds in the mid-week 2026-W47 update.

Why a table is not enough

You already know the table version: issuers, bonds, holdings, glued by foreign keys. That works until:

  • The same issuer shows up as “Apple Inc.”, “APPLE INC”, and “AAPL” in three feeds, so your joins miss each other.
  • A fact has a direction and a type (issued vs held vs guaranteed), not just a cell.
  • You want to walk: which funds hold bonds issued by this parent, through this subsidiary? That is a path, not a column.

Hogan et al.’s open book Knowledge Graphs defines the thing plainly: a graph of data meant to accumulate knowledge of the real world, with nodes for entities and edges for relations. There are two ways to write it down, and you should pick one per store:

  • RDF (triples). Every fact is subject, predicate, object. The RDF 1.1 Primer is the official intro; the RDF 1.2 Primer adds triple terms so you can attach a source, confidence, or date to one fact. Use RDF when you want shared vocabularies (Schema.org, Wikidata) and SPARQL.
  • Property graphs. Nodes with labels, relationships with types, and properties on both. What is Cypher? is the plain intro. Use this for most application graphs, especially when the arrow itself carries data (a role, a weight, a date).

CareerStack’s Knowledge Graph Engineering is the clearest single beginner narrative of that fork. Stanford CS520’s How to Create a Knowledge Graph? is the design-judgement companion: linked-data principles for RDF, and the property-graph calls about label vs property vs relationship. The construction pipeline below is the same either way, and you are not locked in: Neo4j’s Getting Started with Neosemantics (the n10s plugin) pulls an RDF file into a property graph, turning each rdf:type into a label, each plain value into a property, and each link into a relationship. It has you preview the result (n10s.rdf.preview.fetch) and rename ugly predicates (n10s.mapping.add, so runsOn becomes RUNS_ON) before you swap preview for import.

03 · The construction pipeline

Questions first. Then build in order.

Do not start by dumping text into an LLM. Start with the questions, then build in this order:

0
Step 0 · Questions

Write down what the graph must answer

This is the step most first graphs skip, and the one both classic guides start with. Ontology Development 101 (Noy & McGuinness, Stanford) calls them competency questions: a short list of questions the finished graph must be able to answer, used later as the pass/fail test. Neo4j’s Tutorial: Create a graph data model does the same thing with movies (“Which people acted in a movie?”, “Which role did a person play?”). Five to ten questions is plenty. Anything no question needs stays out of the graph for now.

1
Step 1 · Model

Pick the nouns, the verbs, and the key

Read your questions out loud. The nouns become node types (Ontology 101 calls them classes); the verbs become relationship types; descriptive words become properties (slots). Neo4j’s tutorial adds three habits worth stealing: give every node type a unique identifier (a tmdbID, a CUSIP, an LEI), name relationships specifically (ACTED_IN, never CONNECTED_TO), and put a property on the arrow when the question is how two things relate (roles on ACTED_IN). Ontology 101 adds the judgement calls: one class per concept, not one per synonym; a class should be a “kind of” its parent; don’t make a class for something that changes often (a “chilled wine” is a property, not a type).

CS520’s create notes add the property-graph forks you will actually hit: when is gender a label, a property, or a related node? Prefer a label when membership is stable and you often filter on it; prefer a property when the value is simple and rarely queried as a path; prefer a relationship to another node when the value changes over time or you need to hang dates and provenance on the link. For RDF, the same notes restate the linked-data habits: HTTP IRIs for things, reuse existing vocabularies, and owl:sameAs (or equivalent) when two IDs mean one thing.

Want a guided version you can do with your own data? Neo4j GraphAcademy’s Graph Data Modeling Fundamentals walks the whole loop in lessons: model nodes and relationships, add a little sample data, test it with four kinds of question (lookup, connection, aggregation, traversal, each of which pushes the model a different way), then refactor with named patterns such as more specific labels, hub nodes, and turning a property into its own node. Its last section extends the same model to text (a lexical graph of chunks next to the entity graph) and to an ontology.

Prefer to draw the model before typing it? Protégé is the free desktop editor that goes with Ontology 101: its getting-started page opens a sample Pizza ontology, shows classes, properties, and individuals side by side, and runs a built-in reasoner (HermiT, Ctrl+R) that highlights in yellow what the rules imply but you never typed. That yellow is a cheap check that your “kind of” hierarchy says what you meant. Rather write it as code? Owlready2 does the same job from Python: load an ontology (the docs use the same Pizza example), declare classes as Python classes, create individuals, call sync_reasoner() to run the bundled HermiT reasoner, and watch a test pizza with a meat topping get re-filed as NonVegetarianPizza. Then onto.save() writes the file Protégé can open.

Three shapes come up in almost every model. The first is a list of terms with synonyms, such as sectors, asset classes, or product lines. The W3C SKOS Primer is the plain recipe: one concept per ID, one preferred label (skos:prefLabel "Food and Agriculture Organization"), as many alternative labels as you need (skos:altLabel "FAO"), and skos:broader / skos:narrower for the hierarchy. Those alternative labels are also a free head start on the resolve step. The second is a fact that needs a source. Wikidata’s Help:Statements shows how a big public graph handles it: item, property, value, then qualifiers (as of when, in what role), references (which source said so), and a rank. Two sources that disagree can both stay, each with its own reference, and a preferred rank marks the value you trust. The third is a fact with more than two parts: a trade with a buyer, seller, price, date and venue, or a funding round with a funder, recipient, amount and source. Mathematicians call that a hyperedge, an arrow joining many nodes at once. Neo4j’s Modeling designs page says plainly that hyperedges are not supported and turns the fact into an intermediate (event) node, an Employment or an Email, with one arrow to each part. TypeDB’s The n-ary relation takes the other route: one relation with as many named roles as the fact needs. Either way, the date and the source hang off the event, not off whichever party seemed closest. As Neurosymbolic Is a Direction of Travel (Sachin Dev Duggal, July 2026) puts it, if the graph cannot represent the shape of the thing that happened, the system will eventually misremember it.

Inheriting a flat graph from an LLM extractor? AutoOntic (arXiv listing 13 Nov 2026) works backwards from the extracted types and relations: it merges types that mean the same thing, builds a “kind of” hierarchy over them, and adds which node types each relation may join. That is the model step done after the fact, and a reminder that it is cheaper to do it first.

Then write the model down as a file the rest of the pipeline can read:

Source · Cognition OS docs

2
Step 2 · Extract

Pull facts out of your sources

From tables. Map each row to a node and each foreign key to a named arrow. YARRRML does this declaratively for RDF (YAML rules, run in the Matey browser tool or Docker). To run those same rules from Python, Morph-KGC is one pip install morph-kgc away: point a small config file at your mapping, call morph_kgc.materialize(config), and you get back an RDFLib graph you can query at once. It reads CSV, Excel, Parquet, JSON, and SQL databases, and treats blank and nan cells as missing by default, so empty cells do not turn into junk triples. Neo4j’s LOAD CSV and Kùzu’s COPY FROM do it for property graphs. No code at all: Neo4j’s Data Importer Mapping has you draw the nodes and arrows, then point each node at a file and an ID column and each arrow at its From and To ID columns. It names the three shapes your files will come in (the same file, a file with a foreign-key column, or a separate link-table file) and warns about blank IDs: map an empty or null column as a node ID and every blank row collapses into one giant “super node.”

From text, no LLM. The spaCy + NetworkX tutorial is about 30 readable lines: named entities, then co-occurrence or verb edges. REBEL turns a sentence into (head, relation, tail) triplets. GLiNER gliner-relex labels entities and relations in one pass.

From text, with an LLM. Always hand the model your schema from step 1. Never done this before? Neo4j GraphAcademy’s Building Knowledge Graphs with LLMs teaches the whole loop in short lessons: gather, chunk, (optionally) embed, ask the LLM for JSON like {head, relation, tail}, then MERGE each one into the graph. It shows the same documents extracted with no schema (a sprawl of node types) and then with a short list of allowed patterns, which is the clearest picture of why step 1 matters. The no-code version is the Neo4j LLM Knowledge Graph Builder: connect a free AuraDB database, drop in PDFs or web pages, set the node and relationship types, press generate. It is a Labs project, does best on long English prose rather than spreadsheets, and is a separate thing from the Python Knowledge Graph Builder guide in the next sentence. Once that clicks, GraphAcademy’s follow-on course, Constructing Knowledge Graphs with Neo4j GraphRAG for Python (it calls itself advanced and expects you to read Python), runs the same pipeline in an empty sandbox so every node is one you caused. Two lessons stand out: one has the LLM propose a schema from your documents before you write your own, and one changes only the chunk size and shows how much the extracted graph changes. It ends with entity-resolution settings and a bring-your-own-documents build. The cleanest named-parts reference is Neo4j’s Knowledge Graph Builder guide: load, split, schema, extract, prune anything off-schema, write, then resolve. Other recipes do the same job: LlamaIndex SchemaLLMPathExtractor, Neo4j’s unstructured-data guide (LangChain LLMGraphTransformer), Microsoft GraphRAG (graphrag index), Graphiti (add_episode, with dates on edges), OntoGPT (LinkML template in, ontology-grounded output), LightRAG (ainsert), Cognee (remember), iText2KG (build_graph with merge thresholds, so new chunks update one graph instead of starting over), and kg-gen (generate(text, cluster=True), which also groups synonyms; see resolve). For the full document-to-RDF path in one sitting, read From Documents to Triples. For bolting a graph onto an existing vector search setup, read Knowledge Graphs Meet RAG.

Building an agent’s memory rather than a document graph? Graphiti’s Custom Entity and Edge Types is the schema-first version of add_episode: write each node and edge type as a small Python (Pydantic) class, pass an edge_type_map that says which edge may join which pair (("Person", "Company"): ["Employment"]), and Graphiti extracts, checks each item against its class, and stores it. Its advice is the same as step 1’s: keep attributes atomic (a name and an email, not one contact_info string), and make them optional so a missing fact stays missing instead of being guessed.

A recent extraction lesson for shared, multi-user memory: Who Remembers What? (Wang et al., arXiv listing 10 Nov 2026) keeps previously stated preferences while holding private facts inside the scope they belong to. Extract at the right grain, then enforce who may see what.

3
Step 3 · Resolve

Make one node per real thing

“Apple Inc.” and “APPLE INC” must become one node. Skip this and every count and path afterwards is wrong.

  • Still a spreadsheet column: OpenRefine Reconciling matches against Wikidata and lets you pick the right candidate.
  • Still a dataframe: Splink scores likely pairs and clusters them into an estimated unique ID.
  • Already nodes: the Neo4j Entity resolved knowledge graphs tutorial; or the resolvers inside the Knowledge Graph Builder, which merge nodes with the same label by exact name, spaCy similarity, or fuzzy string match.
  • Straight out of an LLM extractor: kg-gen with cluster=True groups names that mean the same thing (“AI” and “artificial intelligence”, “ML” and “machine learning”) and does the same for arrow names (“is type of”, “is a type of”, “is a kind of”). iText2KG’s relation threshold does the arrow-name half too, inside its incremental build.
  • Still free text that must ground to a public KB: ReFinED (Refined.from_pretrained(...).process_text(...)) detects mentions and links them to Wikipedia or Wikidata IDs in one call — the entity-linking twin of OpenRefine’s human-review reconcile.

Every automatic match is a proposal. Check a sample against your own keys (CUSIP, LEI, ticker) before trusting it. iText2KG’s merge thresholds, kg-gen’s clusters, and the Knowledge Graph Builder’s resolvers are the same idea inside an LLM pipeline: similarity proposes, your keys decide.

For a graph that is also an agent’s memory, DISCERN (Ahuja et al., arXiv listing 13 Nov 2026) puts the resolve step at read time: write facts as they arrive, and resolve conflicts when you query, rather than collapsing them on the way in. That is the same spirit as Graphiti’s dated edges, where a new fact can sit beside an older observation.

Source · Cognition OS docs

4
Step 4 · Validate

Make the graph refuse bad data

Turn the model from step 1 into rules the store enforces.

  • RDF: write shapes with SHACL 1.2 Core (its §2 walks a Person/Company example), then run them with pySHACL: pyshacl -s shapes.ttl data.ttl exits 0 when the data conforms and 1 when it does not, so it can gate a load script.
  • Property graph: Neo4j Create constraints (REQUIRE b.cusip IS UNIQUE, or IS NODE KEY) before any MERGE.
  • Document graph: TerminusDB’s schema Classes (see store step) refuse documents that do not match the shape you posted.
  • LLM pipelines: the Knowledge Graph Builder’s pruner drops nodes, arrows, and patterns your schema did not allow (additional_node_types: False). Treat that as a filter, not a guarantee.
  • Provenance: when a fact needs a source or a confidence, the RDF 1.2 Primer annotation pattern and RDF4J’s Triple Terms page put it on the fact itself.
  • People, on a sample: TripleGrader (arXiv listing 10 Nov 2026) is an open-source tool for graders to score extracted triples 0 to 10 and measure how much they agree. When its authors curated triples from four LLMs against two existing gold sets, only 10% to 32% could be kept unchanged. Grade a sample before you trust a run.
  • Whole-graph checks: the Vietnamese Legal Ontology build (arXiv listing 10 Nov 2026) is a worked list of what to test after a load: every node and edge carries its source record and method, and the graph has no duplicate keys, no dangling edges, and no schema violations.
  • Agent memory: MemoryDojo (Yang et al., arXiv listing 9 Nov 2026) finds that memory systems can be poisoned, with substantial variation in the downstream damage; treat a stored memory as untrusted until you can check it. In a governed setting, Runtime Auditability for Healthcare RAG Systems (Chockalingam, SSRN posted 13 Nov 2026) logs every decision to admit, assemble, or release content, with a source trace, a versioned rule, and a human attestation a third party can examine.

Source · Cognition OS docs

5
Step 5 · Store

Pick one place and stay there

You want RDF option Property-graph / document option
A library, no server RDFLib, pyoxigraph Kùzu (archived upstream; lesson only)
Java RDF4J —
A local server Fuseki Neo4j, Memgraph, FalkorDB, TerminusDB (schema-enforced JSON documents with links)
Inside SQL you already run — Apache AGE (Postgres), DuckDB + DuckPGQ
A different dialect — NebulaGraph nGQL
Managed cloud, both models Amazon Neptune Amazon Neptune

Whatever loads the store, load it so you can run the load twice. In Cypher that means MERGE, not CREATE: MERGE finds the exact pattern if it is already there and creates it only if it is not, and ON CREATE SET / ON MATCH SET let you write first-seen and last-seen values differently. The manual’s own advice is to add the uniqueness constraint from step 4 first, because MERGE on its own does not guarantee one node per key when two loads run at once. GraphAcademy’s LLM course ends each extraction with MERGE for the same reason.

LightRAG, Cognee, Graphiti, iText2KG, and the LLM Knowledge Graph Builder write the store for you. It is still a store you should be able to open and query by hand. Kùzu’s upstream repo was archived in October 2025, so learn from its docs but prefer the others for new builds.

Source · Cognition OS docs

Kemory Community Edition (Apache-2.0) is an optional local memory store you can run yourself; it is not a replacement for Neo4j or RDFLib.

6
Step 6 · Query

Ask your step-0 questions

Each competency question should become one query you can run. Cypher draws the path as ASCII art, (a)-[:REL]->(b). SPARQL writes it as triples with variables, ?issuer :issued ?bond. DuckDB writes it inside GRAPH_TABLE (… MATCH …); NebulaGraph uses GO FROM … OVER …. Good practice grounds: the Wikidata SPARQL tutorial (a live graph) and RDFLib’s Querying with SPARQL (the graph you just built). Prefer watching first? Neo4j Live: How to Build a Knowledge Graph walks model, CSV import, and Cypher on camera.

If a question cannot be answered, the dotted arrow in the diagram applies: go back to the model, not to a bigger prompt. Neo4j’s tutorial calls this testing the model (the GraphAcademy modeling course makes it a lesson: load sample data, ask the questions, refactor, retest), and Ontology 101 says the same thing: the proof is whether the graph answers the questions it was built for.

When the graph is also a memory store, When does Hybrid Retrieval Help? (Tallam et al., SSRN posted 13 Nov 2026) surveys combining lexical and semantic retrievers rather than betting on one. CompactionBench (Liu et al., Microsoft Research, 12 Nov 2026) is the matching reminder not to pour the whole graph into the prompt: retrieve the few relevant nodes, or compact what must stay in context.

04 · Worked example

A tiny markets graph. Three nodes, two arrows.

Toy data, not a real holding.

Step 0, questions. (1) Which funds hold a bond issued by Apple Inc.? (2) Who issued this bond?

Step 1, model. Nouns: Issuer, Bond, Fund. Verbs: ISSUED, HELD_BY. Keys: issuer name for the toy (an LEI in real life), bond name (a CUSIP in real life). Patterns: (Issuer)-[:ISSUED]->(Bond), (Bond)-[:HELD_BY]->(Fund).

Steps 2–3, the facts after extract and resolve (“APPLE INC” and “Apple Inc.” merged into one issuer; a ReFinED-style linker would hang a Wikidata QID on that node if you needed a public ID):

Subject Predicate Object
Apple Inc. issued Apple 4.25% notes due 2030
Apple 4.25% notes due 2030 held_by Vanguard Total Bond Market

Steps 4–5, validate and store (Cypher, which runs on Neo4j and, with small changes, Memgraph, FalkorDB, or AGE):

CYPHER
CREATE CONSTRAINT issuer_name IF NOT EXISTS
FOR (i:Issuer) REQUIRE i.name IS UNIQUE;

MERGE (i:Issuer {name: "Apple Inc."})
MERGE (b:Bond {name: "Apple 4.25% notes due 2030"})
  ON CREATE SET b.coupon = 4.25, b.maturity = 2030
MERGE (f:Fund {name: "Vanguard Total Bond Market"})
MERGE (i)-[:ISSUED]->(b)
MERGE (b)-[:HELD_BY]->(f)

Run it twice and you still have three nodes and two arrows. With CREATE you would have six and four. Each node gets its own MERGE line on purpose: merging the whole path in one statement would create a fresh copy of every node whenever any piece of the path is missing.

Step 6, question 1 in Cypher:

CYPHER
MATCH (i:Issuer {name: "Apple Inc."})-[:ISSUED]->(b:Bond)-[:HELD_BY]->(f:Fund)
RETURN f.name AS fund, b.name AS bond

The same question in SPARQL (RDFLib, pyoxigraph, Fuseki, Wikidata-style):

SPARQL
SELECT ?fund ?bond
WHERE {
  ?issuer :name "Apple Inc." .
  ?issuer :issued ?bond .
  ?bond :held_by ?fund .
}

If a holding needs a source, put it on the arrow (h.source, h.as_of), the way Wikidata hangs a reference and a qualifier on a statement. Question 2 is one hop backwards on ISSUED. Both questions answer, so the model passes its own test. The table version of question 1 is two joins and a hope that the issuer keys match; the graph version is “follow ISSUED, then HELD_BY.” If a third question arrives (“which funds share a holding with this one?”), add it to the list and check whether the model already answers it before adding anything new.

05 · Common traps

Five ways a first graph goes wrong.

01

Building before asking.

A graph built without competency questions grows every node type the extractor can find and answers none of the questions you actually have. Write the list first.

02

Duplicate entities.

Two nodes for one issuer split every holding across both. Resolve before you celebrate a node count. A uniqueness constraint stops a second identical key; it does not catch “APPLE INC” vs “Apple Inc.” Entity linking (ReFinED) and reconcile (OpenRefine) are how you catch the second case. And a load script written with CREATE makes a duplicate of everything each time it reruns; use MERGE on the key.

03

No schema, and no check.

Open extraction produces acquired, ACQUIRED, bought, and TOOK_OVER as four relationship types, and you cannot query what you cannot name. Fix the vocabulary before extraction, then enforce it (SHACL plus pySHACL, Neo4j constraints, TerminusDB Classes, or the pruner). If you inherit a graph that is already messy, kg-gen’s edge clustering is a quick way to see which arrow names are really one.

04

Treating LLM output as truth.

Extractors return plausible triples, a draft, not a filing. Keep the source chunk on each edge (the Knowledge Graph Builder’s lexical graph links every entity to the chunk it came from, and the LLM Knowledge Graph Builder app stores the same Document → Chunk → Entity shape, so “which document said this?” is one Cypher query; GraphRAG keeps text units; Graphiti keeps episodes; RDF 1.2 can annotate the triple). Drop facts whose evidence is not in the text, and grade a sample by hand: in TripleGrader’s curation, most LLM-extracted triples needed a correction. Classical extractors are not exempt: they invent edges from co-occurrence. Don't Just Trust Your Memory (Lee et al., arXiv listing 11 Nov 2026) shows the cost of skipping that habit: an agent can fail a task it would have solved without memory, because it follows a lesson that is wrong, or misapplies a valid one. Linking each stored lesson back to its evidence reduces that damage.

05

Squeezing a many-part fact into pairs.

If you catch yourself putting an amount or a date on whichever arrow seemed closest, the fact needs its own event node (step 1, the third shape).

06

Skipping store-and-query.

A NetworkX drawing is a sketch. Until the facts sit in a store you can MATCH or SELECT against, you have nothing reusable next week.

06 · After you have a graph

Keep it honest. A graph that only grows becomes a landfill.

A graph that only grows becomes a landfill. @0xWast3’s Memory Engineering (4 Aug 2026) gives the maintenance loop:

  1. Capture only facts that would still matter in three months.
  2. Consolidate duplicates into one node.
  3. Retrieve the top few relevant nodes for a question, not the whole graph.
  4. Reconcile disagreements: supersede (newer wins, archive the old), coexist (both true in different contexts), or flag the conflict.
  5. Decay unused nodes by archiving them, never deleting. When you compress an old history into a summary node, keep links to the facts it summarises so the summary still has receipts, and down-weight a memory that keeps misleading (The Librarian in Your Head).

Deletion is a chore too. When a source is withdrawn, every fact built from it should go with it. Lightfoot (arXiv listing 10 Nov 2026) shows why provenance makes that easy: because every entity, link, and fact is built from per-passage extractions that remember their chunk, deleting a document is a database operation, and the graph afterwards matches a fresh rebuild from the surviving documents.

Apply those rules to the memory store you already have; do not build a custom vector memory engine. Graphiti and iText2KG do the reconcile step with dates on edges (a new fact can sit beside an older observation). The RAG playbook and CareerStack add the weekly chores: look for orphan nodes and near-duplicates, version the schema, and rerun the competency questions after every change.

From recent research

The 15 and 16 Nov 2026 updates draw on recent agent-memory and graph-construction papers that earn a place here because they teach a construction or maintenance habit, not because they were on a news wire.

Keep the receipts. Can LLM Agents Organize Their Own Memory? (Fu et al., arXiv listing 10 Nov 2026) has the agent summarize, group related information, and revise topics, with every summary still linked to the original interactions as evidence. Discovering Effective Agent Memory Designs through Program Evolution (Ding et al., arXiv listing 13 Nov 2026) finds the same pattern from the other direction: keep raw conversations as retrievable evidence, because extracted memories drop details, and compose that evidence according to the query's intent. Don't Just Trust Your Memory (Lee et al., arXiv listing 11 Nov 2026) shows why the link matters: a stored lesson can be wrong, or right but misapplied, and the agent then fails a task it would have solved without memory.

Write first, resolve later. DISCERN (Ahuja et al., arXiv listing 13 Nov 2026) argues that persistent memory is not mainly a retrieval problem: preserve what you write, and resolve conflicts when you read. That is the same spirit as Graphiti's dated edges.

Do not treat a stored memory as automatically true. MemoryDojo (Yang et al., arXiv listing 9 Nov 2026) finds that memory systems can be poisoned, with substantial variation in the damage. In a governed setting, Runtime Auditability for Healthcare RAG Systems (Chockalingam, SSRN posted 13 Nov 2026) makes every decision to admit, assemble, or release content a logged decision, with a source trace and a human attestation a third party can examine.

Build the graph so it can explain and undo itself. AutoOntic (arXiv listing 13 Nov 2026) shows what open extraction leaves behind, a flat graph with no hierarchy and no rules about which node may join which, and recovers a model from it. TripleGrader (arXiv listing 10 Nov 2026) puts a number on trusting raw extraction: most LLM triples needed a fix. The Vietnamese Legal Ontology (arXiv listing 10 Nov 2026) keeps the source record and method on every node and edge, and Lightfoot (arXiv listing 10 Nov 2026) uses the same habit to delete a document cleanly.

Put time and certainty in the data. Concept-Grounded Attention (Duggal, Swarnalatha Ramanna and Vassiliades, arXiv, September 2026) tested a concept graph inside a transformer against its own switched-off controls. Steering attention with graph structure added little; explicit time added 13 to 25 points on LongMemEval across generators up to 122B parameters, and an epistemic status on each claim cut unsupported assertions in 72–122B models from 19–68% to 0–5%.

Extract with a scope, and retrieve with more than one method. Who Remembers What? (Wang et al., arXiv listing 10 Nov 2026) is about multi-user, multi-agent memory: keep stated preferences, but keep private facts inside the scope they belong to. When does Hybrid Retrieval Help? (Tallam et al., SSRN posted 13 Nov 2026) surveys combining lexical and semantic retrievers rather than betting on one. And don't pour the whole graph into the prompt: CompactionBench (Liu et al., Microsoft Research, 12 Nov 2026) is a reminder that long-horizon agents which cannot compact their context waste tokens and time; retrieve the few relevant nodes, or compact what must stay in context.

Going further: hypergraphs and hyperbolic graphs

Optional, and early. Native hypergraph retrieval stores many-part facts as hyperedges: HyperGraphRAG (Luo et al., 2025) and Hyper-RAG (Feng et al., 2025) report gains over standard RAG and GraphRAG on their own domain benchmarks, not yet independently replicated; the event node above gets you most of the way in any store today. Hyperbolic embeddings place nodes in curved space where deep hierarchies fit with little distortion (Poincaré embeddings, Nickel & Kiela 2017; MuRP, 2019; AttH, Chami et al. 2020). They help link prediction on hierarchy-heavy graphs, mostly at low dimensions. They are a research and embedding-layer technique, not a database feature, and you do not need them to build a graph.

Source · Cognition OS docs

07 · What to read first

Where to start. Six reads, one at a time.

In order, not all at once:

  1. Ontology Development 101 or Neo4j’s Tutorial: Create a graph data model: questions first, then nouns and verbs. CS520’s create notes when you hit “label or property?”. Open Protégé if you want to click through a model instead of writing it, use Owlready2 to do the same from Python, or take Graph Data Modeling Fundamentals to build and test one on your own data.
  2. RDF 1.1 Primer and What is Cypher?: the two ways to write a fact; Wikidata’s Help:Statements for how one fact carries its source. CareerStack if you want one narrative instead.
  3. One build path: spaCy + NetworkX from text, YARRRML run by Morph-KGC, LOAD CSV, or the no-code Data Importer from rows, or GraphAcademy’s Building Knowledge Graphs with LLMs (then its GraphRAG for Python follow-on) followed by the Knowledge Graph Builder or iText2KG for an LLM pipeline.
  4. Reconciling, Splink, or ReFinED: one node per real thing (or one KB ID per mention).
  5. Create constraints, or SHACL 1.2 with pySHACL: make the store say no.
  6. Wikidata SPARQL tutorial: practice asking questions of a real graph.
08 · Source library

Every source, typed and linked.

All 90 how-tos from the catalogue, each tagged with its format, the pipeline step whose section links it, and the date it was first seen. Search, or narrow by step and format.

Step
Format
Nothing matches. Try a broader word, or clear the filters.
09 · Ontology map

The library is itself a graph.

Typed with the core ontology our agents have been drafting (v0.3.0). Hover or tap a step to light up its sources and filter the library. Each dot is one source; click it to open the page.

Swipe to explore →

DocumentEach how-to is a Document, a kind of Work. 90 in all.
SourceThe site that hosts it, joined by publishedBy. 43 sites.
ConceptA pipeline step or primer theme. A Work mentions the Concept whose section links it.
ConceptSchemeThe construction pipeline: the Concepts as one ordered set (dashed frame).
recordedFromThe first-seen date: when the catalogue first recorded the Work.
plain labelsFormat (docs, tutorial, tool, paper, video) and “next step” are catalogue labels, not ontology terms.

Counts per step add up to more than 90 because a source can be linked from more than one step. Step assignment follows where the primer links each source; ten sources linked only from the opening sections sit under Foundations or Keep it honest. The 13 sources from the weekly Ask vs Search desk sit under their own Ask vs Search group, a memory-retrieval keyword cluster rather than a pipeline step.

10 · Changelog

Week by week, W35 to W47.

The catalogue only grows by sources that load and teach a step. Counts come from the first-seen dates in the source table.

W4716 Nov 2026+29 · 90 total

Seven keepers added to the catalog (now 77): three scouted how-tos on modeling terms, sourced facts, and schema-first agent memory, plus four construction papers from the 14 Nov 2026 AI Memory run’s catalog ingest. This week also includes the mid-week research update of 15 Nov (nine papers), which has its own note in the vault and is counted here under W47. On 17 Nov 2026 the new Ask vs Search desk added 13 agent-memory retrieval papers (now 90).

Added that week
What changed in the primer
  • Model gains two everyday shapes: the SKOS Primer for a list of terms with synonyms (prefLabel, altLabel, broader), and Wikidata’s Help:Statements for a fact that needs a source (qualifiers, references, ranks, and disagreeing sources kept side by side). AutoOntic is the after-the-fact version: recovering a hierarchy and domain/range rules from a flat LLM-extracted graph.
  • Extract adds Graphiti’s custom entity and edge types: Pydantic classes plus an edge_type_map, so agent-memory extraction runs against a schema.
  • Validate adds human grading of a sample (TripleGrader: only 10% to 32% of LLM triples kept unchanged) and a whole-graph checklist from the Vietnamese Legal Ontology build (source and method on every node and edge; no duplicate keys, dangling edges, or schema violations).
  • Worked example notes where a source goes (on the arrow, like a Wikidata reference). Common traps extends “treating LLM output as truth” with the TripleGrader finding. The traps stay at five.
  • Keep it honest adds deletion as a maintenance chore, with Lightfoot’s provenance-based document deletion, and From recent research gains a paragraph on the four new papers. “What to read first” adds Help:Statements to item 2 and stays at six items. The metaphor, mermaid pipeline, and worked example are unchanged in shape.
W469 Nov 2026+2 · 61 total

Two construction how-tos added to the catalog (now 61 keepers), and the living primer updated so a first-timer can build and check an ontology from Python, and take a guided next step after the beginner LLM-extraction course.

Added that week
What changed in the primer
  • Model now offers Owlready2 as the code route beside Protégé: load the Pizza ontology, write classes as Python classes, run the bundled HermiT reasoner with sync_reasoner(), and save a file Protégé can open.
  • Extract (from text, with an LLM) adds the GraphAcademy GraphRAG for Python course as the follow-on to Building Knowledge Graphs with LLMs. It is marked advanced; the two lessons called out are letting the LLM propose a schema first, and changing only chunk size to see how much the extracted graph moves.
  • What to read first picks up both links. The metaphor, pipeline diagram, worked example, and traps are unchanged.
W452 Nov 2026+3 · 59 total

Three construction how-tos added to the catalog (now 59 keepers), and the living primer updated so a first-timer can practice modeling on their own data, run table-to-RDF mappings from Python, and move an RDF file into a property graph.

Added that week
What changed in the primer
  • Two ways to write a fact now says you are not locked in: the Neosemantics (n10s) tutorial previews an RDF file as a property graph, renames predicates, then imports it, with each rdf:type becoming a label and each link a relationship.
  • Model adds the GraphAcademy modeling course as the guided, bring-your-own-data path: sample data, four question kinds (lookup, connection, aggregation, traversal), and named refactoring patterns.
  • Extract (from tables) adds Morph-KGC as the pip-installable way to run YARRRML/RML mappings from Python straight into an RDFLib graph, and notes it treats blank and nan cells as missing.
  • Query and What to read first pick up the same links. The metaphor, pipeline diagram, worked example, and traps are unchanged.
W4426 Oct 2026+3 · 56 total

Three construction how-tos added to the catalog (now 56 keepers), and the living primer rewritten so a first-timer can draw a model without code, load spreadsheets without code, and rerun a load without making duplicates.

Added that week
What changed in the primer
  • Model now points to Protégé as the free point-and-click editor that goes with Ontology 101, including the built-in reasoner whose highlighted inferences are a quick check that your "kind of" hierarchy says what you meant.
  • Extract (from tables) adds the no-code path: Data Importer's mapping page, the three file shapes it handles (same file, foreign-key column, link-table file), and its warning that a blank ID column collapses rows into one "super node."
  • Store gains a new rule: write loads you can run twice. MERGE instead of CREATE, ON CREATE / ON MATCH for first-seen vs repeat values, and a uniqueness constraint first, since the manual says MERGE alone does not guarantee uniqueness under concurrent loads.
  • Worked example switched from CREATE to one MERGE per node and arrow, with a note on why merging the whole path in one line backfires.
  • Common traps and What to read first pick up the same three links. The metaphor, pipeline diagram, and maintenance loop are unchanged.
W4319 Oct 2026+3 · 53 total

Three construction how-tos added to the catalog (now 53 keepers), and the living primer rewritten to give a first-timer a guided LLM path, a no-code path, and a tool that cleans up messy arrow names.

Added that week
What changed in the primer
  • Extract (with an LLM) now opens with GraphAcademy’s course as the starting point: gather, chunk, embed, LLM returns {head, relation, tail} JSON, MERGE into Neo4j, then rerun with a short schema of allowed patterns to see the sprawl shrink. The LLM Knowledge Graph Builder is named as the no-code way to do the same thing (Labs project; best on long English prose, weak on spreadsheets). kg-gen joins the recipe list.
  • Resolve adds kg-gen’s cluster=True, which groups entity synonyms ("AI" and "artificial intelligence") and relation synonyms ("is type of" and "is a kind of"), next to iText2KG’s thresholds and the Knowledge Graph Builder resolvers. Same rule as before: similarity proposes, your keys decide.
  • Store notes that the Builder app writes the Neo4j store for you, like LightRAG, Cognee, Graphiti, and iText2KG.
  • Common traps gain two lines: edge clustering as a quick audit of a graph you inherited with messy relationship names, and the Builder’s Document → Chunk → Entity shape as a ready-made way to keep the source on every fact.
  • What to read first step 3 now sends LLM-path readers through the GraphAcademy course before the Knowledge Graph Builder guide or iText2KG.
  • The metaphor (spreadsheet with arrows), pipeline diagram, issuer–bond–fund worked example, and maintenance loop are unchanged; week links point at W43 and the catalog count is 53.
W4212 Oct 2026+4 · 50 total

Four construction how-tos added to the catalog (now 50 keepers), and the living primer rewritten to weave them into model, extract, resolve, and store.

Added that week
What changed in the primer
  • Model cites Stanford CS520’s create notes beside Ontology 101 and Neo4j’s data-modeling tutorial: when to use a label vs a property vs a relationship, plus linked-data habits for RDF.
  • Extract adds iText2KG next to the Knowledge Graph Builder / GraphRAG / LlamaIndex family — incremental build_graph with merge thresholds instead of a one-shot index.
  • Resolve adds ReFinED as the copy-paste entity linker (mention → Wikipedia/Wikidata ID), beside OpenRefine, Splink, and Neo4j’s resolvers.
  • Validate / store fold TerminusDB’s schema Classes into the refuse-bad-data story, and add TerminusDB to the store table as the document-graph local-server option.
  • Metaphor, pipeline diagram, issuer–bond–fund worked example, Memory Engineering loop, and “what to read first” order are unchanged in shape; week links now point at W42. Catalog count in the opener is 50.
W415 Oct 2026+4 · 46 total

Four construction how-tos added to the catalog (now 46 keepers), and the living primer rewritten as a shorter, clearer pass built around one new idea: decide the questions before you build anything.

Added that week
What changed in the primer
  • New first step. The pipeline is now questions → model → extract → resolve → validate → store → query, with a loop back from query to model. Ontology 101’s competency questions and Neo4j’s data-modeling tutorial both start there, so the primer does too.
  • Modeling got its own section. Nouns become node types, verbs become relationship types, every node type gets a unique key, and the arrow carries a property when the question is how two things relate. Schema.org, LinkML, and the Knowledge Graph Builder’s patterns are listed as ways to write the model down.
  • Extract and resolve lean on the Knowledge Graph Builder. It’s the one page that names load, split, schema, extract, prune, write, and resolve as separate parts, and its three resolvers (exact, spaCy semantic, fuzzy) join OpenRefine, Splink, and the Neo4j entity-resolution tutorial.
  • Validate now has a runner. SHACL shapes plus pyshacl -s shapes.ttl data.ttl (exit 0 passes, 1 fails) sit beside Neo4j constraints and the builder’s pruner.
  • Store is a table now instead of a long paragraph: library, Java, local server, inside SQL, other dialect, or managed cloud, for RDF and property graphs.
  • Worked example walks the same issuer, bond, and fund toy through every step, starting from two written questions and ending with the model passing its own test.
  • Common traps adds “building before asking.” The whole primer dropped from about 34 KB to 18 KB, and all 46 catalog URLs are still linked.
W4028 Sep 2026+4 · 42 total

Four construction how-tos added to the catalog; the living primer rewritten from all 42 keepers.

Added that week
What changed in the primer

the primer still uses the spreadsheet-with-arrows metaphor, the issuer–bond–fund example (Cypher + SPARQL), and the Memory Engineering “keep it honest” loop. The pipeline diagram stays extract → resolve → type / validate → store → query.

  • Type / validate adds LinkML’s property-graph schema how-to (Node + Edge classes, edge properties, Schemasheets) and points at the RDF 1.2 Primer §3.5 annotation / reifying-triple pattern for provenance on a fact.
  • Store adds NebulaGraph nGQL CRUD (CREATE SPACE / TAG / EDGE → INSERT → GO) and RDF4J’s RDF 1.2 Triple Terms page as the Java annotation path beside the existing RDF4J getting-started tutorial. Kùzu archive caveat unchanged; AGE / DuckDB / FalkorDB / NebulaGraph called out as preferred new-build peers.
  • Query notes NebulaGraph GO / MATCH and SPARQL 1.2 patterns over annotated triples.
  • How you actually build folds NebulaGraph into the lightweight/SQL/nGQL path and RDF 1.2 annotations into the code-RDF path.
  • Keep it honest still points at Graphiti clocks and Memory Engineering; RDF 1.2 reifying triples noted as the RDF way to attach source / confidence / since.
  • What to read first slots RDF 1.2 Primer beside RDF 1.1 (#1), NebulaGraph beside Cypher docs (#2), RDF4J Triple Terms beside SPARQL playgrounds (#4), and LinkML PG schema beside OntoGPT / constraints (#5).
W3921 Sep 2026+4 · 38 total

Four construction how-tos added to the catalog; the living primer rewritten from all 38 keepers.

Added that week
What changed in the primer

the primer still uses the spreadsheet-with-arrows metaphor, the issuer–bond–fund example (Cypher + SPARQL), and the Memory Engineering “keep it honest” loop. The pipeline diagram stays extract → resolve → type / validate → store → query.

  • Extract adds LightRAG Core (ainsert → entities/relations in graph_storage) and Cognee (remember builds the graph in one call).
  • Store adds Apache AGE (Cypher inside Postgres) and DuckDB Graph Queries (CREATE PROPERTY GRAPH over existing tables). Kùzu archive caveat unchanged; AGE / DuckDB / FalkorDB called out as preferred new-build peers.
  • Query notes AGE cypher(… MATCH), DuckDB GRAPH_TABLE … MATCH, and Cognee recall / LightRAG aquery as retrieval layers on top of a path you can still write yourself.
  • How you actually build gets a fifth structured path (warehouse property graph) and folds AGE into the lightweight/SQL Cypher path.
  • What to read first slots AGE + DuckDB beside Cypher docs (#2) and Cognee / LightRAG beside the text-extract starters (#3).
  • Keep it honest still points at Graphiti clocks and Memory Engineering; Cognee forget / LightRAG edit-delete noted as productized cousins of consolidate and decay.
W3814 Sep 2026+4 · 34 total

Four construction how-tos added to the catalog; the living primer rewritten from all 34 keepers.

Added that week
What changed in the primer

the primer still uses the spreadsheet-with-arrows metaphor, the issuer–bond–fund example (Cypher + SPARQL), and the Memory Engineering “keep it honest” loop. The pipeline diagram stays extract → resolve → type / validate → store → query.

  • Extract adds OntoGPT (ontogpt extract with LinkML templates + ontology grounding) and From Documents to Triples as the sitting-length document→RDF recipe. CareerStack named as the clearest single beginner narrative of the property-graph vs RDF fork.
  • Resolve notes OntoGPT annotators / Documents-to-Triples Wikidata-or-mint-URI beside OpenRefine, Splink, and Neo4j Senzing.
  • Type / validate calls out OntoGPT’s LinkML template as the extract-time vocabulary contract.
  • Store / query unchanged in tooling; query path adds the Neo4j Live video (model → Aura CSV → Cypher) as the first video keeper.
  • What to read first offers CareerStack as an alternate #1, the Live video beside Cypher docs, Documents-to-Triples beside RDFLib create, and OntoGPT beside constraints / resolve.
  • Keep it honest still points at Graphiti clocks and Memory Engineering; CareerStack’s maintenance chapter sits with the RAG playbook’s day-2 jobs.
W377 Sep 2026+5 · 30 total

Five construction how-tos added to the catalog; the living primer rewritten from all 30 keepers.

Added that week
What changed in the primer

the primer still uses the spreadsheet-with-arrows metaphor, the issuer–bond–fund example (Cypher + SPARQL), and the Memory Engineering “keep it honest” loop. The pipeline diagram stays extract → resolve → type / validate → store → query.

  • Extract still lists YARRRML, spaCy + NetworkX, REBEL, GLiNER, LlamaIndex, Neo4j / LLMGraphTransformer, GraphRAG, and Graphiti. Adds the 3 Aug 2026 RAG integration guide as the bolt-on playbook (schema-guided first, source_chunk_id on edges, dual-index join on entity IDs).
  • Resolve unchanged in tools (Neo4j Senzing, OpenRefine, Splink); the RAG playbook’s block / embed / LLM-adjudicate layers are named as the same step on LLM output.
  • Type / validate pairs Schema.org + SHACL with Neo4j Create constraints (IS UNIQUE / IS NODE KEY before MERGE). The worked Cypher example now opens with an issuer uniqueness constraint.
  • Store adds pyoxigraph (embedded RDF + SPARQL) and FalkorDB Getting Started (Docker Cypher). Notes that upstream Kùzu was archived Oct 2025 — docs remain a good CSV→Cypher lesson; new builds prefer Neo4j / Memgraph / FalkorDB unless pinning 0.11.x.
  • Query adds RDFLib Querying with SPARQL (g.query / g.update on the Graph you just built) beside Wikidata, Fuseki, and pyoxigraph store.query.
  • What to read first threads RDFLib create → query, FalkorDB as the active lightweight Cypher path, constraints before MERGE, and pyoxigraph as in-process SPARQL.
  • Keep it honest still points at Graphiti clocks and Memory Engineering; adds the RAG playbook’s day-2 drift jobs and exit criterion.
W3631 Aug 2026+12 · 25 total

Twelve construction how-tos added to the catalog (five morning, four second pass, three third pass); the living primer rewritten from all 25 keepers.

Added that week
What changed in the primer

the primer still uses the spreadsheet-with-arrows metaphor, the issuer–bond–fund example (Cypher + SPARQL), and the Memory Engineering “keep it honest” loop. The pipeline diagram stays extract → resolve → type / validate → store → query.

  • Extract lists YARRRML for tables (CSV/JSON/XML → RDF in Matey) beside the three classical text paths (spaCy + NetworkX, REBEL, GLiNER gliner-relex) and the LLM ones. Graphiti add_episode is the streaming/temporal LLM path.
  • Resolve now has three paths: Neo4j Senzing (already nodes), OpenRefine Reconcile → Start reconciling (spreadsheet column → Wikidata), and Splink (pip install splink, DuckDB cluster at 0.95 → estimated unique person ID on a dataframe).
  • Type / validate still pairs Schema.org typing with SHACL 1.2 §2 (Person / SSN / Company shapes + a validation report). Kùzu’s required CREATE NODE TABLE is the property-graph version of “schema first.”
  • Store adds Fuseki (local SPARQL server: unpack, fuseki-server, load a file at localhost:3030) next to RDFLib and RDF4J, and Neo4j LOAD CSV WITH HEADERS next to Kùzu COPY FROM. Memgraph, Neo4j CREATE / MERGE, and Neptune stay.
  • Query points Fuseki’s /name/sparql (and the dataset query UI) at your file after Wikidata has taught the habit.
  • What to read first keeps spaCy + NetworkX as the first-from-text path, YARRRML as the first-from-rows path, Kùzu as the no-server Cypher sibling, LOAD CSV once Neo4j is running, Fuseki as local SPARQL, and OpenRefine / Splink as the first resolve pages.
  • Keep it honest still points at Graphiti valid_at / invalid_at for a stream of facts. Memory Engineering remains the rule set for a static store. Splink clusters are called out as estimates, not filings.
W3526 Aug 2026+13 · 13 total

The job was to stand up a beginner catalog for creating knowledge graphs, then write a living how-to from it.

Added that week
What changed in the primer

the primer is a spreadsheet-with-arrows how-to: why a table is not enough, the extract → resolve → type/schema → store → query pipeline, a three-node issuer–bond–fund example with Cypher and SPARQL, and the traps (duplicate entities, no schema, treating LLM output as truth). Audience is a smart non-specialist, not a survey paper.