A Coding Guide to Unlock mem0 Memory for Anthropic Claude Bot: Enabling Context-Rich Conversations

In this tutorial, we walk you through setting up a fully functional bot in Google Colab that leverages Anthropic’s Claude model alongside mem0 for seamless memory recall. Combining LangGraph’s intuitive state-machine orchestration with mem0’s powerful vector-based memory store will empower our assistant to remember past conversations, retrieve relevant details on demand, and maintain natural continuity across sessions. Whether you’re building support bots, virtual assistants, or interactive demos, this guide will equip you with a robust foundation for memory-driven AI experiences.

Copy Code

!pip install -qU langgraph mem0ai langchain langchain-anthropic anthropic

First, we install and upgrade LangGraph, the Mem0 AI client, LangChain with its Anthropic connector, and the core Anthropic SDK, ensuring we have all the latest libraries required for building a memory-driven Claude chatbot in Google Colab. Running it upfront will avoid dependency issues and streamline the setup process.

Copy Code

import os
from typing import Annotated, TypedDict, List


from langgraph.graph import StateGraph, START
from langgraph.graph.message import add_messages
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
from langchain_anthropic import ChatAnthropic
from mem0 import MemoryClient

We bring together the core building blocks for our Colab chatbot: it loads the operating-system interface for API keys, Python’s typed dictionaries and annotation utilities for defining conversational state, LangGraph’s graph and message decorators to orchestrate chat flow, LangChain’s message classes for constructing prompts, the ChatAnthropic wrapper to call Claude, and Mem0’s client for persistent memory storage.

Copy Code

os.environ["ANTHROPIC_API_KEY"] = "Use Your Own API Key"
MEM0_API_KEY = "Use Your Own API Key"

We securely inject our Anthropic and Mem0 credentials into the environment and a local variable, ensuring that the ChatAnthropic client and Mem0 memory store can authenticate properly without hard-coding sensitive keys throughout our notebook. Centralizing our API keys here, we maintain a clean separation between code and secrets while enabling seamless access to the Claude model and persistent memory layer.

Copy Code

llm = ChatAnthropic(
    model="claude-3-5-haiku-latest",
    temperature=0.0,
    max_tokens=1024,
    anthropic_api_key=os.environ["ANTHROPIC_API_KEY"]
)
mem0 = MemoryClient(api_key=MEM0_API_KEY)

We initialize our conversational AI core: first, it creates a ChatAnthropic instance configured to talk with Claude 3.5 Sonnet at zero temperature for deterministic replies and up to 1024 tokens per response, using our stored Anthropic key for authentication. Then it spins up a Mem0 MemoryClient with our Mem0 API key, giving our bot a persistent vector-based memory store to save and retrieve past interactions seamlessly.

Copy Code

class State(TypedDict):
    messages: Annotated[List[HumanMessage | AIMessage], add_messages]
    mem0_user_id: str


graph = StateGraph(State)


def chatbot(state: State):
    messages = state["messages"]
    user_id = state["mem0_user_id"]


    memories = mem0.search(messages[-1].content, user_id=user_id)


    context = "n".join(f"- {m['memory']}" for m in memories)
    system_message = SystemMessage(content=(
        "You are a helpful customer support assistant. "
        "Use the context below to personalize your answers:n" + context
    ))


    full_msgs = [system_message] + messages
    ai_resp: AIMessage = llm.invoke(full_msgs)


    mem0.add(
        f"User: {messages[-1].content}nAssistant: {ai_resp.content}",
        user_id=user_id
    )


    return {"messages": [ai_resp]}

We define the conversational state schema and wire it into a LangGraph state machine: the State TypedDict tracks the message history and a Mem0 user ID, and graph = StateGraph(State) sets up the flow controller. Within the chatbot, the most recent user message is used to query Mem0 for relevant memories, a context-enhanced system prompt is constructed, Claude generates a reply, and that new exchange is saved back into Mem0 before returning the assistant’s response.

Copy Code

graph.add_node("chatbot", chatbot)
graph.add_edge(START, "chatbot")
graph.add_edge("chatbot", "chatbot")
compiled_graph = graph.compile()

We plug our chatbot function into LangGraph’s execution flow by registering it as a node named “chatbot,” then connecting the built-in START marker to that node. Hence, the conversation begins there, and finally creates a self-loop edge so each new user message re-enters the same logic. Calling graph.compile() then transforms this node-and-edge setup into an optimized, runnable graph object that will manage each turn of our chat session automatically.

Copy Code

def run_conversation(user_input: str, mem0_user_id: str):
    config = {"configurable": {"thread_id": mem0_user_id}}
    state = {"messages": [HumanMessage(content=user_input)], "mem0_user_id": mem0_user_id}
    for event in compiled_graph.stream(state, config):
        for node_output in event.values():
            if node_output.get("messages"):
                print("Assistant:", node_output["messages"][-1].content)
                return


if __name__ == "__main__":
    print("Welcome! (type 'exit' to quit)")
    mem0_user_id = "customer_123"
    while True:
        user_in = input("You: ")
        if user_in.lower() in ["exit", "quit", "bye"]:
            print("Assistant: Goodbye!")
            break
        run_conversation(user_in, mem0_user_id)

We tie everything together by defining run_conversation, which packages our user input into the LangGraph state, streams it through the compiled graph to invoke the chatbot node, and prints out Claude’s reply. The __main__ guard then launches a simple REPL loop, prompting us to type messages, routing them through our memory-enabled graph, and gracefully exiting when we enter “exit”.

In conclusion, we’ve assembled a conversational AI pipeline that combines Anthropic’s cutting-edge Claude model with mem0’s persistent memory capabilities, all orchestrated via LangGraph in Google Colab. This architecture allows our bot to recall user-specific details, adapt responses over time, and deliver personalized support. From here, consider experimenting with richer memory-retrieval strategies, fine-tuning Claude’s prompts, or integrating additional tools into your graph.

Check out Colab Notebook here. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 95k+ ML SubReddit.

Here’s a brief overview of what we’re building at Marktechpost: