add logg term and short term memory

.gitignore

@@ -0,0 +1,3 @@
+venv
+__pycache__/
+

app.py

@@ -1,124 +1,8 @@
-# import gradio as gr
-# from chabot import chatbot
-# from langchain_core.messages import HumanMessage
-
-# config = {"configurable": {"thread_id": "1"}}
-
-# # ---- Gradio Chat Function ----
-# def chat_fn(message, history):
-#     """
-#     message: current user message (string)
-#     history: list of previous messages [(user, bot), ...]
-#     """
-
-#     # Send message to LangGraph chatbot
-#     res = chatbot.invoke(
-#         {"messages": [HumanMessage(content=message)]},
-#         config=config
-#     )
-
-#     # Get AI response
-#     ai_message = res["messages"][-1].content
-
-#     return ai_message
-
-
-# # ---- Create UI ----
-# demo = gr.ChatInterface(
-#     fn=chat_fn,
-#     title="LangGraph + Groq Chatbot",
-#     description="Chatbot powered by LangGraph, Groq (Qwen3-32B), and memory",
-# )
-
-# if __name__ == "__main__":
-#     demo.launch()
-
-
-
-# import gradio as gr
-# import uuid
-# from langchain_core.messages import HumanMessage
-# from chabot import chatbot
-
-# # -----------------------
-# # Generate Unique Thread ID
-# # -----------------------
-# def new_thread():
-#     config = {"configurable": {"thread_id": str(uuid.uuid4())[:8] }}
-#     return config
-
-
-# # -----------------------
-# # Chat Function
-# # -----------------------
-# def chat_fn(message, history, thread_id):
-#     config = {"configurable": {"thread_id": thread_id}}
-
-#     res = chatbot.invoke(
-#         {"messages": [HumanMessage(content=message)]},
-#         config=config
-#     )
-
-#     ai_message = res["messages"][-1].content
-#     return ai_message
-
-
-# # -----------------------
-# # Start With Default Thread
-# # -----------------------
-# default_thread = new_thread()
-# default_thread = default_thread["configurable"]["thread_id"]
-
-# # -----------------------
-# # Gradio UI
-# # -----------------------
-# with gr.Blocks() as demo:
-
-#     # Store thread id in hidden state
-#     thread_state = gr.State(default_thread)
-
-#     with gr.Row():
-
-#         # -------- Left Sidebar --------
-#         with gr.Column(scale=1):
-#             gr.Markdown("## 🧵 Current Thread ID")
-#             thread_display = gr.Textbox(
-#                 value=default_thread,
-#                 interactive=False,
-#                 label="Thread ID"
-#             )
-
-#             new_chat_btn = gr.Button("➕ New Chat")
-
-#         # -------- Main Chat Area --------
-#         with gr.Column(scale=4):
-#             chatbot_ui = gr.ChatInterface(
-#                 fn=lambda msg, hist: chat_fn(msg, hist, thread_state.value),
-#                 title="LangGraph + Groq Chatbot",
-#                 description="Memory enabled chatbot with unique threads",
-#             )
-
-#     # -----------------------
-#     # New Chat Button Logic
-#     # -----------------------
-#     def reset_chat():
-#         new_id = new_thread()
-#         return new_id, new_id, []
-
-#     new_chat_btn.click(
-#         reset_chat,
-#         outputs=[thread_state, thread_display, chatbot_ui.chatbot]
-#     )
-
-
-# demo.launch()
-
-
-
 import gradio as gr
 import uuid
 from langchain_core.messages import HumanMessage
-from chatbot import chatbot
+# from chatbot import chatbot
+from memory_chatbot import chatbot
 
 
 # -----------------------
@@ -139,7 +23,7 @@ first_thread = new_thread_id()
 # -----------------------
 def chat_fn(message, chat_history, thread_id, all_threads):
 
-    config = {"configurable": {"thread_id": thread_id}}
+    config = {"configurable": {"thread_id": thread_id, "user_id": "user_id"}}
 
     res = chatbot.invoke(
         {"messages": [HumanMessage(content=message)]},

memory_chatbot.py

@@ -0,0 +1,217 @@
+import json
+from typing import TypedDict, Annotated
+
+from dotenv import load_dotenv
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_groq import ChatGroq
+
+from langgraph.graph import START, END, StateGraph
+from langgraph.graph.message import add_messages
+
+# Short-term memory
+from langgraph.checkpoint.memory import InMemorySaver
+
+# Long-term memory
+from langgraph.store.memory import InMemoryStore
+
+# Agent
+from langchain.agents import create_agent
+from tool import tool_tavily,time_date,calculator,python_exec,get_weather,wikipedia_search,scrape_website,read_file,format_json,generate_sql,system_info,save_user_preference
+
+
+load_dotenv()
+
+tools = [tool_tavily,time_date,calculator,python_exec,get_weather,wikipedia_search,scrape_website,read_file,format_json,generate_sql,system_info,save_user_preference]
+
+# -----------------------------
+# Memory Systems
+# -----------------------------
+
+checkpointer = InMemorySaver()
+store = InMemoryStore()
+
+# -----------------------------
+# LLM
+# -----------------------------
+
+llm = ChatGroq(
+    model="qwen/qwen3-32b",
+    temperature=0,
+    reasoning_format="parsed",
+)
+
+# -----------------------------
+# State
+# -----------------------------
+
+class ChatState(TypedDict):
+    messages: Annotated[list[BaseMessage], add_messages]
+
+
+# -----------------------------
+# Memory Analyzer Node
+# -----------------------------
+
+def memory_analyzer(state: ChatState, config, store):
+
+    user_id = config["configurable"]["user_id"]
+
+    last_message = state["messages"][-1].content
+
+    prompt = f"""
+Analyze the message and decide if it contains useful long-term memory.
+
+Possible memory categories:
+- preferences
+- profile
+- interests
+- project
+
+Return JSON format:
+
+{{
+ "store_memory": true/false,
+ "category": "preferences | profile | interests | project",
+ "key": "memory_key",
+ "value": {{}}
+}}
+
+Message:
+{last_message}
+"""
+
+    result = llm.invoke([HumanMessage(content=prompt)])
+
+    try:
+        data = json.loads(result.content)
+
+        if data.get("store_memory"):
+
+            namespace = (user_id, data["category"])
+
+            store.put(
+                namespace,
+                data["key"],
+                data["value"]
+            )
+
+            print("Stored memory:", data)
+
+    except Exception as e:
+        pass
+
+    return {}
+
+
+# -----------------------------
+# Memory Retrieval Node
+# -----------------------------
+
+def memory_retrieval(state: ChatState, config, store):
+
+    user_id = config["configurable"]["user_id"]
+    query = state["messages"][-1].content
+
+    categories = [
+        "preferences",
+        "profile",
+        "interests",
+        "project"
+    ]
+
+    all_memories = []
+
+    for category in categories:
+
+        namespace = (user_id, category)
+
+        results = store.search(
+            namespace,
+            query=query,
+            limit=3
+        )
+
+        all_memories.extend(results)
+
+    memory_text = "\n".join(
+        [f"{m.namespace[1]}: {m.value}" for m in all_memories]
+    )
+
+    if memory_text:
+
+        state["messages"].append(
+            HumanMessage(
+                content=f"Relevant user memories:\n{memory_text}"
+            )
+        )
+
+    return {"messages": state["messages"]}
+
+# -----------------------------
+# Chat Node
+# -----------------------------
+
+
+def chat_node(state: ChatState):
+    agent = create_agent(llm, tools=tools)
+    messages = state["messages"]
+    
+    response = agent.invoke({"messages": messages})
+      
+    # Return only messages added by the agent (exclude the ones we sent in)
+    new_messages = response["messages"][len(messages):]
+    return {"messages": new_messages}
+
+# -----------------------------
+# Graph
+# -----------------------------
+
+graph = StateGraph(ChatState)
+
+graph.add_node("memory_analyzer", memory_analyzer)
+graph.add_node("memory_retrieval", memory_retrieval)
+graph.add_node("chat_node", chat_node)
+
+graph.add_edge(START, "memory_analyzer")
+graph.add_edge("memory_analyzer", "memory_retrieval")
+graph.add_edge("memory_retrieval", "chat_node")
+graph.add_edge("chat_node", END)
+
+chatbot = graph.compile(
+    checkpointer=checkpointer,
+    store=store
+)
+
+# -----------------------------
+# Chat Loop
+# -----------------------------
+
+# config = {
+#     "configurable": {
+#         "thread_id": "thread_1",
+#         "user_id": "user_123"
+#     }
+# }
+
+# messages = []
+
+# while True:
+
+#     user_input = input("\nUser: ")
+
+#     if user_input.lower() in ["quit", "exit"]:
+#         break
+
+#     messages.append(HumanMessage(content=user_input))
+
+#     result = chatbot.invoke(
+#         {"messages": messages},
+#         config
+#     )
+
+#     response = result["messages"][-1].content
+
+#     print("\nAssistant:", response)
+
+#     messages = result["messages"]
+

test.ipynb

@@ -0,0 +1,113 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "2946f394",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import create_agent\n",
+    "from dotenv import load_dotenv\n",
+    "from langchain_groq import ChatGroq\n",
+    "from langchain_core.messages import BaseMessage, HumanMessage\n",
+    "\n",
+    "load_dotenv()\n",
+    "\n",
+    "llm = ChatGroq(\n",
+    "    model=\"qwen/qwen3-32b\",\n",
+    "    temperature=0,\n",
+    "    reasoning_format=\"parsed\",\n",
+    "    streaming=True\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def get_weather(city: str) -> str:\n",
+    "    \"\"\"Get weather for a given city.\"\"\"\n",
+    "\n",
+    "    return f\"It's always sunny in {city}!\"\n",
+    "\n",
+    "tools = [get_weather]\n",
+    "agent = create_agent(llm, tools=tools)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "7ddafbda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for chunk in llm.stream(\n",
+    "#     {\"messages\": [{\"role\": \"user\", \"content\": \"write 500 words eassy on AI\"}]}\n",
+    "# ):\n",
+    "#     if chunk.get(\"model\"):\n",
+    "#         print(chunk.get(\"model\").get(\"messages\")[0].content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "acd47304",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "**The Rise of Artificial Intelligence: Promise and Peril**  \n",
+      "\n",
+      "Artificial Intelligence (AI), the simulation of human intelligence by machines, has emerged as one of the most transformative technologies of the 21st century. From streamlining industries to redefining daily life, AI’s influence is pervasive. However, its rapid advancement also raises critical questions about ethics, employment, and societal impact. As we navigate this dual-edged revolution, understanding AI’s potential and pitfalls is essential for shaping a future that balances innovation with responsibility.  \n",
+      "\n",
+      "AI’s applications span nearly every sector. In healthcare, machine learning algorithms analyze medical data to detect diseases like cancer with unprecedented accuracy, while robotic surgery systems enhance precision in operations. In education, AI-powered platforms personalize learning, adapting to individual student needs and bridging gaps in traditional teaching methods. The financial industry leverages AI for fraud detection, risk management, and algorithmic trading, optimizing decisions in milliseconds. Even creative fields, such as music and art, now incorporate AI tools that generate original content, challenging notions of human creativity. These advancements underscore AI’s capacity to augment human capabilities, driving efficiency and innovation.  \n",
+      "\n",
+      "Yet, the rise of AI is not without challenges. One of the most pressing concerns is job displacement. Automation threatens industries reliant on repetitive tasks, from manufacturing to customer service, potentially exacerbating economic inequality. While new roles in AI development and maintenance are emerging, the transition may leave many workers behind, necessitating robust reskilling initiatives. Additionally, biases embedded in AI systems—often reflecting historical prejudices in training data—can perpetuate discrimination in areas like hiring, lending, and law enforcement. Addressing these biases requires diverse, inclusive datasets and transparent algorithms.  \n",
+      "\n",
+      "Ethical dilemmas further complicate AI’s trajectory. Autonomous weapons, for instance, raise moral questions about delegating life-and-death decisions to machines. Privacy concerns intensify as AI analyzes vast amounts of personal data, often without explicit consent. The 2023 EU AI Act, which classifies AI systems by risk level and imposes strict regulations on high-risk applications, reflects growing global efforts to establish ethical frameworks. However, enforcement remains inconsistent, highlighting the need for international collaboration to prevent misuse.  \n",
+      "\n",
+      "The future of AI hinges on striking a balance between innovation and accountability. Governments, corporations, and academia must collaborate to develop policies that prioritize human welfare. Investments in AI literacy and education will empower individuals to adapt to technological shifts, while ethical AI design—centered on fairness, transparency, and privacy—can mitigate risks. Public dialogue is equally vital, ensuring that diverse perspectives shape AI’s evolution.  \n",
+      "\n",
+      "In conclusion, AI represents both a remarkable opportunity and a profound responsibility. Its ability to solve complex problems and enhance human potential is undeniable, but unchecked, it risks amplifying societal divides and ethical crises. By fostering inclusive, ethical development, we can harness AI as a tool for collective progress rather than a source of division. The choices we make today will determine whether AI becomes a force for good—or a harbinger of unintended consequences."
+     ]
+    }
+   ],
+   "source": [
+    "for chunk in llm.stream(\n",
+    "    [{\"role\": \"user\", \"content\": \"write 500 words essay on AI\"}]\n",
+    "):\n",
+    "    if chunk.content:\n",
+    "        print(chunk.content, end=\"\", flush=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf450c3d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

tool.py

@@ -0,0 +1,108 @@
+from langchain_tavily import TavilySearch
+from langchain.tools import tool
+from datetime import date
+
+import platform
+import json
+import requests
+import wikipedia
+from bs4 import BeautifulSoup
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+tool_tavily = TavilySearch(
+    max_results=5,
+    topic="general"
+)
+
+@tool
+def time_date():
+    """ This give today date in format yyyy-mm-dd """
+    today = date.today()
+    return today
+
+
+@tool
+def calculator(expression: str) -> str:
+    """Evaluate mathematical expressions"""
+    try:
+        return str(eval(expression))
+    except Exception as e:
+        return str(e)
+    
+@tool
+def python_exec(code: str) -> str:
+    """Execute Python code"""
+    try:
+        local_vars = {}
+        exec(code, {}, local_vars)
+        return str(local_vars)
+    except Exception as e:
+        return str(e)
+
+
+
+@tool
+def get_weather(city: str) -> str:
+    """Get current weather for a city"""
+    url = f"https://wttr.in/{city}?format=3"
+    return requests.get(url).text
+
+
+
+@tool
+def wikipedia_search(query: str) -> str:
+    """Search Wikipedia"""
+    try:
+        return wikipedia.summary(query, sentences=3)
+    except:
+        return "No result found"
+    
+
+
+
+@tool
+def scrape_website(url: str) -> str:
+    """Extract text from a webpage"""
+    res = requests.get(url)
+    soup = BeautifulSoup(res.text, "html.parser")
+    return soup.get_text()[:2000]
+
+@tool
+def read_file(path: str) -> str:
+    """Read local file content"""
+    try:
+        with open(path, "r") as f:
+            return f.read()
+    except Exception as e:
+        return str(e)
+    
+
+
+@tool
+def format_json(data: str) -> str:
+    """Format JSON string"""
+    try:
+        parsed = json.loads(data)
+        return json.dumps(parsed, indent=2)
+    except Exception as e:
+        return str(e)
+    
+@tool
+def generate_sql(query: str) -> str:
+    """Convert natural language to SQL"""
+    return f"-- SQL Query for: {query}"
+
+
+@tool
+def system_info() -> str:
+    """Get system information"""
+    return platform.platform()
+
+@tool
+def save_user_preference(text: str) -> str:
+    """Save user preference or important info"""
+    # later connect to store.put()
+    return f"Saved memory: {text}"