Neotoma vs RAG Memory | Deterministic vs Retrieval Memory (Markdown)

Q: What's the difference between RAG memory and deterministic memory?

RAG stores text as vector embeddings and retrieves relevant chunks by similarity. Deterministic memory stores structured observations and composes entity state via reducers, guaranteeing the same inputs always produce the same state.

Q: Is Neotoma a RAG system?

No. Neotoma provides semantic search over structured entity snapshots, but it does not chunk documents or inject retrieved text into prompts. It provides deterministic state composition with formal guarantees.

<!--
  Full-page Markdown export (rendered HTML → GFM).
  Source: https://neotoma.io/ru/neotoma-vs-rag
  Generated: 2026-04-01T11:48:37.265Z
-->
# Neotoma vs RAG memory

RAG (Retrieval-Augmented Generation) memory stores text as vector embeddings and retrieves relevant chunks by semantic similarity. Deterministic memory stores structured observations and composes entity state via reducers. RAG answers 'what is relevant to this query?'; deterministic memory answers 'what was true at this moment?'

RAG and deterministic memory solve different problems in the AI agent stack. Understanding the difference matters for choosing the right architecture.

## What's the difference between RAG memory and deterministic memory?

RAG memory

RAG systems chunk documents, embed them as vectors, and retrieve the most semantically similar chunks at query time. The retrieved chunks are injected into the prompt to give the model relevant context. The system is optimized for recall relevance.

Neotoma

Deterministic memory systems record structured observations about entities and compose them into snapshots using deterministic reducers. The same observations always produce the same state. The system is optimized for state integrity and auditability.

◆

## Guarantee comparison

| Property | RAG memory | Neotoma |
| --- | --- | --- |
| Deterministic state evolution | Not provided | Guaranteed |
| Versioned history | Not provided | Guaranteed |
| Replayable timeline | Not provided | Guaranteed |
| Auditable change log | Not provided | Guaranteed |
| Schema constraints | Not provided | Guaranteed |
| Silent mutation risk | Common risk | Prevented |
| Conflicting facts risk | Common risk | Prevented |
| Reproducible state reconstruction | Not provided | Guaranteed |
| Human inspectability (diffs/lineage) | Partial | Guaranteed |
| Zero-setup onboarding | Not provided | Not provided |
| Semantic similarity search | Guaranteed | Guaranteed |
| Direct human editability | Not provided | Not provided |

◆

## When to use which

Use RAG memory when

You need to augment LLM prompts with relevant context from a document corpus. Approximate retrieval is sufficient, and you don't need to reconstruct historical entity state.

Use Neotoma when

You need to know the exact state of an entity at any past moment, resolve conflicts between multiple writers deterministically, enforce schemas, or provide auditable provenance chains.

## Common questions

### Is Neotoma a RAG system?

No. Neotoma provides semantic search over structured entity snapshots, but it is not a RAG system. It does not chunk documents or inject retrieved text into prompts. It provides deterministic state composition with formal guarantees.

### Can I use RAG alongside Neotoma?

Yes. RAG handles document retrieval for prompt augmentation. Neotoma handles structured entity state with deterministic guarantees. They are complementary.

### Does RAG provide versioned history?

No. Standard RAG systems store the latest version of document chunks. They do not maintain version history, temporal state queries, or auditable change logs for individual entities.

[Install Neotoma](/install)[All memory models](/memory-models)[FAQ](/faq)