Sample Page Title

On this tutorial, we stroll you thru establishing a completely practical bot in Google Colab that leverages Anthropic’s Claude mannequin 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 periods. Whether or not you’re constructing assist 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 anthropic

First, we set up and improve LangGraph, the Mem0 AI consumer, LangChain with its Anthropic connector, and the core Anthropic SDK, guaranteeing we now have all the newest 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, Checklist


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 carry 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 lessons for setting up prompts, the ChatAnthropic wrapper to name Claude, and Mem0’s consumer 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 surroundings and an area variable, guaranteeing that the ChatAnthropic consumer 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 chronic 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 avoid wasting 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"]


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


    context = "n".be part of(f"- {m['memory']}" for m in recollections)
    system_message = SystemMessage(content material=(
        "You're a useful buyer assist assistant. "
        "Use the context beneath 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 newest consumer message is used to question Mem0 for related recollections, 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 eventually 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 robotically.

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 stop)")
    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 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 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 by way of LangGraph in Google Colab. This structure permits our bot to recall user-specific particulars, adapt responses over time, and ship personalised assist. From right here, take into account experimenting with richer memory-retrieval methods, fine-tuning Claude’s prompts, or integrating further instruments into your graph.

Take a look at Colab Pocket book right here. All credit score for this analysis goes to the researchers of this undertaking. Additionally, be happy to comply with 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.