Upload app.py

Improve chat UI and implement search result caching.

This commit fixes the chat display by switching to the default Gradio Chatbot (tuple-based) with a fixed height and returning chat pairs so conversations are visible. It also introduces a per-session resource cache to store web search results keyed by the query, preventing repeated searches and ensuring all resources shown come from real results. When searching, previously seen URLs are filtered out before adding to sources. State management now includes the resource cache alongside chat history, pairs, sources, and plan.

app.py

@@ -14,13 +14,15 @@ SYSTEM_PROMPT = (
     "conversation and gathered resources."
 )
 
-def chat(user_message, chat_history, chat_pairs, sources, plan):
+def chat(user_message, chat_history, chat_pairs, sources, plan, resource_cache):
     """Handle a user chat message and return updated chat state."""
-    # Ensure lists are initialised
+    # Ensure lists/dicts are initialised
     if chat_history is None:
         chat_history = []
     if chat_pairs is None:
         chat_pairs = []
+    if resource_cache is None:
+        resource_cache = {}
     # Append the user's message to the conversation history (list of dictionaries for Chatbot)
     chat_history.append({"role": "user", "content": user_message})
     # Build messages including system prompt for API call
@@ -131,8 +133,14 @@ def chat(user_message, chat_history, chat_pairs, sources, plan):
         lower_msg = user_message.lower()
         if any(trig in lower_msg for trig in search_triggers):
             try:
-                # Perform web search using the entire user message as the query
-                results = run_web_search(user_message, num_results=5, domain_filter="")
+                # Perform web search using the entire user message as the query. Use cached results if available
+                query_key = user_message.strip().lower()
+                if query_key in resource_cache:
+                    results = resource_cache[query_key]
+                else:
+                    results = run_web_search(user_message, num_results=5, domain_filter="")
+                    # store results in cache for future queries
+                    resource_cache[query_key] = results
                 # Normalize results:
                 # Tavily may return a dictionary with a "results" key containing
                 # the list of search results. If so, extract that list. If it's a
@@ -146,10 +154,24 @@ def chat(user_message, chat_history, chat_pairs, sources, plan):
                 # Ensure the sources list is initialised
                 if sources is None:
                     sources = []
-                sources.extend(normalized_results)
+                # Filter out duplicate URLs already in sources
+                existing_urls = set()
+                for src in sources:
+                    if isinstance(src, dict):
+                        url = src.get("url")
+                        if url:
+                            existing_urls.add(url)
+                new_results = []
+                for r in normalized_results:
+                    if isinstance(r, dict):
+                        url = r.get("url")
+                        if url and url not in existing_urls:
+                            new_results.append(r)
+                            existing_urls.add(url)
+                sources.extend(new_results)
                 # Summarise results into a simple string with title and URL
                 summary_lines = []
-                for r in normalized_results:
+                for r in new_results:
                     # Defensive: ensure r is a dict
                     if isinstance(r, dict):
                         title = r.get("title", "")
@@ -159,7 +181,10 @@ def chat(user_message, chat_history, chat_pairs, sources, plan):
                 if summary_lines:
                     assistant_reply = "Here are some resources I found:\n" + "\n".join(summary_lines)
                 else:
-                    assistant_reply = "I couldn't find any results for that query."
+                    if normalized_results:
+                        assistant_reply = "I've already shared the relevant resources from this search."
+                    else:
+                        assistant_reply = "I couldn't find any results for that query."
             except Exception as e:
                 assistant_reply = (
                     "An error occurred during web search. Please ensure your search API key is configured.\n"
@@ -228,8 +253,8 @@ def chat(user_message, chat_history, chat_pairs, sources, plan):
     chat_history.append({"role": "assistant", "content": assistant_reply})
     # Append pair to display history for any other uses (kept for compatibility)
     chat_pairs.append((user_message, assistant_reply))
-    # For Chatbot with type="messages", return the chat_history as the first output
-    return chat_history, chat_history, chat_pairs, sources, plan
+    # For Chatbot with default type (list of (user, assistant) tuples), return chat_pairs as the first output
+    return chat_pairs, chat_history, chat_pairs, sources, plan, resource_cache
 
 def run_search(query, chat_history, chat_pairs, sources, plan, num_results=5, domain_filter=""):
     """Execute a web search and update sources list."""
@@ -309,9 +334,10 @@ with gr.Blocks() as demo:
 Chat with the assistant to brainstorm your course idea. You can ask the assistant to search the internet directly in the chat. When you're ready, click **Finalize Outline** to generate a course plan. Then generate the final course package (ZIP)."""
     )
     # Chat interface components
-    # Use 'messages' type for Chatbot. The Chatbot expects a list of message dictionaries
-    # (e.g. {"role": "user", "content": "..."}) when type="messages".
-    chatbot = gr.Chatbot(label="Conversation", type="messages")
+    # Use the default Chatbot type (list of (user, assistant) tuples). This avoids CSS issues with the
+    # messages type and makes the conversation visible without custom styling. Specify a height to
+    # constrain the display area.
+    chatbot = gr.Chatbot(label="Conversation", height=400)
     msg_input = gr.Textbox(label="Your message", placeholder="Type your message and press Enter", lines=1)
     # Buttons and outputs (search is triggered via chat; no separate search controls)
     finalize_btn = gr.Button("Finalize Outline")
@@ -323,12 +349,15 @@ Chat with the assistant to brainstorm your course idea. You can ask the assistan
     state_chat_pairs = gr.State([])
     state_sources = gr.State([])
     state_plan = gr.State("")
+    # Cache for previously fetched search results (keyed by lowercased query). Helps prevent
+    # duplicate web searches and ensures all returned resources are real and consistent.
+    state_resource_cache = gr.State({})
     # Handle chat submission: update chatbot display and states
     msg_input.submit(
         chat,
-        inputs=[msg_input, state_chat_history, state_chat_pairs, state_sources, state_plan],
-        # First output goes to the Chatbot; we return the updated chat history (list of messages)
-        outputs=[chatbot, state_chat_history, state_chat_pairs, state_sources, state_plan],
+        inputs=[msg_input, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache],
+        # First output goes to the Chatbot; return the updated chat pairs for proper display
+        outputs=[chatbot, state_chat_history, state_chat_pairs, state_sources, state_plan, state_resource_cache],
     )
     # Finalize outline button: generate course plan and store it
     finalize_btn.click(