Major fix: Update LangChain initialization and improve error handling for Hugging Face compatibility

streamlit_app.py

@@ -95,199 +95,203 @@ def load_document_chunks():
 @st.cache_resource
 def get_chat_model():
     """Get the chat model for initial RAG."""
-    try:
-        # First attempt with minimal params
-        return ChatOpenAI(
-            model="gpt-4.1-mini",
-            temperature=0,
-        )
-    except Exception as e:
-        print(f"Error initializing chat model: {str(e)}")
-        # Try with just model name
-        try:
-            return ChatOpenAI(
-                model="gpt-4.1-mini"
-            )
-        except Exception as e2:
-            print(f"Final attempt for chat model: {str(e2)}")
-            # Last resort with no parameters
-            return ChatOpenAI()
+    import os
+    # Most minimal initialization possible for Hugging Face environment
+    api_key = os.environ.get("OPENAI_API_KEY", "")
+    print(f"Initializing chat model with API key starting with: {api_key[:4]}...")
+    return ChatOpenAI(api_key=api_key, model_name="gpt-4.1-mini")
 
 @st.cache_resource
 def get_agent_model():
     """Get the more powerful model for agent and evaluation."""
-    try:
-        # First attempt with minimal params
-        return ChatOpenAI(
-            model="gpt-4.1",
-            temperature=0,
-        )
-    except Exception as e:
-        print(f"Error initializing agent model: {str(e)}")
-        # Try with just model name
-        try:
-            return ChatOpenAI(
-                model="gpt-4.1"
-            )
-        except Exception as e2:
-            print(f"Final attempt for agent model: {str(e2)}")
-            # Last resort with no parameters
-            return ChatOpenAI()
+    import os
+    # Most minimal initialization possible for Hugging Face environment
+    api_key = os.environ.get("OPENAI_API_KEY", "")
+    print(f"Initializing agent model with API key starting with: {api_key[:4]}...")
+    return ChatOpenAI(api_key=api_key, model_name="gpt-4.1")
 
 @st.cache_resource
 def get_embedding_model():
     """Get the embedding model."""
-    from langchain_openai import OpenAIEmbeddings
     import os
+    from langchain_openai import OpenAIEmbeddings
     
-    # Simplest possible initialization
-    try:
-        api_key = os.environ.get("OPENAI_API_KEY", "")
-        print(f"Using API key: {api_key[:4]}...{api_key[-4:] if len(api_key) > 8 else ''}")
-        
-        # Most minimal initialization - one parameter only
-        return OpenAIEmbeddings(model="text-embedding-3-small")
-    except Exception as e:
-        print(f"Error initializing embeddings: {str(e)}")
-        # Try more minimal approach (in case model param is causing issues)
-        try:
-            return OpenAIEmbeddings()
-        except Exception as e2:
-            print(f"Final attempt to initialize embeddings failed: {str(e2)}")
-            raise
+    # Absolutely minimal initialization for Hugging Face compatibility
+    api_key = os.environ.get("OPENAI_API_KEY", "")
+    print(f"Initializing embeddings with API key starting with: {api_key[:4]}...")
+    
+    # Minimal parameters - only model_name and api_key
+    return OpenAIEmbeddings(
+        model="text-embedding-3-small",
+        api_key=api_key
+    )
 
 @st.cache_resource
 def setup_qdrant_client():
     """Set up the Qdrant client."""
+    import os
+    
+    print(f"Setting up Qdrant client with path: {str(QDRANT_DIR)}")
+    
+    # Check if directory exists
+    if not os.path.exists(QDRANT_DIR):
+        print(f"WARNING: Qdrant directory does not exist: {str(QDRANT_DIR)}")
+        raise ValueError(f"Qdrant directory not found at {str(QDRANT_DIR)}")
+    
+    # Try creating the client with minimal parameters
     try:
         return QdrantClient(path=str(QDRANT_DIR))
     except Exception as e:
-        # If there's an issue with the standard approach, print diagnostics and retry
-        print(f"QdrantClient initialization error: {str(e)}")
-        print(f"Checking if directory exists: {os.path.exists(str(QDRANT_DIR))}")
+        print(f"Error initializing QdrantClient with path: {str(e)}")
         
-        # Try alternative approach with explicit collection params
-        if os.path.exists(str(QDRANT_DIR)):
-            try:
-                # Try with location parameter instead
-                return QdrantClient(location=str(QDRANT_DIR))
-            except Exception as e2:
-                print(f"Alternative initialization also failed: {str(e2)}")
-                raise
-        else:
-            raise ValueError(f"Qdrant directory does not exist: {str(QDRANT_DIR)}")
+        # Try with location parameter
+        try:
+            return QdrantClient(location=str(QDRANT_DIR))
+        except Exception as e2:
+            print(f"Error initializing with location: {str(e2)}")
+            
+            # Last attempt with in-memory client
+            print("Attempting to create in-memory client")
+            return QdrantClient(":memory:")
 
 def retrieve_documents(query, k=5):
     """Retrieve relevant documents for a query."""
-    # Get models and data
+    # Define collection name
+    collection_name = "kohavi_ab_testing_pdf_collection"
+    
     try:
-        embedding_model = get_embedding_model()
-        chunks = load_document_chunks()
-        client = setup_qdrant_client()
+        print(f"Starting document retrieval for query: '{query[:30]}...'")
+        
+        # Get models and data
+        try:
+            embedding_model = get_embedding_model()
+        except Exception as e:
+            print(f"Error getting embedding model: {str(e)}")
+            return [], []
+            
+        try:
+            chunks = load_document_chunks()
+            print(f"Loaded {len(chunks)} document chunks")
+        except Exception as e:
+            print(f"Error loading document chunks: {str(e)}")
+            return [], []
+            
+        try:
+            client = setup_qdrant_client()
+            print("Successfully created Qdrant client")
+        except Exception as e:
+            print(f"Error setting up Qdrant client: {str(e)}")
+            return [], []
+        
+        # Check if collection exists
+        try:
+            collections = client.get_collections()
+            print(f"Available collections: {collections}")
+            
+            collection_info = client.get_collection(collection_name)
+            print(f"Collection info: {collection_info}")
+        except Exception as e:
+            print(f"Error checking collection: {str(e)}")
+            return [], []
         
         # Create a mapping of IDs to documents
         docs_by_id = {i: doc for i, doc in enumerate(chunks)}
         
         # Get query embedding
-        query_embedding = embedding_model.embed_query(query)
+        try:
+            query_embedding = embedding_model.embed_query(query)
+            print(f"Generated embedding of length {len(query_embedding)}")
+        except Exception as e:
+            print(f"Error creating query embedding: {str(e)}")
+            return [], []
         
-        # Try various search methods until one works
+        # Search for relevant documents
         results = None
+        
+        # Try different querying approaches
         try:
-            # Try simplest query_points call
+            # Simple query_points call
             results = client.query_points(
-                collection_name="kohavi_ab_testing_pdf_collection",
+                collection_name=collection_name,
                 query_vector=query_embedding,
                 limit=k
             )
-            print("Successfully used query_points method")
-        except Exception as e:
-            print(f"First query attempt failed: {str(e)}")
+            print(f"Retrieved {len(results)} results with query_points")
+        except Exception as e1:
+            print(f"First query approach failed: {str(e1)}")
+            
             try:
-                # Try with explicit parameters
-                results = client.query_points(
-                    collection_name="kohavi_ab_testing_pdf_collection",
+                # Try with minimum parameters
+                results = client.search(
+                    collection_name=collection_name,
                     query_vector=query_embedding,
-                    with_payload=True,
                     limit=k
                 )
-                print("Successfully used query_points with explicit parameters")
+                print(f"Retrieved {len(results)} results with search method")
             except Exception as e2:
-                print(f"Second query attempt failed: {str(e2)}")
-                try:
-                    # Fall back to deprecated search method
-                    results = client.search(
-                        collection_name="kohavi_ab_testing_pdf_collection",
-                        query_vector=query_embedding,
-                        limit=k
-                    )
-                    print("Successfully used deprecated search method")
-                except Exception as e3:
-                    print(f"All query methods failed: {str(e3)}")
-                    # No results found - return empty list
-                    return [], []
+                print(f"Second query approach failed: {str(e2)}")
+                return [], []
         
-        # If we got here but results is still None, return empty lists
-        if results is None:
-            print("No results found with any query method")
+        # Handle empty results
+        if not results:
+            print("No results found in vector store")
             return [], []
             
-        # Convert results to documents
+        # Process results
         documents = []
-        sources_dict = {}  # Use a dictionary to track unique sources by file+page
+        sources_dict = {}
         
-        print(f"Retrieved {len(results)} search results")
+        print(f"Processing {len(results)} search results")
         
         for result in results:
-            doc_id = result.id
-            if doc_id in docs_by_id:
-                doc = docs_by_id[doc_id]
-                documents.append(doc)
-                
-                # Debug the metadata
-                print(f"Document metadata: {doc.metadata}")
-                
-                # Extract source info
-                source_path = doc.metadata.get("source", "")
-                filename = source_path.split("/")[-1] if "/" in source_path else source_path
-                
-                # Remove .pdf extension if present
-                if filename.lower().endswith('.pdf'):
-                    filename = filename[:-4]
-                
-                # Default to the full filename if we can't extract a title
-                if not filename:
-                    filename = "Unknown Source"
+            try:
+                doc_id = result.id
+                if doc_id in docs_by_id:
+                    doc = docs_by_id[doc_id]
+                    documents.append(doc)
                     
-                # Get page number, use a default if not available
-                page = doc.metadata.get("page", "unknown")
-                
-                # All PDF sources in data directory are by Ron Kohavi, so add his name as prefix
-                title = f"Ron Kohavi: {filename}"
-                
-                # Create a unique key for this source based on filename and page
-                source_key = f"{filename}_{page}"
-                
-                # Only add to sources if we haven't seen this exact source (same file, same page) before
-                if source_key not in sources_dict:
-                    sources_dict[source_key] = {
-                        "title": title,
-                        "page": page,
-                        "score": float(result.score),
-                        "type": "pdf"
-                    }
-                    print(f"Added source: {title}, Page: {page}")
-                else:
-                    print(f"Skipping duplicate source: {title}, Page: {page}")
+                    # Extract metadata for sources
+                    source_path = doc.metadata.get("source", "")
+                    filename = source_path.split("/")[-1] if "/" in source_path else source_path
+                    
+                    # Remove .pdf extension if present
+                    if filename.lower().endswith('.pdf'):
+                        filename = filename[:-4]
+                    
+                    # Default to the full filename if we can't extract a title
+                    if not filename:
+                        filename = "Unknown Source"
+                        
+                    # Get page number, use a default if not available
+                    page = doc.metadata.get("page", "unknown")
+                    
+                    # Add prefix for consistency
+                    title = f"Ron Kohavi: {filename}"
+                    
+                    # Create a unique key for this source
+                    source_key = f"{filename}_{page}"
+                    
+                    # Only add unique sources
+                    if source_key not in sources_dict:
+                        sources_dict[source_key] = {
+                            "title": title,
+                            "page": page,
+                            "score": float(result.score),
+                            "type": "pdf"
+                        }
+                        print(f"Added source: {title}, Page: {page}")
+            except Exception as e:
+                print(f"Error processing result: {str(e)}")
+                continue
         
-        # Convert the dictionary of unique sources back to a list
+        # Convert sources dictionary to list
         sources = list(sources_dict.values())
         
         print(f"Returning {len(documents)} documents with {len(sources)} unique sources")
         return documents, sources
+        
     except Exception as e:
-        print(f"Error in retrieve_documents: {str(e)}")
-        # Return empty results in case of any error
+        print(f"Unexpected error in retrieve_documents: {str(e)}")
         return [], []
 
 def rephrase_query(query):