add: simple gradio app with langgraph

app.py

@@ -0,0 +1,271 @@
+import functools
+import os
+import uuid
+import asyncio
+import gradio as gr
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import MessagesState, END, StateGraph
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
+from langgraph.checkpoint.memory import MemorySaver
+
+SYSTEM_PROMPT = """
+You are an assistant that can manage Trello boards and projects.
+You will be given a set of tools to work with. Each time you decide to use a tool that modifies in any way a Trello board, you MUST ask the user if wants to proceed.
+If the user's answer is negative, then you have to abort everything and end the conversation.
+"""
+
+
+class LangGraphAgent:
+    def __init__(self):
+        self.agent_app = None
+        self.config = {"configurable": {"thread_id": f"{str(uuid.uuid4())}"}}
+        self.memory = MemorySaver()
+
+    def reset_thread(self):
+        """Resets the conversation thread for the agent."""
+        self.config = {"configurable": {"thread_id": f"{str(uuid.uuid4())}"}}
+        print(
+            f"Chat thread reset. New Thread ID: {self.config['configurable']['thread_id']}"
+        )
+
+    async def setup(self):
+        print("Setting up LangGraphAgent...")
+        mcp_client = MultiServerMCPClient(
+            {
+                "trello": {
+                    "url": "http://localhost:8000/sse",
+                    "transport": "sse",
+                }
+            }
+        )
+
+        tools = await mcp_client.get_tools()
+        tool_node = ToolNode(tools)
+
+        # Ensure NEBIUS_API_KEY is set
+        api_key = os.getenv("NEBIUS_API_KEY")
+        if not api_key:
+            raise ValueError("NEBIUS_API_KEY environment variable not set.")
+
+        llm_with_tools = ChatOpenAI(
+            model="meta-llama/Meta-Llama-3.1-8B-Instruct",
+            temperature=0.0,
+            api_key=api_key,
+            base_url="https://api.studio.nebius.com/v1/",
+        )
+        llm_with_tools = llm_with_tools.bind_tools(tools)
+
+        async def call_llm(state: MessagesState):
+            response = await llm_with_tools.ainvoke(
+                state["messages"]
+            )  # Use await for async invoke
+            return {"messages": [response]}
+
+        graph = StateGraph(MessagesState)
+        graph.add_node("llm", functools.partial(call_llm))
+        graph.add_node("tool", tool_node)
+        graph.set_entry_point("llm")
+
+        def should_continue(state: MessagesState):
+            last_message = state["messages"][-1]
+            return (
+                "tool"
+                if hasattr(last_message, "tool_calls") and last_message.tool_calls
+                else END
+            )
+
+        graph.add_conditional_edges("llm", should_continue, {"tool": "tool", END: END})
+        graph.add_edge("tool", "llm")
+
+        self.agent_app = graph.compile(checkpointer=self.memory)
+        print("LangGraphAgent setup complete.")
+
+    async def generate_responses_for_turn(
+        self, user_message_text: str, is_first_turn_in_ui: bool
+    ) -> list[str]:
+        """
+        Generates a list of bot utterances for the current turn based on user input.
+        """
+        langgraph_input_messages = []
+        # The SYSTEM_PROMPT is added to the graph input only if it's the first UI interaction *and*
+        # the checkpointer implies it's the start of a new conversation for the thread_id.
+        # MemorySaver will handle loading history; system prompt is good for first message of a thread.
+
+        # Check current state in memory to decide if SystemMessage is truly needed
+        thread_state = await self.memory.aget(self.config)  # Use aget for async
+        is_new_thread_conversation = (
+            not thread_state
+            or not thread_state.get("values")
+            or not thread_state["values"]["messages"]
+        )
+
+        if is_new_thread_conversation:
+            print("Adding System Prompt for new conversation thread.")
+            langgraph_input_messages.append(
+                SystemMessage(content=SYSTEM_PROMPT.strip())
+            )
+
+        langgraph_input_messages.append(HumanMessage(content=user_message_text))
+
+        bot_responses_this_turn = []
+        processed_message_ids_in_stream = set()
+
+        async for result in self.agent_app.astream(
+            {"messages": langgraph_input_messages},
+            config=self.config,
+            stream_mode="values",
+        ):
+            if not result or "messages" not in result or not result["messages"]:
+                continue
+
+            latest_message_in_graph_state = result["messages"][-1]
+
+            if (
+                isinstance(latest_message_in_graph_state, AIMessage)
+                and latest_message_in_graph_state.id
+                not in processed_message_ids_in_stream
+            ):
+                current_ai_msg = latest_message_in_graph_state
+                # Add message ID to set of processed messages to avoid duplication from multiple stream events
+                # for the same underlying message object.
+                # However, AIMessages can be broken into chunks if streaming content.
+                # For now, with stream_mode="values", we get full messages.
+                # The id check is crucial if the same AIMessage object instance appears multiple times in the stream values.
+
+                newly_generated_content_for_this_step = []
+
+                # 1. Handle AIMessage content
+                if current_ai_msg.content:
+                    # Add content if it's new or different from the last added piece
+                    if (
+                        not bot_responses_this_turn
+                        or bot_responses_this_turn[-1] != current_ai_msg.content
+                    ):
+                        newly_generated_content_for_this_step.append(
+                            str(current_ai_msg.content)
+                        )
+
+                # 2. Handle tool calls
+                if hasattr(current_ai_msg, "tool_calls") and current_ai_msg.tool_calls:
+                    for tool_call in current_ai_msg.tool_calls:
+                        # Check if this specific tool call has been processed (e.g., by ID if available, or by content)
+                        # For simplicity, we assume each tool_call in a new AIMessage is distinct for now
+                        call_str = f"**Tool Call:** `{tool_call['name']}`\n*Arguments:* `{tool_call['args']}`"
+                        newly_generated_content_for_this_step.append(call_str)
+
+                if newly_generated_content_for_this_step:
+                    bot_responses_this_turn.extend(
+                        newly_generated_content_for_this_step
+                    )
+                    processed_message_ids_in_stream.add(
+                        current_ai_msg.id
+                    )  # Mark this AIMessage ID as processed
+
+        # Deduplicate consecutive identical messages that might arise from streaming nuances
+        final_bot_responses = []
+        if bot_responses_this_turn:
+            final_bot_responses.append(bot_responses_this_turn[0])
+            for i in range(1, len(bot_responses_this_turn)):
+                if bot_responses_this_turn[i] != bot_responses_this_turn[i - 1]:
+                    final_bot_responses.append(bot_responses_this_turn[i])
+
+        return final_bot_responses
+
+
+agent = LangGraphAgent()
+
+# Apply a theme
+theme = gr.themes.Soft(
+    primary_hue="blue", secondary_hue="sky", neutral_hue="slate"
+).set(
+    body_background_fill="linear-gradient(to right, #f0f4f8, #e6e9f0)",  # Light gradient background
+    block_background_fill="white",
+    block_border_width="1px",
+    block_shadow="*shadow_drop_lg",
+    button_primary_background_fill="*primary_500",
+    button_primary_text_color="white",
+    button_secondary_background_fill="*secondary_500",
+    button_secondary_text_color="white",
+)
+
+with gr.Blocks(theme=theme, title="Trello AI Assistant") as demo:
+    gr.Markdown(
+        """
+        # Trello AI Assistant
+        Manage your Trello boards and projects with AI assistance.
+        """
+    )
+
+    chatbot = gr.Chatbot(
+        label="Conversation",
+        bubble_full_width=False,
+        height=600,
+        avatar_images=(
+            None,
+            "https://upload.wikimedia.org/wikipedia/commons/thumb/7/72/Brandon_Sanderson_in_2018.jpg/800px-Brandon_Sanderson_in_2018.jpg?20230101015657",
+        ),
+        # (user_avatar, bot_avatar) - replace bot avatar with something better or remove
+    )
+
+    with gr.Row():
+        msg = gr.Textbox(
+            label="Your Message",
+            placeholder="Type your message here and press Enter to send...",
+            scale=4,  # Make textbox take more space
+            autofocus=True,
+        )
+        # submit_button = gr.Button("Send", variant="primary", scale=1) # Optional: if you want an explicit send button
+
+    clear_button = gr.Button("🗑️ Clear Chat & Reset Conversation")
+
+    async def respond(user_message_text, chat_history):
+        if not user_message_text.strip():
+            return (
+                chat_history,
+                "",
+            )  # Ignore empty input, return current history and clear textbox
+
+        is_first_turn = not chat_history
+
+        # Append user message to chat_history optimistically for immediate display
+        # Bot response will fill in the 'None' later or add new [None, bot_msg] rows
+        # This makes UI feel more responsive.
+        # chat_history.append([user_message_text, None]) # Temporarily removed for simpler logic below
+
+        ai_utterances = await agent.generate_responses_for_turn(
+            user_message_text, is_first_turn
+        )
+
+        if ai_utterances:
+            chat_history.append([user_message_text, ai_utterances[0]])
+            for i in range(1, len(ai_utterances)):
+                chat_history.append([None, ai_utterances[i]])
+        else:
+            # If agent provides no utterances (e.g. error or no action)
+            chat_history.append(
+                [user_message_text, "I don't have a response for that right now."]
+            )
+
+        return chat_history, ""  # Return updated history and clear the textbox
+
+    # Event handlers
+    msg.submit(respond, [msg, chatbot], [chatbot, msg])
+
+    # if submit_button: # If you add explicit send button
+    #     submit_button.click(respond, [msg, chatbot], [chatbot, msg])
+
+    def clear_chat_and_reset_agent():
+        agent.reset_thread()
+        return [], ""  # Clears chatbot UI and textbox
+
+    clear_button.click(clear_chat_and_reset_agent, None, [chatbot, msg], queue=False)
+
+    # Load agent setup when the app starts
+    # Using a lambda to ensure asyncio.run is called within the demo's event loop context if needed
+    demo.load(lambda: asyncio.run(agent.setup()))
+
+if __name__ == "__main__":
+    demo.launch()