Complete guide for using MemoryGraph with LlamaIndex for RAG pipelines and chat applications.

Installation

pip install memorygraphsdk[llamaindex]

This installs both memorygraphsdk and llama-index-core.

Overview

The MemoryGraph SDK provides two main integrations for LlamaIndex:

• MemoryGraphChatMemory - For chat engines with persistent memory
• MemoryGraphRetriever - For RAG pipelines using memories as knowledge base

Quick Start: Chat Memory

from memorygraphsdk.integrations.llamaindex import MemoryGraphChatMemory
from llama_index.core.chat_engine import SimpleChatEngine
from llama_index.core import Settings
from llama_index.llms.openai import OpenAI

# Configure LlamaIndex
Settings.llm = OpenAI(model="gpt-4", temperature=0.7)

# Create memory with session isolation
memory = MemoryGraphChatMemory(
    api_key="mg_your_key_here",
    session_id="user_123"  # Optional: isolate conversations
)

# Create chat engine with memory
chat_engine = SimpleChatEngine.from_defaults(memory=memory)

# Have a conversation
response = chat_engine.chat("I'm working on a Redis timeout issue")
print(response)

# Memory persists - retrieve in next session
response = chat_engine.chat("What was I working on?")
print(response)  # Remembers Redis timeout!

MemoryGraphChatMemory API

Constructor

MemoryGraphChatMemory(
    api_key: str,
    session_id: str = "default",
    memory_key: str = "chat_history",
    return_messages: bool = True
)

Methods

# Retrieve relevant memories for the input
messages = memory.get(input="Redis timeout")

# Store a message in memory
memory.put({
    "role": "user",
    "content": "How do I fix Redis timeouts?"
})

# Replace all messages in current session
memory.set_messages([
    {"role": "system", "content": "You are a helpful assistant"},
    {"role": "user", "content": "Hello"}
])

# Reset memory (no-op - memories are permanent)
memory.reset()

Multi-Session Chat Application

from memorygraphsdk.integrations.llamaindex import MemoryGraphChatMemory
from llama_index.core.chat_engine import SimpleChatEngine
from llama_index.core import Settings
from llama_index.llms.openai import OpenAI

Settings.llm = OpenAI(model="gpt-4")

def create_chat_for_user(user_id: str):
    """Create a chat engine with user-specific memory."""
    memory = MemoryGraphChatMemory(
        api_key="mg_...",
        session_id=f"user_{user_id}"
    )
    return SimpleChatEngine.from_defaults(memory=memory)

# User 1's conversation
chat1 = create_chat_for_user("alice")
chat1.chat("I'm debugging a Redis issue")

# User 2's conversation (isolated)
chat2 = create_chat_for_user("bob")
chat2.chat("I'm optimizing SQL queries")

# Later - memories are preserved
chat1_new = create_chat_for_user("alice")
response = chat1_new.chat("What was I debugging?")
# Response: "You were debugging a Redis issue"

MemoryGraphRetriever API

Use MemoryGraph as a knowledge base for RAG pipelines.

Constructor

MemoryGraphRetriever(
    api_key: str,
    memory_types: list[str] | None = None,
    min_importance: float = 0.0,
    limit: int = 5
)

Usage

from memorygraphsdk.integrations.llamaindex import MemoryGraphRetriever
from llama_index.core.query_engine import RetrieverQueryEngine

# Create retriever
memory_retriever = MemoryGraphRetriever(
    api_key="mg_...",
    memory_types=["solution", "fix", "code_pattern"],
    min_importance=0.7,
    limit=5
)

# Use in query engine
query_engine = RetrieverQueryEngine.from_args(
    retriever=memory_retriever,
    verbose=True
)

# Query using memories as knowledge base
response = query_engine.query("What's the best way to handle Redis timeouts?")
print(response)

Hybrid Search: Documents + Memories

from memorygraphsdk.integrations.llamaindex import MemoryGraphRetriever
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.retrievers import QueryFusionRetriever

# Load documents
documents = SimpleDirectoryReader("./docs").load_data()
doc_index = VectorStoreIndex.from_documents(documents)
doc_retriever = doc_index.as_retriever(similarity_top_k=5)

# Create memory retriever
memory_retriever = MemoryGraphRetriever(
    api_key="mg_...",
    memory_types=["solution"],
    limit=5
)

# Combine both retrievers
fusion_retriever = QueryFusionRetriever(
    retrievers=[doc_retriever, memory_retriever],
    similarity_top_k=10,
    num_queries=1
)

# Query across both sources
nodes = fusion_retriever.retrieve("Redis timeout solutions")
for node in nodes:
    print(f"- {node.text[:100]}...")

Learning Agent Pattern

Automatically store important learnings from conversations:

from memorygraphsdk import MemoryGraphClient
from memorygraphsdk.integrations.llamaindex import (
    MemoryGraphChatMemory,
    MemoryGraphRetriever
)
from llama_index.core.chat_engine import SimpleChatEngine

class LearningAgent:
    def __init__(self, api_key: str, session_id: str):
        self.client = MemoryGraphClient(api_key=api_key)
        self.session_id = session_id
        self.memory = MemoryGraphChatMemory(
            api_key=api_key,
            session_id=session_id
        )
        self.retriever = MemoryGraphRetriever(api_key=api_key)
        self.chat_engine = SimpleChatEngine.from_defaults(
            memory=self.memory
        )

    def chat(self, message: str):
        """Chat and automatically learn from important exchanges."""
        response = self.chat_engine.chat(message)

        # Extract and store important learnings
        if self._is_important(message, str(response)):
            self.client.create_memory(
                type="solution",
                title=message[:100],
                content=str(response),
                tags=self._extract_tags(message),
                importance=0.8,
                context={"session_id": self.session_id}
            )

        return response

    def recall_similar(self, query: str):
        """Recall similar past learnings."""
        return self.retriever.retrieve(query)

    def _is_important(self, message: str, response: str) -> bool:
        keywords = ["fix", "solve", "how to", "error", "issue"]
        return any(kw in message.lower() for kw in keywords)

    def _extract_tags(self, message: str) -> list[str]:
        common_tags = ["redis", "timeout", "database", "api"]
        return [tag for tag in common_tags if tag in message.lower()]

# Usage
agent = LearningAgent(api_key="mg_...", session_id="dev_session")
response = agent.chat("How do I fix Redis timeouts?")
# Important exchanges are automatically stored!

Best Practices

1. Use Session IDs for Isolation

# Good: Isolated sessions per user
memory = MemoryGraphChatMemory(
    api_key="mg_...",
    session_id=f"user_{user_id}"
)

# Avoid: Shared session for all users
memory = MemoryGraphChatMemory(api_key="mg_...")

2. Filter Memories by Type

# Retrieve only actionable memories
retriever = MemoryGraphRetriever(
    api_key="mg_...",
    memory_types=["solution", "fix", "code_pattern"],
    min_importance=0.5
)

3. Combine with Document Search

# Hybrid: Documents + Memories
fusion_retriever = QueryFusionRetriever(
    retrievers=[
        doc_retriever,      # Official documentation
        memory_retriever    # Team learnings
    ],
    similarity_top_k=10
)

Troubleshooting

Memory Not Persisting

Issue: Chat history not saved between sessions

Solution: Ensure you're using the same session_id:

# Session 1
memory1 = MemoryGraphChatMemory(
    api_key="mg_...",
    session_id="user_123"  # Use consistent ID
)

# Session 2 (later)
memory2 = MemoryGraphChatMemory(
    api_key="mg_...",
    session_id="user_123"  # Same ID
)

No Results from Retriever

Solution 1: Search all types:

retriever = MemoryGraphRetriever(
    api_key="mg_...",
    memory_types=None  # Search all types
)

Solution 2: Lower importance threshold:

retriever = MemoryGraphRetriever(
    api_key="mg_...",
    min_importance=0.0  # Include all importances
)

Next Steps

• SDK Overview
• LangChain Integration
• CrewAI Integration
• Code Examples