feat(integration): integrate hospital customization pipeline with main RAG system

- Move hospital customization to Step 1.5 for early execution
- Add parallel retrieval: general medical guidelines + hospital-specific docs
- Rename customization/src/retrieval to custom_retrieval to resolve import conflicts
- Fix field name mismatch in app.py fallback flow (medical_advice vs advice)
- Add enhanced keyword extraction for better hospital document matching
- Update generation.py to handle hospital_custom chunk classification
- Ensure conditional return values based on DEBUG_MODE to fix Gradio warnings

Major architectural changes:
- Hospital docs now retrieved alongside general guidelines
- LLM-based keyword extraction improves hospital document relevance
- Graceful fallback when no medical condition found but hospital docs available
- All components properly integrated with error handling

app.py

@@ -31,6 +31,9 @@ current_dir = Path(__file__).parent
 src_dir = current_dir / "src"
 sys.path.insert(0, str(src_dir))
 
+# Also add project root to ensure customization module can be imported
+sys.path.insert(0, str(current_dir))
+
 # Import OnCall.ai modules
 try:
     from user_prompt import UserPromptProcessor
@@ -141,14 +144,84 @@ class OnCallAIInterface:
                 processing_steps.append("   🚫 Query identified as non-medical")
                 return non_medical_msg, '\n'.join(processing_steps), "{}", "{}"
             
+            # STEP 1.5: Hospital-Specific Customization (Early retrieval)
+            # Run this early since it has its own keyword extraction
+            customization_results = []
+            retrieval_results = {}  # Initialize early for hospital results
+            try:
+                from customization.customization_pipeline import retrieve_document_chunks
+                
+                processing_steps.append("\n🏥 Step 1.5: Checking hospital-specific guidelines...")
+                custom_start = datetime.now()
+                
+                # Use original user query since hospital module has its own keyword extraction
+                custom_results = retrieve_document_chunks(user_query, top_k=3, llm_client=self.llm_client)
+                custom_time = (datetime.now() - custom_start).total_seconds()
+                
+                if custom_results:
+                    processing_steps.append(f"   📋 Found {len(custom_results)} hospital-specific guidelines")
+                    processing_steps.append(f"   ⏱️ Customization time: {custom_time:.3f}s")
+                    
+                    # Store customization results for later use
+                    customization_results = custom_results
+                    
+                    # Add custom results to retrieval_results for the generator
+                    retrieval_results['customization_results'] = custom_results
+                else:
+                    processing_steps.append("   ℹ️ No hospital-specific guidelines found")
+            except ImportError as e:
+                processing_steps.append(f"   ⚠️ Hospital customization module not available: {str(e)}")
+                if DEBUG_MODE:
+                    print(f"Import error: {traceback.format_exc()}")
+            except Exception as e:
+                processing_steps.append(f"   ⚠️ Customization search skipped: {str(e)}")
+                if DEBUG_MODE:
+                    print(f"Customization error: {traceback.format_exc()}")
+            
             # STEP 2: User Confirmation (Auto-simulated)
             processing_steps.append("\n🤝 Step 2: User confirmation (auto-confirmed for demo)")
             confirmation = self.user_prompt_processor.handle_user_confirmation(condition_result)
             
             if not condition_result.get('condition'):
-                no_condition_msg = "Unable to identify a specific medical condition. Please rephrase your query with more specific medical terms."
                 processing_steps.append("   ⚠️ No medical condition identified")
-                return no_condition_msg, '\n'.join(processing_steps), "{}", "{}"
+                
+                # If we have hospital customization results, we can still try to provide help
+                if customization_results:
+                    processing_steps.append("   ℹ️ Using hospital-specific guidelines to assist...")
+                    
+                    # Create a minimal retrieval_results structure for generation
+                    retrieval_results['processed_results'] = []
+                    
+                    # Skip to generation with hospital results only
+                    processing_steps.append("\n🧠 Step 4: Generating advice based on hospital guidelines...")
+                    gen_start = datetime.now()
+                    
+                    medical_advice_result = self.medical_generator.generate_medical_advice(
+                        condition_result.get('condition', user_query),
+                        retrieval_results,
+                        intention="general"
+                    )
+                    
+                    gen_time = (datetime.now() - gen_start).total_seconds()
+                    medical_advice = medical_advice_result.get('medical_advice', 'Unable to generate advice')
+                    
+                    processing_steps.append(f"   ⏱️ Generation time: {gen_time:.3f}s")
+                    
+                    # Format guidelines display
+                    guidelines_display = f"Hospital Guidelines Found: {len(customization_results)}"
+                    
+                    # Conditional return based on DEBUG_MODE
+                    if DEBUG_MODE:
+                        return (medical_advice, '\n'.join(processing_steps), guidelines_display, "{}")
+                    else:
+                        return (medical_advice, '\n'.join(processing_steps), guidelines_display)
+                else:
+                    # No condition and no hospital results
+                    no_condition_msg = "Unable to identify a specific medical condition. Please rephrase your query with more specific medical terms."
+                    if DEBUG_MODE:
+                        return no_condition_msg, '\n'.join(processing_steps), "{}", "{}"
+                    else:
+                        return no_condition_msg, '\n'.join(processing_steps), "{}"
             
             processing_steps.append(f"   ✅ Confirmed condition: {condition_result.get('condition')}")
             
@@ -161,9 +234,13 @@ class OnCallAIInterface:
             if not search_query:
                 search_query = condition_result.get('condition', user_query)
             
-            retrieval_results = self.retrieval_system.search(search_query, top_k=5)
+            # Search for general medical guidelines
+            general_results = self.retrieval_system.search(search_query, top_k=5)
             step3_time = (datetime.now() - step3_start).total_seconds()
             
+            # Merge with existing retrieval_results (which contains hospital customization)
+            retrieval_results.update(general_results)
+            
             processed_results = retrieval_results.get('processed_results', [])
             emergency_count = len([r for r in processed_results if r.get('type') == 'emergency'])
             treatment_count = len([r for r in processed_results if r.get('type') == 'treatment'])
@@ -179,6 +256,8 @@ class OnCallAIInterface:
             else:
                 guidelines_display = self._format_user_friendly_sources(processed_results)
             
+            # Hospital customization already done in Step 1.5
+            
             # STEP 4: Medical Advice Generation
             processing_steps.append("\n🧠 Step 4: Generating evidence-based medical advice...")
             step4_start = datetime.now()
@@ -235,12 +314,20 @@ class OnCallAIInterface:
             if not DEBUG_MODE:
                 technical_details = self._sanitize_technical_details(technical_details)
             
-            return (
-                medical_advice,
-                '\n'.join(processing_steps),
-                guidelines_display,
-                json.dumps(technical_details, indent=2)
-            )
+            # Conditional return based on DEBUG_MODE
+            if DEBUG_MODE:
+                return (
+                    medical_advice,
+                    '\n'.join(processing_steps),
+                    guidelines_display,
+                    json.dumps(technical_details, indent=2)
+                )
+            else:
+                return (
+                    medical_advice,
+                    '\n'.join(processing_steps),
+                    guidelines_display
+                )
             
         except Exception as e:
             error_msg = f"❌ System error: {str(e)}"
@@ -252,12 +339,20 @@ class OnCallAIInterface:
                 "query": user_query
             }
             
-            return (
-                "I apologize, but I encountered an error while processing your medical query. Please try rephrasing your question or contact technical support.",
-                '\n'.join(processing_steps),
-                "{}",
-                json.dumps(error_details, indent=2)
-            )
+            # Conditional return based on DEBUG_MODE
+            if DEBUG_MODE:
+                return (
+                    "I apologize, but I encountered an error while processing your medical query. Please try rephrasing your question or contact technical support.",
+                    '\n'.join(processing_steps),
+                    "{}",
+                    json.dumps(error_details, indent=2)
+                )
+            else:
+                return (
+                    "I apologize, but I encountered an error while processing your medical query. Please try rephrasing your question or contact technical support.",
+                    '\n'.join(processing_steps),
+                    "{}"
+                )
     
     def _format_guidelines_display(self, processed_results: List[Dict]) -> str:
         """Format retrieved guidelines for user-friendly display"""

customization/customization_pipeline.py

@@ -9,7 +9,9 @@ from pathlib import Path
 from typing import List, Dict
 
 # Add src directory to Python path
-sys.path.insert(0, str(Path(__file__).parent / 'src'))
+src_path = Path(__file__).parent / 'src'
+if str(src_path) not in sys.path:
+    sys.path.insert(0, str(src_path))
 
 # Import necessary modules
 from models.embedding_models import load_biomedbert_model
@@ -17,8 +19,8 @@ from data.loaders import load_annotations
 from indexing.document_indexer import build_document_index
 from indexing.embedding_creator import create_tag_embeddings, create_chunk_embeddings
 from indexing.storage import save_document_system, load_document_system_with_annoy
-from retrieval.document_retriever import create_document_tag_mapping
-from retrieval.chunk_retriever import find_relevant_chunks_with_fallback
+from custom_retrieval.document_retriever import create_document_tag_mapping
+from custom_retrieval.chunk_retriever import find_relevant_chunks_with_fallback
 
 
 def build_customization_embeddings():
@@ -68,7 +70,7 @@ def build_customization_embeddings():
     return True
 
 
-def retrieve_document_chunks(query: str, top_k: int = 5) -> List[Dict]:
+def retrieve_document_chunks(query: str, top_k: int = 5, llm_client=None) -> List[Dict]:
     """Retrieve relevant document chunks using two-stage ANNOY retrieval.
     
     Stage 1: Find relevant documents using tag embeddings (medical concepts)
@@ -77,6 +79,7 @@ def retrieve_document_chunks(query: str, top_k: int = 5) -> List[Dict]:
     Args:
         query: The search query
         top_k: Number of chunks to retrieve
+        llm_client: Optional LLM client for keyword extraction
         
     Returns:
         List of dictionaries containing chunk information
@@ -98,8 +101,24 @@ def retrieve_document_chunks(query: str, top_k: int = 5) -> List[Dict]:
         print("❌ Failed to load ANNOY manager")
         return []
     
-    # Create query embedding
-    query_embedding = embedding_model.encode(query)
+    # Extract medical keywords for better matching
+    search_query = query
+    if llm_client:
+        try:
+            print(f"🔍 Extracting medical keywords from: '{query}'")
+            keywords = llm_client.extract_medical_keywords_for_customization(query)
+            if keywords:
+                search_query = " ".join(keywords)
+                print(f"✅ Using keywords for search: '{search_query}'")
+            else:
+                print("ℹ️ No keywords extracted, using original query")
+        except Exception as e:
+            print(f"⚠️ Keyword extraction failed, using original query: {e}")
+    else:
+        print("ℹ️ No LLM client provided, using original query")
+    
+    # Create query embedding using processed search query
+    query_embedding = embedding_model.encode(search_query)
     
     # Stage 1: Find relevant documents using tag ANNOY index
     print(f"🔍 Stage 1: Finding relevant documents for query: '{query}'")

customization/src/demos/demo_runner.py

@@ -7,11 +7,11 @@ from data.loaders import load_annotations
 from indexing.document_indexer import build_document_index
 from indexing.embedding_creator import create_tag_embeddings, create_chunk_embeddings
 from indexing.storage import save_document_system, load_document_system, load_document_system_with_annoy
-from retrieval.document_retriever import (
+from custom_retrieval.document_retriever import (
     create_document_tag_mapping, find_relevant_documents, 
     find_relevant_documents_with_fallback
 )
-from retrieval.chunk_retriever import (
+from custom_retrieval.chunk_retriever import (
     find_relevant_chunks, get_documents_for_rag, get_chunks_for_rag,
     find_relevant_chunks_with_fallback
 )

customization/src/rag/medical_rag_pipeline.py

@@ -7,8 +7,8 @@ from typing import Dict, List, Optional, Tuple
 from sentence_transformers import SentenceTransformer
 
 # Import existing retrieval components
-from retrieval.document_retriever import find_relevant_documents
-from retrieval.chunk_retriever import find_relevant_chunks, get_chunks_for_rag
+from custom_retrieval.document_retriever import find_relevant_documents
+from custom_retrieval.chunk_retriever import find_relevant_chunks, get_chunks_for_rag
 from models.embedding_models import load_biomedbert_model
 
 

src/generation.py

@@ -128,6 +128,7 @@ class MedicalAdviceGenerator:
         treatment_chunks = classified_chunks.get("treatment_subset", [])
         symptom_chunks = classified_chunks.get("symptom_subset", [])      # Dataset B (future)
         diagnosis_chunks = classified_chunks.get("diagnosis_subset", [])  # Dataset B (future)
+        hospital_custom_chunks = classified_chunks.get("hospital_custom", [])  # Hospital customization
         
         # Select chunks based on intention or intelligent defaults
         selected_chunks = self._select_chunks_by_intention(
@@ -135,7 +136,8 @@ class MedicalAdviceGenerator:
             emergency_chunks=emergency_chunks,
             treatment_chunks=treatment_chunks,
             symptom_chunks=symptom_chunks,
-            diagnosis_chunks=diagnosis_chunks
+            diagnosis_chunks=diagnosis_chunks,
+            hospital_custom_chunks=hospital_custom_chunks
         )
         
         # Build context block from selected chunks
@@ -161,7 +163,8 @@ class MedicalAdviceGenerator:
             "emergency_subset": [],
             "treatment_subset": [],
             "symptom_subset": [],      # Reserved for Dataset B
-            "diagnosis_subset": []     # Reserved for Dataset B
+            "diagnosis_subset": [],     # Reserved for Dataset B
+            "hospital_custom": []      # Hospital-specific customization
         }
         
         # Process results from current dual-index system
@@ -180,29 +183,49 @@ class MedicalAdviceGenerator:
                 logger.warning(f"Unknown chunk type: {chunk_type}, defaulting to STAT (tentative)")
                 classified["emergency_subset"].append(chunk)
         
+        # Process hospital customization results if available
+        customization_results = retrieval_results.get('customization_results', [])
+        if customization_results:
+            for custom_chunk in customization_results:
+                # Convert customization format to standard chunk format
+                standardized_chunk = {
+                    'type': 'hospital_custom',
+                    'text': custom_chunk.get('chunk_text', ''),
+                    'distance': 1 - custom_chunk.get('score', 0),  # Convert score to distance
+                    'matched': f"Hospital Doc: {custom_chunk.get('document', 'Unknown')}",
+                    'metadata': custom_chunk.get('metadata', {})
+                }
+                classified["hospital_custom"].append(standardized_chunk)
+            logger.info(f"Added {len(customization_results)} hospital-specific chunks")
+        
         # TODO: Future integration point for Dataset B
         # When Dataset B team provides symptom/diagnosis data:
         # classified["symptom_subset"] = process_dataset_b_symptoms(retrieval_results)
         # classified["diagnosis_subset"] = process_dataset_b_diagnosis(retrieval_results)
         
         logger.info(f"Classified chunks: Emergency={len(classified['emergency_subset'])}, "
-                   f"Treatment={len(classified['treatment_subset'])}")
+                   f"Treatment={len(classified['treatment_subset'])}, "
+                   f"Hospital Custom={len(classified['hospital_custom'])}")
         
         return classified
 
     def _select_chunks_by_intention(self, intention: Optional[str], 
                                    emergency_chunks: List, treatment_chunks: List,
-                                   symptom_chunks: List, diagnosis_chunks: List) -> List:
+                                   symptom_chunks: List, diagnosis_chunks: List,
+                                   hospital_custom_chunks: List = None) -> List:
         """
         Select optimal chunk combination based on query intention
         
         Args:
             intention: Detected or specified intention  
             *_chunks: Chunks from different dataset sources
+            hospital_custom_chunks: Hospital-specific customization chunks
             
         Returns:
             List of selected chunks for prompt construction
         """
+        hospital_custom_chunks = hospital_custom_chunks or []
+        
         if intention and intention in self.dataset_priorities:
             # Use predefined priorities for known intentions
             priorities = self.dataset_priorities[intention]
@@ -212,6 +235,9 @@ class MedicalAdviceGenerator:
             selected_chunks.extend(emergency_chunks[:priorities["emergency_subset"]])
             selected_chunks.extend(treatment_chunks[:priorities["treatment_subset"]])
             
+            # Add hospital custom chunks alongside
+            selected_chunks.extend(hospital_custom_chunks)
+            
             # TODO: Future Dataset B integration
             # selected_chunks.extend(symptom_chunks[:priorities["symptom_subset"]])
             # selected_chunks.extend(diagnosis_chunks[:priorities["diagnosis_subset"]])
@@ -220,7 +246,7 @@ class MedicalAdviceGenerator:
             
         else:
             # No specific intention - let LLM judge from best available chunks
-            all_chunks = emergency_chunks + treatment_chunks + symptom_chunks + diagnosis_chunks
+            all_chunks = emergency_chunks + treatment_chunks + symptom_chunks + diagnosis_chunks + hospital_custom_chunks
             
             # Sort by relevance (distance) and take top 6
             all_chunks_sorted = sorted(all_chunks, key=lambda x: x.get("distance", 999))
@@ -251,10 +277,19 @@ class MedicalAdviceGenerator:
             distance = chunk.get("distance", 0)
             
             # Format each chunk with metadata
-            context_part = f"""
+            if chunk_type == 'hospital_custom':
+                # Special formatting for hospital-specific guidelines
+                source_label = "Hospital Protocol"
+                context_part = f"""
+[Guideline {i}] (Source: {source_label}, Relevance: {1-distance:.3f})
+📋 {chunk.get('matched', 'Hospital Document')}
+{chunk_text}
+                """.strip()
+            else:
+                context_part = f"""
 [Guideline {i}] (Source: {chunk_type.title()}, Relevance: {1-distance:.3f})
 {chunk_text}
-            """.strip()
+                """.strip()
             
             context_parts.append(context_part)
         

src/llm_clients.py

@@ -9,7 +9,7 @@ Date: 2025-07-29
 
 import logging
 import os
-from typing import Dict, Optional, Union
+from typing import Dict, Optional, Union, List
 from huggingface_hub import InferenceClient
 from dotenv import load_dotenv
 
@@ -162,6 +162,86 @@ DO NOT provide medical advice."""
                 'latency': latency  # Include latency even for error cases
             }
 
+    def extract_medical_keywords_for_customization(
+        self, 
+        query: str, 
+        max_tokens: int = 50, 
+        timeout: Optional[float] = None
+    ) -> List[str]:
+        """
+        Extract key medical concepts for hospital customization matching.
+        
+        Args:
+            query: Medical query text
+            max_tokens: Maximum tokens to generate
+            timeout: Specific API call timeout
+        
+        Returns:
+            List of key medical keywords/concepts
+        """
+        import time
+        
+        # Start timing
+        start_time = time.time()
+        
+        try:
+            self.logger.info(f"Extracting medical keywords for: {query}")
+            
+            # Prepare chat completion request for keyword extraction
+            response = self.client.chat.completions.create(
+                model="m42-health/Llama3-Med42-70B",
+                messages=[
+                    {
+                        "role": "system", 
+                        "content": """You are a medical keyword extractor. Extract 2-4 key medical concepts from queries for hospital document matching.
+
+Return ONLY the key medical terms/concepts, separated by commas.
+
+Examples:
+- "Patient with severe chest pain and shortness of breath" → "chest pain, dyspnea, cardiac"
+- "How to manage atrial fibrillation in emergency?" → "atrial fibrillation, arrhythmia, emergency"
+- "Stroke protocol for elderly patient" → "stroke, cerebrovascular, elderly"
+
+Focus on: conditions, symptoms, procedures, body systems."""
+                    },
+                    {
+                        "role": "user", 
+                        "content": query
+                    }
+                ],
+                max_tokens=max_tokens
+            )
+            
+            # Calculate latency
+            end_time = time.time()
+            latency = end_time - start_time
+            
+            # Extract keywords from response
+            keywords_text = response.choices[0].message.content or ""
+            
+            # Log response and latency
+            self.logger.info(f"Keywords extracted: {keywords_text}")
+            self.logger.info(f"Keyword extraction latency: {latency:.4f} seconds")
+            
+            # Parse keywords
+            keywords = [k.strip() for k in keywords_text.split(',') if k.strip()]
+            
+            # Filter out empty or very short keywords
+            keywords = [k for k in keywords if len(k) > 2]
+            
+            return keywords
+            
+        except Exception as e:
+            # Calculate latency even for failed requests
+            end_time = time.time()
+            latency = end_time - start_time
+            
+            self.logger.error(f"Medical keyword extraction error: {str(e)}")
+            self.logger.error(f"Query that caused error: {query}")
+            
+            # Return empty list on error
+            return []
+
     def _extract_condition(self, response: str) -> str:
         """
         Extract medical condition from model response.

test_retrieval_pipeline.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script for OnCall.ai retrieval pipeline
-
-This script tests the complete flow:
-user_input → user_prompt.py → retrieval.py
-
-Author: OnCall.ai Team
-Date: 2025-07-30
-"""
-
-import sys
-import os
-from pathlib import Path
-import logging
-import json
-from datetime import datetime
-
-# Add src directory to Python path
-sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
-
-# Import our modules
-from user_prompt import UserPromptProcessor
-from retrieval import BasicRetrievalSystem
-from llm_clients import llm_Med42_70BClient
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler('test_retrieval_pipeline.log')
-    ]
-)
-logger = logging.getLogger(__name__)
-
-def test_retrieval_pipeline():
-    """
-    Test the complete retrieval pipeline
-    """
-    print("="*60)
-    print("OnCall.ai Retrieval Pipeline Test")
-    print("="*60)
-    print(f"Test started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    print()
-    
-    try:
-        # Initialize components
-        print("🔧 Initializing components...")
-        
-        # Initialize LLM client
-        llm_client = llm_Med42_70BClient()
-        print("✅ LLM client initialized")
-        
-        # Initialize retrieval system
-        retrieval_system = BasicRetrievalSystem()
-        print("✅ Retrieval system initialized")
-        
-        # Initialize user prompt processor
-        user_prompt_processor = UserPromptProcessor(
-            llm_client=llm_client,
-            retrieval_system=retrieval_system
-        )
-        print("✅ User prompt processor initialized")
-        print()
-        
-        # Test queries
-        test_queries = [
-            "how to treat acute MI?",
-            "patient with chest pain and shortness of breath",
-            "sudden neurological symptoms suggesting stroke",
-            "acute stroke management protocol"
-        ]
-        
-        results = []
-        
-        for i, query in enumerate(test_queries, 1):
-            print(f"🔍 Test {i}/{len(test_queries)}: Testing query: '{query}'")
-            print("-" * 50)
-            
-            try:
-                # Step 1: Extract condition keywords
-                print("Step 1: Extracting condition keywords...")
-                condition_result = user_prompt_processor.extract_condition_keywords(query)
-                
-                print(f"  Condition: {condition_result.get('condition', 'None')}")
-                print(f"  Emergency keywords: {condition_result.get('emergency_keywords', 'None')}")
-                print(f"  Treatment keywords: {condition_result.get('treatment_keywords', 'None')}")
-                
-                if not condition_result.get('condition'):
-                    print("  ⚠️  No condition extracted, skipping retrieval")
-                    continue
-                
-                # Step 2: User confirmation (simulated)
-                print("\nStep 2: User confirmation (simulated as 'yes')")
-                confirmation = user_prompt_processor.handle_user_confirmation(condition_result)
-                print(f"  Confirmation type: {confirmation.get('type', 'Unknown')}")
-                
-                # Step 3: Perform retrieval
-                print("\nStep 3: Performing retrieval...")
-                search_query = f"{condition_result.get('emergency_keywords', '')} {condition_result.get('treatment_keywords', '')}".strip()
-                
-                if not search_query:
-                    search_query = condition_result.get('condition', query)
-                
-                print(f"  Search query: '{search_query}'")
-                
-                retrieval_results = retrieval_system.search(search_query, top_k=5)
-                
-                # Display results
-                print(f"\n📊 Retrieval Results:")
-                print(f"  Total results: {retrieval_results.get('total_results', 0)}")
-                
-                emergency_results = retrieval_results.get('emergency_results', [])
-                treatment_results = retrieval_results.get('treatment_results', [])
-                
-                print(f"  Emergency results: {len(emergency_results)}")
-                print(f"  Treatment results: {len(treatment_results)}")
-                
-                # Show top results
-                if 'processed_results' in retrieval_results:
-                    processed_results = retrieval_results['processed_results'][:3]  # Show top 3
-                    print(f"\n  Top {len(processed_results)} results:")
-                    for j, result in enumerate(processed_results, 1):
-                        print(f"    {j}. Type: {result.get('type', 'Unknown')}")
-                        print(f"       Distance: {result.get('distance', 'Unknown'):.4f}")
-                        print(f"       Text preview: {result.get('text', '')[:100]}...")
-                        print(f"       Matched: {result.get('matched', 'None')}")
-                        print(f"       Treatment matched: {result.get('matched_treatment', 'None')}")
-                        print()
-                
-                # Store results for summary
-                test_result = {
-                    'query': query,
-                    'condition_extracted': condition_result.get('condition', ''),
-                    'emergency_keywords': condition_result.get('emergency_keywords', ''),
-                    'treatment_keywords': condition_result.get('treatment_keywords', ''),
-                    'search_query': search_query,
-                    'total_results': retrieval_results.get('total_results', 0),
-                    'emergency_count': len(emergency_results),
-                    'treatment_count': len(treatment_results),
-                    'success': True
-                }
-                results.append(test_result)
-                
-                print("✅ Test completed successfully")
-                
-            except Exception as e:
-                logger.error(f"Error in test {i}: {e}", exc_info=True)
-                test_result = {
-                    'query': query,
-                    'error': str(e),
-                    'success': False
-                }
-                results.append(test_result)
-                print(f"❌ Test failed: {e}")
-            
-            print("\n" + "="*60 + "\n")
-        
-        # Print summary
-        print_test_summary(results)
-        
-        # Save results to file
-        save_test_results(results)
-        
-        return results
-        
-    except Exception as e:
-        logger.error(f"Critical error in pipeline test: {e}", exc_info=True)
-        print(f"❌ Critical error: {e}")
-        return []
-
-def print_test_summary(results):
-    """Print test summary"""
-    print("📋 TEST SUMMARY")
-    print("="*60)
-    
-    successful_tests = [r for r in results if r.get('success', False)]
-    failed_tests = [r for r in results if not r.get('success', False)]
-    
-    print(f"Total tests: {len(results)}")
-    print(f"Successful: {len(successful_tests)}")
-    print(f"Failed: {len(failed_tests)}")
-    print(f"Success rate: {len(successful_tests)/len(results)*100:.1f}%")
-    print()
-    
-    if successful_tests:
-        print("✅ Successful tests:")
-        for result in successful_tests:
-            print(f"  - '{result['query']}'")
-            print(f"    Condition: {result.get('condition_extracted', 'None')}")
-            print(f"    Results: {result.get('total_results', 0)} total "
-                  f"({result.get('emergency_count', 0)} emergency, "
-                  f"{result.get('treatment_count', 0)} treatment)")
-            print()
-    
-    if failed_tests:
-        print("❌ Failed tests:")
-        for result in failed_tests:
-            print(f"  - '{result['query']}': {result.get('error', 'Unknown error')}")
-        print()
-
-def save_test_results(results):
-    """Save test results to JSON file"""
-    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-    filename = f"test_results_{timestamp}.json"
-    
-    try:
-        with open(filename, 'w', encoding='utf-8') as f:
-            json.dump({
-                'timestamp': datetime.now().isoformat(),
-                'test_results': results
-            }, f, indent=2, ensure_ascii=False)
-        
-        print(f"📁 Test results saved to: {filename}")
-        
-    except Exception as e:
-        logger.error(f"Failed to save test results: {e}")
-        print(f"⚠️  Failed to save test results: {e}")
-
-if __name__ == "__main__":
-    test_retrieval_pipeline()