Updated LLMs

app.py

@@ -29,45 +29,133 @@ PASSING_SCORE = 30  # Need this to get my certificate!
 
 def setup_llm():
     """
-    Setting up the LLM - trying OpenAI first since it usually works better,
-    but falling back to HuggingFace if I don't have OpenAI credits
+    Setting up the LLM - trying multiple free/cheap providers since OpenAI is expensive!
+    
+    Priority order:
+    1. Groq (fast and often has generous free tier)
+    2. Together AI (good open models, reasonable pricing)
+    3. HuggingFace (free fallback)
+    4. OpenAI (if I have credits)
     """
-    logger.info("Setting up LLM...")
+    logger.info("Setting up LLM with multiple provider options...")
     
-    # Try OpenAI first (better performance but costs money)
-    openai_key = os.getenv("OPENAI_API_KEY")
-    if openai_key:
+    # Try Groq first (often has generous free tier and is very fast)
+    groq_key = os.getenv("GROQ_API_KEY")
+    if groq_key:
         try:
-            from llama_index.llms.openai import OpenAI
-            llm = OpenAI(
-                api_key=openai_key,
-                model="gpt-4o-mini",  # Good balance of performance and cost
+            # Try the official Groq import
+            from llama_index.llms.groq import Groq
+            llm = Groq(
+                api_key=groq_key,
+                model="llama3-groq-70b-8192-tool-use-preview",  # Known working Groq model
+                max_tokens=1024,
+                temperature=0.1
+            )
+            logger.info("🚀 Got Groq working!")
+            return llm
+        except ImportError:
+            logger.warning("Groq LlamaIndex integration not available, trying generic OpenAI-compatible...")
+            try:
+                # Fallback: Use OpenAI client with Groq endpoint
+                from llama_index.llms.openai import OpenAI
+                llm = OpenAI(
+                    api_key=groq_key,
+                    model="llama3-groq-70b-8192-tool-use-preview",
+                    api_base="https://api.groq.com/openai/v1",
+                    max_tokens=1024,
+                    temperature=0.1
+                )
+                logger.info("🚀 Got Groq working via OpenAI-compatible API!")
+                return llm
+            except Exception as e:
+                logger.warning(f"Groq didn't work: {e}")
+        except Exception as e:
+            logger.warning(f"Groq didn't work: {e}")
+    
+    # Try Together AI (good selection of open models)
+    together_key = os.getenv("TOGETHER_API_KEY")
+    if together_key:
+        try:
+            # Try the official Together import
+            from llama_index.llms.together import Together
+            llm = Together(
+                api_key=together_key,
+                model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",  # Known working Together model
                 max_tokens=1024,
-                temperature=0.1  # Low temp for more consistent answers
+                temperature=0.1
             )
-            logger.info("Got OpenAI working!")
+            logger.info("🤝 Got Together AI working!")
             return llm
+        except ImportError:
+            logger.warning("Together AI LlamaIndex integration not available, trying generic OpenAI-compatible...")
+            try:
+                # Fallback: Use OpenAI client with Together endpoint
+                from llama_index.llms.openai import OpenAI
+                llm = OpenAI(
+                    api_key=together_key,
+                    model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+                    api_base="https://api.together.xyz/v1",
+                    max_tokens=1024,
+                    temperature=0.1
+                )
+                logger.info("🤝 Got Together AI working via OpenAI-compatible API!")
+                return llm
+            except Exception as e:
+                logger.warning(f"Together AI didn't work: {e}")
         except Exception as e:
-            logger.warning(f"OpenAI didn't work: {e}")
+            logger.warning(f"Together AI didn't work: {e}")
     
-    # Fallback to HuggingFace (free but maybe not as good)
+    # Fallback to HuggingFace (free but slower)
     hf_token = os.getenv("HF_TOKEN")
     if hf_token:
         try:
             from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
             llm = HuggingFaceInferenceAPI(
-                model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
+                model_name="meta-llama/Llama-3.1-70B-Instruct",  # Good HF model
                 token=hf_token,
                 max_new_tokens=512,
                 temperature=0.1
             )
-            logger.info("Using HuggingFace LLM")
+            logger.info("🤗 Using HuggingFace as fallback")
+            return llm
+        except Exception as e:
+            logger.warning(f"HuggingFace failed: {e}")
+    
+    # Try OpenAI last (in case I get more credits)
+    openai_key = os.getenv("OPENAI_API_KEY")
+    if openai_key:
+        try:
+            from llama_index.llms.openai import OpenAI
+            llm = OpenAI(
+                api_key=openai_key,
+                model="gpt-4o-mini",
+                max_tokens=1024,
+                temperature=0.1
+            )
+            logger.info("🔄 Trying OpenAI...")
             return llm
         except Exception as e:
-            logger.error(f"HuggingFace also failed: {e}")
+            logger.warning(f"OpenAI still having issues: {e}")
     
     # If we get here, nothing worked
-    raise RuntimeError("No LLM available! Need either OPENAI_API_KEY or HF_TOKEN")
+    error_msg = """
+    No LLM available! Please set one of these API keys in your Space secrets:
+    
+    🎯 RECOMMENDED (Free/Cheap):
+    - GROQ_API_KEY (Fast, generous free tier)
+    - TOGETHER_API_KEY (Good open models)
+    
+    🔄 ALTERNATIVES:
+    - HF_TOKEN (Free but slower)
+    - OPENAI_API_KEY (If you get more credits)
+    
+    Get keys from:
+    - Groq: https://console.groq.com/
+    - Together: https://api.together.xyz/
+    """
+    
+    logger.error(error_msg)
+    raise RuntimeError(error_msg)
 
 class MyGAIAAgent:
     """
@@ -347,7 +435,7 @@ Required to pass: {PASSING_SCORE}%
         logger.error(error_msg)
         return error_msg, pd.DataFrame(results)
 
-# Create the Gradio interface (template pattern)
+# Create the Gradio interface with chat + GAIA evaluation
 with gr.Blocks(title="My GAIA Agent") as demo:
     gr.Markdown("# 🤖 My GAIA Benchmark Agent")
     gr.Markdown("""
@@ -360,37 +448,109 @@ with gr.Blocks(title="My GAIA Agent") as demo:
     - 👥 Query a database of personas
     
     **Goal:** Score 30%+ on GAIA benchmark to pass the course!
-    
-    **Instructions:**
-    1. **Login** to HuggingFace using the button below
-    2. **Click "Run GAIA Evaluation"** and wait (takes 5-10 minutes)
-    3. **See your results** and hopefully pass with 30%+!
     """)
     
     # Login button (template pattern)
     gr.LoginButton()
     
-    gr.Markdown("### Step 2: Run the Evaluation")
-    gr.Markdown("⏰ This might take 5-10 minutes...")
-    
-    run_btn = gr.Button("🚀 Run GAIA Evaluation", variant="primary", size="lg")
-    
-    gr.Markdown("### Step 3: Results")
-    
-    status_text = gr.Textbox(
-        label="📊 My Results",
-        lines=10,
-        interactive=False,
-        placeholder="Results will show here..."
-    )
-    
-    results_df = gr.DataFrame(label="📝 Question by Question Results", wrap=True)
-    
-    # Button connection (template pattern - this is the key!)
-    run_btn.click(
-        fn=run_gaia_evaluation,
-        outputs=[status_text, results_df]
-    )
+    # Create tabs for different functionalities
+    with gr.Tabs():
+        
+        # Tab 1: GAIA Evaluation (main functionality)
+        with gr.TabItem("🎯 GAIA Evaluation"):
+            gr.Markdown("### Run the Official GAIA Evaluation")
+            gr.Markdown("⏰ This might take 5-10 minutes...")
+            
+            run_btn = gr.Button("🚀 Run GAIA Evaluation", variant="primary", size="lg")
+            
+            status_text = gr.Textbox(
+                label="📊 My Results",
+                lines=10,
+                interactive=False,
+                placeholder="Results will show here..."
+            )
+            
+            results_df = gr.DataFrame(label="📝 Question by Question Results", wrap=True)
+            
+            # Button connection (template pattern)
+            run_btn.click(
+                fn=run_gaia_evaluation,
+                outputs=[status_text, results_df]
+            )
+        
+        # Tab 2: Chat Interface (for testing)
+        with gr.TabItem("💬 Test Chat"):
+            gr.Markdown("### Chat with My Agent")
+            gr.Markdown("Test your agent here before running the official evaluation!")
+            
+            # Simple chat interface
+            chatbot = gr.Chatbot(label="Chat with My Agent", height=400)
+            msg_input = gr.Textbox(
+                label="Your Message",
+                placeholder="Ask me anything! Try: 'What is 15% of 847?' or 'Search for recent AI news'",
+                lines=2
+            )
+            
+            with gr.Row():
+                send_btn = gr.Button("Send", variant="primary")
+                clear_btn = gr.Button("Clear Chat")
+            
+            # Chat functionality
+            def chat_with_agent(message, history):
+                """Simple chat function to test my agent"""
+                if not message.strip():
+                    return history, ""
+                
+                try:
+                    # Create agent if needed (cache it)
+                    if not hasattr(chat_with_agent, 'agent'):
+                        logger.info("Creating agent for chat...")
+                        chat_with_agent.agent = MyGAIAAgent()
+                        logger.info("Chat agent ready!")
+                    
+                    # Get response from agent
+                    response = chat_with_agent.agent(message)
+                    
+                    # Add to chat history
+                    history.append((message, response))
+                    
+                except Exception as e:
+                    error_response = f"Sorry, I had an error: {str(e)}"
+                    history.append((message, error_response))
+                
+                return history, ""  # Return updated history and clear input
+            
+            def clear_chat():
+                """Clear the chat history"""
+                return [], ""
+            
+            # Connect chat functions
+            send_btn.click(
+                fn=chat_with_agent,
+                inputs=[msg_input, chatbot],
+                outputs=[chatbot, msg_input]
+            )
+            
+            msg_input.submit(  # Allow Enter key to send
+                fn=chat_with_agent,
+                inputs=[msg_input, chatbot],
+                outputs=[chatbot, msg_input]
+            )
+            
+            clear_btn.click(
+                fn=clear_chat,
+                outputs=[chatbot, msg_input]
+            )
+            
+            # Some example questions
+            gr.Markdown("""
+            **Try these example questions:**
+            - `What is 25 * 17?`
+            - `Search for recent news about AI`
+            - `Find creative people in the persona database`
+            - `What's the weather in Paris?`
+            - `Analyze this CSV: name,age\\nAlice,25\\nBob,30`
+            """)
     
     gr.Markdown("---")
     gr.Markdown("🤞 Fingers crossed I pass this course!")
@@ -399,18 +559,39 @@ if __name__ == "__main__":
     print("🎯 My GAIA Agent - Final Course Project")
     print("=" * 50)
     
-    # Check my environment
-    openai_key = os.getenv("OPENAI_API_KEY")
+    # Check my environment and available LLM providers
+    print("\n🔍 Available LLM Providers:")
+    
+    groq_key = os.getenv("GROQ_API_KEY")
+    together_key = os.getenv("TOGETHER_API_KEY")
     hf_token = os.getenv("HF_TOKEN")
+    openai_key = os.getenv("OPENAI_API_KEY")
     
-    if openai_key:
-        print("✅ OpenAI key found")
+    providers_found = []
+    
+    if groq_key:
+        providers_found.append("Groq")
+        print("✅ GROQ_API_KEY found - Groq available!")
+    if together_key:
+        providers_found.append("Together AI")
+        print("✅ TOGETHER_API_KEY found - Together AI available!")
     if hf_token:
-        print("✅ HuggingFace token found")
-    if not openai_key and not hf_token:
-        print("⚠️ No API keys! Add OPENAI_API_KEY or HF_TOKEN to secrets")
+        providers_found.append("HuggingFace")
+        print("✅ HF_TOKEN found - HuggingFace available!")
+    if openai_key:
+        providers_found.append("OpenAI")
+        print("✅ OPENAI_API_KEY found - OpenAI available!")
+    
+    if providers_found:
+        print(f"\n🎉 Found {len(providers_found)} LLM provider(s): {', '.join(providers_found)}")
+        print(f"   Will use: {providers_found[0]} (highest priority)")
+    else:
+        print("\n⚠️ No API keys found! Add at least one to Space secrets:")
+        print("   - GROQ_API_KEY (recommended - fast & often free)")
+        print("   - TOGETHER_API_KEY (good open models)")
+        print("   - HF_TOKEN (free fallback)")
     
-    print(f"🎯 Need {PASSING_SCORE}% to pass the course")
+    print(f"\n🎯 Need {PASSING_SCORE}% to pass the course")
     print("🚀 Starting my agent...")
     
     demo.launch(debug=True, share=False, show_error=True)

requirements.txt

@@ -9,9 +9,11 @@ pandas>=1.5.0
 # Main LlamaIndex stuff - this is the core framework we learned about
 llama-index-core>=0.10.0
 
-# Different LLM options - trying both OpenAI and HuggingFace
-llama-index-llms-openai
-llama-index-llms-huggingface-api
+# Multiple LLM options - using correct package names
+llama-index-llms-openai              # OpenAI (if I have credits)
+llama-index-llms-huggingface-api     # HuggingFace (free option)
+llama-index-llms-groq                # Groq (fast and often free)
+llama-index-llms-together            # Together AI (good models)
 
 # For the RAG part with embeddings and vector search
 llama-index-retrievers-bm25

test_hf_space.py

@@ -137,7 +137,7 @@ def test_my_persona_database():
     print("\n👥 Testing My Persona Database...")
     
     try:
-        from my_retriever import test_my_personas
+        from retriever import test_my_personas
         
         # Run the built-in test
         success = test_my_personas()

tools.py

@@ -236,7 +236,7 @@ def create_persona_tool(llm=None):
     try:
         # Try to load the persona data first
         try:
-            from my_retriever import get_persona_query_engine
+            from retriever import get_persona_query_engine
             query_engine = get_persona_query_engine(llm=llm)
         except ImportError:
             # Fallback if my_retriever doesn't exist