Skip to content

README.md

Latest commit

 

History

History
252 lines (189 loc) · 6.75 KB

README.md

File metadata and controls

252 lines (189 loc) · 6.75 KB
Raw

MemoryGraph SDK

Python SDK for MemoryGraph - the graph-based memory layer for AI agents.

Installation

pip install memorygraphsdk

With framework integrations:

# LlamaIndex integration
pip install memorygraphsdk[llamaindex]

# LangChain integration
pip install memorygraphsdk[langchain]

# CrewAI integration
pip install memorygraphsdk[crewai]

# AutoGen integration
pip install memorygraphsdk[autogen]

# All integrations
pip install memorygraphsdk[all]

Quick Start

from memorygraphsdk import MemoryGraphClient

# Initialize client (api_key can also be set via MEMORYGRAPH_API_KEY env var)
client = MemoryGraphClient(api_key="mgraph_your_key_here")

# Create a memory
memory = client.create_memory(
    type="solution",
    title="Fixed Redis timeout issue",
    content="Used exponential backoff with max 5 retries. Key was setting proper timeout values.",
    tags=["redis", "timeout", "solution"],
    importance=0.8
)
print(f"Created memory: {memory.id}")

# Search memories
results = client.search_memories(query="redis timeout", limit=10)
for mem in results:
    print(f"- {mem.title}: {mem.content[:100]}...")

# Create relationships
client.create_relationship(
    from_memory_id=solution_id,
    to_memory_id=problem_id,
    relationship_type="SOLVES"
)

# Get related memories
related = client.get_related_memories(
    memory_id=problem_id,
    relationship_types=["SOLVES"]
)

Async Client

from memorygraphsdk import AsyncMemoryGraphClient

async with AsyncMemoryGraphClient(api_key="mgraph_...") as client:
    memory = await client.create_memory(
        type="solution",
        title="Async solution",
        content="..."
    )

    memories = await client.search_memories(query="async")

Framework Integrations

LlamaIndex

from memorygraphsdk.integrations.llamaindex import MemoryGraphChatMemory
from llama_index.core.chat_engine import SimpleChatEngine

memory = MemoryGraphChatMemory(api_key="mgraph_...")
chat_engine = SimpleChatEngine.from_defaults(memory=memory)

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

LangChain

from memorygraphsdk.integrations.langchain import MemoryGraphMemory
from langchain.chains import ConversationChain

memory = MemoryGraphMemory(api_key="mgraph_...")
chain = ConversationChain(memory=memory, llm=llm)

response = chain.run("What Redis issues have we seen?")

CrewAI

from memorygraphsdk.integrations.crewai import MemoryGraphCrewMemory
from crewai import Agent

memory = MemoryGraphCrewMemory(api_key="mgraph_...")
agent = Agent(
    role="Developer",
    goal="Solve technical problems",
    memory=memory
)

API Reference

MemoryGraphClient

Method Description
create_memory(...) Create a new memory
get_memory(id) Get memory by ID
update_memory(id, ...) Update a memory
delete_memory(id) Delete a memory
search_memories(...) Search for memories
recall_memories(query) Natural language recall
create_relationship(...) Create relationship
get_related_memories(id) Get related memories

Memory Types

  • task - Tasks and todos
  • solution - Solutions to problems
  • problem - Problems encountered
  • error - Errors and exceptions
  • fix - Bug fixes
  • code_pattern - Code patterns
  • workflow - Workflows and processes
  • conversation - Chat/conversation messages (used by integrations)
  • general - General information

Relationship Types

  • SOLVES - Solution → Problem
  • CAUSES - Cause → Effect
  • TRIGGERS - Trigger → Event
  • REQUIRES - Dependent → Dependency
  • RELATED_TO - General association

Configuration

Environment variables:

export MEMORYGRAPH_API_KEY="mgraph_..."
export MEMORYGRAPH_API_URL="https://api.memorygraph.dev"  # optional

Or in code:

client = MemoryGraphClient(
    api_key="mgraph_...",
    api_url="https://api.memorygraph.dev",
    timeout=30.0
)

Error Handling

from memorygraphsdk import (
    MemoryGraphClient,
    AuthenticationError,
    RateLimitError,
    NotFoundError
)

try:
    memory = client.get_memory("invalid-id")
except AuthenticationError:
    print("Invalid API key")
except NotFoundError:
    print("Memory not found")
except RateLimitError:
    print("Rate limit exceeded, please retry")

Model Synchronization

The SDK models are kept in sync with the core memorygraph models. Key types:

MemoryType (13 types)

task, code_pattern, problem, solution, project, technology, error, fix, command, file_context, workflow, general, conversation

RelationshipType (35 types)

All relationship types from core are available in SDK, organized into categories:

  • Causal: CAUSES, TRIGGERS, LEADS_TO, PREVENTS, BREAKS
  • Solution: SOLVES, ADDRESSES, ALTERNATIVE_TO, IMPROVES, REPLACES
  • Context: OCCURS_IN, APPLIES_TO, WORKS_WITH, REQUIRES, USED_IN
  • Learning: BUILDS_ON, CONTRADICTS, CONFIRMS, GENERALIZES, SPECIALIZES
  • Similarity: SIMILAR_TO, VARIANT_OF, RELATED_TO, ANALOGY_TO, OPPOSITE_OF
  • Workflow: FOLLOWS, DEPENDS_ON, ENABLES, BLOCKS, PARALLEL_TO
  • Quality: EFFECTIVE_FOR, INEFFECTIVE_FOR, PREFERRED_OVER, DEPRECATED_BY, VALIDATED_BY

Bi-temporal Fields

The SDK Relationship model includes optional bi-temporal tracking fields:

  • valid_from: When the relationship became valid
  • valid_until: When the relationship expires
  • recorded_at: When the relationship was recorded
  • invalidated_by: ID of memory that invalidated this relationship

See tests/test_model_sync.py for automated sync verification.

Documentation

Features

  • Synchronous and Async - Full async/await support for high-performance applications
  • Type-Safe - Complete type hints and Pydantic models
  • Framework Integrations - Native support for LlamaIndex, LangChain, CrewAI, and AutoGen
  • Graph-Based - Relationships between memories for complex reasoning
  • Search & Recall - Powerful search with natural language queries
  • Error Handling - Comprehensive exception handling with specific error types

Get API Key

Sign up at memorygraph.dev to get your API key.

Support

License

Apache 2.0