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

In this tutorial, we are going to you by preparing a robot that works at full capacity in Google Colab that takes advantage of the Antholbroid Claude model alongside MEM0 to remind smooth memory. The combination of a government coincidence of the intuitive machine in Langgraph with the Mem0 Memory Store will enable our assistant to remember previous conversations, recover related details on demand, and maintain normal continuity through sessions. Whether you are building robots support, apparent assistants or interactive offers, this guide will provide you with a strong institution for artificial intelligence experiences that depend on memory.

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

First, we install and upgrade Langgraph, Mem0 AI, Langchain client with anthropophy connection, and the basic SDK, ensuring that we have all the latest libraries required to build a memory -based Chatbot in Google Colab. It will operate in advance to avoid dependency problems and simplify the preparation process.

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 combine our Colab Chatbot basic building blocks: It downloads the API operating system interface, written Python Python and explanatory comments facilities to determine Mediats chapters, Wanggraph, Decorarators of theses, Mem0 Flow, Mem0’s Flows Flow.

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

We have securely achieved the Antarbur and MEM0 reliance data in the environment and a local variable, ensuring that the great customer and Mem0 memory store can properly ratify without sensitive keys to solid coding during our notebook. Centrality of our application programming interface keys here, we maintain a clean season between the code and secrets while enabling smooth access to the Claude model and the ongoing memory layer.

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)

Convertational Ai Core: First, it creates a common counter -forming to speak with Claude 3.5 Sonnet at zero temperature for inevitable responses and up to 1024 icons for each response, using our human key stored for ratification. Then it revolves around the Mem0 Memoryclient using the Mem0 API key, giving our BOT a memory store on the vector to save and recover the previous reactions smoothly.

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 conversation status scheme and we receive it to the Langgraph Condition: tracking Typeeddict Case Register and MEM0 user identifier, and Graph = steagraph (status) prepare a flow control unit. Inside Chatbot, the latest user message is used to inquire about the MEM0 for relevant memories, an improved system is created for the context, Claude replies, and the new exchange is saved again to the MEM0 before the assistant response.

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

We connect our Chatbot function to the Langgraph implementation flow by registering it as a knot called “Chatbot”, then connecting the starting starting mark with this knot. Thus, the conversation begins there, and finally it creates a self -edge, so every new user message re -introduces the same logic. Call Graph.comPile () and then converts this setting and knots into an improved graphic object that can be run that will run each turn of the chat session automatically.

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 connect everything together by selecting Run_conversion, which pacates our user inserted in the Langgraph case, and it appears through the translated chart to call the Chatbot node, and print Claude’s response. The __main__ goalkeeper then launches a simple replacement loop, which prompted us to write the messages and direct them through the graph that supports our memory, and gracefully exit when we enter “exit”.

In conclusion, we collected the Conversation Amnesty International Pipeline combining the Anthropor’s advanced model with the MEM0 continuous memory capabilities, all of which were organized via Langgraph in Google Colab. This architecture allows us to remember the user’s details, adapting responses over time, and provide personal support. From here, consider the experience of a richer strategies for memory, drafting Claude’s claims, or combining additional tools into your chart.

Payment Clap notebook here. All the credit for this research goes to researchers in this project. Also, do not hesitate to follow us twitter And do not forget to join 95K+ ML Subreddit.

Here is a brief overview of what we build in Marktechpost: