Fix

agent.py

@@ -17,15 +17,20 @@ from langgraph.prebuilt import tools_condition, ToolNode
 from langchain_huggingface import HuggingFaceEmbeddings
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
-from langchain_community.vectorstores import Chroma
+try:
+    from langchain_community.vectorstores import Chroma
+except ImportError:
+    from langchain.vectorstores import Chroma
 from langchain_core.documents import Document
 from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
 from langchain_core.tools import tool
 from langchain_core.language_models.base import BaseLanguageModel
 from langchain.tools.retriever import create_retriever_tool
-from langchain.vectorstores import Chroma
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.schema import Document
+try:
+    from langchain.embeddings import HuggingFaceEmbeddings as LegacyHFEmbeddings
+except ImportError:
+    LegacyHFEmbeddings = HuggingFaceEmbeddings
+from langchain.schema import Document as LegacyDocument
 import json
 import requests
 from typing import List, Dict, Any
@@ -33,7 +38,7 @@ import re
 import math
 from datetime import datetime
 
-# Custom HuggingFace LLM wrapper
+# Custom HuggingFace LLM wrapper with better error handling
 class SimpleHuggingFaceLLM(BaseLanguageModel):
     def __init__(self, repo_id: str, hf_token: str):
         super().__init__()
@@ -41,6 +46,30 @@ class SimpleHuggingFaceLLM(BaseLanguageModel):
         self.hf_token = hf_token
         self.api_url = f"https://api-inference.huggingface.co/models/{repo_id}"
         self.headers = {"Authorization": f"Bearer {hf_token}"}
+        
+        # Test the connection
+        self._test_connection()
+    
+    def _test_connection(self):
+        """Test if the model is accessible"""
+        payload = {
+            "inputs": "Hello",
+            "parameters": {
+                "max_new_tokens": 10,
+                "temperature": 0.1,
+                "return_full_text": False
+            }
+        }
+        
+        try:
+            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=30)
+            if response.status_code != 200:
+                print(f"Model {self.repo_id} test failed with status {response.status_code}: {response.text}")
+                raise Exception(f"Model not accessible: {response.status_code}")
+            print(f"Model {self.repo_id} test successful")
+        except Exception as e:
+            print(f"Model {self.repo_id} connection test failed: {e}")
+            raise e
     
     def _generate(self, messages, stop=None, run_manager=None, **kwargs):
         # Convert messages to a single prompt
@@ -54,25 +83,34 @@ class SimpleHuggingFaceLLM(BaseLanguageModel):
             "parameters": {
                 "max_new_tokens": 512,
                 "temperature": 0.1,
-                "return_full_text": False
+                "return_full_text": False,
+                "do_sample": False
             }
         }
         
         try:
-            response = requests.post(self.api_url, headers=self.headers, json=payload)
+            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=60)
             if response.status_code == 200:
                 result = response.json()
                 if isinstance(result, list) and len(result) > 0:
                     generated_text = result[0].get('generated_text', '')
+                elif isinstance(result, dict):
+                    generated_text = result.get('generated_text', str(result))
                 else:
                     generated_text = str(result)
                 
                 from langchain_core.outputs import LLMResult, Generation
                 return LLMResult(generations=[[Generation(text=generated_text)]])
             else:
-                return LLMResult(generations=[[Generation(text=f"Error: {response.status_code}")]])
+                error_msg = f"API Error {response.status_code}: {response.text[:200]}"
+                print(error_msg)
+                from langchain_core.outputs import LLMResult, Generation
+                return LLMResult(generations=[[Generation(text=f"Error: {error_msg}")]])
         except Exception as e:
-            return LLMResult(generations=[[Generation(text=f"Error: {str(e)}")]])
+            error_msg = f"Request failed: {str(e)}"
+            print(error_msg)
+            from langchain_core.outputs import LLMResult, Generation
+            return LLMResult(generations=[[Generation(text=error_msg)]])
     
     def invoke(self, input, config=None, **kwargs):
         if isinstance(input, list):
@@ -87,6 +125,11 @@ class SimpleHuggingFaceLLM(BaseLanguageModel):
     @property
     def _llm_type(self):
         return "huggingface_custom"
+    
+    def _call(self, prompt: str, stop=None, run_manager=None, **kwargs):
+        """Legacy method for compatibility"""
+        result = self._generate(prompt)
+        return result.generations[0][0].text
 
 # ---- Enhanced Tools ----
 
@@ -217,17 +260,35 @@ def simple_calculation(expression: str) -> str:
     except Exception as e:
         return f"Calculation error: {str(e)}"
 
-# ---- Embedding & Vector Store Setup ----
+# ---- Embedding & Vector Store Setup with better error handling ----
 def setup_vector_store():
     try:
-        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+        # Try different embedding models
+        embedding_models = [
+            "sentence-transformers/all-MiniLM-L6-v2",
+            "sentence-transformers/all-mpnet-base-v2"
+        ]
+        
+        embeddings = None
+        for model_name in embedding_models:
+            try:
+                embeddings = HuggingFaceEmbeddings(model_name=model_name)
+                print(f"Successfully loaded embeddings: {model_name}")
+                break
+            except Exception as e:
+                print(f"Failed to load embeddings {model_name}: {e}")
+                continue
+        
+        if embeddings is None:
+            print("Could not load any embedding model, skipping vector store setup")
+            return None
         
         # Check if metadata.jsonl exists and load it
         if os.path.exists('metadata.jsonl'):
             json_QA = []
             with open('metadata.jsonl', 'r') as jsonl_file:
                 for line in jsonl_file:
-                    if line.strip():  # Skip empty lines
+                    if line.strip():
                         try:
                             json_QA.append(json.loads(line))
                         except:
@@ -244,29 +305,37 @@ def setup_vector_store():
                         documents.append(doc)
                 
                 if documents:
-                    vector_store = Chroma.from_documents(
-                        documents=documents,
-                        embedding=embeddings,
-                        persist_directory="./chroma_db",
-                        collection_name="my_collection"
-                    )
-                    vector_store.persist()
-                    print(f"Vector store created with {len(documents)} documents")
-                    return vector_store
+                    try:
+                        vector_store = Chroma.from_documents(
+                            documents=documents,
+                            embedding=embeddings,
+                            persist_directory="./chroma_db",
+                            collection_name="my_collection"
+                        )
+                        vector_store.persist()
+                        print(f"Vector store created with {len(documents)} documents")
+                        return vector_store
+                    except Exception as e:
+                        print(f"Error creating vector store with documents: {e}")
         
         # Create empty vector store if no data
-        vector_store = Chroma(
-            embedding_function=embeddings,
-            persist_directory="./chroma_db",
-            collection_name="my_collection"
-        )
-        print("Empty vector store created")
-        return vector_store
+        try:
+            vector_store = Chroma(
+                embedding_function=embeddings,
+                persist_directory="./chroma_db",
+                collection_name="my_collection"
+            )
+            print("Empty vector store created")
+            return vector_store
+        except Exception as e:
+            print(f"Error creating empty vector store: {e}")
+            return None
         
     except Exception as e:
         print(f"Vector store setup error: {e}")
         return None
 
+# Try to setup vector store, but don't fail if it doesn't work
 vector_store = setup_vector_store()
 
 @tool
@@ -325,21 +394,26 @@ tools = [
     wiki_search, web_search, similar_question_search
 ]
 
-# ---- Graph Definition ----
+# ---- Graph Definition with better error handling ----
 def build_graph(provider: str = "huggingface"):
     """Build the agent graph with custom HuggingFace integration"""
     
     if provider == "huggingface":
-        # Use custom HuggingFace LLM with fallback models
+        if not hf_token:
+            raise ValueError("HUGGINGFACE_INFERENCE_TOKEN is required but not found in environment variables")
+        
+        # Use custom HuggingFace LLM with better model selection
         models_to_try = [
+            "microsoft/DialoGPT-medium",
             "google/flan-t5-base",
-            "microsoft/DialoGPT-medium", 
-            "bigscience/bloom-560m"
+            "facebook/blenderbot-400M-distill",
+            "microsoft/DialoGPT-small"
         ]
         
         llm = None
         for model_id in models_to_try:
             try:
+                print(f"Trying to initialize model: {model_id}")
                 llm = SimpleHuggingFaceLLM(repo_id=model_id, hf_token=hf_token)
                 print(f"Successfully initialized model: {model_id}")
                 break
@@ -348,7 +422,7 @@ def build_graph(provider: str = "huggingface"):
                 continue
         
         if llm is None:
-            raise ValueError("Failed to initialize any HuggingFace model")
+            raise ValueError("Failed to initialize any HuggingFace model. Please check your HUGGINGFACE_INFERENCE_TOKEN and internet connection.")
     else:
         raise ValueError("Only 'huggingface' provider is supported")
 
@@ -388,7 +462,7 @@ def build_graph(provider: str = "huggingface"):
         
         return {"messages": context_messages + messages}
 
-    # Build simplified graph (without complex tool routing for now)
+    # Build simplified graph
     builder = StateGraph(MessagesState)
     builder.add_node("retriever", retriever)
     builder.add_node("assistant", assistant)

app.py

@@ -1,3 +1,4 @@
+
 import os
 import gradio as gr
 import requests
@@ -7,19 +8,23 @@ from agent import build_graph
 from langchain_core.messages import HumanMessage
 import time
 
-# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Improved Agent Definition ---
 class BasicAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("Initializing BasicAgent...")
         try:
+            # Add more verbose logging
+            print("Building graph...")
             self.graph = build_graph()
             print("Graph built successfully.")
         except Exception as e:
             print(f"Error building graph: {e}")
+            print(f"Error type: {type(e).__name__}")
+            import traceback
+            traceback.print_exc()
             raise e
         
     def __call__(self, question: str) -> str:
@@ -28,6 +33,8 @@ class BasicAgent:
         try:
             # Clean the question
             question = question.strip()
+            if not question:
+                return "Empty question received"
             
             # Wrap the question in a HumanMessage
             messages = [HumanMessage(content=question)]
@@ -36,6 +43,7 @@ class BasicAgent:
             max_retries = 3
             for attempt in range(max_retries):
                 try:
+                    print(f"Attempt {attempt + 1} to process question...")
                     result = self.graph.invoke({"messages": messages})
                     
                     if 'messages' in result and result['messages']:
@@ -50,21 +58,36 @@ class BasicAgent:
                             # Additional cleanup
                             answer = answer.replace("Assistant: ", "").strip()
                             
+                            # Handle empty or error responses
+                            if not answer or "Error:" in answer or "error" in answer.lower():
+                                if attempt < max_retries - 1:
+                                    print(f"Got error response, retrying: {answer[:100]}")
+                                    time.sleep(2)
+                                    continue
+                                else:
+                                    return "Unable to generate answer"
+                            
                             print(f"Agent answer (first 100 chars): {answer[:100]}...")
                             return answer
                         else:
                             return str(answer)
                     else:
+                        print("No messages in result")
+                        if attempt < max_retries - 1:
+                            time.sleep(2)
+                            continue
                         return "No response generated"
                         
                 except Exception as e:
                     print(f"Attempt {attempt + 1} failed: {e}")
                     if attempt == max_retries - 1:
                         return f"Error processing question: {str(e)}"
-                    time.sleep(1)  # Brief pause before retry
+                    time.sleep(2)  # Brief pause before retry
             
         except Exception as e:
             print(f"Error in agent call: {e}")
+            import traceback
+            traceback.print_exc()
             return f"Agent error: {str(e)}"
 
 
@@ -94,6 +117,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         print("Agent initialized successfully.")
     except Exception as e:
         print(f"Error instantiating agent: {e}")
+        import traceback
+        traceback.print_exc()
         return f"Error initializing agent: {e}", None
     
     # In the case of an app running as a Hugging Face space, this link points toward your codebase
@@ -148,20 +173,25 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             if not submitted_answer or submitted_answer.strip() == "":
                 submitted_answer = "No answer generated"
             
+            # Clean up the answer further
+            submitted_answer = str(submitted_answer).strip()
+            if submitted_answer.startswith("Error:") or submitted_answer.startswith("Agent error:"):
+                submitted_answer = "Unable to process question"
+            
             answers_payload.append({
                 "task_id": task_id, 
-                "submitted_answer": str(submitted_answer).strip()
+                "submitted_answer": submitted_answer
             })
             
             results_log.append({
                 "Task ID": task_id, 
                 "Question": question_text[:200] + "..." if len(question_text) > 200 else question_text, 
-                "Submitted Answer": str(submitted_answer).strip()
+                "Submitted Answer": submitted_answer
             })
             
         except Exception as e:
              print(f"Error running agent on task {task_id}: {e}")
-             error_answer = f"AGENT ERROR: {str(e)}"
+             error_answer = "Processing error occurred"
              answers_payload.append({
                  "task_id": task_id, 
                  "submitted_answer": error_answer