Training Example: SurrealDB – Review the Data, Give Your Score & Compare to the Real AI Evaluation

[H1] The context layer for AI agents
The database where storage, context, and memory are one transaction.Start buildingBook a demo
[IMG: Babcock]
[IMG: ING]
[IMG: Nvidia]
[IMG: Apple]
[IMG: Samsung]
[IMG: Tencent]
[IMG: PolyAI]
[IMG: Verizon]
[IMG: Walmart]
[IMG: Carrier]
[IMG: Saks Fifth Avenue]
[IMG: San Francisco Compute Company]
[IMG: Shield AI]
[IMG: Babcock]
[IMG: ING]
[IMG: Nvidia]
[IMG: Apple]
[IMG: Samsung]
[IMG: Tencent]
[IMG: PolyAI]
[IMG: Verizon]
[IMG: Walmart]
[IMG: Carrier]
[IMG: Saks Fifth Avenue]
[IMG: San Francisco Compute Company]
[IMG: Shield AI]
MULTI-MODEL
[H1] Five databases become one
Stop stitching databases together. SurrealDB unifies your entire context layer in a single multi-model engine - one query language, one transaction, one deployment.Before - Multiple databasesClient0msYour application5 SDKs · 5 drivers · 5 connection poolsVectordatabaseProprietary APIFull-text searchdatabaseSearch DSLTime-seriesdatabaseInfluxQL / FluxRelational / documentdatabaseSQL / MQLGraphdatabaseCypher / GremlinEventual consistency onlyAfter - SurrealDBClient0msYour application1 SDK · 1 driver · 1 connection pool
[IMG: SurrealDB]
SurrealDBSurrealQLVectorsFull-textTime-seriesDocumentsGraphsSingle ACID transactionStrong consistencyTHE PLATFORM
[H1] The only vertical stack from storage to memory
No other product offers this. Object storage to agent memory. One transaction boundary. One permission model. One deployment.SPECTRON
[H3] Memory
Your agents remember users, accumulate preferences, and reason over history - no separate memory layer needed.
[IMG: Memory icon]
SURREALDB
[H3] Context
Documents, graphs, vectors, and time-series in one ACID transaction. One query gives the agent everything it needs to reason.
[IMG: SurrealDB icon]
STORAGE
[H3] Storage
Distributed storage with quorum consensus. Compute-storage separation, object storage, and elastic scale beneath the context layer.
[IMG: Storage icon]
THE ARCHITECTURE
[H2] One stack. Four layers. Every layer under one roof.
Spectron gives agents persistent memory. SurrealDB unifies every data model in one ACID transaction. The storage engine separates compute from storage on commodity object storage. No glue code. No middleware.The context layerApplications
[IMG: Spectron]
SpectronMemoryEntity extractionKnowledge graphTemporal factsHybrid retrieval
[IMG: SurrealDB]
SurrealDBContextDocumentsGraphsVectorsTime-seriesAuthAPIs
[IMG: SurrealDS]
StorageStorageQuorum consensusCompute-storage sep.Scale to zero
[IMG: SurrealDS]
Object storage (S3 / GCS / Azure Blob)WHY IT BREAKS
[H1] Agents fail due to context. Not models.
Your model can reason. It just has nothing reliable to reason over. Five systems. Five consistency models. Context that fragments at every seam.
[H3] Context that leaks at every seam
Data flows between five systems. Relationships, history, and metadata fragment at every boundary.App stateUser sessionVector DBEmbeddingsGraph DBRelationsDoc storeDocumentsAuthIdentityData fragments at every system boundary
[H3] Writes that half-succeed
Memory updates in one system, state fails in another. Without unified transactions, partial writes corrupt context.Single transactionVector DBWrite embeddingGraph DBWrite relationcommittedinconsistent staterolled back
[H3] Latency that compounds
Every system adds a network hop. Round trips stack under load until agents miss their response window.AgentVector DBGraph DBDoc storeAuthTotalCumulative latency
[H3] Five systems to keep alive
Five failure modes, five monitoring setups, five sets of credentials. The glue code becomes the product.Vector DBSimilarity searchauthconfigmonitorGraph DBRelationship storeauthconfigmonitorDoc storeRaw document indexauthconfigmonitorAuth serviceIdentity & tokensauthconfigmonitorCache layerHot key storeauthconfigmonitorFive systems. Five auth configs. Five things to scale, secure, and keep alive.HOW IT WORKS
[H1] The read-think-write loop
Read, think, write - in a single transaction.
[H3] Read
Graph traversal, vector search, and temporal facts - one SurrealQL statement, one round trip.SurrealQLMulti-model queryGraphVectorTemporalUnified result set
[H3] Think
Documents, relationships, embeddings, and history arrive together. The agent reasons over complete context.Result setMulti-model query outputDocumentsRelationsVectorsHistoryComplete context
[H3] Write
Persist decisions, update entities, trigger events - one ACID transaction, no partial writes.BEGIN TRANSACTIONACID transaction boundaryUpdateCreateTriggerCOMMITTEDWHY SURREALDB
[H1] Every failure has a structural fix.
Each failure mode has a structural fix - built into the engine, not bolted on top.FIXES: CONTEXT LEAKS
[H3] Multi-model in one engine
Documents, graphs, vectors, and time-series are native primitives in one query. No stitching across systems.FIXES: PARTIAL WRITES
[H3] ACID across all data models
Graph updates, document writes, and vector index changes happen in a single transaction. All succeed or none do.FIXES: COMPOUNDING LATENCY
[H3] One query, one round trip
SurrealQL composes graph traversal, vector search, and temporal filtering in a single statement. No multi-system orchestration.FIXES: OPERATIONAL OVERHEAD
[H3] Built-in backend
Auth, permissions, API endpoints, live queries, and event triggers. The database is the backend.SURREALQL
[H1] One query. Every model.
Graph traversals, vector search, transactions, and access control in one expressive language.MULTI-MODEL QUERYGraph, vector, and temporal data in one round trip.LET $vec = fn::embed("running shoes");SELECT ->purchased->product AS history, ->reviewed->product[WHERE vector::similarity::cosine( embedding, $vec ) > 0.8 ] AS relevant, ->prefs[WHERE valid_at <= time::now()] AS prefsFROM ONLY $user;ACID TRANSACTIONSMulti-model writes succeed together or not at all.BEGIN TRANSACTION;LET $order = CREATE order SET user = $auth.id, product = product:headphones, total = product:headphones.price;RELATE $auth.id->purchased->product:headphones SET at = time::now();UPDATE product:headphones SET stock -= 1;COMMIT TRANSACTION;BUILT-IN AUTHAuthentication and row-level security in the database.DEFINE ACCESS account ON DATABASE TYPE RECORD SIGNUP ( CREATE user SET email = $email, pass = crypto::argon2::generate($pass) ) SIGNIN ( SELECT * FROM user WHERE email = $email AND crypto::argon2::compare(pass, $pass) );DEFINE TABLE order PERMISSIONS FOR select WHERE user = $auth.id FOR create WHERE $auth.id != NONE;Explore real-world query patterns across search, graphs, agents, and more.Hybrid RAGVector + full-text search context retrievalGraph RAGGraph-based re-ranking of search resultsContext expansionGraph traversal for related document discoveryKnowledge graphsGraph modelling and traversal queriesAgent memoryVector, graph, and time-series with state invalidationConversational memoryThreaded chat history with graph contextAgentic tool useTyped function schemas for agent discoveryLive queriesReal-time subscriptions for reactive stateRecommendationsGraph traversal + vector collaborative filteringGeospatial queriesLocation-aware queries with spatial indexesEvent-driven automationTriggers and side effects on data changesMulti-tenant accessRow-level security for data isolation-- Hybrid RAG retrieval. Blends vector cosine similarity with BM25-- full-text search into a single weighted score, so results are-- both semantically relevant and keyword-accurate.-- Step 1: Embed the user's natural language queryLET $query = "How do I configure access control?";LET $embedding = fn::embed($query);-- Step 2: Run a hybrid search combining vector and full-text scores-- Vector candidatesLET $vs =SELECT id, vector::similarity::cosine(embedding, $embedding) AS vsFROM documentWHERE embedding <|20,COSINE|> $embeddingORDER BY vs DESCLIMIT 20;-- Text candidatesLET $ft = SELECT id, search::score(1) AS tsFROM documentWHERE content @1@ $queryORDER BY ts DESCLIMIT 20;-- Fuse the two ranked listsSELECT * FROM search::rrf([$vs, $ft], 5, 60)ORDER BY rrf_score DESC;-- Graph-enhanced RAG with re-ranking. Over-fetches candidates via-- hybrid search, then uses graph connectivity to boost documents-- that are well-cited within the candidate set — surfacing-- authoritative context that pure similarity would underrank.-- Step 1: Embed the queryLET $query = "How do I configure access control?";LET $embedding = fn::embed($query);-- Step 2: Over-fetch candidates via hybrid vector + full-text search-- Vector candidatesLET $vs =SELECT id, vector::similarity::cosine(embedding, $embedding) AS vsFROM documentWHERE embedding <|20,COSINE|> $embeddingORDER BY vs DESCLIMIT 20;-- Text candidatesLET $ft = SELECT id, search::score(1) AS tsFROM documentWHERE content @1@ $queryORDER BY ts DESCLIMIT 20;-- Fuse the two ranked listsLET $candidates = SELECT * FROM search::rrf([$vs, $ft], 5, 60)ORDER BY rrf_score DESC;-- Step 3: Re-rank using graph authority within the candidate setLET $ids = $candidates.id;SELECT id, title, content, rrf_score, -- Count inbound references from other candidates (graph authority) count(<-references<-document[WHERE id IN $ids]) AS authority, -- Blend retrieval relevance with graph connectivity (rrf_score * 0.7) + (authority * 0.15) AS final_scoreFROM $candidatesORDER BY final_score DESCLIMIT 5;-- Graph context expansion. Finds seed documents via hybrid search,-- then walks the document reference graph to surface related context-- that pure vector or keyword search would miss.-- Step 1: Embed the queryLET $query = "How do I configure access control?";LET $embedding = fn::embed($query);-- Step 2: Find seed documents via hybrid vector + full-text search-- Vector candidatesLET $vs =SELECT id, vector::similarity::cosine(embedding, $embedding) AS vsFROM documentWHERE embedding <|20,COSINE|> $embeddingORDER BY vs DESCLIMIT 20;-- Text candidatesLET $ft = SELECT id, search::score(0) AS tsFROM documentWHERE content @0@ "How"ORDER BY ts DESCLIMIT 20;-- Fuse the two ranked listsLET $seeds = SELECT * FROM search::rrf([$vs, $ft], 5, 60)ORDER BY rrf_score DESC;-- Step 3: Traverse the document graph to pull in related contextRETURN { -- The seed documents found by hybrid search matches: $seeds, -- Walk outbound edges to find documents these seeds cite referenced: $seeds->references->document, -- Walk inbound edges to find documents that cite these seeds referenced_by: $seeds<-references<-document};-- Knowledge graph modelling. Entities are records with vector-- embeddings, connected by typed graph edges that carry their own-- properties. Multi-hop traversals query the graph in one statement.-- Step 1: Create entity records with embeddings for semantic searchCREATE entity:openai SET name = "OpenAI", type = "organisation", embedding = fn::embed("OpenAI AI research company");CREATE entity:gpt4 SET name = "GPT-4", type = "model", embedding = fn::embed("GPT-4 large language model");-- Step 2: Connect entities with typed graph edgesRELATE entity:openai->developed->entity:gpt4 SET at = d"2023-03-14", context = "Released as a multimodal LLM";-- Step 3: Query with multi-hop traversals across the graphSELECT name, -- Follow outbound "developed" edges to find what OpenAI built ->developed->entity.name AS built, -- Continue traversal: who uses what OpenAI built? ->developed->entity<-used_by<-entity.name AS users, -- Follow a different edge type for partnerships ->partnered_with->entity.name AS partnersFROM entity:openai;-- Agent memory with state invalidation. Memories carry TTLs and-- vector embeddings. An event automatically detects when a new fact-- supersedes an older one via semantic similarity, and links them-- with a graph edge. Recall uses recency-weighted scoring so newer-- versions of a fact naturally rank higher.-- Step 1: Store a memory with a TTL and link the agent to itCREATE memory SET agent = agent:main, content = "User prefers dark mode UI", embedding = fn::embed("User prefers dark mode UI"), created_at = time::now(), valid_until = time::now() + 7d;RELATE agent:main->recalls->memory:last SET strength = 1.0, at = time::now();-- Step 2: Auto-detect superseded facts on every new memoryDEFINE EVENT detect_supersedes ON memory WHEN $event = "CREATE" THEN { -- Find existing memories that are semantically near-identical LET $similar = SELECT id FROM memory WHERE id != $after.id AND vector::similarity::cosine(embedding, $after.embedding) > 0.92; -- Link the new memory to each older version it supersedes FOR $old IN $similar { RELATE $after.id->supersedes->$old.id SET at = time::now(); };};-- Step 3: Recall memories with recency-weighted relevanceLET $context = fn::embed("What are the user preferences?");SELECT content, created_at, vector::similarity::cosine(embedding, $context) AS semantic, -- Walk the supersedes graph to see what this fact replaced ->supersedes->memory.content AS supersedes, -- Walk back to find which agent stored this memory <-recalls<-agent.id AS source, -- Recency decay so newer facts naturally outrank older versions semantic * math::pow(math::E, -0.1 * duration::days(time::now() - created_at)) AS scoreFROM memoryWHERE embedding <|4,COSINE|> $context AND valid_until > time::now()ORDER BY score DESCLIMIT 10;-- Conversational memory. Sessions and messages are linked by graph-- edges, making it easy to retrieve full threads in order. Each-- message carries a vector embedding so past conversations can be-- searched semantically across all sessions.-- Step 1: Create a conversation session for the current userLET $session = CREATE session SET user = $auth.id, started_at = time::now(), topic = "Project planning";-- Step 2: Store a message and link it to the session via graph edgeLET $msg = CREATE message SET role = "user", content = "What tasks are left for launch?", embedding = fn::embed("What tasks are left for launch?"), at = time::now();RELATE $session->contains->$msg SET position = 1;-- Step 3: Retrieve the full conversation thread via graph traversalSELECT role, content, at FROM $session->contains->messageORDER BY at ASC;-- Step 4: Semantic search across all past conversationsLET $q = fn::embed("launch checklist");SELECT content, -- Walk the graph back to find which session this message belongs to <-contains<-session.topic AS session, vector::similarity::cosine(embedding, $q) AS relevanceFROM messageWHERE embedding <|4,COSINE|> $qORDER BY relevance DESCLIMIT 5;-- Agentic tool use. Typed functions act as tools that agents can-- discover via database introspection and invoke by name. Each-- function has typed parameters, and can run queries, create-- records, and traverse the graph internally.-- Step 1: Define a document search tool with typed parametersDEFINE FUNCTION fn::search_docs($query: string, $limit: int) { LET $emb = fn::embed($query); RETURN SELECT id, title, content, vector::similarity::cosine(embedding, $emb) AS score FROM document WHERE embedding &

[IMG: SurrealDB hero illustration]
[H1] Context, made atomic
Documents, graphs, vectors, time-series, and relational data as native primitives in a single ACID transaction. No plugins, no bolt-ons, no frankenstack.Get startedTry SurrealDB
[IMG: Babcock]
[IMG: ING]
[IMG: Nvidia]
[IMG: Apple]
[IMG: Samsung]
[IMG: Tencent]
[IMG: PolyAI]
[IMG: Verizon]
[IMG: Walmart]
[IMG: Carrier]
[IMG: Saks Fifth Avenue]
[IMG: San Francisco Compute Company]
[IMG: Shield AI]
[IMG: Babcock]
[IMG: ING]
[IMG: Nvidia]
[IMG: Apple]
[IMG: Samsung]
[IMG: Tencent]
[IMG: PolyAI]
[IMG: Verizon]
[IMG: Walmart]
[IMG: Carrier]
[IMG: Saks Fifth Avenue]
[IMG: San Francisco Compute Company]
[IMG: Shield AI]
[H3] Native multi-model engine
Documents, graphs, vectors, full-text search, time-series, and relational data - fully unified in one database and query language. No plugins or bolt-ons.
[IMG: Result mode view]
[H3] AI data layer
Built for context, memory, search, and retrieval - combining vectors, graphs, full-text search, and relational joins in one engine.
[IMG: AI data layer illustration]
[H3] Deploy anywhere, scale horizontally
Same API runs from in-memory, embedded and edge devices to self-hosted or highly scalable in the cloud.
[IMG: Deploy anywhere illustration]
[H3] Real-time and event-driven
Built-in real-time subscriptions, event triggers, and streaming updates to power reactive, real-time experiences.
[IMG: Real-time messaging illustration]
[H3] Enterprise security and compliance
RBAC, record-level permissions, JWT auth, multi-tenant isolation, and SOC 2 / ISO 27001 compliance built in.
[IMG: Authentication and users illustration]
[H3] Developer tools
Surrealist visual IDE, WebAssembly plugins, and SurrealQL - the best of SQL, NoSQL, and graph in one syntax.
[IMG: SurrealQL query pane]
[H3] MCP server
Connect AI tools directly to SurrealDB through the Model Context Protocol. Queries, schema exploration, graph traversal, and vector search as MCP tool calls.
[IMG: MCP tool connections illustration]
[H3] High-performance, reliable core
Built in Rust with full ACID guarantees. Memory-safe, thread-safe, and crash-resilient by design.
[IMG: Rust-powered performance illustration]
See all featuresHOW IT WORKS
[H1] Multi-model query architecture
One query flows through documents, graphs, vectors, and time-series - resolved from a single transactional snapshot.SurrealDB SDKPostgres-compatible clientGraphQL client
[IMG: SurrealDB]
SurrealDBRPC protocolPostgreSQL wire protocolGraphQL endpointSurrealQL parserANSI-SQL parserGraphQL parser and schema generatorSurrealDB executorExecution logical planExecution physical planDocument processing
[IMG: SurrealDS]
Key-value engine data storage and retrievalDEPLOY ANYWHERE
[H1] Single binary, any device
In-memory, embedded, edge, WASM, or cloud - the same engine runs everywhere.Agent or applicationPython, C, C++, Rust, Java, or JavaScript runtimeIn-process native communication
[IMG: SurrealDB]
SurrealDBQuery engineStorage engine(Local disk or block storage)Periodic storage data compactionand compacted data storage
[IMG: SurrealDS]
Local diskHOW SURREALDB COMPARES
[H1] Every other agent stack is a frankenstack
Document store, graph database, vector database, cache, message broker, memory middleware - glued together and prayed over. SurrealDB replaces all of it.
[H3] vs. Postgres
Postgres bolts on vectors with pgvector and graphs with recursive CTEs. SurrealDB makes every model native - no extensions, no workarounds.
[H3] vs. MongoDB
MongoDB is a document store. Graph traversal, vector search, and temporal queries require separate systems. SurrealDB unifies them.
[H3] vs. Neo4j
Neo4j is a graph database. Documents, vectors, and time-series require separate infrastructure. SurrealDB does it all in one engine.
[H3] vs. Vector databases
Pinecone, Chroma, and Weaviate store embeddings. SurrealDB stores embeddings alongside their entities, relationships, and temporal context.
[H3] vs. Memory middleware
Mem0 layers memory on top of fragmented databases. Spectron builds memory directly into SurrealDB - one transaction, no consistency gaps.
[H3] vs. Agent databases
HelixDB and HydraDB internalise a frankenstack. SurrealDB provides true multi-model unification with ACID across all data types.
[H3] Features
Explore the full set of capabilities built into SurrealDB - from multi-model querying and vector search to real-time subscriptions and record-level permissions.
[H3] Roadmap
See what's planned, what's in development, and what's already shipped. Follow the evolution of SurrealDB from database to full platform.
[H3] Releases
Browse every release with detailed changelogs, new features, performance improvements, and bug fixes across all SurrealDB versions.GET STARTED
[H1] Start building with SurrealDB
The only database where a graph edge is a full document, a vector embedding lives in the same ACID transaction, and context is atomic.Get startedTry SurrealDB

[IMG: The context wall whitepaper hero illustration]
[H1] Why AI agents need a multi-model foundation
Beyond knowledge graphs to real-time contextual reasoning.Explore the platformDownload PDFEnterprise AI initiatives in 2026 share a common failure pattern. The cause is not the model. It is the architecture beneath the model. As the initial hype surrounding Large Language Models matures into the deployment of autonomous agents, enterprises are hitting a “Context Wall.” While LLMs provide the reasoning engine, they lack a persistent, structured, and real-time memory layer. This paper introduces the Enterprise Semantic Foundation (ESF) - a unified, multi-model substrate that merges the stability of Knowledge Graphs with the dynamism of Context Graphs. It argues that the next leap in AI utility will not come from larger models, but from a shift in data architecture.EXECUTIVE SUMMARY
[H3] The problem
LLMs are stateless; RAG is a temporary patch. Agents need 'living' memory. Current attempts rely on fragmented 'frankenstacks' - disparate vector, graph, and document databases stitched together with complex glue code.
[H3] The thesis
Traditional single-model stores and fragmented data platforms are structurally misaligned with the requirements of agentic state. The bottleneck is architectural, not model-related.
[H3] The solution
A unified 'Context Graph' built on a multi-model foundation that treats storage as an active participant in reasoning - not a passive retrieval layer.INTRODUCTION
[H2] From static graphs to active context
Enterprise infrastructure has evolved through three distinct generations. Each subsumes the previous one rather than replacing it. A well-designed context graph anchors itself to the canonical facts of a knowledge graph and the governed definitions of a semantic layer.
[H3] The semantic layer
Hand-built YAML definitions and LookML models that mapped business terms like “revenue” and “churn” to specific SQL queries. Semantic layers brought discipline to analytics, but they were static, manually maintained, and brittle. When a team member left or a product line launched, the definitions went stale.
[H3] The knowledge graph
Structured representations of what an organisation knows, encoded as nodes and relationships. Knowledge graphs brought relational structure to enterprise data - ontologies, entity resolution, and canonical facts. They remain powerful tools for search, recommendation, and retrospective analysis.
[H3] The context graph
A live, transactional representation of what is happening right now, enriched with the semantic meaning of why it matters. The context graph captures state: the agent's current goals, its observations, the relationships between the entities it is reasoning about, and the situational relevance of everything in its environment.The architectural challenge is building a foundation that can hold all three - static definitions, stable facts, and dynamic state - in a single, unified, transactional system. Without the context graph, agents suffer from digital amnesia. They know who the user is, but they forget why they are talking.THE 2026 ENTERPRISE REALITY
[H2] Hitting the wall
Nearly every organisation with a data team attempted to deploy some form of agentic workflow in 2024 and 2025: a customer support agent, a data analyst, an internal knowledge assistant. Most of those efforts failed.
[H3] Failed pilots
Agents struggled to answer basic questions correctly. “What was revenue growth last quarter?” produced wrong answers, not because the model could not reason, but because the agent lacked the context to understand how revenue was actually defined in that organisation, which tables were authoritative, and how the definition had changed since a team member left.
[H3] Cost and governance
Running a production agentic system on a “frankenstack” of four specialist databases means paying for four sets of infrastructure, managing four data synchronisation pipelines, enforcing access controls across four systems, and debugging failures that span all of them. Procurement teams are asking for consolidation.
[H3] Architecture, not models
Models have improved. The context problem has not. Longer context windows do not solve the fundamental issue: an agent that cannot access reliable, structured, real-time context will hallucinate, contradict itself, and fail to coordinate with other agents regardless of how capable its underlying model is.THE ARCHITECTURE OF AGENCY
[H2] Why AI needs a context layer
The shift from human-driven analytics to autonomous agency introduces a fundamentally different set of requirements. Humans query data to find insights. Agents query data to decide what to do next. That distinction changes everything about how a data architecture must behave.
[H3] The read-think-write loop
An AI agent operates through a continuous cycle: perceive the environment, reason over memory, commit an action or observation back to storage. This loop runs in milliseconds, and it never stops.Modern data platforms are optimised for analytical throughput. They are designed to answer questions about the past at scale. Fast ingest makes data queryable quickly; it does not provide the ability to lock a record, mutate it, and guarantee that the next agent in the loop reads the updated value within the same millisecond window. That requires read-after-write transactional consistency - a property that streaming ingest architectures are not designed to deliver.SurrealQLMulti-model queryGraphVectorTemporalUnified result setResult setMulti-model query outputDocumentsRelationsVectorsHistoryComplete contextBEGIN TRANSACTIONACID transaction boundaryUpdateCreateTriggerCOMMITTED
[H3] The state problem
Agents are not stateless. They track goals, monitor sub-tasks, and maintain a working memory of their progress. When an agent is coordinating a complex workflow, it must be able to lock a resource, update a belief, and trigger a downstream action - all within a single consistent operation. This requires ACID compliance and granular transactional control. Analytical platforms are not built for this. They are built to tell you what happened. Agents need infrastructure that shapes what happens next.
[H3] The missing layer: context
What is missing from every existing data architecture - whether a traditional warehouse, a modern lakehouse, or a distributed data mesh - is a dedicated context layer. A context layer is an active, low-latency, transactional substrate that holds the live state of an agent's understanding: what it knows right now, what it is currently doing, and how that relates to everything else in the system.The context layer must live at the database layer, not above it, because only at the database layer can context be kept consistent, governed, secured, and transactionally unified with the canonical knowledge that grounds it.
[H3] How context gets built
Context enters the system through multiple channels: automated pipelines that ingest canonical data from existing warehouses and semantic layers, agent-generated observations written back during the read-think-write loop, human-curated business definitions and rules contributed by domain experts, and self-updating flows where agent corrections are incorporated back into the context graph.A multi-model foundation supports all of these ingestion patterns natively. Canonical facts arrive as structured documents. Relationships between entities are expressed as graph edges. Semantic embeddings are stored alongside the data they describe. Because all three models exist in the same transactional system, an update to a business definition, its relationships, and its embedding can be committed atomically - eliminating the synchronisation gaps that plague fragmented architectures.THE CONTEXT LAYER
[H2] Why multi-model wins
The transition from Large Language Models to Autonomous Agents represents a shift from “stateless inference” to “stateful reasoning.” In many current architectures, memory is fragmented across a “frankenstack” of specialised databases - a vector store for similarity, a graph database for relationships, and a relational or document store for metadata. This fragmentation imposes a significant “Cognitive Tax” on the agent and a “Semantic Tax” on the developer.
[H3] The fragmented memory tax
When an agent's memory is split across multiple systems, the unification of that data happens at the application layer. This creates several architectural bottlenecks.App stateUser sessionVector DBEmbeddingsGraph DBRelationsDoc storeDocumentsAuthIdentityData fragments at every system boundaryAgentVector DBGraph DBDoc storeAuthTotalCumulative latency
[H3] Latency of reconstruction
Every time an agent needs to 'remember' something, it must make multiple asynchronous calls to different APIs, wait for the results, and then use application logic to join that data together. In an autonomous loop, these milliseconds compound into seconds of 'thinking' time.
[H3] Semantic drift
When a document is updated in a NoSQL store, but its corresponding vector embedding in a separate store isn't refreshed, or its relationship in a graph database remains stale, the agent begins to reason over contradictory information.
[H3] Loss of dimensionality
A standalone vector search can tell an agent that 'Product A is similar to Product B,' but it cannot easily explain why - the relationship - or show the structured constraints - the price, the stock, the owner - without a complex multi-stage join.
[H3] Consistency boundaries
Each system has its own consistency model. The agent's view of the world depends on which system it queries and when - non-deterministic behaviour invisible in development, catastrophic in production.
[H3] Why memory middleware is not enough
Products such as Mem0 provide a useful abstraction layer, but are built on top of the same fragmented infrastructure: a vector store for semantic retrieval, optionally a graph layer for relationship tracking, and a relational store for metadata. The abstraction hides the complexity from the developer, but it does not eliminate it. When context changes in one underlying system, synchronisation to others is not guaranteed. The semantic drift problem persists underneath the abstraction.Memory middleware treats context as something to be retrieved and injected into a prompt. It does not treat context as a live, transactional substrate that the agent reasons within. For autonomous agents coordinating complex workflows with enterprise governance requirements, the foundation must be deeper.Vector DBSimilarity searchauthconfigmonitorGraph DBRelationship storeauthconfigmonitorDoc storeRaw document indexauthconfigmonitorAuth serviceIdentity & tokensauthconfigmonitorCache layerHot key storeauthconfigmonitorFive systems. Five auth configs. Five things to scale, secure, and keep alive.
[H3] The multi-model advantage: atomic context
A native multi-model foundation - where the database engine treats documents, graphs, and vectors as first-class citizens of the same storage layer - solves the memory problem by providing atomic context. A single “memory” is not a collection of pointers across different systems; it is a unified record.
[H3] From “pointers” to “rich edges”
In a traditional graph database, an edge is a simple line between two nodes. In a multi-model semantic foundation, edges are documents. An agent can traverse a relationship and find, embedded directly within that link, the vector embedding of the last interaction, the JSON metadata of the permissioning logic, and the relational history of the connection. The agent fetches a “complete thought” in one operation.
[H3] Reduced cognitive load
By eliminating the boundary between the “what” (document), the “how it relates” (graph), and the “what it's like” (vector), agents are provided with a memory layer that mirrors human cognition: interconnected, multidimensional, and instantly accessible.Single transactionVector DBWrite embeddingGraph DBWrite relationcommittedinconsistent staterolled backCONTEXT GRAPH SUPPORT
[H2] Knowledge vs. experience: the static and the fluid
Most enterprises have spent the last decade building Knowledge Graphs as “dictionaries of truth.” They are excellent at defining what a company knows, but they are remarkably poor at helping an agent decide what to do now.
[H3] The knowledge graph (the map)
Contains stable, ontological facts. “Product X is a subscription service,” “User Y lives in New York,” “London is a city.” These are high-trust, low-velocity data points.
[H3] The context graph (the journey)
Contains ephemeral, situational relevance. “The agent is currently troubleshooting Product X for User Y, who is frustrated because of a recent billing error.” For an AI agent, the “truth” of the Knowledge Graph is useless without the “relevance” of the Context Graph.
[H3] Why native graph support matters for agency
Modern vector databases such as Pinecone, Chroma, and Weaviate now support metadata filtering, hybrid search, and namespace scoping. These are genuine improvements. However, they remain fundamentally flat: they can tell an agent that two things are semantically similar, but they cannot model the structured relationships between entities, enforce transactional consistency across updates, or traverse impact paths through a connected graph. Similarity is not context.Consider a concrete example. An agent monitoring a production system receives an alert about a failing API endpoint. With a vector database, the agent can search for documentation semantically similar to the error message. Useful, but shallow. With a graph-capable multi-model database, the agent can traverse from the failing endpoint to the upstream service that depends on it, to the team that owns that service, to the on-call engineer currently assigned, and simultaneously retrieve the vector-embedded runbook most relevant to this specific failure mode - all in a single query.The structural traversal and the semantic search are not two separate operations stitched together in application code; they are one atomic operation.
[H3] Relationship over similarity
A vector search might find a manual about 'Server Errors.' A graph-native query finds the specific server that is down, the upstream services it impacts, and the on-call engineer currently assigned to it.
[H3] The impact radius
When an event occurs, an agent can 'walk the graph' to see how far the ripples go. This is a structural calculation that flat data structures cannot perform efficiently.
[H3] Filtered reasoning
By using the graph as a native layer, agents can prune their search space. Instead of searching 'all documents,' the agent follows the edges: 'Search only the documents related to the specific version of the software this user is running.'MULTI-AGENT SHARED STATE
[H2] Solving the shared state problem
As AI moves from single-task assistants to Multi-Agent Systems, the architectural challenge shifts from ind

[IMG: SurrealDB Labs]
Explore official and community examples, tools, libraries, and integrations built around SurrealDB - all in one place. Find client SDKs, videos, development tools, and learning resources to help you build and scale your applications. Have something to share? Check out our guide on creating a new Lab to contribute your own.VideosData management
[H3] 10 schema tips for SurrealDB
SDSurrealDBOfficialVideosData management
[H3] 10 Tips and Tricks for Surrealist
SDSurrealDBOfficialSource code
[H3] allographer
Nim ORM and query builder that supports SurrealDB.Itsumura H.Software EngineerSource code
[H3] Aspire Integration
.NET Aspire hosting integration for local SurrealDB dev stacks.David BottiauSoftware EngineerSource code
[H3] AspNetCore.HealthChecks.SurrealDb
ASP.NET Core health check package for monitoring SurrealDB connectivity.David BottiauSoftware EngineerVideosExamples
[H3] Beyond Surreal? A closer look at NewSQL Relational Data - Beyond Fireship.
FireshipContent Creator - Software EngineerDocumentation
[H3] Build a realtime presence web application using SurrealDB Live Queries
Official tutorial: build a realtime presence app with live queries.David BottiauSoftware EngineerVideosData management
[H3] Building an App with Graph Relations, Live Queries and Authentication
SDSurrealDBOfficialSource codeData managementExamples
[H3] CLI phone book in Python using SurrealDB as database.
Tutorial building a CLI phonebook in Python with SurrealDB.Gabor SzaboSoftware EngineerVideosData management
[H3] CRUD using SurrealDB in RUST | SurrealDB
SDSurrealDBOfficialVideosData management
[H3] Designing your schema in Surrealist
SDSurrealDBOfficialVideosData management
[H3] Different ways to perform a Vector Search in SurrealDB
SDSurrealDBOfficialVideosData management
[H3] Document-Style Relationships in SurrealDB
SDSurrealDBOfficialVideosToolingData management
[H3] Embed Surrealist in your projects
SDSurrealDBOfficialVideosData managementCloud
[H3] Getting started with Surreal Cloud
SDSurrealDBOfficialVideosData management
[H3] Getting started with SurrealDB using our JavaScript SDK
SDSurrealDBOfficialVideos
[H3] Getting started with SurrealDB using our Rust SDK
SDSurrealDBOfficialSource code
[H3] Getting started with SurrealDB using Python and Docker.
Walkthrough for running SurrealDB with Python and Docker.Gabor SzaboSoftware EngineerVideosCloud
[H3] Getting started with SurrealDB! Future of cloud databases (maybe)?
Chris HayContent CreatorVideosData management
[H3] Getting started with Surrealist
SDSurrealDBOfficialSource codeTooling
[H3] GKE using Terraform
Terraform module for running SurrealDB on Google Kubernetes Engine.Dylan VanmaliSoftware EngineerVideosData management
[H3] Graph-Style Relationships in SurrealDB
SDSurrealDBOfficialVideosAI
[H3] Graph, Full-Text Search and Vector Search in Surrealist
SDSurrealDBOfficialVideosExamples
[H3] Hosting Surreal DB in Rust in Less Than 3 Minutes.
Gui BibeauSoftware EngineerVideosAIExamples
[H3] How a luxury fashion retailer scaled personalised recommendations using Surre
SDSurrealDBOfficialVideosExamples
[H3] How I built a SaaS powered by SurrealDB
SDSurrealDBOfficialVideosData management
[H3] How to Build A Full Stack Rust Dashboard App with Leptos, Actix Web and SurrealDB
SDSurrealDBOfficialVideosExamples
[H3] How to Build A Rust Backend with Actix Web and SurrealDB (Full Tutorial)
SDSurrealDBOfficialVideosData management
[H3] How to do a Full-Text Search Query in SurrealQL
SDSurrealDBOfficialVideosExamples
[H3] How to Simplify Your Tech Stack with SurrealDB
SDSurrealDBOfficialBlogpostsExamples
[H3] How to Use SurrealDB with the Fresh Framework and Deno.
Rajdeep SinghSoftware EngineerBlogpostsData management
[H3] Improve database management with SurrealDB
Alexander NnakwueSoftware EngineerSource codeExamples
[H3] IoT telemetry example
Reference IoT telemetry ingest and queries with SurrealDB.Martin SchaerSolutions EngineerVideosExamples
[H3] Livestream series documenting learning SurrealDB.
XkontiContent CreatorVideosCloud
[H3] Network capabilities in Surreal Cloud
SDSurrealDBOfficialVideosData management
[H3] Relational-Style Relationships in SurrealDB
SDSurrealDBOfficialVideosData management
[H3] Run SurrealDB in your browser using our WASM engine
SDSurrealDBOfficialVideosData management
[H3] Run SurrealDB inside NodeJS using our NodeJS engine
SDSurrealDBOfficialVideosExamples
[H3] Rust Powered Database SurrealDB (It's Pretty Ambitious) - Code to the Moon.
Code to the MoonContent CreatorVideosData management
[H3] Schemaless vs Schemafull Databases
SDSurrealDBOfficialBlogpostsExamples
[H3] Setting up an invite system
Mordechai HadadSoftware EngineerBlogpostsExamples
[H3] Simple API with Gin/Gonic and SurrealDB (GO).
Atharva DeshpandeSoftware EngineerSource codeData managementLibraries
[H3] Surreal Transfer
CLI utilities for exporting and importing SurrealDB data.Lucy EganSoftware EngineerSource codeAIExamples
[H3] Surreal-4o Fine-tuned Model Datasets for SurrealQL Queries - Project to create structured datasets for OpenAI.
Structured datasets for fine-tuning models on SurrealQL-style queries.Sebastian FritschFullstack DeveloperSource codeLibraries
[H3] surreal-codegen
Code generation tooling for SurrealDB-backed TypeScript projects.Albert MarashiSoftware EngineerSource codeLibraries
[H3] surreal-ts
Generate TypeScript types from SurrealDB schema and queries.horvbalintSoftware EngineerVideosData managementExamples
[H3] SurrealDB - Rust Embedded Database - Quick Tutorial.
Jeremy ChoneSoftware EngineerSource codeExamplesTemplates
[H3] SurrealDB + Go Driver Starter.
Starter project wiring the official SurrealDB Go SDK into an application.Salman ShahSoftware EngineerSource codeTemplates
[H3] SurrealDB + Vue Blog Starter.
Vue.js blog starter template backed by SurrealDB.Fadel SrWitherSoftware EngineerSource codeAI
[H3] SurrealDB AI Assistant
Web AI assistant that queries and explores a SurrealDB database.JimpexSoftware EngineerSource codeExamplesAI
[H3] SurrealDB AI Docs Retrieval - Project to showcase: How to build a GPT-Based question-answering system on top of SurrealDB Docs.
RAG-style demo that answers questions using SurrealDB documentation.Kyryl TruskovskyiMachine Learning EngineerSource codeAIExamples
[H3] SurrealDB as a Vector Store for LangChain - A Jupyter notebook demonstrating how to use SurrealDB as a Vector Store.
Jupyter notebook showing SurrealDB as a LangChain vector store.Karim LalaniSoftware EngineerSource codeTooling
[H3] SurrealDB GitHub Action
GitHub Action to run SurrealDB in CI pipelines.SDSurrealDBOfficialSource codeData management
[H3] SurrealDB Grafana datasource
Official Grafana data source for SurrealDB queries.Grafana LabsObservabilityVideos
[H3] SurrealDB in 100 seconds.
FireshipContent CreatorSource codeAI
[H3] SurrealDB MCP Server
Model Context Protocol server that connects AI tools to SurrealDB.David WhatleySoftware EngineerSource codeSecurity
[H3] SurrealDB ODataV4 Connector
OData v4 tooling and connector work for SurrealDB.Andrew G. KnackstedtSr Backend EngineerSource codeTooling
[H3] SurrealDB Presence Demo - Demo project on how to create a realtime presence web application using SurrealDB Live Queries.
Sample realtime presence app built with SurrealDB live queries.David BottiauSoftware EngineerDocumentationAI
[H3] SurrealDB Vector Store for LangChain
LangChain documentation for using SurrealDB as a vector store.LangChainOpen Source ProjectSource codeLibraries
[H3] surrealdb_extra
Rust helper crate extending the official SurrealDB driver.Jakin010Software EngineerSource code
[H3] surrealdb-client-generator
Generate typed API clients from your SurrealDB schema and queries.Sebastian WesselSoftware EngineerDocumentation
[H3] surrealdb-extras
Rust API reference for the surrealdb-extras helper crate.Frederik UniSoftware EngineerSource code
[H3] surrealdb-flutter
Dart and Flutter client for connecting to SurrealDB.Duhan BalciSoftware EngineerSource code
[H3] surrealdb-valibot
Validate SurrealDB records using Valibot schemas.Levy van der ValkWeb DeveloperSource code
[H3] surrealdb-zod
Define and validate SurrealDB-shaped data with Zod.Levy van der ValkWeb DeveloperVideos
[H3] SurrealDB. The Kitchen Sink Document Store that might dethrone Firebase.
Ray VillalobosContent CreatorSource code
[H3] surrealdb.c
Official C bindings and examples for embedding SurrealDB.SDSurrealDBOfficialSource code
[H3] surrealdb/surrealdb
Official SurrealDB container image on Docker Hub.SDSurrealDBOfficialVideosData management
[H3] Surrealist for Power Users
SDSurrealDBOfficialSource code
[H3] Surrealist Python tool
Python driver and ergonomic query helpers for SurrealDB.KotolexSoftware EngineerSource codeExamplesTemplates
[H3] SvelteKit Surreal Database Authentication
SvelteKit example with SurrealDB-backed sign-in and sessions.Jonathan GambleSoftware EngineerVideosSecurity
[H3] Understanding User Groups in SurrealDB
SDSurrealDBOfficialBlogpostsSecurity
[H3] Unlocking SurrealDB: Building a Real-World Multi-Tenant RBAC System Made Easy (4 Part Series).
Sebastian WesselSoftware EngineerSource codeData management
[H3] UnrealORM: TypeScript ORM built for SurrealDB
TypeScript ORM designed around SurrealDB models and relations.JimpexSoftware EngineerSource codeAI
[H3] Use SurrealDB with LangChain
Reference integration for using SurrealDB with LangChain.SDSurrealDBOfficialVideos
[H3] Using SurrealDB to prove football statistics.
Joseph McCarthyContent Creator