> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wazoo.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Comparisons

> How Worlds compares to memory and retrieval alternatives.

Worlds is a context engine for agents that need verifiable facts, not just
similar text. These pages compare Worlds against the alternatives you are likely
weighing: memory layers, agent runtimes, vector stores, and building it
yourself.

## What Worlds provides

* Graph storage: RDF triples in an append-only, chronological fact ledger.
* Hybrid search: vector, full-text, and RDF filters fused by reciprocal rank
  fusion.
* SPARQL queries: declarative, deterministic graph traversal.
* Verifiable provenance: every fact carries a traceable path to its source.
* Provider-agnostic: you connect your own LLMs and embedding providers.
* Edge-ready adapters: LibSQL/Turso and Postgres backends.

## What Worlds does not do

Worlds is deliberately narrow. It does not:

* Host an LLM. You bring the model. Worlds stores and retrieves facts; the model
  decides what to ask.
* Host an embedding service. Embeddings come from the embedding provider you
  configure.
* Extract memory automatically. Memory in Worlds is curated. Facts enter a world
  deliberately, through import and patches, rather than being inferred from
  transcripts.
* Run agents. Worlds is not an agent runtime. It is a context source that agents
  query through tool calls.
* Replace your primary database. Worlds is a context engine, not a general
  operational store. Adapters persist to your existing substrate.
* Equate vector similarity with relevance. Similarity != relevance. Vectors are
  only one retrieval signal in Worlds. The graph structure and SPARQL filters
  ensure agents retrieve exact, verifiable facts rather than loose semantic
  guesses.

## How the alternatives line up

| Alternative                                               | Core model                      | Retrieval                      | Provenance          | Managed?              |
| :-------------------------------------------------------- | :------------------------------ | :----------------------------- | :------------------ | :-------------------- |
| [CocoIndex](/comparisons/cocoindex)                       | Incremental vector sidecar      | Vector similarity & ETL        | Derived sidecar     | Python / Postgres     |
| [DIY memory infra](/comparisons/diy-memory-infra)         | Custom stack                    | Custom                         | Your job            | You run it            |
| [DIY triplestore](/comparisons/diy-triplestore)           | RDF graph                       | SPARQL                         | Your job            | You run it            |
| [Document databases](/comparisons/document-databases)     | Semi-structured JSON docs       | Field queries & aggregations   | Document-level      | Managed or self-host  |
| [GBrain](/comparisons/gbrain)                             | Personal context vault          | Vector similarity & key lookup | Note-level          | Self-hosted           |
| [Google Dataplex](/comparisons/google-dataplex)           | Enterprise data fabric          | Data catalog & SQL queries     | Lineage metadata    | Google Cloud          |
| [Google OKF](/comparisons/google-okf)                     | Open Knowledge Format           | Schema payload & serialization | Entity-level        | Open specification    |
| [Google Search](/comparisons/google-search)               | Knowledge Graph + Web Search    | Web search & Knowledge Panels  | Web URLs            | Google Cloud          |
| [Hermes Agent Memory](/comparisons/hermes)                | Multi-tier memory & skills      | FTS5 search + system prompt    | Session / file      | Local CLI runtime     |
| [Key-value stores](/comparisons/key-value-stores)         | High-speed key-value cache      | Direct key lookup              | None                | Managed or self-host  |
| [LangMem](/comparisons/langmem)                           | LangGraph vector memory         | Similarity search              | None                | SDK, self-managed     |
| [Letta](/comparisons/letta)                               | Stateful agent runtime          | Files and vector index         | File-level          | Self-host             |
| [LLM Wiki](/comparisons/llm-wiki)                         | Agent-compiled markdown wiki    | File traversal & wikilinks     | Article-level       | Vault files           |
| [Maindex](/comparisons/maindex)                           | Typed memory layer              | MCP-based retrieval            | Provenance-typed    | Managed               |
| [Mem0](/comparisons/mem0)                                 | Extracted agent memories        | Similarity search              | Item-level          | Hosted or self-host   |
| [Memblock](/comparisons/memblock)                         | Block-based memory structures   | Block lookup + vectors         | Session-level       | Managed               |
| [MemClaw](/comparisons/memclaw)                           | Shared fleet partition          | Partition-aware retrieval      | Governed access     | Managed               |
| [MemMachine](/comparisons/memmachine)                     | Graph + SQL hybrid              | Graph traversal + vectors      | Graph-derived       | Self-host or cloud    |
| [MemSearch](/comparisons/memsearch)                       | Standalone memory library       | Similarity search              | None                | Library, self-managed |
| [MemSpan](/comparisons/memspan)                           | Portable files                  | Dynamic file loading           | None                | Local files           |
| [MemSync](/comparisons/memsync)                           | Verified-embedding memory API   | Similarity over embeddings     | Inference-verified  | Managed               |
| [Message queues](/comparisons/message-queues)             | Sequential event streams        | Log consumer offset streaming  | Stream log-level    | Managed or self-host  |
| [Palantir Foundry](/comparisons/palantir)                 | Enterprise Object Ontology      | Proprietary Ontology APIs      | Pipeline / Lineage  | Enterprise SaaS       |
| [Polygres](/comparisons/polygres)                         | Custom Postgres schemas + graph | `pgGraph` + `pgContext` SQL    | Relational lineage  | Managed or extensions |
| [Reducto](/comparisons/reducto)                           | Layout-aware document parser    | JSON extraction & chunk search | Document bounding   | Cloud API             |
| [Relational databases](/comparisons/relational-databases) | Normalised SQL tables           | SQL queries & JOINs            | Foreign key lineage | Managed or self-host  |
| [Supermemory](/comparisons/supermemory)                   | Extracted memories              | Search, memory graph           | Partial             | Hosted or self-host   |
| [TextQL](/comparisons/textql)                             | Warehouse semantic layer        | Natural language SQL & search  | Data catalog        | Managed Cloud         |
| [Traditional triplestores](/comparisons/triplestores)     | Dedicated RDF graph engine      | Standard SPARQL 1.1            | Quad-level          | Self-host or cloud    |
| [TrustGraph](/comparisons/trustgraph)                     | RDF graph (auto-extracted)      | GraphRAG + SPARQL              | Extraction traces   | Self-host             |
| [Twilio Memory Store](/comparisons/twilio-memory-store)   | Structured memory buckets       | Bucket lookup + vectors        | Bucket-level        | Managed               |
| [Vault-LD](/comparisons/vault-ld)                         | Markdown to/from RDF round-trip | YAML-LD + `@context` parser    | Note-level          | Open specification    |
| [Vector databases](/comparisons/vector-databases)         | Embedding index                 | Nearest neighbors              | None                | Usually hosted        |
| [Zep](/comparisons/zep)                                   | Extracted agent memories        | Similarity search              | Session-level       | Hosted or self-host   |

Polygres adds graph-style retrieval over Postgres records rather than RDF
triples. Turso is the substrate underneath Worlds' `worlds-libsql` adapter
rather than a direct alternative.

The remaining alternatives cluster by model. Similarity layers such as LangMem,
MemSearch, and MemSync recall by embedding. Graph-shaped stores such as
MemMachine combine a knowledge graph with SQL. Governed services such as Twilio
Memory Store, MemClaw, and Maindex organize structure and access. MemSpan trades
structure for portability. None of them exposes a queryable, append-only fact
[ledger](/worlds/index) with deterministic SPARQL verification.

## When to choose Worlds

Choose Worlds when conformance and interoperability are non-negotiable: agents
that rely on W3C open standards (RDF, SPARQL), portable memory layers, and
deterministic graph verification across any database or model provider. The
append-only ledger and SPARQL query engine keep agent context interoperable and
inspectable across database and model providers.

Real-world problems Worlds solves:

* **Your AI coding assistant forgets your codebase between sessions.** Chat logs
  truncate and vector recall drifts from the facts. Store facts about your APIs,
  conventions, and past decisions in a world so the next session resumes from
  verified graph state instead of a truncated conversation log.
* **Your multi-step agent drifts from the facts mid-task.** Long task chains
  accumulate errors when each step reasons from fuzzy similarity. SPARQL pattern
  matching confirms that entities and relationships exist before the agent acts
  on them, keeping multi-hop reasoning grounded in facts.
* **You cannot answer "where did this fact come from?"** In strict environments,
  every assertion needs a traceable source. The append-only ledger records
  quad-level provenance, so you can audit where each fact came from and when it
  entered the world.
* **You are locked into one vector store or model provider.** Worlds is
  provider-agnostic: you bring your own LLMs and embedding providers, and
  adapters persist to LibSQL/Turso or Postgres, so context stays portable.

## Next steps

* [Worlds overview](/projects/worlds)
* [Search](/worlds/search)
* [Query](/worlds/query)
* [MemSDK](/projects/memsdk)