Knowledge Graph Memory

The core data model is a labeled property graph or RDF triple store. Information is decomposed into discrete entities (nodes) and relationships (edges), each with associated properties.

• Nodes represent objects, concepts, or events (e.g., Person:Alice, Product:ModelX, Event:Meeting_2024-03-15).
• Edges define typed connections (e.g., WORKS_FOR, HAS_FEATURE, ATTENDED_BY).
• This explicit structure allows for deterministic traversal and querying using languages like Cypher or SPARQL, enabling precise answers to relational questions like "Who reports to the CTO?"

Unlike vector stores that rely on statistical similarity, knowledge graphs support symbolic reasoning. The graph's structure allows for:

• Multi-hop inference: Traversing multiple edges to deduce new facts (e.g., Alice → WORKS_FOR → DeptA → MANAGED_BY → Bob implies Alice's indirect manager is Bob).
• Rule-based deduction: Applying logical rules (e.g., If X IS_A Mammal THEN X IS_A Animal) to infer new relationships.
• Path-based queries: Finding all connections between two entities, revealing latent relationships. This provides explainability, as the reasoning chain is the explicit path through the graph.

Modern implementations are often hybrid, combining symbolic graphs with vector embeddings.

• Node/Edge Embeddings: Entities and relationships can be encoded into dense vectors using models like TransE or node2vec, enabling similarity search within the graph structure.
• Dual-Phase Retrieval: A query first retrieves candidate sub-graphs via symbolic patterns, then uses vector similarity to rank or refine results based on semantic context.
• This combines the precision of graph traversal with the flexibility of semantic search for ambiguous or natural language queries.

Knowledge Graph Memory typically employs a flexible, evolving ontology—a formal specification of concepts, relationships, and constraints.

• Schema-on-Write vs. Schema-on-Read: While an ontology provides structure, many graph databases allow for dynamic addition of new node and relationship types without costly schema migrations.
• Taxonomic Reasoning: Hierarchical relationships (IS_A, PART_OF) enable inheritance of properties. Knowing ModelX IS_A ElectricVehicle allows inference that it HAS a Battery.
• This makes the memory adaptable to new domains and information types encountered by an agent during its operation.

Effective agent memory must capture when facts are true and under what context. Knowledge graphs support this through:

• Temporal Edges/Properties: Relationships can be annotated with validity intervals (valid_from, valid_to) or event timestamps.
• Versioned Subgraphs: Snapshots of the graph state can be stored, allowing the agent to reason about past states or track the provenance of information.
• Context Nodes: Specific situations, sessions, or environments can be modeled as nodes, with facts linked to them. This isolates knowledge relevant to a particular task or user session.

Knowledge Graph Memory is foundational for complex enterprise agentic systems.

• Use Cases: Drug discovery (mapping protein interactions), fraud detection (linking entities in transaction networks), supply chain reasoning (modeling part dependencies), and customer 360 profiles.
• Enabling Technologies: Graph databases like Neo4j, Amazon Neptune, TigerGraph, and JanusGraph provide the storage and query engines. Frameworks like LangChain and LlamaIndex offer abstractions for integrating graphs with LLM agents.
• This architecture moves agents from simple chat responders to systems capable of deep, audit-trail reasoning over organizational knowledge.

A memory storage system that represents information as high-dimensional vectors (embeddings) to enable efficient similarity-based search and retrieval. It is the primary complement to Knowledge Graph Memory, handling unstructured semantic search.

• Core Function: Stores text, images, or other data as dense vectors in a high-dimensional space.
• Retrieval Mechanism: Uses approximate nearest neighbor (ANN) search to find vectors similar to a query embedding.
• Typical Use Case: Powering the initial recall of relevant documents or facts before a knowledge graph performs structured reasoning on the retrieved content.
• Example Technology: Pinecone, Weaviate, or pgvector.

A short-term, high-speed memory component that temporarily holds and manipulates information relevant to the current task or cognitive operation. It acts as the agent's conscious 'scratchpad'.

• Analogy: Similar to a CPU's L1/L2 cache or human working memory.
• Key Characteristics: Volatile, limited capacity, fast access.
• Primary Role: Maintains the immediate context of a conversation, the steps of a plan in execution, or intermediate reasoning results.
• Interaction with Knowledge Graph: The working buffer holds the specific entities and relationships being actively reasoned about, which are often fetched from the larger Knowledge Graph Memory.

A memory subsystem responsible for storing and recalling specific events, experiences, and their associated contextual details in chronological order. It provides an agent with a sense of history.

• Structure: Often implemented as a temporal sequence of events, which can be stored as a specialized graph where nodes are events and edges are temporal or causal links.
• Difference from Semantic Memory: Episodic memory is autobiographical ('I completed the API integration at 3 PM'), while semantic memory is factual ('An API is an Application Programming Interface').
• Use Case: Enabling an agent to reflect on past failures, summarize its activities over a session, or learn from historical outcomes.

A structured memory component that stores general world knowledge, facts, concepts, and their interrelationships, independent of specific personal experiences. Knowledge Graph Memory is a direct implementation of a semantic memory layer.

• Content: Encyclopedic knowledge, domain ontologies, schema definitions, and universal truths.
• Key Benefit: Enables deductive reasoning and inference. If the graph knows 'A is a B' and 'B has property C', it can infer 'A has property C'.
• Example: A graph storing that (Python)-[IS_A]->(Programming Language), (Programming Language)-[HAS_PARADIGM]->(Object-Oriented), allowing the inference that Python can be object-oriented.

The algorithms and strategies for efficiently searching and retrieving relevant information from an agent's memory systems. Effective retrieval is what makes memory useful.

• Hybrid Search: Combines dense vector search (from a Vector Store) for semantic similarity with sparse keyword search for exact term matching and graph traversal (from a Knowledge Graph) for relational reasoning.
• Query Planning: The process of decomposing a user's question into sub-queries best suited for different memory backends (e.g., vector search for 'documents about neural networks', graph traversal for 'authors who cited this paper').
• Reranking: Post-processing initial retrieval results using a cross-encoder or other model to improve final relevance.

A machine learning framework and memory model, inspired by the neocortex, that uses hierarchical networks of nodes to learn spatial and temporal patterns from streaming data. It represents a biologically-inspired approach to sequence memory.

• Core Idea: Neurons are arranged in columns; active columns represent the current input, and predictive columns represent expected future input.
• Key Strength: Excels at anomaly detection and sequence prediction on continuous, real-time data streams.
• Contrast with Knowledge Graph Memory: While HTM is superb for unsupervised temporal pattern learning, Knowledge Graph Memory is designed for explicit, symbolic representation of entities and relationships for logical reasoning. They can be complementary systems.