Una guía de codificación para desbloquear la memoria MEM0 para el bote de Claude antrópico: habilitando conversaciones ricas en contexto

En este tutorial, lo acompañamos a través de la configuración de un bot completamente funcional en Google Colab que aprovecha Modelo Claude de Anthrope junto a MEM0 Para el retiro de memoria sin costura. La combinación de la orquestación intuitiva de máquinas estatales de Langgraph con la poderosa tienda de memoria basada en vectores de MEM0 capacitará a nuestro asistente para recordar conversaciones pasadas, recuperar detalles relevantes a pedido y mantener la continuidad natural en todas las sesiones. Ya sea que esté creando bots de soporte, asistentes virtuales o demostraciones interactivas, esta guía lo equipará con una base robusta para las experiencias de IA basadas en la memoria.

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

Primero, instalamos y actualizamos Langgraph, el cliente MEM0 AI, Langchain con su conector antrópico y el SDK antrópico central, asegurando que tengamos las últimas bibliotecas necesarias para construir un chatbot Claude basado en la memoria en Google Colab. Ejecutarlo por adelantado evitará problemas de dependencia y agilizará el proceso de configuración.

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

Reúnemos los bloques de construcción principales para nuestro Colab Chatbot: carga la interfaz del sistema operativo para las teclas API, los diccionarios tipados de Python y las utilidades de anotación para definir el estado de conversación, el gráfico de Langgraph y los decoradores de mensajes para orquestar el flujo de chat, las clases de mensajes de Langchain para la construcción de la construcción de la construcción del chatanthrópico a la llamada de los chatanthope a la llamada de los memios.

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

Inyectamos de forma segura nuestras credenciales antrópicas y MEM0 en el entorno y una variable local, asegurando que el cliente Chatantrópico y el almacén de memoria MEM0 puedan autenticarse correctamente sin las claves sensibles de codificación dura en nuestro cuaderno. Centralizando nuestras claves API aquí, mantenemos una separación limpia entre el código y los secretos, al tiempo que permite un acceso perfecto al modelo Claude y una capa de memoria persistente.

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)

Inicializamos nuestro núcleo de IA conversacional: primero, crea una instancia de chatantrópica configurada para hablar con el soneto Claude 3.5 a temperatura cero para respuestas deterministas y hasta 1024 tokens por respuesta, utilizando nuestra clave antrópica almacenada para la autenticación. Luego gira un Mem0 MemoryClient con nuestra tecla API MEM0, dando a nuestro BOT un almacén de memoria persistente basado en vectores para guardar y recuperar interacciones pasadas sin problemas.

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]}

Definimos el esquema de estado de conversación y lo alencionamos en una máquina de estado de Langgraph: el Estado Typeddict rastrea el historial de mensajes y una ID de usuario de MEM0, y Graph = StateGraph (State) establece el controlador de flujo. Dentro del chatbot, el mensaje de usuario más reciente se utiliza para consultar MEM0 para recuerdos relevantes, se construye un mensaje del sistema mejorado con el contexto, Claude genera una respuesta y ese nuevo intercambio se guarda en MEM0 antes de devolver la respuesta del asistente.

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

Conectamos nuestra función de chatbot al flujo de ejecución de Langgraph registrándolo como un nodo llamado “chatbot”, luego conectando el marcador de inicio incorporado a ese nodo. Por lo tanto, la conversación comienza allí, y finalmente crea una ventaja de ascenso, por lo que cada nuevo mensaje de usuario vuelve a entrar en la misma lógica. Llamar a Graph.compile () luego transforma esta configuración de nodo y borde en un objeto gráfico optimizado y ejecutable que administrará cada giro de nuestra sesión de chat automáticamente.

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)

Atitamos todo juntos definiendo run_conversation, que empaqueta nuestro estado de usuario en el estado de Langgraph, lo transmite a través del gráfico compilado para invocar el nodo de chatbot e imprime la respuesta de Claude. El __main__ Guard luego lanza un bucle de replica simple, lo que nos lleva a escribir mensajes, enrutarlos a través de nuestro gráfico habilitado para la memoria y salir con gracia cuando ingresamos “Salir”.

En conclusión, hemos ensamblado una tubería de IA conversacional que combina el modelo Claude de vanguardia de Anthrope con las capacidades de memoria persistentes de MEM0, todas orquestadas a través de Langgraph en Google Colab. Esta arquitectura permite a nuestro BOT recordar los detalles específicos del usuario, adaptar las respuestas a lo largo del tiempo y ofrecer soporte personalizado. A partir de aquí, considere experimentar con estrategias de retrieval de memoria más ricas, ajuste de las indicaciones de Claude o integrar herramientas adicionales en su gráfico.

Verificar Notebook Colab aquí. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro 95k+ ml de subreddit.

Aquí hay una breve descripción de lo que estamos construyendo en MarkTechPost: