first commt

.env

@@ -0,0 +1 @@
+GROQ_API_KEY = gsk_0hPoH6j7ExBFHfANeVjZruldUJSHRRTDIzBU

app.py

@@ -0,0 +1,237 @@
+# 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
+
+
+# -----------------------
+# Generate Thread ID
+# -----------------------
+def new_thread_id():
+    return str(uuid.uuid4())[:8]
+
+
+# -----------------------
+# First Thread
+# -----------------------
+first_thread = new_thread_id()
+
+
+# -----------------------
+# Chat Function
+# -----------------------
+def chat_fn(message, chat_history, thread_id, all_threads):
+
+    config = {"configurable": {"thread_id": thread_id}}
+
+    res = chatbot.invoke(
+        {"messages": [HumanMessage(content=message)]},
+        config=config
+    )
+
+    ai_message = res["messages"][-1].content
+
+    # Append in NEW format
+    chat_history.append({"role": "user", "content": message})
+    chat_history.append({"role": "assistant", "content": ai_message})
+
+    all_threads[thread_id] = chat_history
+
+    return "", chat_history, all_threads
+
+
+# -----------------------
+# Create New Thread
+# -----------------------
+def create_new_thread(all_threads):
+    new_id = new_thread_id()
+    all_threads[new_id] = []
+
+    return (
+        all_threads,
+        gr.update(choices=list(all_threads.keys()), value=new_id),
+        new_id,
+        []
+    )
+
+
+# -----------------------
+# Switch Thread
+# -----------------------
+def switch_thread(thread_id, all_threads):
+    history = all_threads.get(thread_id, [])
+    return thread_id, history
+
+
+# -----------------------
+# UI
+# -----------------------
+with gr.Blocks() as demo:
+
+    thread_state = gr.State(first_thread)
+    threads_state = gr.State({first_thread: []})
+
+    with gr.Row():
+
+        # Sidebar
+        with gr.Column(scale=1):
+            gr.Markdown("## 🧵 Threads")
+
+            thread_radio = gr.Radio(
+                choices=[first_thread],
+                value=first_thread,
+                label="Select Thread"
+            )
+
+            new_chat_btn = gr.Button("➕ New Chat")
+
+        # Main Chat
+        with gr.Column(scale=4):
+
+            chatbot_ui = gr.Chatbot()
+            msg_box = gr.Textbox(placeholder="Type message and press Enter")
+
+            msg_box.submit(
+                chat_fn,
+                inputs=[msg_box, chatbot_ui, thread_state, threads_state],
+                outputs=[msg_box, chatbot_ui, threads_state],
+            )
+
+    # New Chat Button
+    new_chat_btn.click(
+        create_new_thread,
+        inputs=threads_state,
+        outputs=[
+            threads_state,
+            thread_radio,
+            thread_state,
+            chatbot_ui
+        ]
+    )
+
+    # Switch Thread
+    thread_radio.change(
+        switch_thread,
+        inputs=[thread_radio, threads_state],
+        outputs=[thread_state, chatbot_ui]
+    )
+
+
+demo.launch()

chatbot.py

@@ -0,0 +1,41 @@
+from langgraph.graph import START,END,StateGraph
+from typing import TypedDict, Annotated
+from langchain_core.messages import BaseMessage,HumanMessage
+from langchain_groq import ChatGroq
+from langgraph.graph.message import add_messages
+from langgraph.checkpoint.memory import InMemorySaver  
+from dotenv import load_dotenv
+
+load_dotenv()
+
+checkpointer= InMemorySaver()
+
+llm = ChatGroq(
+    model="qwen/qwen3-32b",
+    temperature=0,
+    max_tokens=None,
+    reasoning_format="parsed",
+    timeout=None,
+    max_retries=2,
+    # other params...
+)
+
+
+class ChatStat(TypedDict):
+    messages: Annotated[list[BaseMessage],add_messages]
+
+
+def chat_node(state : ChatStat):
+    messages = state['messages']
+    response = llm.invoke(messages)
+    return {'messages': [response]}
+
+
+graph = StateGraph(ChatStat)
+
+graph.add_node("chat_node",chat_node)
+
+graph.add_edge(START,'chat_node')
+graph.add_edge("chat_node",END)
+
+chatbot = graph.compile(checkpointer=checkpointer)