feat: Unify UI into single chatbot interface

- Replace tabbed interface with single unified chatbot
- Auto-detect YouTube URLs vs questions in chat input
- Show personalized welcome messages based on login state
- Fix ChromaDB client reference (chroma_client -> _default_client)
- Remove unsupported type="messages" parameter from Chatbot
- Add handling for both video analysis and Q&A in one interface

app.py

@@ -23,22 +23,32 @@ try:
 except ImportError:
     ZEROGPU_AVAILABLE = False
 
-# Initialize ChromaDB client (persistent storage)
-chroma_client = chromadb.Client()
-collection = chroma_client.get_or_create_collection(
-    name="video_knowledge",
-    metadata={"hnsw:space": "cosine"}
-)
-
-# Global embedding model
-embedding_model = None
+# Global embedding model (shared - stateless)
+_embedding_model = None
 
 
 def get_embedding_model():
-    global embedding_model
-    if embedding_model is None:
-        embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
-    return embedding_model
+    global _embedding_model
+    if _embedding_model is None:
+        _embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
+    return _embedding_model
+
+
+def create_session_collection(session_id: str):
+    """Create a per-session ChromaDB collection."""
+    client = chromadb.Client()
+    return client.get_or_create_collection(
+        name=f"video_knowledge_{session_id}",
+        metadata={"hnsw:space": "cosine"}
+    )
+
+
+# Default collection for backward compatibility
+_default_client = chromadb.Client()
+collection = _default_client.get_or_create_collection(
+    name="video_knowledge",
+    metadata={"hnsw:space": "cosine"}
+)
 
 
 def hello(profile: gr.OAuthProfile | None) -> str:
@@ -520,8 +530,8 @@ def clear_knowledge_base() -> str:
     global collection
     try:
         # Delete and recreate collection
-        chroma_client.delete_collection("video_knowledge")
-        collection = chroma_client.get_or_create_collection(
+        _default_client.delete_collection("video_knowledge")
+        collection = _default_client.get_or_create_collection(
             name="video_knowledge",
             metadata={"hnsw:space": "cosine"}
         )
@@ -530,191 +540,180 @@ def clear_knowledge_base() -> str:
         return f"Error clearing knowledge base: {e!s}"
 
 
+def handle_chat(
+    message: str,
+    history: list[dict],
+    profile: gr.OAuthProfile | None,
+    oauth_token: gr.OAuthToken | None,
+    progress: gr.Progress = gr.Progress(),
+) -> tuple[list[dict], str]:
+    """Unified chat handler that processes URLs or answers questions."""
+    history = history or []
+
+    if not message or not message.strip():
+        return history, ""
+
+    # Add user message to history
+    history.append({"role": "user", "content": message})
+
+    # Check if user is logged in
+    if profile is None:
+        history.append({
+            "role": "assistant",
+            "content": "Please sign in with HuggingFace first using the button above."
+        })
+        return history, ""
+
+    message = message.strip()
+
+    # Check if it's a YouTube URL
+    is_url, normalized = is_valid_youtube_url(message)
+
+    if is_url:
+        # Process the YouTube video
+        history.append({
+            "role": "assistant",
+            "content": "I'll analyze that video for you. This may take a few minutes..."
+        })
+
+        try:
+            result = _process_youtube_impl(normalized, 5, profile, progress)
+
+            # Summarize the result for chat
+            if "Error" in result or "Please" in result:
+                history.append({"role": "assistant", "content": result})
+            else:
+                # Extract just the summary
+                lines = result.split("\n")
+                title = next((l.replace("## ", "") for l in lines if l.startswith("## ")), "the video")
+
+                history.append({
+                    "role": "assistant",
+                    "content": (
+                        f"Done! I've analyzed **{title}** and added it to my knowledge base.\n\n"
+                        f"I extracted the transcript and analyzed key visual frames. "
+                        f"You can now ask me questions about this video!\n\n"
+                        f"Try asking:\n"
+                        f"- What are the main topics discussed?\n"
+                        f"- Summarize the key points\n"
+                        f"- What was shown in the video?"
+                    )
+                })
+        except Exception as e:
+            history.append({
+                "role": "assistant",
+                "content": f"Sorry, I couldn't analyze that video: {e}"
+            })
+    else:
+        # Check if we have any analyzed videos
+        if collection.count() == 0:
+            history.append({
+                "role": "assistant",
+                "content": (
+                    "I don't have any videos analyzed yet. "
+                    "Please paste a YouTube URL and I'll analyze it for you!\n\n"
+                    "Example: `https://youtube.com/watch?v=...`"
+                )
+            })
+        else:
+            # Answer question about videos
+            if oauth_token is None:
+                history.append({
+                    "role": "assistant",
+                    "content": "Authentication error. Please try refreshing the page."
+                })
+            else:
+                response = chat_with_videos(message, history, profile, oauth_token)
+                history.append({"role": "assistant", "content": response})
+
+    return history, ""
+
+
+def get_welcome_message(profile: gr.OAuthProfile | None) -> list[dict]:
+    """Get initial chat message based on login state."""
+    if profile:
+        return [{
+            "role": "assistant",
+            "content": (
+                f"Hi **{profile.name}**! I'm your Video Analyzer assistant.\n\n"
+                f"**Here's how I work:**\n"
+                f"1. Paste a YouTube URL and I'll analyze it\n"
+                f"2. Ask me questions about the video content\n\n"
+                f"Let's get started - paste a YouTube video URL!"
+            )
+        }]
+    return [{
+        "role": "assistant",
+        "content": (
+            "Welcome to Video Analyzer!\n\n"
+            "I can analyze YouTube videos and answer questions about them.\n\n"
+            "**Please sign in with HuggingFace** to get started."
+        )
+    }]
+
+
 def create_demo() -> gr.Blocks:
     """Create and configure the Gradio demo application."""
-    with gr.Blocks(title="Video Analyzer") as demo:
-        # Header - always visible
+    with gr.Blocks(title="Video Analyzer", theme=gr.themes.Soft()) as demo:
         gr.Markdown("# Video Analyzer")
-        gr.Markdown("Download, transcribe, analyze, and chat with YouTube videos using AI")
-
-        # Login section - shown when not logged in
-        with gr.Column(visible=True) as login_section:
-            gr.Markdown("---")
-            gr.Markdown("## Welcome!")
-            gr.Markdown(
-                "This app lets you:\n"
-                "- **Download** YouTube videos or playlists\n"
-                "- **Transcribe** audio using OpenAI Whisper\n"
-                "- **Analyze** video frames with AI vision\n"
-                "- **Chat** about video content using Qwen2.5-72B\n\n"
-                "**Sign in with HuggingFace to get started:**"
-            )
-            with gr.Row():
-                gr.Column(scale=1)
-                with gr.Column(scale=1):
-                    gr.LoginButton(size="lg")
-                gr.Column(scale=1)
-
-        # Main app section - shown after login
-        with gr.Column(visible=False) as main_section:
-            with gr.Row():
-                with gr.Column(scale=3):
-                    user_info = gr.Markdown()
-                with gr.Column(scale=1):
-                    gr.LoginButton(size="sm")
-
-            gr.Markdown("---")
-
-            with gr.Tabs():
-                with gr.TabItem("Analyze Videos"):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            gr.Markdown("### Enter a YouTube URL")
-                            url_input = gr.Textbox(
-                                label="YouTube URL",
-                                placeholder="https://www.youtube.com/watch?v=...",
-                                lines=1,
-                            )
-
-                            with gr.Row():
-                                submit_btn = gr.Button(
-                                    "Analyze Video",
-                                    variant="primary",
-                                    size="lg",
-                                    scale=3,
-                                )
-                                num_frames = gr.Slider(
-                                    label="Frames to analyze",
-                                    minimum=3,
-                                    maximum=10,
-                                    value=5,
-                                    step=1,
-                                    scale=1,
-                                )
-
-                        with gr.Column(scale=1):
-                            gr.Markdown("### What happens")
-                            gr.Markdown(
-                                "1. Download video\n"
-                                "2. Transcribe audio (Whisper)\n"
-                                "3. Analyze key frames (BLIP)\n"
-                                "4. Store in knowledge base"
-                            )
-                            gr.Markdown("### Knowledge Base")
-                            kb_status_analyze = gr.Markdown()
-                            with gr.Row():
-                                refresh_btn = gr.Button("Refresh", size="sm")
-                                clear_btn = gr.Button("Clear All", size="sm", variant="stop")
-
-                            clear_status = gr.Markdown()
-
-                    gr.Markdown("### Results")
-                    output = gr.Markdown(
-                        value="*Paste a YouTube URL and click Analyze Video*",
-                    )
 
-                    submit_btn.click(
-                        fn=process_youtube,
-                        inputs=[url_input, num_frames],
-                        outputs=[output],
-                    ).then(
-                        fn=get_knowledge_stats,
-                        outputs=[kb_status_analyze],
-                    )
+        with gr.Row():
+            with gr.Column(scale=4):
+                gr.Markdown("*Analyze YouTube videos and chat about their content*")
+            with gr.Column(scale=1):
+                gr.LoginButton()
 
-                    refresh_btn.click(
-                        fn=get_knowledge_stats,
-                        outputs=[kb_status_analyze],
-                    )
+        chatbot = gr.Chatbot(
+            label="Video Analyzer",
+            height=500,
+        )
 
-                    clear_btn.click(
-                        fn=clear_knowledge_base,
-                        outputs=[clear_status],
-                    ).then(
-                        fn=get_knowledge_stats,
-                        outputs=[kb_status_analyze],
-                    )
+        with gr.Row():
+            msg_input = gr.Textbox(
+                label="Message",
+                placeholder="Paste a YouTube URL or ask a question...",
+                scale=5,
+                lines=1,
+            )
+            send_btn = gr.Button("Send", variant="primary", scale=1)
+
+        with gr.Row():
+            kb_status = gr.Markdown()
+            clear_btn = gr.Button("Clear Chat", size="sm")
+
+        # Wire up chat
+        send_btn.click(
+            fn=handle_chat,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input],
+        ).then(
+            fn=get_knowledge_stats,
+            outputs=[kb_status],
+        )
 
-                with gr.TabItem("Chat with Videos"):
-                    with gr.Row():
-                        with gr.Column(scale=3):
-                            kb_stats = gr.Markdown()
-
-                            chatbot = gr.Chatbot(
-                                label="Video Chat",
-                                height=350,
-                            )
-
-                            with gr.Row():
-                                chat_input = gr.Textbox(
-                                    label="Your Question",
-                                    placeholder="What was discussed in the video?",
-                                    scale=4,
-                                    lines=1,
-                                )
-                                chat_btn = gr.Button("Ask", variant="primary", scale=1)
-
-                        with gr.Column(scale=1):
-                            gr.Markdown("### Sample Questions")
-                            gr.Markdown(
-                                "Try asking:\n"
-                                "- What are the main topics?\n"
-                                "- Summarize the key points\n"
-                                "- What was shown visually?\n"
-                                "- Any mentions of [topic]?"
-                            )
-                            clear_chat_btn = gr.Button("Clear Chat", size="sm")
-
-                    def respond(
-                        message: str,
-                        history: list[dict],
-                        profile: gr.OAuthProfile | None,
-                        oauth_token: gr.OAuthToken | None,
-                    ):
-                        response = chat_with_videos(message, history, profile, oauth_token)
-                        history = history or []
-                        history.append({"role": "user", "content": message})
-                        history.append({"role": "assistant", "content": response})
-                        return history, ""
-
-                    chat_btn.click(
-                        fn=respond,
-                        inputs=[chat_input, chatbot],
-                        outputs=[chatbot, chat_input],
-                    )
-                    chat_input.submit(
-                        fn=respond,
-                        inputs=[chat_input, chatbot],
-                        outputs=[chatbot, chat_input],
-                    )
-                    clear_chat_btn.click(
-                        fn=lambda: [],
-                        outputs=[chatbot],
-                    )
+        msg_input.submit(
+            fn=handle_chat,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input],
+        ).then(
+            fn=get_knowledge_stats,
+            outputs=[kb_status],
+        )
 
-        # Handle login state changes
-        def check_login(profile: gr.OAuthProfile | None):
-            if profile:
-                return (
-                    gr.update(visible=False),  # Hide login section
-                    gr.update(visible=True),   # Show main section
-                    f"Welcome, **{profile.name}**!",
-                )
-            return (
-                gr.update(visible=True),   # Show login section
-                gr.update(visible=False),  # Hide main section
-                "",
-            )
+        clear_btn.click(
+            fn=lambda: [],
+            outputs=[chatbot],
+        )
 
+        # Initialize chat with welcome message
         demo.load(
-            fn=check_login,
-            inputs=None,
-            outputs=[login_section, main_section, user_info],
+            fn=get_welcome_message,
+            outputs=[chatbot],
+        )
+        demo.load(
+            fn=get_knowledge_stats,
+            outputs=[kb_status],
         )
-
-        # Also refresh knowledge base stats on load
-        demo.load(get_knowledge_stats, outputs=kb_status_analyze)
-        demo.load(get_knowledge_stats, outputs=kb_stats)
 
     return demo