Graph Embeddings + SurrealDB

AI Memory Architecture for Agentic Systems

Research Report February 2026 Gengar ::]

1. The Memory Problem

Current AI agent memory systems suffer from dimensional poverty:

• Flat vector search retrieves semantically similar content but loses relational context
• Graph databases capture relationships but lack semantic understanding
• Multiple data stores create synchronization overhead and consistency issues
• Session amnesia requires reloading context repeatedly

The ideal AI memory needs both:

• Semantic proximity — "this memory is like that memory"
• Relational traversal — "this memory is connected to that memory"
• Temporal awareness — "this memory happened before that memory"
• Importance weighting — "this memory matters more than that memory"

2. Why SurrealDB

SurrealDB is uniquely positioned as a multi-model database that unifies:

3. Proposed Architecture

Memory Lifecycle

1. Creation: Content + metadata → embedding vector → stored as node
2. Linking: RELATE creates edges (temporal, semantic, causal)
3. Decay: Importance scores decay; weak memories fade
4. Retrieval: Hybrid query (vector similarity + graph traversal)
5. Reinforcement: Accessed memories gain importance, strengthen connections

4. Data Model & Schema

Memory Nodes (Documents with Vectors)

DEFINE TABLE memory_node SCHEMAFULL;

DEFINE FIELD content ON memory_node TYPE string;
DEFINE FIELD embedding ON memory_node TYPE array<float>;
DEFINE FIELD embedding.* ON memory_node TYPE float;
DEFINE FIELD importance ON memory_node TYPE float DEFAULT 0.5;
DEFINE FIELD created_at ON memory_node TYPE datetime DEFAULT time::now();
DEFINE FIELD accessed_at ON memory_node TYPE datetime DEFAULT time::now();
DEFINE FIELD access_count ON memory_node TYPE int DEFAULT 0;
DEFINE FIELD memory_type ON memory_node TYPE string;
DEFINE FIELD source ON memory_node TYPE string;
DEFINE FIELD metadata ON memory_node TYPE object;

-- Vector index for similarity search
DEFINE INDEX memory_embedding_idx ON memory_node 
    FIELDS embedding 
    MTREE DIMENSION 1536 
    DISTANCE COSINE;
    

Memory Edges (Graph Relations)

-- Temporal: memory A happened before memory B
DEFINE TABLE temporal_rel SCHEMAFULL TYPE RELATION;
DEFINE FIELD in ON temporal_rel TYPE record<memory_node>;
DEFINE FIELD out ON temporal_rel TYPE record<memory_node>;
DEFINE FIELD strength ON temporal_rel TYPE float DEFAULT 1.0;

-- Semantic: memory A is related to memory B
DEFINE TABLE semantic_rel SCHEMAFULL TYPE RELATION;
DEFINE FIELD in ON semantic_rel TYPE record<memory_node>;
DEFINE FIELD out ON semantic_rel TYPE record<memory_node>;
DEFINE FIELD relation_type ON semantic_rel TYPE string;
DEFINE FIELD strength ON semantic_rel TYPE float;

-- Causal: memory A caused/led to memory B
DEFINE TABLE causal_rel SCHEMAFULL TYPE RELATION;
DEFINE FIELD in ON causal_rel TYPE record<memory_node>;
DEFINE FIELD out ON causal_rel TYPE record<memory_node>;
DEFINE FIELD confidence ON causal_rel TYPE float;
    

Full-Text Search Index

DEFINE ANALYZER memory_analyzer 
    TOKENIZERS class, camel 
    FILTERS lowercase, snowball(english);

DEFINE INDEX memory_content_search ON memory_node 
    FIELDS content 
    SEARCH ANALYZER memory_analyzer 
    BM25;
    

5. Query Patterns

Pattern 1: Pure Vector Similarity

-- Find memories semantically similar to query embedding
SELECT *, vector::similarity::cosine(embedding, $query_vector) as similarity
FROM memory_node
WHERE embedding <|10|> $query_vector
ORDER BY similarity DESC;
    

Pattern 2: Graph Traversal

-- Find all memories temporally connected to a specific memory
SELECT * FROM memory_node:specific_id
    ->temporal_rel->memory_node
    ->temporal_rel->memory_node;

-- Find memories related through any path
SELECT * FROM memory_node:start_id
    ->*->memory_node
    WHERE importance > 0.7;
    

Pattern 3: Hybrid (Vector + Graph)

-- Find similar memories, then traverse their connections
LET $similar = (
    SELECT id FROM memory_node
    WHERE embedding <|5|> $query_vector
);

-- Get the similar nodes plus their connected memories
SELECT *, 
    vector::similarity::cosine(embedding, $query_vector) as similarity
FROM $similar
    ->semantic_rel->memory_node
    OR id IN $similar.id
ORDER BY importance * similarity DESC
LIMIT 20;
    

Pattern 4: Importance-Weighted Recall

-- Boost memories that are both similar AND important
SELECT *, 
    vector::similarity::cosine(embedding, $query_vector) * importance as score
FROM memory_node
WHERE embedding <|20|> $query_vector
ORDER BY score DESC
LIMIT 10;
    

Pattern 5: Temporal Context Window

-- Get memories around a specific time, connected by temporal edges
SELECT * FROM memory_node
WHERE created_at > $start_time AND created_at < $end_time
    OR id IN (
        SELECT VALUE out FROM temporal_rel 
        WHERE in = $anchor_memory
    )
ORDER BY created_at;
    

6. Integration Strategy

Option A: Direct SurrealDB Integration (Recommended)

Option B: Hybrid (SurrealDB + File Cache)

Python SDK Example

from surrealdb import Surreal
import openai

class GraphMemory:
    def __init__(self, db_url="ws://localhost:8000"):
        self.db = Surreal(db_url)
        self.db.signin({"user": "root", "pass": "root"})
        self.db.use("agent", "memory")
    
    async def store(self, content: str, memory_type: str = "observation"):
        # Generate embedding
        embedding = await self._embed(content)
        
        # Create memory node
        memory = await self.db.create("memory_node", {
            "content": content,
            "embedding": embedding,
            "memory_type": memory_type,
            "importance": 0.5,
            "created_at": "time::now()"
        })
        
        # Link to recent memories
        await self._create_temporal_links(memory[0]["id"])
        return memory[0]
    
    async def recall(self, query: str, limit: int = 10):
        embedding = await self._embed(query)
        
        # Hybrid: vector search + graph expansion
        results = await self.db.query("""
            LET $similar = (
                SELECT id FROM memory_node 
                WHERE embedding <|5|> $embedding
            );
            SELECT *, vector::similarity::cosine(embedding, $embedding) as sim 
            FROM $similar->semantic_rel->memory_node OR id IN $similar.id
            ORDER BY importance * sim DESC
            LIMIT $limit
        """, {"embedding": embedding, "limit": limit})
        
        return results
    
    async def _embed(self, text: str) -> list:
        response = await openai.embeddings.create(
            model="text-embedding-3-small",
            input=text
        )
        return response.data[0].embedding
    

7. Comparison with Neo4j GraphRAG

8. Recommendations

Migration Path

1. Phase 1: Keep current file-based memory for working context
2. Phase 2: Add SurrealDB for long-term memory persistence
3. Phase 3: Migrate retrieval logic to hybrid (vector + graph)
4. Phase 4: Add importance decay and memory consolidation

Risk Assessment