Knowledge Graph AI Memory: Build Smart Memory Networks for AI

Want to upgrade from flat text storage to intelligent knowledge graphs? This guide compares Graphiti, Neo4j, and SQLite approaches for AI memory - with code examples and tool recommendations.

Why Knowledge Graphs for AI Memory?

Traditional text storage has limitations:

• ❌ No relationship understanding ("User prefers X" vs "User discussed X with Y")
• ❌ Limited semantic search (keyword matching only)
• ❌ Flat structure (no hierarchy or connections)

Knowledge graph advantages:

• ✅ Entity relationships ("User prefers Python")
• ✅ Semantic reasoning ("If user likes A, they might like B")
• ✅ Graph traversal (find all related memories)
• ✅ Smarter context injection (inject related entities, not just keywords)

Approach 1: Graphiti + Neo4j (Advanced)

Graphiti is a Python framework for building AI agent memory as knowledge graphs.Neo4j is the leading graph database.

# Graphiti + Neo4j example
from graphiti import Graphiti, Entity, Relationship

# Create knowledge graph
graph = Graphiti(neo4j_uri="neo4j+s://...")

# Add entity (User preference)
user = Entity(type="User", name="Alice", properties={"role": "developer"})
graph.add_entity(user)

# Add relationship (User prefers Python)
rel = Relationship(source=user, type="PREFERS", target="Python")
graph.add_relationship(rel)

# Query: Find all technologies user prefers
results = graph.query("""
  MATCH (u:User)-[:PREFERS]->(tech)
  WHERE u.name = "Alice"
  RETURN tech.name
""")

Pros: True graph database, Advanced querying (Cypher), Temporal reasoning, Enterprise-ready.

Cons: Requires Neo4j hosting (costly), Steep learning curve, Overkill for simple memory needs.

Approach 2: AI Memory (SQLite FTS5)

AI Memory uses SQLite with FTS5 (Full-Text Search) to provide graph-like capabilities without the complexity of a graph database.

Why choose SQLite over Neo4j?

• ✅ Zero setup (SQLite is built-in)
• ✅ Fast full-text search (FTS5 is highly optimized)
• ✅ File-based (easy backup, sync, deploy)
• ✅ Sufficient for 95% of AI memory use cases

Approach 3: MemPalace (Open Source)

MemPalace is an open-source Python tool that builds AI memory as knowledge graphs.

Building a Simple Knowledge Graph (No Neo4j)

You can build graph-like memory structures using SQLite and JSON.

import sqlite3
import json

conn = sqlite3.connect('memory_graph.db')

# Create table with JSON entities
conn.execute('''
  CREATE TABLE memories (
    id INTEGER PRIMARY KEY,
    content TEXT,
    entities TEXT,  -- JSON col
    related_to INTEGER
  )
''')

# Save memory with entity extraction
memory = {
    "content": "Alice prefers Python",
    "entities": json.dumps({
        "people": ["Alice"],
        "topics": ["Python", "data science"],
        "preferences": ["Python"]
    }),
    "related_to": None
}
conn.execute('INSERT INTO memories (content, entities, related_to) VALUES (?, ?, ?)',
             (memory['content'], memory['entities'], memory['related_to']))
conn.commit()

Visualizing Knowledge Graphs

When to Use Knowledge Graphs

FAQ