langchain-memorae

MeMorae memory and retrieval adapters for LangChain, LangGraph, and local chatbots.

What it does

langchain-memorae connects Python applications to an existing MeMorae backend with a project API key. It can save user and optionally assistant messages as sources, then retrieve relevant long-term memory context for a conversation. MeMorae controls extraction, approval, and retrieval; the package does not bypass those rules.

GitHub · PyPI

Install

python -m pip install langchain-memorae

The MeMorae backend must already be running and reachable from your application. LangChain core and the classic memory interface are installed as package dependencies. The examples have optional dependencies: python -m pip install 'langchain-memorae[examples]'.

Development install

From the repository root, install an editable copy:

python -m pip install -e integrations/langchain-memorae

Configure

Set these variables in the server environment where your chatbot runs:

Create a project API key in the MeMorae dashboard's project API key settings. Copy it when it is created or revealed, and store it in a server-side secret manager or an untracked .env file.

Quickstart

import os
from langchain_memorae import MeMoraeMemory

memory = MeMoraeMemory(
    api_key=os.environ["MEMORAE_API_KEY"],
    base_url=os.getenv("MEMORAE_BASE_URL", "http://localhost:8000"),
    subject_id=os.environ["MEMORAE_SUBJECT_ID"],
    namespace=os.getenv("MEMORAE_NAMESPACE", "default"),
)

context = memory.load_memory_variables({"input": "What food do I like?"})
print(context["history"])
memory.save_context({"input": "I love pizza"}, {"output": "Got it."})

history is a compact string containing the memories returned for the input query. Messages are submitted for asynchronous MeMorae processing. Supported facts become retrievable after extraction and indexing complete.

LangChain memory

Call load_memory_variables before generating the response, then save_context with the turn. Set save_assistant=True if assistant messages should also be submitted as sources; by default, only the user message is saved.

from langchain_memorae import MeMoraeMemory

memory = MeMoraeMemory(
    api_key=api_key,
    base_url=base_url,
    subject_id=subject_id,
    namespace=namespace,
    save_assistant=True,
)

context = memory.load_memory_variables({"input": question})["history"]
answer = chatbot.generate(question, context=context)
memory.save_context({"input": question}, {"output": answer})

Retriever

Use MeMoraeRetriever anywhere a LangChain retriever is accepted. invoke returns LangChain Document objects; each document includes memory_id, type, and available source_ids metadata.

from langchain_memorae import MeMoraeRetriever

retriever = MeMoraeRetriever(
    api_key=api_key,
    base_url=base_url,
    subject_id=subject_id,
    namespace=namespace,
)
docs = retriever.invoke("What sports do I enjoy?")

LangGraph

Use a recall node before the answer node. Pass the recalled context into the prompt, then use a save node after the answer to record the user turn. The complete runnable example is in examples/langgraph_chatbot.py.

def recall(state):
    return {"history": memory.load_memory_variables({"input": state["input"]})["history"]}

def save(state):
    memory.save_context({"input": state["input"]}, {"output": state["output"]})
    return {}

Local chatbot integration

For Flask, Ollama, or another local Python chatbot, load memories for the incoming message, add the returned string to your prompt or context, generate the answer, and save the user message and (optionally) assistant answer. See examples/local_chatbot_flask.py. The ChatOpenAI example is in examples/basic_chatbot.py.

Indexing and troubleshooting

Ingestion is asynchronous. Newly submitted messages can take a few seconds to appear in retrieval. For local Docker deployments, make sure the worker and Beat services are running; the retrieval indexes also need to be available.

Security and scope

Keep MEMORAE_API_KEY on the server. Never expose it in browser JavaScript, commit .env, or print the key in logs. Use one stable subject_id per end user so their memories remain scoped to that user. Use namespace to separate memory spaces for the same subject, and pass the same subject and namespace when saving and retrieving.

clear() does not delete remote MeMorae memories. Manage remote memory lifecycle through the MeMorae dashboard and its review controls.