Upload folder using huggingface_hub

nbs/01_clinical_tutor.ipynb

@@ -59,7 +59,7 @@
    ],
    "source": [
     "#| export\n",
-    "from typing import Dict, List, Optional, Tuple, Any\n",
+    "from typing import Dict, List, Optional, Tuple, Any, AsyncGenerator\n",
     "import os\n",
     "import json\n",
     "import logging\n",
@@ -179,17 +179,29 @@
     "            list: Generated SMART goals\n",
     "        \"\"\"\n",
     "        prompt = f\"\"\"Generate {num_goals} SMART learning goals for a medical trainee in {specialty} ({setting}).\n",
-    "\n",
-    "For each goal:\n",
-    "1. Select an appropriate category from: {', '.join(cat.value for cat in LearningCategory)}\n",
-    "2. Write a specific, measurable goal that builds clinical competence\n",
-    "\n",
-    "Format as JSON array with fields:\n",
-    "- category: Learning category name\n",
-    "- smart_version: SMART formatted goal text\n",
-    "\n",
-    "Goals should be specific to the {setting} setting in {specialty}.\"\"\"\n",
-    "\n",
+    "    \n",
+    "    For each goal:\n",
+    "    1. Select an appropriate category from: {', '.join(cat.value for cat in LearningCategory)}\n",
+    "    2. Write a specific, measurable goal that builds clinical competence\n",
+    "    \n",
+    "    Format as JSON array with fields:\n",
+    "    - category: Learning category name\n",
+    "    - smart_version: SMART formatted goal text\n",
+    "    \n",
+    "    For example:\n",
+    "    [\n",
+    "      {{\n",
+    "        \"category\": \"Clinical Reasoning\",\n",
+    "        \"smart_version\": \"Accurately diagnose acute coronary syndrome in 5 chest pain cases over 2 weeks with 90% agreement with attending assessment\"\n",
+    "      }},\n",
+    "      {{\n",
+    "        \"category\": \"Management\",\n",
+    "        \"smart_version\": \"Successfully develop and implement management plans for 3 complex cardiac patients with multiple comorbidities by week 4\"\n",
+    "      }}\n",
+    "    ]\n",
+    "    \n",
+    "    Goals should be specific to the {setting} setting in {specialty}.\"\"\"\n",
+    "    \n",
     "        try:\n",
     "            response = await self._get_completion([{\n",
     "                \"role\": \"system\",\n",
@@ -213,12 +225,34 @@
     "                )\n",
     "                goals.append(goal)\n",
     "            \n",
+    "            logger.info(f\"Generated {len(goals)} SMART goals\")\n",
     "            return goals\n",
     "            \n",
     "        except Exception as e:\n",
     "            logger.error(f\"Error generating goals: {str(e)}\")\n",
-    "            return []\n",
-    "    \n",
+    "            # Instead of returning empty list, generate some default goals\n",
+    "            default_goals = [\n",
+    "                SmartGoal(\n",
+    "                    id=f\"goal_{uuid.uuid4()}\",\n",
+    "                    category=LearningCategory.CLINICAL_REASONING,\n",
+    "                    original_input=\"\",\n",
+    "                    smart_version=f\"Develop systematic approach to common {specialty} presentations in {setting} setting\",\n",
+    "                    specialty=specialty,\n",
+    "                    setting=setting,\n",
+    "                    created_at=datetime.now()\n",
+    "                ),\n",
+    "                SmartGoal(\n",
+    "                    id=f\"goal_{uuid.uuid4()}\",\n",
+    "                    category=LearningCategory.MANAGEMENT,\n",
+    "                    original_input=\"\",\n",
+    "                    smart_version=f\"Create evidence-based management plans for basic {specialty} conditions\",\n",
+    "                    specialty=specialty,\n",
+    "                    setting=setting,\n",
+    "                    created_at=datetime.now()\n",
+    "                )\n",
+    "            ]\n",
+    "            return default_goals\n",
+    "        \n",
     "    async def generate_smart_goal(\n",
     "        self,\n",
     "        user_input: str,\n",
@@ -270,15 +304,15 @@
     "            logger.error(f\"Error generating SMART goal: {str(e)}\")\n",
     "            return None\n",
     "    \n",
-    "    async def discuss_case(self, message: str) -> str:\n",
+    "    async def discuss_case(self, message: str) -> AsyncGenerator[str, None]:\n",
     "        \"\"\"\n",
-    "        Process case discussion message.\n",
+    "        Process case discussion message with streaming response.\n",
     "        \n",
     "        Args:\n",
     "            message: User's message\n",
-    "            \n",
-    "        Returns:\n",
-    "            str: Tutor's response\n",
+    "                \n",
+    "        Yields:\n",
+    "            str: Streamed tokens of tutor's response\n",
     "        \"\"\"\n",
     "        try:\n",
     "            # Add to discussion history\n",
@@ -289,27 +323,27 @@
     "            \n",
     "            # Build conversation prompt\n",
     "            system_prompt = self._build_discussion_prompt()\n",
-    "            \n",
     "            messages = [{\n",
     "                \"role\": \"system\",\n",
     "                \"content\": system_prompt\n",
     "            }]\n",
     "            messages.extend(self.current_discussion)\n",
     "            \n",
-    "            # Get response\n",
-    "            response = await self._get_completion(messages)\n",
+    "            # Get streaming response\n",
+    "            full_response = \"\"\n",
+    "            async for token in self._get_completion_stream(messages):\n",
+    "                full_response += token\n",
+    "                yield token\n",
     "            \n",
-    "            # Add to history\n",
+    "            # Add complete response to history after streaming\n",
     "            self.current_discussion.append({\n",
     "                \"role\": \"assistant\",\n",
-    "                \"content\": response\n",
+    "                \"content\": full_response\n",
     "            })\n",
     "            \n",
-    "            return response\n",
-    "            \n",
     "        except Exception as e:\n",
     "            logger.error(f\"Error in discussion: {str(e)}\")\n",
-    "            return \"I apologize, but I encountered an error. Please try again.\"\n",
+    "            yield \"I apologize, but I encountered an error. Please try again.\"\n",
     "    \n",
     "    def end_discussion(self) -> None:\n",
     "        \"\"\"End current discussion.\"\"\"\n",
@@ -341,37 +375,35 @@
     "        Remember: The learner has strong foundational knowledge. Focus on advanced clinical concepts\n",
     "        rather than basic science.\"\"\"\n",
     "\n",
-    "    async def _get_completion(\n",
+    "    async def _get_completion_stream(\n",
     "        self,\n",
     "        messages: List[Dict],\n",
     "        temperature: float = 0.7,\n",
     "        max_retries: int = 3\n",
-    "    ) -> str:\n",
+    "    ) -> AsyncGenerator[str, None]:\n",
     "        \"\"\"\n",
-    "        Get completion from OpenRouter API with retry logic.\n",
+    "        Get streaming completion from OpenRouter API with retry logic.\n",
     "        \n",
     "        Args:\n",
     "            messages: Conversation messages\n",
     "            temperature: Response temperature\n",
     "            max_retries: Maximum retry attempts\n",
     "            \n",
-    "        Returns:\n",
-    "            str: Model response\n",
-    "            \n",
-    "        Raises:\n",
-    "            OpenRouterException: If API calls fail after retries\n",
+    "        Yields:\n",
+    "            str: Response tokens as they arrive\n",
     "        \"\"\"\n",
     "        headers = {\n",
     "            \"Authorization\": f\"Bearer {self.api_key}\",\n",
     "            \"Content-Type\": \"application/json\",\n",
-    "            \"HTTP-Referer\": \"http://localhost:7860\"  # Or your actual domain\n",
+    "            \"HTTP-Referer\": \"http://localhost:7860\"\n",
     "        }\n",
     "        \n",
     "        data = {\n",
     "            \"model\": self.model,\n",
     "            \"messages\": messages,\n",
     "            \"temperature\": temperature,\n",
-    "            \"max_tokens\": 2000\n",
+    "            \"max_tokens\": 2000,\n",
+    "            \"stream\": True  # Enable streaming\n",
     "        }\n",
     "        \n",
     "        for attempt in range(max_retries):\n",
@@ -384,15 +416,31 @@
     "                        timeout=30\n",
     "                    ) as response:\n",
     "                        response.raise_for_status()\n",
-    "                        result = await response.json()\n",
-    "                        return result[\"choices\"][0][\"message\"][\"content\"]\n",
+    "                        \n",
+    "                        # Process streaming response\n",
+    "                        async for line in response.content:\n",
+    "                            text = line.decode('utf-8').strip()\n",
+    "                            if text.startswith('data: '):\n",
+    "                                try:\n",
+    "                                    json_str = text[6:]  # Remove 'data: ' prefix\n",
+    "                                    if json_str == '[DONE]':\n",
+    "                                        break\n",
+    "                                    \n",
+    "                                    chunk = json.loads(json_str)\n",
+    "                                    if token := chunk['choices'][0]['delta'].get('content'):\n",
+    "                                        yield token\n",
+    "                                        \n",
+    "                                except json.JSONDecodeError:\n",
+    "                                    continue\n",
+    "                                    \n",
+    "                        return\n",
     "                        \n",
     "            except Exception as e:\n",
     "                if attempt == max_retries - 1:\n",
     "                    raise OpenRouterException(f\"API call failed: {str(e)}\")\n",
     "                logger.warning(f\"Retry {attempt + 1} after error: {str(e)}\")\n",
-    "                await asyncio.sleep(1 * (attempt + 1))  # Exponential backoff\n",
-    "    \n",
+    "                await asyncio.sleep(1 * (attempt + 1))  # Exponential backoff  \n",
+    "                \n",
     "    def get_discussion_history(self) -> List[Dict]:\n",
     "        \"\"\"\n",
     "        Get current discussion history.\n",
@@ -794,13 +842,14 @@
     }
    ],
    "source": [
-    "# | hide\n",
+    "#| hide\n",
     "\n",
     "from wardbuddy.clinical_tutor import ClinicalTutor\n",
     "from wardbuddy.learning_context import LearningCategory, SmartGoal\n",
     "\n",
     "async def test_clinical_tutor():\n",
     "    \"\"\"Test basic clinical tutor functionality.\"\"\"\n",
+    "    # Setup test environment\n",
     "    if not os.getenv(\"OPENROUTER_API_KEY\"):\n",
     "        print(\"Skipping tests: No API key\")\n",
     "        return\n",
@@ -812,28 +861,50 @@
     "    test_case = \"28yo M with chest pain, 2 days duration\"\n",
     "    \n",
     "    try:\n",
-    "        # Basic discussion test\n",
-    "        response = await tutor.discuss_case(test_case)\n",
-    "        assert isinstance(response, str)\n",
-    "        assert len(response) > 0\n",
+    "        # Test streaming discussion\n",
+    "        full_response = \"\"\n",
+    "        async for token in tutor.discuss_case(test_case):\n",
+    "            full_response += token\n",
+    "        \n",
+    "        assert isinstance(full_response, str)\n",
+    "        assert len(full_response) > 0\n",
+    "        print(\"Discussion test passed\")\n",
     "        \n",
     "        # Test goal generation\n",
     "        goals = await tutor.generate_smart_goals(\"Emergency Medicine\", \"ED\")\n",
-    "        assert len(goals) > 0\n",
+    "        assert isinstance(goals, list), \"Expected goals to be a list\"\n",
+    "        assert len(goals) > 0, \"Expected at least one goal\"\n",
+    "        assert all(isinstance(goal, SmartGoal) for goal in goals), \"Expected all items to be SmartGoal objects\"\n",
+    "        print(\"Goal generation test passed\")\n",
+    "        \n",
+    "        # Test basic goal properties\n",
+    "        test_goal = goals[0]\n",
+    "        assert test_goal.specialty == \"Emergency Medicine\", \"Wrong specialty\"\n",
+    "        assert test_goal.setting == \"ED\", \"Wrong setting\"\n",
+    "        assert isinstance(test_goal.category, LearningCategory), \"Wrong category type\"\n",
+    "        assert isinstance(test_goal.smart_version, str), \"Wrong goal text type\"\n",
+    "        print(\"Goal properties test passed\")\n",
     "        \n",
     "        # Clear discussion\n",
     "        tutor.end_discussion()\n",
-    "        assert len(tutor.get_discussion_history()) == 0\n",
+    "        assert len(tutor.get_discussion_history()) == 0, \"Discussion history not cleared\"\n",
+    "        print(\"Discussion clearing test passed\")\n",
     "        \n",
-    "        print(\"All tests passed!\")\n",
+    "        print(\"\\nAll tests passed! ✅\")\n",
     "        \n",
     "    except Exception as e:\n",
-    "        print(f\"Test failed: {str(e)}\")\n",
+    "        print(f\"\\nTest failed ❌: {str(e)}\")\n",
     "        raise\n",
     "\n",
     "# Run tests\n",
     "if __name__ == \"__main__\":\n",
-    "    asyncio.run(test_clinical_tutor())"
+    "    try:\n",
+    "        asyncio.run(test_clinical_tutor())\n",
+    "    except RuntimeError:\n",
+    "        # Handle case where event loop is already running\n",
+    "        loop = asyncio.get_event_loop()\n",
+    "        if loop.is_running():\n",
+    "            loop.create_task(test_clinical_tutor())"
    ]
   },
   {

nbs/02_learning_interface.ipynb

@@ -59,7 +59,7 @@
    ],
    "source": [
     "#| export\n",
-    "from typing import Dict, List, Optional, Tuple, Any\n",
+    "from typing import Dict, List, Optional, Tuple, Any, AsyncGenerator\n",
     "import gradio as gr\n",
     "from pathlib import Path\n",
     "import asyncio\n",
@@ -181,6 +181,50 @@
     "        self.settings = [\"Clinic\", \"Wards\", \"ED\"]\n",
     "        \n",
     "        logger.info(\"Learning interface initialized\")\n",
+    "\n",
+    "    async def process_chat(\n",
+    "        self,\n",
+    "        message: str,\n",
+    "        history: List[List[str]],\n",
+    "        state: Dict[str, Any]\n",
+    "    ) -> AsyncGenerator[Tuple[List[List[str]], str, Dict[str, Any]], None]:\n",
+    "        \"\"\"Process chat messages with streaming.\"\"\"\n",
+    "        try:\n",
+    "            if not message.strip():\n",
+    "                yield history, \"\", state\n",
+    "                return\n",
+    "            \n",
+    "            # Start new discussion if none active\n",
+    "            if not state.get(\"discussion_active\"):\n",
+    "                state[\"discussion_active\"] = True\n",
+    "                state[\"discussion_start\"] = datetime.now().isoformat()\n",
+    "            \n",
+    "            # Initialize history if needed\n",
+    "            if history is None:\n",
+    "                history = []\n",
+    "            \n",
+    "            # Add user message\n",
+    "            history.append([message, \"\"])\n",
+    "            \n",
+    "            # Update display\n",
+    "            yield history, \"\", state\n",
+    "            \n",
+    "            # Process response with streaming\n",
+    "            current_response = \"\"\n",
+    "            async for token in self.tutor.discuss_case(message):\n",
+    "                current_response += token\n",
+    "                history[-1][1] = current_response\n",
+    "                yield history, \"\", state\n",
+    "            \n",
+    "            state[\"last_message\"] = datetime.now().isoformat()\n",
+    "            yield history, \"\", state\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            logger.error(f\"Error in chat: {str(e)}\")\n",
+    "            if history is None:\n",
+    "                history = []\n",
+    "            history.append([message, \"I apologize, but I encountered an error. Please try again.\"])\n",
+    "            yield history, \"\", state\n",
     "    \n",
     "    def create_interface(self) -> gr.Blocks:\n",
     "        \"\"\"Create Gradio interface.\"\"\"\n",
@@ -225,24 +269,35 @@
     "                    \n",
     "                    # Chat interface\n",
     "                    chatbot = gr.Chatbot(\n",
-    "                        height=400,\n",
-    "                        show_label=False\n",
+    "                        height=500,\n",
+    "                        label=\"Case Discussion\",\n",
+    "                        show_label=True,\n",
+    "                        elem_classes=[\"dashboard-card\"]\n",
     "                    )\n",
     "                    \n",
     "                    with gr.Row():\n",
-    "                        message = gr.Textbox(\n",
+    "                        msg = gr.Textbox(\n",
     "                            label=\"Present your case or ask questions\",\n",
-    "                            placeholder=\"Present your case as you would to your supervisor...\",\n",
-    "                            lines=4\n",
+    "                            placeholder=\"Present your case...\",\n",
+    "                            lines=5\n",
     "                        )\n",
     "                        \n",
-    "                        audio_input = gr.Audio(\n",
-    "                            sources=\"microphone\",\n",
-    "                            type=\"numpy\",\n",
+    "                        # Add voice input\n",
+    "                        audio_msg = gr.Audio(\n",
     "                            label=\"Or speak your case\",\n",
+    "                            sources=[\"microphone\"],\n",
+    "                            type=\"numpy\",\n",
     "                            streaming=True\n",
     "                        )\n",
     "                    \n",
+    "                    # Wire up chat with streaming\n",
+    "                    msg.submit(\n",
+    "                        self.process_chat,\n",
+    "                        inputs=[msg, chatbot, state],\n",
+    "                        outputs=[chatbot, msg, state],\n",
+    "                        queue=False  # Important for streaming\n",
+    "                    )                    \n",
+    "            \n",
     "                    with gr.Row():\n",
     "                        clear = gr.Button(\"Clear Discussion\")\n",
     "                        end = gr.Button(\n",

wardbuddy/_modidx.py

@@ -11,8 +11,8 @@ d = { 'settings': { 'branch': 'main',
                                                                                                'wardbuddy/clinical_tutor.py'),
                                           'wardbuddy.clinical_tutor.ClinicalTutor._build_discussion_prompt': ( 'clinical_tutor.html#clinicaltutor._build_discussion_prompt',
                                                                                                                'wardbuddy/clinical_tutor.py'),
-                                          'wardbuddy.clinical_tutor.ClinicalTutor._get_completion': ( 'clinical_tutor.html#clinicaltutor._get_completion',
-                                                                                                      'wardbuddy/clinical_tutor.py'),
+                                          'wardbuddy.clinical_tutor.ClinicalTutor._get_completion_stream': ( 'clinical_tutor.html#clinicaltutor._get_completion_stream',
+                                                                                                             'wardbuddy/clinical_tutor.py'),
                                           'wardbuddy.clinical_tutor.ClinicalTutor.clear_discussion': ( 'clinical_tutor.html#clinicaltutor.clear_discussion',
                                                                                                        'wardbuddy/clinical_tutor.py'),
                                           'wardbuddy.clinical_tutor.ClinicalTutor.discuss_case': ( 'clinical_tutor.html#clinicaltutor.discuss_case',
@@ -64,6 +64,8 @@ d = { 'settings': { 'branch': 'main',
                                                                                                                    'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.LearningInterface.create_interface': ( 'learning_interface.html#learninginterface.create_interface',
                                                                                                                    'wardbuddy/learning_interface.py'),
+                                              'wardbuddy.learning_interface.LearningInterface.process_chat': ( 'learning_interface.html#learninginterface.process_chat',
+                                                                                                               'wardbuddy/learning_interface.py'),
                                               'wardbuddy.learning_interface.create_css': ( 'learning_interface.html#create_css',
                                                                                            'wardbuddy/learning_interface.py')},
             'wardbuddy.main': { 'wardbuddy.main.launch': ('main.html#launch', 'wardbuddy/main.py'),

wardbuddy/clinical_tutor.py

@@ -6,7 +6,7 @@
 __all__ = ['logger', 'OpenRouterException', 'ClinicalTutor']
 
 # %% ../nbs/01_clinical_tutor.ipynb 4
-from typing import Dict, List, Optional, Tuple, Any
+from typing import Dict, List, Optional, Tuple, Any, AsyncGenerator
 import os
 import json
 import logging
@@ -87,17 +87,29 @@ class ClinicalTutor:
             list: Generated SMART goals
         """
         prompt = f"""Generate {num_goals} SMART learning goals for a medical trainee in {specialty} ({setting}).
-
-For each goal:
-1. Select an appropriate category from: {', '.join(cat.value for cat in LearningCategory)}
-2. Write a specific, measurable goal that builds clinical competence
-
-Format as JSON array with fields:
-- category: Learning category name
-- smart_version: SMART formatted goal text
-
-Goals should be specific to the {setting} setting in {specialty}."""
-
+    
+    For each goal:
+    1. Select an appropriate category from: {', '.join(cat.value for cat in LearningCategory)}
+    2. Write a specific, measurable goal that builds clinical competence
+    
+    Format as JSON array with fields:
+    - category: Learning category name
+    - smart_version: SMART formatted goal text
+    
+    For example:
+    [
+      {{
+        "category": "Clinical Reasoning",
+        "smart_version": "Accurately diagnose acute coronary syndrome in 5 chest pain cases over 2 weeks with 90% agreement with attending assessment"
+      }},
+      {{
+        "category": "Management",
+        "smart_version": "Successfully develop and implement management plans for 3 complex cardiac patients with multiple comorbidities by week 4"
+      }}
+    ]
+    
+    Goals should be specific to the {setting} setting in {specialty}."""
+    
         try:
             response = await self._get_completion([{
                 "role": "system",
@@ -121,12 +133,34 @@ Goals should be specific to the {setting} setting in {specialty}."""
                 )
                 goals.append(goal)
             
+            logger.info(f"Generated {len(goals)} SMART goals")
             return goals
             
         except Exception as e:
             logger.error(f"Error generating goals: {str(e)}")
-            return []
-    
+            # Instead of returning empty list, generate some default goals
+            default_goals = [
+                SmartGoal(
+                    id=f"goal_{uuid.uuid4()}",
+                    category=LearningCategory.CLINICAL_REASONING,
+                    original_input="",
+                    smart_version=f"Develop systematic approach to common {specialty} presentations in {setting} setting",
+                    specialty=specialty,
+                    setting=setting,
+                    created_at=datetime.now()
+                ),
+                SmartGoal(
+                    id=f"goal_{uuid.uuid4()}",
+                    category=LearningCategory.MANAGEMENT,
+                    original_input="",
+                    smart_version=f"Create evidence-based management plans for basic {specialty} conditions",
+                    specialty=specialty,
+                    setting=setting,
+                    created_at=datetime.now()
+                )
+            ]
+            return default_goals
+        
     async def generate_smart_goal(
         self,
         user_input: str,
@@ -178,15 +212,15 @@ Format as JSON with fields:
             logger.error(f"Error generating SMART goal: {str(e)}")
             return None
     
-    async def discuss_case(self, message: str) -> str:
+    async def discuss_case(self, message: str) -> AsyncGenerator[str, None]:
         """
-        Process case discussion message.
+        Process case discussion message with streaming response.
         
         Args:
             message: User's message
-            
-        Returns:
-            str: Tutor's response
+                
+        Yields:
+            str: Streamed tokens of tutor's response
         """
         try:
             # Add to discussion history
@@ -197,27 +231,27 @@ Format as JSON with fields:
             
             # Build conversation prompt
             system_prompt = self._build_discussion_prompt()
-            
             messages = [{
                 "role": "system",
                 "content": system_prompt
             }]
             messages.extend(self.current_discussion)
             
-            # Get response
-            response = await self._get_completion(messages)
+            # Get streaming response
+            full_response = ""
+            async for token in self._get_completion_stream(messages):
+                full_response += token
+                yield token
             
-            # Add to history
+            # Add complete response to history after streaming
             self.current_discussion.append({
                 "role": "assistant",
-                "content": response
+                "content": full_response
             })
             
-            return response
-            
         except Exception as e:
             logger.error(f"Error in discussion: {str(e)}")
-            return "I apologize, but I encountered an error. Please try again."
+            yield "I apologize, but I encountered an error. Please try again."
     
     def end_discussion(self) -> None:
         """End current discussion."""
@@ -249,37 +283,35 @@ Format as JSON with fields:
         Remember: The learner has strong foundational knowledge. Focus on advanced clinical concepts
         rather than basic science."""
 
-    async def _get_completion(
+    async def _get_completion_stream(
         self,
         messages: List[Dict],
         temperature: float = 0.7,
         max_retries: int = 3
-    ) -> str:
+    ) -> AsyncGenerator[str, None]:
         """
-        Get completion from OpenRouter API with retry logic.
+        Get streaming completion from OpenRouter API with retry logic.
         
         Args:
             messages: Conversation messages
             temperature: Response temperature
             max_retries: Maximum retry attempts
             
-        Returns:
-            str: Model response
-            
-        Raises:
-            OpenRouterException: If API calls fail after retries
+        Yields:
+            str: Response tokens as they arrive
         """
         headers = {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",
-            "HTTP-Referer": "http://localhost:7860"  # Or your actual domain
+            "HTTP-Referer": "http://localhost:7860"
         }
         
         data = {
             "model": self.model,
             "messages": messages,
             "temperature": temperature,
-            "max_tokens": 2000
+            "max_tokens": 2000,
+            "stream": True  # Enable streaming
         }
         
         for attempt in range(max_retries):
@@ -292,15 +324,31 @@ Format as JSON with fields:
                         timeout=30
                     ) as response:
                         response.raise_for_status()
-                        result = await response.json()
-                        return result["choices"][0]["message"]["content"]
+                        
+                        # Process streaming response
+                        async for line in response.content:
+                            text = line.decode('utf-8').strip()
+                            if text.startswith('data: '):
+                                try:
+                                    json_str = text[6:]  # Remove 'data: ' prefix
+                                    if json_str == '[DONE]':
+                                        break
+                                    
+                                    chunk = json.loads(json_str)
+                                    if token := chunk['choices'][0]['delta'].get('content'):
+                                        yield token
+                                        
+                                except json.JSONDecodeError:
+                                    continue
+                                    
+                        return
                         
             except Exception as e:
                 if attempt == max_retries - 1:
                     raise OpenRouterException(f"API call failed: {str(e)}")
                 logger.warning(f"Retry {attempt + 1} after error: {str(e)}")
-                await asyncio.sleep(1 * (attempt + 1))  # Exponential backoff
-    
+                await asyncio.sleep(1 * (attempt + 1))  # Exponential backoff  
+                
     def get_discussion_history(self) -> List[Dict]:
         """
         Get current discussion history.

wardbuddy/learning_interface.py

@@ -6,7 +6,7 @@
 __all__ = ['logger', 'create_css', 'LearningInterface']
 
 # %% ../nbs/02_learning_interface.ipynb 4
-from typing import Dict, List, Optional, Tuple, Any
+from typing import Dict, List, Optional, Tuple, Any, AsyncGenerator
 import gradio as gr
 from pathlib import Path
 import asyncio
@@ -92,6 +92,50 @@ class LearningInterface:
         self.settings = ["Clinic", "Wards", "ED"]
         
         logger.info("Learning interface initialized")
+
+    async def process_chat(
+        self,
+        message: str,
+        history: List[List[str]],
+        state: Dict[str, Any]
+    ) -> AsyncGenerator[Tuple[List[List[str]], str, Dict[str, Any]], None]:
+        """Process chat messages with streaming."""
+        try:
+            if not message.strip():
+                yield history, "", state
+                return
+            
+            # Start new discussion if none active
+            if not state.get("discussion_active"):
+                state["discussion_active"] = True
+                state["discussion_start"] = datetime.now().isoformat()
+            
+            # Initialize history if needed
+            if history is None:
+                history = []
+            
+            # Add user message
+            history.append([message, ""])
+            
+            # Update display
+            yield history, "", state
+            
+            # Process response with streaming
+            current_response = ""
+            async for token in self.tutor.discuss_case(message):
+                current_response += token
+                history[-1][1] = current_response
+                yield history, "", state
+            
+            state["last_message"] = datetime.now().isoformat()
+            yield history, "", state
+            
+        except Exception as e:
+            logger.error(f"Error in chat: {str(e)}")
+            if history is None:
+                history = []
+            history.append([message, "I apologize, but I encountered an error. Please try again."])
+            yield history, "", state
     
     def create_interface(self) -> gr.Blocks:
         """Create Gradio interface."""
@@ -136,24 +180,35 @@ class LearningInterface:
                     
                     # Chat interface
                     chatbot = gr.Chatbot(
-                        height=400,
-                        show_label=False
+                        height=500,
+                        label="Case Discussion",
+                        show_label=True,
+                        elem_classes=["dashboard-card"]
                     )
                     
                     with gr.Row():
-                        message = gr.Textbox(
+                        msg = gr.Textbox(
                             label="Present your case or ask questions",
-                            placeholder="Present your case as you would to your supervisor...",
-                            lines=4
+                            placeholder="Present your case...",
+                            lines=5
                         )
                         
-                        audio_input = gr.Audio(
-                            sources="microphone",
-                            type="numpy",
+                        # Add voice input
+                        audio_msg = gr.Audio(
                             label="Or speak your case",
+                            sources=["microphone"],
+                            type="numpy",
                             streaming=True
                         )
                     
+                    # Wire up chat with streaming
+                    msg.submit(
+                        self.process_chat,
+                        inputs=[msg, chatbot, state],
+                        outputs=[chatbot, msg, state],
+                        queue=False  # Important for streaming
+                    )                    
+            
                     with gr.Row():
                         clear = gr.Button("Clear Discussion")
                         end = gr.Button(