On this tutorial, we stroll you thru establishing a completely purposeful bot in Google Colab that leverages Anthropic’s Claude model alongside mem0 for seamless reminiscence recall. Combining LangGraph’s intuitive state-machine orchestration with mem0’s highly effective vector-based reminiscence retailer will empower our assistant to recollect previous conversations, retrieve related particulars on demand, and preserve pure continuity throughout classes. Whether or not you’re constructing help bots, digital assistants, or interactive demos, this information will equip you with a sturdy basis for memory-driven AI experiences.
!pip set up -qU langgraph mem0ai langchain langchain-anthropic anthropicFirst, we set up and improve LangGraph, the Mem0 AI shopper, LangChain with its Anthropic connector, and the core Anthropic SDK, guaranteeing we’ve got all the most recent libraries required for constructing a memory-driven Claude chatbot in Google Colab. Operating it upfront will keep away from dependency points and streamline the setup course of.
import os
from typing import Annotated, TypedDict, Listing
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 MemoryClientWe deliver collectively the core constructing blocks for our Colab chatbot: it masses the operating-system interface for API keys, Python’s typed dictionaries and annotation utilities for outlining conversational state, LangGraph’s graph and message decorators to orchestrate chat circulation, LangChain’s message courses for setting up prompts, the ChatAnthropic wrapper to name Claude, and Mem0’s shopper for persistent reminiscence storage.
os.environ["ANTHROPIC_API_KEY"] = "Use Your Personal API Key"
MEM0_API_KEY = "Use Your Personal API Key"We securely inject our Anthropic and Mem0 credentials into the atmosphere and an area variable, guaranteeing that the ChatAnthropic shopper and Mem0 reminiscence retailer can authenticate correctly with out hard-coding delicate keys all through our pocket book. Centralizing our API keys right here, we preserve a clear separation between code and secrets and techniques whereas enabling seamless entry to the Claude mannequin and protracted reminiscence layer.
llm = ChatAnthropic(
mannequin="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 occasion configured to speak with Claude 3.5 Sonnet at zero temperature for deterministic replies and as much as 1024 tokens per response, utilizing our saved Anthropic key for authentication. Then it spins up a Mem0 MemoryClient with our Mem0 API key, giving our bot a persistent vector-based reminiscence retailer to save lots of and retrieve previous interactions seamlessly.
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"]
reminiscences = mem0.search(messages[-1].content material, user_id=user_id)
context = "n".be part of(f"- {m['memory']}" for m in reminiscences)
system_message = SystemMessage(content material=(
"You're a useful buyer help assistant. "
"Use the context under to personalize your solutions:n" + context
))
full_msgs = [system_message] + messages
ai_resp: AIMessage = llm.invoke(full_msgs)
mem0.add(
f"Consumer: {messages[-1].content material}nAssistant: {ai_resp.content material}",
user_id=user_id
)
return {"messages": [ai_resp]}We outline the conversational state schema and wire it right into a LangGraph state machine: the State TypedDict tracks the message historical past and a Mem0 consumer ID, and graph = StateGraph(State) units up the circulation controller. Throughout the chatbot, the latest consumer message is used to question Mem0 for related reminiscences, a context-enhanced system immediate is constructed, Claude generates a reply, and that new change is saved again into Mem0 earlier than returning the assistant’s response.
graph.add_node("chatbot", chatbot)
graph.add_edge(START, "chatbot")
graph.add_edge("chatbot", "chatbot")
compiled_graph = graph.compile()We plug our chatbot operate into LangGraph’s execution circulation by registering it as a node named “chatbot,” then connecting the built-in START marker to that node. Therefore, the dialog begins there, and at last creates a self-loop edge so every new consumer message re-enters the identical logic. Calling graph.compile() then transforms this node-and-edge setup into an optimized, runnable graph object that can handle every flip of our chat session mechanically.
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 occasion in compiled_graph.stream(state, config):
for node_output in occasion.values():
if node_output.get("messages"):
print("Assistant:", node_output["messages"][-1].content material)
return
if __name__ == "__main__":
print("Welcome! (sort 'exit' to give up)")
mem0_user_id = "customer_123"
whereas True:
user_in = enter("You: ")
if user_in.decrease() in ["exit", "quit", "bye"]:
print("Assistant: Goodbye!")
break
run_conversation(user_in, mem0_user_id)
We tie every part collectively by defining run_conversation, which packages our consumer enter into the LangGraph state, streams it by means of the compiled graph to invoke the chatbot node, and prints out Claude’s reply. The __main__ guard then launches a easy REPL loop, prompting us to sort messages, routing them by means of our memory-enabled graph, and gracefully exiting once we enter “exit”.
In conclusion, we’ve assembled a conversational AI pipeline that mixes Anthropic’s cutting-edge Claude mannequin with mem0’s persistent reminiscence capabilities, all orchestrated through LangGraph in Google Colab. This structure permits our bot to recall user-specific particulars, adapt responses over time, and ship personalised help. From right here, contemplate experimenting with richer memory-retrieval methods, fine-tuning Claude’s prompts, or integrating extra instruments into your graph.
Try Colab Notebook here. All credit score for this analysis goes to the researchers of this venture. Additionally, be happy to observe us on Twitter and don’t overlook to hitch our 95k+ ML SubReddit.
Right here’s a short overview of what we’re constructing at Marktechpost:
Asif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is dedicated to harnessing the potential of Synthetic Intelligence for social good. His most up-to-date endeavor is the launch of an Synthetic Intelligence Media Platform, Marktechpost, which stands out for its in-depth protection of machine studying and deep studying information that’s each technically sound and simply comprehensible by a large viewers. The platform boasts of over 2 million month-to-month views, illustrating its reputation amongst audiences.