Types

Mem types every entity it extracts. Out of the box it uses generic words: concept, product, method, term. That is fine for most people, and doing nothing here costs you nothing.

But if you work in a domain with its own nouns, those generic words are a downgrade. An antibody team does not have products and concepts. It has cell lines, assays, antibodies, targets, protocols, instruments. A litigation team has matters, clients, opposing parties, statutes, filings, deadlines.

Teaching Mem those words changes three things: extraction starts reasoning in your vocabulary, the same real-world thing stops landing under two different types, and your graph becomes something you can question by kind.

Where it lives

Open Graph, then the Types tab in the right panel.

That is the whole surface. Your vocabulary is not a settings screen, because a type is a claim about what the things in your graph are, and you can only judge that claim while looking at them. Opening the tab turns on the lens; leaving it puts the graph back exactly as it was.

First useful action

Open Graph and click Types. If you have never set this up, you will see something honest: every entity Mem has ever extracted, grey, grouped by whatever word Mem picked on its own.

Say what your work is about in one sentence. "We are an antibody discovery team."

Mem reads your actual graph, comes back with a draft vocabulary built out of the words already in it, and shows how many of your entities each proposed type would cover. Accept it and the canvas repaints in your own colours.

That is the whole cold start. No empty form, no schema editor.

Reading the canvas

Once a vocabulary exists, the lens is a picture of it.

• Colour is the claim. Each type gets a colour. Every entity carrying that type takes it.
• Grey is what you have not claimed. Words Mem invented that your vocabulary does not cover stay colourless. That is the work queue, and it is visible instead of buried.
• Everything else recedes. Memories, conversations and documents dim while the lens is on, so the entity layer is the one you are actually looking at.
• Named regions. Where a type's entities genuinely sit together in the graph, Mem draws and labels that region. Where they do not, it draws nothing rather than implying a shape that is not there.

Hover a type to light up exactly the things it names. Click it to fly the camera to them. Click again to release.

Claiming a word

Two ways, both one gesture.

Drag it in. Pull a grey word onto a coloured one. Mem records it as another spelling of that type. If entities are already using the old spelling, it offers to move them, and shows you the result on the canvas before you commit.

Keep it as its own type. If the word deserves to be a type in its own right, take it as one.

Suggestions

Mem watches for drift and proposes small corrections: two types that are really one, a recurring word that deserves promoting, a spelling that keeps showing up. Each suggestion says why, in one line, and hovering it lights up the entities it would touch.

Nothing changes your vocabulary without you saying yes.

Moving existing entities

Renaming a type does not silently rewrite your graph. Mem previews the migration first, on the real nodes: the affected entities repaint in the colour they would become, with an exact count. Apply it and they move for good. Decline and nothing happened.

Entities are skipped when a same-named entity already holds the target type, and Mem tells you how many.

What Mem never does

• Never requires a vocabulary. Unconfigured behaves exactly as it always did, everywhere.
• Never fails an extraction over a type. A word outside your vocabulary is recorded and surfaced, not rejected and not silently invented.
• Never changes your vocabulary on its own. Suggestions are suggestions.
• Never throws a word away. Retired types keep working as aliases forever, so old exports re-import cleanly.

From the terminal

Everything above is scriptable.

nmem ontology show                          # types, coverage, and unclaimed words
nmem ontology draft "antibody discovery lab" # draft one from your graph
nmem ontology proposals                     # the review queue
nmem ontology accept <id>
nmem ontology retype --from CELLLINE --to CELL_LINE   # preview
nmem ontology retype --from CELLLINE --to CELL_LINE --apply

Nothing that changes data runs without an explicit flag. draft prints the command to apply what it drafted; retype previews unless you pass --apply.

For your AI tools

Agents connected over MCP can read the vocabulary and work inside it: ontology_read returns your types with their descriptions and examples, entity_search finds reuse candidates before anything is written, and ontology_propose puts a suggestion in your review queue. An agent can suggest; only you can change the vocabulary.

Requirements

The conversational draft and the suggestion loop need a tool-capable model: a remote provider or Nowledge AI. Reading and editing your vocabulary by hand works everywhere.