Skip to main content

​
Installation

pip install langchain-engram

​
EngramRetriever

Drop Engram into any LangChain chain as a retriever: 
from langchain_engram import EngramRetriever
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

retriever = EngramRetriever(
    api_key="mk_your_key",
    agent_id="user-123",
    base_url="http://localhost:8080",
    top_k=10,
)

chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o"),
    retriever=retriever,
)

response = chain.invoke("What does this user prefer in terms of communication style?")

​
Storing memories from conversations

After each conversation turn, extract and store relevant memories: 
from engram import Engram

client = Engram(base_url="http://localhost:8080", api_key="mk_your_key")

# Extract memories from a conversation
conversation = [
    {"role": "user", "content": "I've been learning Rust for the past 6 months and I'm really enjoying it"},
    {"role": "assistant", "content": "That's great! Rust has a steep learning curve but the performance benefits are worth it."},
    {"role": "user", "content": "Yeah, I especially like how it handles memory without garbage collection"},
]

extracted = client.memories.extract(
    agent_id="user-123",
    conversation=conversation,
    auto_store=True,  # automatically stores extracted memories
)

for memory in extracted:
    print(f"Stored: {memory.content} (confidence: {memory.confidence:.2f})")

​
Full agent example

from langchain_engram import EngramRetriever
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI
from engram import Engram
from langchain_core.messages import HumanMessage, AIMessage

client = Engram(base_url="http://localhost:8080", api_key="mk_your_key")
agent_id = "user-123"

retriever = EngramRetriever(
    api_key="mk_your_key",
    agent_id=agent_id,
    base_url="http://localhost:8080",
    top_k=8,
)

llm = ChatOpenAI(model="gpt-4o-mini")

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a helpful assistant with memory of past conversations.
    
Relevant memories about this user:
{context}

Use these memories to personalise your responses."""),
    MessagesPlaceholder("chat_history"),
    ("human", "{input}"),
])


def chat(user_input: str, history: list) -> str:
    # Recall relevant memories
    memories = retriever.invoke(user_input)
    context = "\n".join([f"- {m.page_content}" for m in memories])

    # Generate response
    chain = prompt | llm
    response = chain.invoke({
        "context": context,
        "chat_history": history,
        "input": user_input,
    })

    # Store the conversation turn as a memory
    client.memories.extract(
        agent_id=agent_id,
        conversation=[
            {"role": "user", "content": user_input},
            {"role": "assistant", "content": response.content},
        ],
        auto_store=True,
    )

    return response.content


# Usage
history = []
while True:
    user_input = input("You: ")
    response = chat(user_input, history)
    print(f"Agent: {response}")
    history.extend([HumanMessage(user_input), AIMessage(response)])

​
Configuration options

EngramRetriever(
    api_key="mk_...",
    agent_id="user-123",
    base_url="http://localhost:8080",
    top_k=10,
    min_confidence=0.5,      # filter out low-confidence memories
    graph_weight=0.4,         # weight of graph traversal vs. vector search
    memory_type="preference", # filter by memory type (optional)
)