Python SDK

pip install memvid-sdk

import memvid_sdk as memvid
import os

# Create a new memory file
mem = memvid.create('knowledge.mv2')

# Add documents
mem.put(
    title='Meeting Notes',
    label='notes',
    metadata={'source': 'slack'},
    text='Alice mentioned she works at Anthropic...',
    enable_embedding=True
)

# Search
results = mem.find('who works at AI companies?')
print(results['hits'])

# Ask questions with AI
answer = mem.ask(
    'What does Alice do?',
    model='gpt-4o-mini',
    api_key=os.environ['OPENAI_API_KEY']
)
print(answer['text'])

# Close when done
mem.close()

import memvid_sdk as memvid

# Automatically closes when done
with memvid.use('basic', 'memory.mv2') as mem:
    mem.put(title='Doc', label='test', metadata={}, text='Content')
    results = mem.find('query')

# LangChain
mem = memvid.use('langchain', 'knowledge.mv2')
retriever = mem.as_retriever()

# LlamaIndex
mem = memvid.use('llamaindex', 'knowledge.mv2')
query_engine = mem.as_query_engine()

# CrewAI
mem = memvid.use('crewai', 'knowledge.mv2')
tools = mem.tools

# AutoGen
mem = memvid.use('autogen', 'knowledge.mv2')

# Haystack
mem = memvid.use('haystack', 'knowledge.mv2')

from memvid_sdk.embeddings import (
    OpenAIEmbeddings,
    GeminiEmbeddings,
    MistralEmbeddings,
    CohereEmbeddings,
    VoyageEmbeddings,
    NvidiaEmbeddings,
    LOCAL_EMBEDDING_MODELS
)
import os

# OpenAI
openai = OpenAIEmbeddings(api_key=os.environ['OPENAI_API_KEY'])

# Gemini
gemini = GeminiEmbeddings(api_key=os.environ['GEMINI_API_KEY'])

# Mistral
mistral = MistralEmbeddings(api_key=os.environ['MISTRAL_API_KEY'])

# Local models (no API required)
mem.put(
    title='Doc',
    label='test',
    metadata={},
    text='Content',
    enable_embedding=True,
    embedding_model=LOCAL_EMBEDDING_MODELS['BGE_SMALL']
)

# Extract facts using rules engine
result = mem.enrich('rules')

# View extracted cards
cards = mem.memories()
print(f"Extracted {cards['count']} memory cards")

# Get entity state (O(1) lookup)
alice = mem.state('Alice')
print(alice['slots'])
# {'employer': 'Anthropic', 'role': 'Engineer'}

# Add memory cards manually
mem.add_memory_cards([
    {'entity': 'Alice', 'slot': 'employer', 'value': 'Anthropic'},
    {'entity': 'Bob', 'slot': 'team', 'value': 'Infrastructure'}
])

# Start recording session
session_id = mem.session_start("Debug Session")

# Perform operations (all recorded)
mem.put(title="Meeting Notes", label="notes", metadata={}, text="Discussed Q4...")
results = mem.find("roadmap", k=5)

# Add checkpoints at key moments
mem.session_checkpoint()

# End session
summary = mem.session_end()
print(f"Recorded {summary['action_count']} actions")

# Replay with different parameters
replay_result = mem.session_replay(
    session_id,
    adaptive=True,
    top_k=20
)
print(f"Match rate: {replay_result['match_rate']:.1%}")

# Delete session when done
mem.session_delete(session_id)

from memvid_sdk import (
    CapacityExceededError,
    LockedError,
    VecDimensionMismatchError,
    EmbeddingFailedError,
    MemvidError
)

try:
    mem.put(title='Doc', label='test', metadata={}, text='Content')
except CapacityExceededError:
    print('Storage limit reached')
except LockedError:
    print('File locked by another process')
except VecDimensionMismatchError:
    print('Embedding dimension mismatch')
except EmbeddingFailedError:
    print('Embedding generation failed')
except MemvidError as e:
    print(f'Error [{e.code}]: {e.message}')

from typing import Dict, Any

def process_memory(path: str) -> Dict[str, Any]:
    mem = memvid.use('basic', path)
    results: Dict[str, Any] = mem.find('query')
    return results