Upload folder using huggingface_hub

README.md

@@ -1,12 +1,6 @@
 ---
-title: Module05
-emoji: 🌖
-colorFrom: pink
-colorTo: yellow
+title: module05
+app_file: agentgradio.py
 sdk: gradio
-sdk_version: 5.46.1
-app_file: app.py
-pinned: false
+sdk_version: 4.44.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agentefinal.py

@@ -0,0 +1,463 @@
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from typing import TypedDict, Literal
+import uuid
+from IPython.display import Image, display
+
+from datetime import datetime
+from trustcall import create_extractor
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.messages import merge_message_runs, HumanMessage, SystemMessage
+
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, MessagesState, END, START
+from langgraph.store.base import BaseStore
+from langgraph.store.memory import InMemoryStore
+
+
+load_dotenv()
+model = ChatOpenAI(model="gpt-4.1-mini", temperature=0)
+# Update memory tool
+class UpdateMemory(TypedDict):
+    """ Decision on what memory type to update """
+    update_type: Literal['user', 'todo', 'instructions']
+
+# User profile schema
+class Profile(BaseModel):
+    """This is the profile of the user you are chatting with"""
+    name: Optional[str] = Field(description="The user's name", default=None)
+    location: Optional[str] = Field(description="The user's location", default=None)
+    job: Optional[str] = Field(description="The user's job", default=None)
+    connections: list[str] = Field(
+        description="Personal connection of the user, such as family members, friends, or coworkers",
+        default_factory=list
+    )
+    interests: list[str] = Field(
+        description="Interests that the user has", 
+        default_factory=list
+    )
+
+# ToDo schema
+class ToDo(BaseModel):
+    task: str = Field(description="The task to be completed.")
+    time_to_complete: Optional[int] = Field(description="Estimated time to complete the task (minutes).")
+    deadline: Optional[datetime] = Field(
+        description="When the task needs to be completed by (if applicable)",
+        default=None
+    )
+    solutions: list[str] = Field(
+        description="List of specific, actionable solutions (e.g., specific ideas, service providers, or concrete options relevant to completing the task)",
+        min_items=1,
+        default_factory=list
+    )
+    status: Literal["not started", "in progress", "done", "archived"] = Field(
+        description="Current status of the task",
+        default="not started"
+    )
+
+# Create the Trustcall extractor for updating the user profile 
+profile_extractor = create_extractor(
+    model,
+    tools=[Profile],
+    tool_choice="Profile",
+)
+
+# Inspect the tool calls made by Trustcall
+class Spy:
+    def __init__(self):
+        self.called_tools = []
+
+    def __call__(self, run):
+        # Collect information about the tool calls made by the extractor.
+        q = [run]
+        while q:
+            r = q.pop()
+            if r.child_runs:
+                q.extend(r.child_runs)
+            if r.run_type == "chat_model":
+                self.called_tools.append(
+                    r.outputs["generations"][0][0]["message"]["kwargs"]["tool_calls"]
+                )
+
+# Initialize the spy
+spy = Spy()
+
+def extract_tool_info(tool_calls, schema_name="Memory"):
+    """Extract information from tool calls for both patches and new memories.
+    
+    Args:
+        tool_calls: List of tool calls from the model
+        schema_name: Name of the schema tool (e.g., "Memory", "ToDo", "Profile")
+    """
+
+    # Initialize list of changes
+    changes = []
+    
+    for call_group in tool_calls:
+        for call in call_group:
+            if call['name'] == 'PatchDoc':
+                if call['args'].get('patches') and len(call['args']['patches']) > 0:
+                    changes.append({
+                        'type': 'update',
+                        'doc_id': call['args']['json_doc_id'],
+                        'planned_edits': call['args']['planned_edits'],
+                        'value': call['args']['patches'][0]['value']
+                    })
+            elif call['name'] == schema_name:
+                changes.append({
+                    'type': 'new',
+                    'value': call['args']
+                })
+
+    # Format results as a single string
+    result_parts = []
+    for change in changes:
+        if change['type'] == 'update':
+            result_parts.append(
+                f"Document {change['doc_id']} updated:\n"
+                f"Plan: {change['planned_edits']}\n"
+                f"Added content: {change['value']}"
+            )
+        else:
+            result_parts.append(
+                f"New {schema_name} created:\n"
+                f"Content: {change['value']}"
+            )
+    
+    return "\n\n".join(result_parts)
+
+# Inspect spy.called_tools to see exactly what happened during the extraction
+schema_name = "Memory"
+changes = extract_tool_info(spy.called_tools, schema_name)
+print(changes)
+
+# Chatbot instruction for choosing what to update and what tools to call 
+MODEL_SYSTEM_MESSAGE = """You are a helpful chatbot. 
+
+You are designed to be a companion to a user, helping them keep track of their ToDo list.
+
+You have a long term memory which keeps track of three things:
+1. The user's profile (general information about them) 
+2. The user's ToDo list
+3. General instructions for updating the ToDo list
+
+Here is the current User Profile (may be empty if no information has been collected yet):
+<user_profile>
+{user_profile}
+</user_profile>
+
+Here is the current ToDo List (may be empty if no tasks have been added yet):
+<todo>
+{todo}
+</todo>
+
+Here are the current user-specified preferences for updating the ToDo list (may be empty if no preferences have been specified yet):
+<instructions>
+{instructions}
+</instructions>
+
+Here are your instructions for reasoning about the user's messages:
+
+1. Reason carefully about the user's messages as presented below. 
+
+2. Decide whether any of the your long-term memory should be updated:
+- If personal information was provided about the user, update the user's profile by calling UpdateMemory tool with type `user`
+- If tasks are mentioned, update the ToDo list by calling UpdateMemory tool with type `todo`
+- If the user has specified preferences for how to update the ToDo list, update the instructions by calling UpdateMemory tool with type `instructions`
+
+3. Tell the user that you have updated your memory, if appropriate:
+- Do not tell the user you have updated the user's profile
+- Tell the user them when you update the todo list
+- Do not tell the user that you have updated instructions
+
+4. Err on the side of updating the todo list. No need to ask for explicit permission.
+
+5. Respond naturally to user user after a tool call was made to save memories, or if no tool call was made."""
+
+# Trustcall instruction
+TRUSTCALL_INSTRUCTION = """Reflect on following interaction. 
+
+Use the provided tools to retain any necessary memories about the user. 
+
+Use parallel tool calling to handle updates and insertions simultaneously.
+
+System Time: {time}"""
+
+# Instructions for updating the ToDo list
+CREATE_INSTRUCTIONS = """Reflect on the following interaction.
+
+Based on this interaction, update your instructions for how to update ToDo list items. 
+
+Use any feedback from the user to update how they like to have items added, etc.
+
+Your current instructions are:
+
+<current_instructions>
+{current_instructions}
+</current_instructions>"""
+
+# Node definitions
+def task_mAIstro(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Load memories from the store and use them to personalize the chatbot's response."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Retrieve profile memory from the store
+    namespace = ("profile", user_id)
+    memories = store.search(namespace)
+    if memories:
+        user_profile = memories[0].value
+    else:
+        user_profile = None
+
+    # Retrieve task memory from the store
+    namespace = ("todo", user_id)
+    memories = store.search(namespace)
+    todo = "\n".join(f"{mem.value}" for mem in memories)
+
+    # Retrieve custom instructions
+    namespace = ("instructions", user_id)
+    memories = store.search(namespace)
+    if memories:
+        instructions = memories[0].value
+    else:
+        instructions = ""
+    
+    system_msg = MODEL_SYSTEM_MESSAGE.format(user_profile=user_profile, todo=todo, instructions=instructions)
+
+    # Respond using memory as well as the chat history
+    response = model.bind_tools([UpdateMemory], parallel_tool_calls=False).invoke([SystemMessage(content=system_msg)]+state["messages"])
+
+    return {"messages": [response]}
+
+def update_profile(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Reflect on the chat history and update the memory collection."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Define the namespace for the memories
+    namespace = ("profile", user_id)
+
+    # Retrieve the most recent memories for context
+    existing_items = store.search(namespace)
+
+    # Format the existing memories for the Trustcall extractor
+    tool_name = "Profile"
+    existing_memories = ([(existing_item.key, tool_name, existing_item.value)
+                          for existing_item in existing_items]
+                          if existing_items
+                          else None
+                        )
+
+    # Merge the chat history and the instruction
+    TRUSTCALL_INSTRUCTION_FORMATTED=TRUSTCALL_INSTRUCTION.format(time=datetime.now().isoformat())
+    updated_messages=list(merge_message_runs(messages=[SystemMessage(content=TRUSTCALL_INSTRUCTION_FORMATTED)] + state["messages"][:-1]))
+
+    # Invoke the extractor
+    result = profile_extractor.invoke({"messages": updated_messages, 
+                                         "existing": existing_memories})
+
+    # Save the memories from Trustcall to the store
+    for r, rmeta in zip(result["responses"], result["response_metadata"]):
+        store.put(namespace,
+                  rmeta.get("json_doc_id", str(uuid.uuid4())),
+                  r.model_dump(mode="json"),
+            )
+    tool_calls = state['messages'][-1].tool_calls
+    return {"messages": [{"role": "tool", "content": "updated profile", "tool_call_id":tool_calls[0]['id']}]}
+
+def update_todos(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Reflect on the chat history and update the memory collection."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Define the namespace for the memories
+    namespace = ("todo", user_id)
+
+    # Retrieve the most recent memories for context
+    existing_items = store.search(namespace)
+
+    # Format the existing memories for the Trustcall extractor
+    tool_name = "ToDo"
+    existing_memories = ([(existing_item.key, tool_name, existing_item.value)
+                          for existing_item in existing_items]
+                          if existing_items
+                          else None
+                        )
+
+    # Merge the chat history and the instruction
+    TRUSTCALL_INSTRUCTION_FORMATTED=TRUSTCALL_INSTRUCTION.format(time=datetime.now().isoformat())
+    updated_messages=list(merge_message_runs(messages=[SystemMessage(content=TRUSTCALL_INSTRUCTION_FORMATTED)] + state["messages"][:-1]))
+
+    # Initialize the spy for visibility into the tool calls made by Trustcall
+    spy = Spy()
+    
+    # Create the Trustcall extractor for updating the ToDo list 
+    todo_extractor = create_extractor(
+    model,
+    tools=[ToDo],
+    tool_choice=tool_name,
+    enable_inserts=True
+    ).with_listeners(on_end=spy)
+
+    # Invoke the extractor
+    result = todo_extractor.invoke({"messages": updated_messages, 
+                                    "existing": existing_memories})
+
+    # Save the memories from Trustcall to the store
+    for r, rmeta in zip(result["responses"], result["response_metadata"]):
+        store.put(namespace,
+                  rmeta.get("json_doc_id", str(uuid.uuid4())),
+                  r.model_dump(mode="json"),
+            )
+        
+    # Respond to the tool call made in task_mAIstro, confirming the update
+    tool_calls = state['messages'][-1].tool_calls
+
+    # Extract the changes made by Trustcall and add the the ToolMessage returned to task_mAIstro
+    todo_update_msg = extract_tool_info(spy.called_tools, tool_name)
+    return {"messages": [{"role": "tool", "content": todo_update_msg, "tool_call_id":tool_calls[0]['id']}]}
+
+def update_instructions(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Reflect on the chat history and update the memory collection."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+    
+    namespace = ("instructions", user_id)
+
+    existing_memory = store.get(namespace, "user_instructions")
+        
+    # Format the memory in the system prompt
+    system_msg = CREATE_INSTRUCTIONS.format(current_instructions=existing_memory.value if existing_memory else None)
+    new_memory = model.invoke([SystemMessage(content=system_msg)]+state['messages'][:-1] + [HumanMessage(content="Please update the instructions based on the conversation")])
+
+    # Overwrite the existing memory in the store 
+    key = "user_instructions"
+    store.put(namespace, key, {"memory": new_memory.content})
+    tool_calls = state['messages'][-1].tool_calls
+    return {"messages": [{"role": "tool", "content": "updated instructions", "tool_call_id":tool_calls[0]['id']}]}
+
+# Conditional edge
+def route_message(state: MessagesState, config: RunnableConfig, store: BaseStore) -> Literal[END, "update_todos", "update_instructions", "update_profile"]:
+
+    """Reflect on the memories and chat history to decide whether to update the memory collection."""
+    message = state['messages'][-1]
+    if len(message.tool_calls) ==0:
+        return END
+    else:
+        tool_call = message.tool_calls[0]
+        if tool_call['args']['update_type'] == "user":
+            return "update_profile"
+        elif tool_call['args']['update_type'] == "todo":
+            return "update_todos"
+        elif tool_call['args']['update_type'] == "instructions":
+            return "update_instructions"
+        else:
+            raise ValueError
+
+# Create the graph + all nodes
+builder = StateGraph(MessagesState)
+
+# Define the flow of the memory extraction process
+builder.add_node(task_mAIstro)
+builder.add_node(update_todos)
+builder.add_node(update_profile)
+builder.add_node(update_instructions)
+builder.add_edge(START, "task_mAIstro")
+builder.add_conditional_edges("task_mAIstro", route_message)
+builder.add_edge("update_todos", "task_mAIstro")
+builder.add_edge("update_profile", "task_mAIstro")
+builder.add_edge("update_instructions", "task_mAIstro")
+
+# Store for long-term (across-thread) memory
+across_thread_memory = InMemoryStore()
+
+# Checkpointer for short-term (within-thread) memory
+within_thread_memory = MemorySaver()
+
+# We compile the graph with the checkpointer and store
+graph = builder.compile(checkpointer=within_thread_memory, store=across_thread_memory)
+
+with open("agentefinal.png", "wb") as f:
+    f.write(graph.get_graph().draw_mermaid_png())
+
+# We supply a thread ID for short-term (within-thread) memory
+# We supply a user ID for long-term (across-thread) memory 
+config = {"configurable": {"thread_id": "1", "user_id": "Lance"}}
+
+# User input to create a profile memory
+input_messages = [HumanMessage(content="My name is Lance. I live in SF with my wife. I have a 1 year old daughter.")]
+
+print("------------------")
+print("Mensaje: 1")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+# User input for a ToDo
+input_messages = [HumanMessage(content="My wife asked me to book swim lessons for the baby.")]
+
+print("------------------")
+print("Mensaje: 2")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+# User input to update instructions for creating ToDos
+input_messages = [HumanMessage(content="When creating or updating ToDo items, include specific local businesses / vendors.")]
+print("------------------")
+print("Mensaje: 3")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+
+# Check for updated instructions
+user_id = "Lance"
+print("------------------")
+print("Mensaje: 4 Actualización")
+print("------------------")
+# Search 
+for memory in across_thread_memory.search(("instructions", user_id)):
+    print(memory.value)
+
+# User input for a ToDo
+input_messages = [HumanMessage(content="I need to fix the jammed electric Yale lock on the door.")]
+print("------------------")
+print("Mensaje: 5")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+# Namespace for the memory to save
+user_id = "Lance"
+print("------------------")
+print("Mensaje: 6")
+print("------------------")
+# Search 
+for memory in across_thread_memory.search(("todo", user_id)):
+    print(memory.value)
+
+# User input to update an existing ToDo
+input_messages = [HumanMessage(content="For the swim lessons, I need to get that done by end of November.")]
+print("------------------")
+print("Mensaje: 7")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()

agentgradio.py

@@ -0,0 +1,421 @@
+# agentefinal_gradio.py
+# ---------------------
+# Interfaz web con Gradio para tu agente basado en LangGraph + Trustcall.
+# Toma como base tu agentefinal.py y expone un Chatbot en localhost.
+
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from typing import TypedDict, Literal
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+from trustcall import create_extractor
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.messages import merge_message_runs, HumanMessage, SystemMessage
+
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, MessagesState, END, START
+from langgraph.store.base import BaseStore
+from langgraph.store.memory import InMemoryStore
+
+# --- NUEVO: Gradio
+import gradio as gr
+
+# ---------------------------------------------------------------------
+# CARGA DE VARIABLES DE ENTORNO (por ejemplo, OPENAI_API_KEY desde .env)
+# ---------------------------------------------------------------------
+load_dotenv()
+
+# ---------------------------------------------------------------------
+# MODELO BASE
+# ---------------------------------------------------------------------
+# Puedes ajustar el modelo/temperatura si lo necesitas.
+model = ChatOpenAI(model="gpt-4.1-mini", temperature=0)
+
+# ---------------------------------------------------------------------
+# TOOLS / ESQUEMAS
+# ---------------------------------------------------------------------
+class UpdateMemory(TypedDict):
+    """ Decision on what memory type to update """
+    update_type: Literal['user', 'todo', 'instructions']
+
+class Profile(BaseModel):
+    """This is the profile of the user you are chatting with"""
+    name: Optional[str] = Field(description="The user's name", default=None)
+    location: Optional[str] = Field(description="The user's location", default=None)
+    job: Optional[str] = Field(description="The user's job", default=None)
+    connections: list[str] = Field(
+        description="Personal connection of the user, such as family members, friends, or coworkers",
+        default_factory=list
+    )
+    interests: list[str] = Field(
+        description="Interests that the user has",
+        default_factory=list
+    )
+
+class ToDo(BaseModel):
+    task: str = Field(description="The task to be completed.")
+    time_to_complete: Optional[int] = Field(description="Estimated time to complete the task (minutes).")
+    deadline: Optional[datetime] = Field(
+        description="When the task needs to be completed by (if applicable)",
+        default=None
+    )
+    solutions: list[str] = Field(
+        description="List of specific, actionable solutions (e.g., specific ideas, service providers, or concrete options relevant to completing the task)",
+        min_items=1,
+        default_factory=list
+    )
+    status: Literal["not started", "in progress", "done", "archived"] = Field(
+        description="Current status of the task",
+        default="not started"
+    )
+
+# Extractor para perfil
+profile_extractor = create_extractor(
+    model,
+    tools=[Profile],
+    tool_choice="Profile",
+)
+
+# ---------------------------------------------------------------------
+# UTILIDAD PARA INSPECCIONAR LLAMADAS DE HERRAMIENTAS (Trustcall)
+# ---------------------------------------------------------------------
+class Spy:
+    def __init__(self):
+        self.called_tools = []
+
+    def __call__(self, run):
+        q = [run]
+        while q:
+            r = q.pop()
+            if getattr(r, "child_runs", None):
+                q.extend(r.child_runs)
+            if getattr(r, "run_type", None) == "chat_model":
+                try:
+                    self.called_tools.append(
+                        r.outputs["generations"][0][0]["message"]["kwargs"]["tool_calls"]
+                    )
+                except Exception:
+                    pass
+
+def extract_tool_info(tool_calls, schema_name="Memory"):
+    """Extrae información útil de las tool calls (Trustcall)."""
+    changes = []
+    for call_group in tool_calls:
+        for call in call_group:
+            if call.get('name') == 'PatchDoc':
+                if call.get('args', {}).get('patches'):
+                    changes.append({
+                        'type': 'update',
+                        'doc_id': call['args'].get('json_doc_id'),
+                        'planned_edits': call['args'].get('planned_edits'),
+                        'value': call['args']['patches'][0].get('value')
+                    })
+            elif call.get('name') == schema_name:
+                changes.append({'type': 'new', 'value': call.get('args')})
+
+    result_parts = []
+    for change in changes:
+        if change['type'] == 'update':
+            result_parts.append(
+                f"Document {change['doc_id']} updated:\n"
+                f"Plan: {change['planned_edits']}\n"
+                f"Added content: {change['value']}"
+            )
+        else:
+            result_parts.append(
+                f"New {schema_name} created:\n"
+                f"Content: {change['value']}"
+            )
+    return "\n\n".join(result_parts)
+
+# ---------------------------------------------------------------------
+# PROMPTS DEL AGENTE
+# ---------------------------------------------------------------------
+MODEL_SYSTEM_MESSAGE = """You are a helpful chatbot.
+
+You are designed to be a companion to a user, helping them keep track of their ToDo list.
+
+You have a long term memory which keeps track of three things:
+1. The user's profile (general information about them)
+2. The user's ToDo list
+3. General instructions for updating the ToDo list
+
+Here is the current User Profile (may be empty if no information has been collected yet):
+<user_profile>
+{user_profile}
+</user_profile>
+
+Here is the current ToDo List (may be empty if no tasks have been added yet):
+<todo>
+{todo}
+</todo>
+
+Here are the current user-specified preferences for updating the ToDo list (may be empty if no preferences have been specified yet):
+<instructions>
+{instructions}
+</instructions>
+
+Here are your instructions for reasoning about the user's messages:
+
+1. Reason carefully about the user's messages as presented below.
+
+2. Decide whether any of the your long-term memory should be updated:
+- If personal information was provided about the user, update the user's profile by calling UpdateMemory tool with type `user`
+- If tasks are mentioned, update the ToDo list by calling UpdateMemory tool with type `todo`
+- If the user has specified preferences for how to update the ToDo list, update the instructions by calling UpdateMemory tool with type `instructions`
+
+3. Tell the user that you have updated your memory, if appropriate:
+- Do not tell the user you have updated the user's profile
+- Tell the user them when you update the todo list
+- Do not tell the user that you have updated instructions
+
+4. Err on the side of updating the todo list. No need to ask for explicit permission.
+
+5. Respond naturally to user user after a tool call was made to save memories, or if no tool call was made."""
+
+TRUSTCALL_INSTRUCTION = """Reflect on following interaction.
+
+Use the provided tools to retain any necessary memories about the user.
+
+Use parallel tool calling to handle updates and insertions simultaneously.
+
+System Time: {time}"""
+
+CREATE_INSTRUCTIONS = """Reflect on the following interaction.
+
+Based on this interaction, update your instructions for how to update ToDo list items.
+
+Use any feedback from the user to update how they like to have items added, etc.
+
+Your current instructions are:
+
+<current_instructions>
+{current_instructions}
+</current_instructions>"""
+
+# ---------------------------------------------------------------------
+# NODOS DEL GRAFO
+# ---------------------------------------------------------------------
+def task_mAIstro(state: MessagesState, config: RunnableConfig, store: BaseStore):
+    """Carga memorias y responde con el modelo, decidiendo si llamar UpdateMemory."""
+    user_id = config["configurable"]["user_id"]
+
+    # Profile
+    namespace = ("profile", user_id)
+    memories = store.search(namespace)
+    user_profile = memories[0].value if memories else None
+
+    # ToDo
+    namespace = ("todo", user_id)
+    memories = store.search(namespace)
+    todo = "\n".join(f"{mem.value}" for mem in memories)
+
+    # Instrucciones
+    namespace = ("instructions", user_id)
+    memories = store.search(namespace)
+    instructions = memories[0].value if memories else ""
+
+    system_msg = MODEL_SYSTEM_MESSAGE.format(
+        user_profile=user_profile,
+        todo=todo,
+        instructions=instructions
+    )
+
+    response = model.bind_tools([UpdateMemory], parallel_tool_calls=False).invoke(
+        [SystemMessage(content=system_msg)] + state["messages"]
+    )
+    return {"messages": [response]}
+
+def update_profile(state: MessagesState, config: RunnableConfig, store: BaseStore):
+    """Actualiza memoria de perfil con Trustcall."""
+    user_id = config["configurable"]["user_id"]
+    namespace = ("profile", user_id)
+
+    existing_items = store.search(namespace)
+    tool_name = "Profile"
+    existing_memories = ([(existing_item.key, tool_name, existing_item.value)
+                          for existing_item in existing_items] if existing_items else None)
+
+    TRUSTCALL_INSTRUCTION_FORMATTED = TRUSTCALL_INSTRUCTION.format(time=datetime.now().isoformat())
+    updated_messages = list(merge_message_runs(
+        messages=[SystemMessage(content=TRUSTCALL_INSTRUCTION_FORMATTED)] + state["messages"][:-1]
+    ))
+
+    result = profile_extractor.invoke({"messages": updated_messages, "existing": existing_memories})
+
+    for r, rmeta in zip(result["responses"], result["response_metadata"]):
+        store.put(namespace, rmeta.get("json_doc_id", str(uuid.uuid4())), r.model_dump(mode="json"))
+
+    tool_calls = state['messages'][-1].tool_calls
+    return {"messages": [{"role": "tool", "content": "updated profile", "tool_call_id": tool_calls[0]['id']}]}
+
+def update_todos(state: MessagesState, config: RunnableConfig, store: BaseStore):
+    """Actualiza ToDos con Trustcall (inserciones + parches)."""
+    user_id = config["configurable"]["user_id"]
+    namespace = ("todo", user_id)
+
+    existing_items = store.search(namespace)
+    tool_name = "ToDo"
+    existing_memories = ([(existing_item.key, tool_name, existing_item.value)
+                          for existing_item in existing_items] if existing_items else None)
+
+    TRUSTCALL_INSTRUCTION_FORMATTED = TRUSTCALL_INSTRUCTION.format(time=datetime.now().isoformat())
+    updated_messages = list(merge_message_runs(
+        messages=[SystemMessage(content=TRUSTCALL_INSTRUCTION_FORMATTED)] + state["messages"][:-1]
+    ))
+
+    spy = Spy()
+    todo_extractor = create_extractor(
+        model,
+        tools=[ToDo],
+        tool_choice=tool_name,
+        enable_inserts=True
+    ).with_listeners(on_end=spy)
+
+    result = todo_extractor.invoke({"messages": updated_messages, "existing": existing_memories})
+
+    for r, rmeta in zip(result["responses"], result["response_metadata"]):
+        store.put(namespace, rmeta.get("json_doc_id", str(uuid.uuid4())), r.model_dump(mode="json"))
+
+    tool_calls = state['messages'][-1].tool_calls
+    todo_update_msg = extract_tool_info(spy.called_tools, tool_name)
+    return {"messages": [{"role": "tool", "content": todo_update_msg or "updated todos", "tool_call_id": tool_calls[0]['id']}]}
+
+def update_instructions(state: MessagesState, config: RunnableConfig, store: BaseStore):
+    """Actualiza instrucciones personalizadas del usuario."""
+    user_id = config["configurable"]["user_id"]
+    namespace = ("instructions", user_id)
+
+    existing_memory = store.get(namespace, "user_instructions")
+    system_msg = CREATE_INSTRUCTIONS.format(
+        current_instructions=existing_memory.value if existing_memory else None
+    )
+
+    new_memory = model.invoke(
+        [SystemMessage(content=system_msg)] +
+        state['messages'][:-1] +
+        [HumanMessage(content="Please update the instructions based on the conversation")]
+    )
+
+    store.put(namespace, "user_instructions", {"memory": new_memory.content})
+    tool_calls = state['messages'][-1].tool_calls
+    return {"messages": [{"role": "tool", "content": "updated instructions", "tool_call_id": tool_calls[0]['id']}]}
+
+def route_message(state: MessagesState, config: RunnableConfig, store: BaseStore) -> Literal[END, "update_todos", "update_instructions", "update_profile"]:
+    """Decide qué colección actualizar según la tool call del modelo."""
+    message = state['messages'][-1]
+    if len(getattr(message, "tool_calls", []) or []) == 0:
+        return END
+    tool_call = message.tool_calls[0]
+    ut = tool_call['args']['update_type']
+    if ut == "user":
+        return "update_profile"
+    elif ut == "todo":
+        return "update_todos"
+    elif ut == "instructions":
+        return "update_instructions"
+    else:
+        raise ValueError("Unknown update_type")
+
+# ---------------------------------------------------------------------
+# COMPILACIÓN DEL GRAFO + MEMORIA
+# ---------------------------------------------------------------------
+def build_graph():
+    builder = StateGraph(MessagesState)
+    builder.add_node(task_mAIstro)
+    builder.add_node(update_todos)
+    builder.add_node(update_profile)
+    builder.add_node(update_instructions)
+
+    builder.add_edge(START, "task_mAIstro")
+    builder.add_conditional_edges("task_mAIstro", route_message)
+    builder.add_edge("update_todos", "task_mAIstro")
+    builder.add_edge("update_profile", "task_mAIstro")
+    builder.add_edge("update_instructions", "task_mAIstro")
+
+    across_thread_memory = InMemoryStore()   # memoria largo plazo (en RAM)
+    within_thread_memory = MemorySaver()     # checkpointing corto plazo
+
+    graph = builder.compile(checkpointer=within_thread_memory, store=across_thread_memory)
+    return graph, across_thread_memory, within_thread_memory
+
+GRAPH, STORE, CHECKPOINTER = build_graph()
+
+# ---------------------------------------------------------------------
+# FUNCIÓN DE CHAT PARA GRADIO
+# ---------------------------------------------------------------------
+def chat_fn(user_input, history, user_id, thread_id):
+    """
+    - user_input: texto del usuario
+    - history: historial [(user, bot), ...] mostrado en Gradio
+    - user_id: id lógico para memoria a largo plazo (e.g., nombre)
+    - thread_id: id del hilo para memoria de corto plazo
+    """
+    # Config para LangGraph
+    config = {"configurable": {"thread_id": str(thread_id or "1"), "user_id": str(user_id or "default")}}
+    input_messages = [HumanMessage(content=user_input or "")]
+
+    # Ejecutar grafo por streaming y quedarnos con el último mensaje
+    response_text = ""
+    try:
+        for chunk in GRAPH.stream({"messages": input_messages}, config, stream_mode="values"):
+            msg = chunk["messages"][-1]
+            # msg puede ser un ChatMessage, ToolMessage, etc.
+            content = getattr(msg, "content", None)
+            if content:
+                response_text = content
+    except Exception as e:
+        response_text = f"Oops, hubo un error procesando tu mensaje: {e}"
+
+    # Actualizamos historial para el componente Chatbot
+    history = (history or []) + [(user_input, response_text)]
+    return history, history
+
+def clear_fn():
+    return [], []
+
+# ---------------------------------------------------------------------
+# UI DE GRADIO
+# ---------------------------------------------------------------------
+def build_ui():
+    with gr.Blocks(title="Agente con Memoria (LangGraph + Trustcall)") as demo:
+        gr.Markdown("## 🧠 Agente ToDo con memoria (LangGraph + Trustcall) + Gradio")
+
+        with gr.Row():
+            user_id = gr.Textbox(label="User ID (memoria largo plazo)", value="Lance")
+            thread_id = gr.Textbox(label="Thread ID (memoria corto plazo)", value="1")
+
+        chatbot = gr.Chatbot(label="Chat")
+        msg = gr.Textbox(label="Escribe tu mensaje", placeholder="Hola, me llamo... Añade 'reservar clases...' etc.", lines=2)
+        with gr.Row():
+            send = gr.Button("Enviar", variant="primary")
+            clear = gr.Button("Limpiar historial")
+
+        state = gr.State([])  # historial
+
+        # Acciones
+        msg.submit(chat_fn, [msg, state, user_id, thread_id], [chatbot, state])
+        send.click(chat_fn, [msg, state, user_id, thread_id], [chatbot, state])
+        clear.click(lambda: ([], []), None, [chatbot, state])
+
+        gr.Markdown(
+            "Consejo: usa un **User ID** constante para que la memoria de perfil y ToDos "
+            "se mantenga entre mensajes. Cambia el **Thread ID** para conversaciones paralelas."
+        )
+    return demo
+
+# ---------------------------------------------------------------------
+# MAIN
+# ---------------------------------------------------------------------
+if __name__ == "__main__":
+    demo = build_ui()
+    demo.queue().launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )

memoryagent03.py

@@ -0,0 +1,164 @@
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+from trustcall import create_extractor
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
+from typing import TypedDict, Literal
+
+load_dotenv()
+model = ChatOpenAI(model="gpt-4.1-mini", temperature=0)
+
+class Memory(BaseModel):
+    content: str = Field(description="The main content of the memory. For example: User expressed interest in learning about French.")
+
+class MemoryCollection(BaseModel):
+    memories: list[Memory] = Field(description="A list of memories about the user.")
+
+# Inspect the tool calls made by Trustcall
+class Spy:
+    def __init__(self):
+        self.called_tools = []
+
+    def __call__(self, run):
+        # Collect information about the tool calls made by the extractor.
+        q = [run]
+        while q:
+            r = q.pop()
+            if r.child_runs:
+                q.extend(r.child_runs)
+            if r.run_type == "chat_model":
+                self.called_tools.append(
+                    r.outputs["generations"][0][0]["message"]["kwargs"]["tool_calls"]
+                )
+
+# Initialize the spy
+spy = Spy()
+
+# Create the extractor
+trustcall_extractor = create_extractor(
+    model,
+    tools=[Memory],
+    tool_choice="Memory",
+    enable_inserts=True,
+)
+
+# Add the spy as a listener
+trustcall_extractor_see_all_tool_calls = trustcall_extractor.with_listeners(on_end=spy)
+
+# Instruction
+instruction = """Extract memories from the following conversation:"""
+
+# Conversation
+conversation = [HumanMessage(content="Hi, I'm Lance."), 
+                AIMessage(content="Nice to meet you, Lance."), 
+                HumanMessage(content="This morning I had a nice bike ride in San Francisco.")]
+
+# Invoke the extractor
+result = trustcall_extractor.invoke({"messages": [SystemMessage(content=instruction)] + conversation})
+
+print("------------------")
+print("Mensaje: 1")
+print("------------------")
+# Messages contain the tool calls
+for m in result["messages"]:
+    m.pretty_print()
+
+# Update the conversation
+updated_conversation = [AIMessage(content="That's great, did you do after?"), 
+                        HumanMessage(content="I went to Tartine and ate a croissant."),                        
+                        AIMessage(content="What else is on your mind?"),
+                        HumanMessage(content="I was thinking about my Japan, and going back this winter!"),]
+
+
+print("------------------")
+print("Mensaje: 2: Update system message")
+print("------------------")
+# Update the instruction
+system_msg = """Update existing memories and create new ones based on the following conversation:"""
+
+# We'll save existing memories, giving them an ID, key (tool name), and value
+tool_name = "Memory"
+existing_memories = [(str(i), tool_name, memory.model_dump()) for i, memory in enumerate(result["responses"])] if result["responses"] else None
+print(existing_memories)
+
+# Invoke the extractor with our updated conversation and existing memories
+result = trustcall_extractor_see_all_tool_calls.invoke({"messages": updated_conversation, 
+                                                        "existing": existing_memories})
+
+print("------------------")
+print("Mensaje: 3: metadata and tool calls")
+print("------------------")
+# Metadata contains the tool call  
+for m in result["response_metadata"]: 
+    print(m)
+
+print("------------------")
+print("Mensaje: 4: metadata and tool calls")
+print("------------------")
+# Messages contain the tool calls
+for m in result["messages"]:
+    m.pretty_print()
+
+print("------------------")
+print("Mensaje: 5: Parsed responses")
+print("------------------")
+# Parsed responses
+for m in result["responses"]:
+    print(m)
+
+print("------------------")
+print("Mensaje: 6: Inspect the tool calls made by Trustcall")
+print("------------------")
+# Inspect the tool calls made by Trustcall
+print(spy.called_tools)
+
+def extract_tool_info(tool_calls, schema_name="Memory"):
+    """Extract information from tool calls for both patches and new memories.
+    
+    Args:
+        tool_calls: List of tool calls from the model
+        schema_name: Name of the schema tool (e.g., "Memory", "ToDo", "Profile")
+    """
+
+    # Initialize list of changes
+    changes = []
+    
+    for call_group in tool_calls:
+        for call in call_group:
+            if call['name'] == 'PatchDoc':
+                changes.append({
+                    'type': 'update',
+                    'doc_id': call['args']['json_doc_id'],
+                    'planned_edits': call['args']['planned_edits'],
+                    'value': call['args']['patches'][0]['value']
+                })
+            elif call['name'] == schema_name:
+                changes.append({
+                    'type': 'new',
+                    'value': call['args']
+                })
+
+    # Format results as a single string
+    result_parts = []
+    for change in changes:
+        if change['type'] == 'update':
+            result_parts.append(
+                f"Document {change['doc_id']} updated:\n"
+                f"Plan: {change['planned_edits']}\n"
+                f"Added content: {change['value']}"
+            )
+        else:
+            result_parts.append(
+                f"New {schema_name} created:\n"
+                f"Content: {change['value']}"
+            )
+    
+    return "\n\n".join(result_parts)
+
+print("------------------")
+print("Mensaje: 7: Extracted changes")
+print("------------------")
+# Inspect spy.called_tools to see exactly what happened during the extraction
+schema_name = "Memory"
+changes = extract_tool_info(spy.called_tools, schema_name)
+print(changes)

memoryschema02.py

@@ -0,0 +1,334 @@
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from typing import TypedDict, List
+import uuid
+from langgraph.store.memory import InMemoryStore
+from pydantic import BaseModel, Field
+
+from langchain_core.messages import HumanMessage
+from IPython.display import Image, display
+
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, MessagesState, START, END
+from langgraph.store.base import BaseStore
+
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
+from langchain_core.runnables.config import RunnableConfig
+from trustcall import create_extractor
+
+
+load_dotenv()
+model = ChatOpenAI(model="gpt-4.1-mini", temperature=0) 
+
+from typing import TypedDict, List
+
+class UserProfile(TypedDict):
+    """User profile schema with typed fields"""
+    user_name: str  # The user's preferred name
+    interests: List[str]  # A list of the user's interests
+
+# TypedDict instance
+user_profile: UserProfile = {
+    "user_name": "Lance",
+    "interests": ["biking", "technology", "coffee"]
+}
+print("------------------")
+print("User Profile:")
+print("------------------")
+print(user_profile)
+
+# Initialize the in-memory store
+in_memory_store = InMemoryStore()
+
+# Namespace for the memory to save
+user_id = "1"
+namespace_for_memory = (user_id, "memory")
+
+# Save a memory to namespace as key and value
+key = "user_profile"
+value = user_profile
+in_memory_store.put(namespace_for_memory, key, value)
+
+# Search 
+for m in in_memory_store.search(namespace_for_memory):
+    print(m.dict())
+
+# Get the memory by namespace and key
+profile = in_memory_store.get(namespace_for_memory, "user_profile")
+print (profile.value)
+
+# Bind schema to model
+model_with_structure = model.with_structured_output(UserProfile)
+
+# Invoke the model to produce structured output that matches the schema
+structured_output = model_with_structure.invoke([HumanMessage("My name is Lance, I like to bike.")])
+print("------------------")
+print("Structured Output:")
+print("------------------")
+print(structured_output)
+
+# Chatbot instruction
+MODEL_SYSTEM_MESSAGE = """You are a helpful assistant with memory that provides information about the user. 
+If you have memory for this user, use it to personalize your responses.
+Here is the memory (it may be empty): {memory}"""
+
+# Create new memory from the chat history and any existing memory
+CREATE_MEMORY_INSTRUCTION = """Create or update a user profile memory based on the user's chat history. 
+This will be saved for long-term memory. If there is an existing memory, simply update it. 
+Here is the existing memory (it may be empty): {memory}"""
+
+def call_model(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Load memory from the store and use it to personalize the chatbot's response."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Retrieve memory from the store
+    namespace = ("memory", user_id)
+    existing_memory = store.get(namespace, "user_memory")
+
+    # Format the memories for the system prompt
+    if existing_memory and existing_memory.value:
+        memory_dict = existing_memory.value
+        formatted_memory = (
+            f"Name: {memory_dict.get('user_name', 'Unknown')}\n"
+            f"Interests: {', '.join(memory_dict.get('interests', []))}"
+        )
+    else:
+        formatted_memory = None
+
+    # Format the memory in the system prompt
+    system_msg = MODEL_SYSTEM_MESSAGE.format(memory=formatted_memory)
+
+    # Respond using memory as well as the chat history
+    response = model.invoke([SystemMessage(content=system_msg)]+state["messages"])
+
+    return {"messages": response}
+
+def write_memory(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Reflect on the chat history and save a memory to the store."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Retrieve existing memory from the store
+    namespace = ("memory", user_id)
+    existing_memory = store.get(namespace, "user_memory")
+
+    # Format the memories for the system prompt
+    if existing_memory and existing_memory.value:
+        memory_dict = existing_memory.value
+        formatted_memory = (
+            f"Name: {memory_dict.get('user_name', 'Unknown')}\n"
+            f"Interests: {', '.join(memory_dict.get('interests', []))}"
+        )
+    else:
+        formatted_memory = None
+        
+    # Format the existing memory in the instruction
+    system_msg = CREATE_MEMORY_INSTRUCTION.format(memory=formatted_memory)
+
+    # Invoke the model to produce structured output that matches the schema
+    new_memory = model_with_structure.invoke([SystemMessage(content=system_msg)]+state['messages'])
+
+    # Overwrite the existing use profile memory
+    key = "user_memory"
+    store.put(namespace, key, new_memory)
+
+# Define the graph
+builder = StateGraph(MessagesState)
+builder.add_node("call_model", call_model)
+builder.add_node("write_memory", write_memory)
+builder.add_edge(START, "call_model")
+builder.add_edge("call_model", "write_memory")
+builder.add_edge("write_memory", END)
+
+# Store for long-term (across-thread) memory
+across_thread_memory = InMemoryStore()
+
+# Checkpointer for short-term (within-thread) memory
+within_thread_memory = MemorySaver()
+
+# Compile the graph with the checkpointer fir and store
+graph = builder.compile(checkpointer=within_thread_memory, store=across_thread_memory)
+
+with open("memoryschema01.png", "wb") as f:
+    f.write(graph.get_graph().draw_mermaid_png())
+
+# We supply a thread ID for short-term (within-thread) memory
+# We supply a user ID for long-term (across-thread) memory 
+config = {"configurable": {"thread_id": "1", "user_id": "1"}}
+
+# User input 
+input_messages = [HumanMessage(content="Hi, my name is Lance and I like to bike around San Francisco and eat at bakeries.")]
+
+print("------------------")
+print("Mensaje 1:")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+
+# Namespace for the memory to save
+user_id = "1"
+namespace = ("memory", user_id)
+existing_memory = across_thread_memory.get(namespace, "user_memory")
+print("------------------")
+print("Memory after first message:")
+print("------------------")
+print(existing_memory.value)
+
+
+
+# Schema TrustCall para crear y actualizar esquemas de perfil
+class UserProfile(BaseModel):
+    """ Profile of a user """
+    user_name: str = Field(description="The user's preferred name")
+    user_location: str = Field(description="The user's location")
+    interests: list = Field(description="A list of the user's interests")
+
+# Create the extractor
+trustcall_extractor = create_extractor(
+    model,
+    tools=[UserProfile],
+    tool_choice="UserProfile", # Enforces use of the UserProfile tool
+)
+
+# Chatbot instruction
+MODEL_SYSTEM_MESSAGE = """You are a helpful assistant with memory that provides information about the user. 
+If you have memory for this user, use it to personalize your responses.
+Here is the memory (it may be empty): {memory}"""
+
+# Extraction instruction
+TRUSTCALL_INSTRUCTION = """Create or update the memory (JSON doc) to incorporate information from the following conversation:"""
+
+def call_model(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Load memory from the store and use it to personalize the chatbot's response."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Retrieve memory from the store
+    namespace = ("memory", user_id)
+    existing_memory = store.get(namespace, "user_memory")
+
+    # Format the memories for the system prompt
+    if existing_memory and existing_memory.value:
+        memory_dict = existing_memory.value
+        formatted_memory = (
+            f"Name: {memory_dict.get('user_name', 'Unknown')}\n"
+            f"Location: {memory_dict.get('user_location', 'Unknown')}\n"
+            f"Interests: {', '.join(memory_dict.get('interests', []))}"      
+        )
+    else:
+        formatted_memory = None
+
+    # Format the memory in the system prompt
+    system_msg = MODEL_SYSTEM_MESSAGE.format(memory=formatted_memory)
+
+    # Respond using memory as well as the chat history
+    response = model.invoke([SystemMessage(content=system_msg)]+state["messages"])
+
+    return {"messages": response}
+
+def write_memory(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Reflect on the chat history and save a memory to the store."""
+    
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Retrieve existing memory from the store
+    namespace = ("memory", user_id)
+    existing_memory = store.get(namespace, "user_memory")
+        
+    # Get the profile as the value from the list, and convert it to a JSON doc
+    existing_profile = {"UserProfile": existing_memory.value} if existing_memory else None
+    
+    # Invoke the extractor
+    result = trustcall_extractor.invoke({"messages": [SystemMessage(content=TRUSTCALL_INSTRUCTION)]+state["messages"], "existing": existing_profile})
+    
+    # Get the updated profile as a JSON object
+    updated_profile = result["responses"][0].model_dump()
+
+    # Save the updated profile
+    key = "user_memory"
+    store.put(namespace, key, updated_profile)
+
+# Define the graph
+builder = StateGraph(MessagesState)
+builder.add_node("call_model", call_model)
+builder.add_node("write_memory", write_memory)
+builder.add_edge(START, "call_model")
+builder.add_edge("call_model", "write_memory")
+builder.add_edge("write_memory", END)
+
+# Store for long-term (across-thread) memory
+across_thread_memory = InMemoryStore()
+
+# Checkpointer for short-term (within-thread) memory
+within_thread_memory = MemorySaver()
+
+# Compile the graph with the checkpointer fir and store
+graph = builder.compile(checkpointer=within_thread_memory, store=across_thread_memory)
+
+# We supply a thread ID for short-term (within-thread) memory
+# We supply a user ID for long-term (across-thread) memory 
+config = {"configurable": {"thread_id": "1", "user_id": "1"}}
+
+# User input 
+input_messages = [HumanMessage(content="Hi, my name is Lance")]
+
+print("------------------")
+print("Chatbot with TrustCall: Mensaje 1")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+# User input 
+input_messages = [HumanMessage(content="I like to bike around San Francisco")]
+
+print("------------------")
+print("Chatbot with TrustCall: Mensaje 2")
+print("------------------")
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+print("------------------")
+print("Chatbot with TrustCall: Memory after messages")
+print("------------------")
+# Namespace for the memory to save
+user_id = "1"
+namespace = ("memory", user_id)
+existing_memory = across_thread_memory.get(namespace, "user_memory")
+print(existing_memory.dict())
+
+print("------------------")
+print("Chatbot with TrustCall: Mensaje 3")
+print("------------------")
+# User input 
+input_messages = [HumanMessage(content="I also enjoy going to bakeries")]
+
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+print("------------------")
+print("Chatbot with TrustCall: Mensaje 4")
+print("------------------")
+# We supply a thread ID for short-term (within-thread) memory
+# We supply a user ID for long-term (across-thread) memory 
+config = {"configurable": {"thread_id": "2", "user_id": "1"}}
+
+# User input 
+input_messages = [HumanMessage(content="What bakeries do you recommend for me?")]
+
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()

memorystore01.py

@@ -0,0 +1,211 @@
+from dotenv import load_dotenv
+import uuid
+from langgraph.store.memory import InMemoryStore
+from langchain_openai import ChatOpenAI
+from IPython.display import Image, display
+
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph, MessagesState, START, END
+from langgraph.store.base import BaseStore
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.runnables.config import RunnableConfig
+
+
+load_dotenv()
+model = ChatOpenAI(model="gpt-4.1-mini", temperature=0)
+
+
+in_memory_store = InMemoryStore()
+# Namespace for the memory to save
+user_id = "1"
+namespace_for_memory = (user_id, "memories")
+
+# Save a memory to namespace as key and value
+key = str(uuid.uuid4())
+
+# The value needs to be a dictionary
+value = {"food_preference" : "I like pizza"}
+
+# Save the memory
+in_memory_store.put(namespace_for_memory, key, value)
+
+# Search
+memories = in_memory_store.search(namespace_for_memory)
+# The key, value
+print("--------------")
+print("Memories:")
+print(memories[0].key, memories[0].value)
+# Get the memory by namespace and key
+memory = in_memory_store.get(namespace_for_memory, key)
+print("--------------")
+print("Memory by key:")
+print(memory.dict())
+
+# Chatbot with long-term memory
+
+# Chatbot instruction
+MODEL_SYSTEM_MESSAGE = """You are a helpful assistant with memory that provides information about the user.
+If you have memory for this user, use it to personalize your responses.
+Here is the memory (it may be empty): {memory}"""
+
+# Create new memory from the chat history and any existing memory
+CREATE_MEMORY_INSTRUCTION = """"You are collecting information about the user to personalize your responses.
+
+CURRENT USER INFORMATION:
+{memory}
+
+INSTRUCTIONS:
+1. Review the chat history below carefully
+2. Identify new information about the user, such as:
+   - Personal details (name, location)
+   - Preferences (likes, dislikes)
+   - Interests and hobbies
+   - Past experiences
+   - Goals or future plans
+3. Merge any new information with existing memory
+4. Format the memory as a clear, bulleted list
+5. If new information conflicts with existing memory, keep the most recent version
+
+Remember: Only include factual information directly stated by the user. Do not make assumptions or inferences.
+
+Based on the chat history below, please update the user information:"""
+
+def call_model(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Load memory from the store and use it to personalize the chatbot's response."""
+
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Retrieve memory from the store
+    namespace = ("memory", user_id)
+    key = "user_memory"
+    existing_memory = store.get(namespace, key)
+
+    # Extract the actual memory content if it exists and add a prefix
+    if existing_memory:
+        # Value is a dictionary with a memory key
+        existing_memory_content = existing_memory.value.get('memory')
+    else:
+        existing_memory_content = "No existing memory found."
+
+    # Format the memory in the system prompt
+    system_msg = MODEL_SYSTEM_MESSAGE.format(memory=existing_memory_content)
+
+    # Respond using memory as well as the chat history
+    response = model.invoke([SystemMessage(content=system_msg)]+state["messages"])
+
+    return {"messages": response}
+
+def write_memory(state: MessagesState, config: RunnableConfig, store: BaseStore):
+
+    """Reflect on the chat history and save a memory to the store."""
+
+    # Get the user ID from the config
+    user_id = config["configurable"]["user_id"]
+
+    # Retrieve existing memory from the store
+    namespace = ("memory", user_id)
+    existing_memory = store.get(namespace, "user_memory")
+
+    # Extract the memory
+    if existing_memory:
+        existing_memory_content = existing_memory.value.get('memory')
+    else:
+        existing_memory_content = "No existing memory found."
+
+    # Format the memory in the system prompt
+    system_msg = CREATE_MEMORY_INSTRUCTION.format(memory=existing_memory_content)
+    new_memory = model.invoke([SystemMessage(content=system_msg)]+state['messages'])
+
+    # Overwrite the existing memory in the store
+    key = "user_memory"
+
+    # Write value as a dictionary with a memory key
+    store.put(namespace, key, {"memory": new_memory.content})
+
+# Define the graph
+builder = StateGraph(MessagesState)
+builder.add_node("call_model", call_model)
+builder.add_node("write_memory", write_memory)
+builder.add_edge(START, "call_model")
+builder.add_edge("call_model", "write_memory")
+builder.add_edge("write_memory", END)
+
+# Store for long-term (across-thread) memory
+across_thread_memory = InMemoryStore()
+
+# Checkpointer for short-term (within-thread) memory
+within_thread_memory = MemorySaver()
+
+# Compile the graph with the checkpointer fir and store
+graph = builder.compile(checkpointer=within_thread_memory, store=across_thread_memory)
+
+# with open("memorystore01.png", "wb") as f:
+#     f.write(graph.get_graph().draw_mermaid_png())
+
+# We supply a thread ID for short-term (within-thread) memory
+# We supply a user ID for long-term (across-thread) memory
+config = {"configurable": {"thread_id": "1", "user_id": "1"}}
+
+
+print("-------------------")
+print("Mensaje 1")
+print("-------------------")
+# User input
+input_messages = [HumanMessage(content="Hi, my name is Lance")]
+
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+print("-------------------")
+print("Mensaje 2")
+print("-------------------")
+# User input
+input_messages = [HumanMessage(content="I like to bike around San Francisco")]
+
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+print("-------------------")
+print("Mensaje Hilo")
+print("-------------------")
+thread = {"configurable": {"thread_id": "1"}}
+state = graph.get_state(thread).values
+for m in state["messages"]:
+    m.pretty_print()
+
+print("-------------------")
+print("user memory")
+print("-------------------")
+# Namespace for the memory to save
+user_id = "1"
+namespace = ("memory", user_id)
+existing_memory = across_thread_memory.get(namespace, "user_memory")
+print(existing_memory.dict())
+
+print("-------------------")
+print("thread_id 2")
+print("-------------------")
+# We supply a user ID for across-thread memory as well as a new thread ID
+config = {"configurable": {"thread_id": "2", "user_id": "1"}}
+
+# User input
+input_messages = [HumanMessage(content="Hi! Where would you recommend that I go biking?")]
+
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()
+
+print("-------------------")
+print("Last")
+print("-------------------")
+# User input
+input_messages = [HumanMessage(content="Great, are there any bakeries nearby that I can check out? I like a croissant after biking.")]
+
+# Run the graph
+for chunk in graph.stream({"messages": input_messages}, config, stream_mode="values"):
+    chunk["messages"][-1].pretty_print()