Update app.py

app.py

@@ -1,479 +1,186 @@
 """
-GAIA Test Application for Hugging Face Agents Course Certification
+Minimal Gradio interface for a simple AI assistant without smolagents
 
-This application provides a simulated GAIA benchmark test environment with 20 questions
-from Level 1 of the GAIA benchmark. It allows users to practice for the certification
-test and automatically calculates their score.
+This is a standalone version that uses only Hugging Face Inference API directly.
+It creates a simple Gradio interface for text generation.
 """
 
 import os
+import sys
 import json
-import gradio as gr
 import requests
-from typing import List, Dict, Any, Tuple
+import gradio as gr
 
-# Sample GAIA Level 1 questions (20 questions for certification practice)
-GAIA_SAMPLE_QUESTIONS = [
-    {
-        "id": "gaia_l1_001",
-        "question": "What is the capital city of Japan?",
-        "answer": "Tokyo",
-        "category": "factual",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_002",
-        "question": "Calculate the area of a circle with radius 5 cm. Express your answer in square centimeters with one decimal place.",
-        "answer": "78.5",
-        "category": "mathematical",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_003",
-        "question": "Who wrote the novel '1984'?",
-        "answer": "George Orwell",
-        "category": "factual",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_004",
-        "question": "What is the chemical symbol for gold?",
-        "answer": "Au",
-        "category": "factual",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_005",
-        "question": "If a train travels at 60 miles per hour, how far will it travel in 2.5 hours?",
-        "answer": "150 miles",
-        "category": "mathematical",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_006",
-        "question": "What is the largest planet in our solar system?",
-        "answer": "Jupiter",
-        "category": "factual",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_007",
-        "question": "Calculate 15% of 240.",
-        "answer": "36",
-        "category": "mathematical",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_008",
-        "question": "Who painted the Mona Lisa?",
-        "answer": "Leonardo da Vinci",
-        "category": "factual",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_009",
-        "question": "What is the boiling point of water in degrees Celsius at standard atmospheric pressure?",
-        "answer": "100",
-        "category": "factual",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_010",
-        "question": "If x + 3 = 8, what is the value of x?",
-        "answer": "5",
-        "category": "mathematical",
-        "difficulty": "easy"
-    },
-    {
-        "id": "gaia_l1_011",
-        "question": "What is the main ingredient in guacamole?",
-        "answer": "Avocado",
-        "category": "factual",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_012",
-        "question": "If a rectangle has a length of 12 cm and a width of 8 cm, what is its perimeter?",
-        "answer": "40 cm",
-        "category": "mathematical",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_013",
-        "question": "Who was the first person to walk on the moon?",
-        "answer": "Neil Armstrong",
-        "category": "factual",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_014",
-        "question": "What is the square root of 144?",
-        "answer": "12",
-        "category": "mathematical",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_015",
-        "question": "Which element has the chemical symbol 'O'?",
-        "answer": "Oxygen",
-        "category": "factual",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_016",
-        "question": "A store is having a 30% off sale. If an item originally costs $85, what is the sale price?",
-        "answer": "$59.50",
-        "category": "mathematical",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_017",
-        "question": "What is the largest ocean on Earth?",
-        "answer": "Pacific Ocean",
-        "category": "factual",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_018",
-        "question": "If 3x - 7 = 14, what is the value of x?",
-        "answer": "7",
-        "category": "mathematical",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_019",
-        "question": "Who wrote 'Romeo and Juliet'?",
-        "answer": "William Shakespeare",
-        "category": "factual",
-        "difficulty": "medium"
-    },
-    {
-        "id": "gaia_l1_020",
-        "question": "What is the capital of Australia?",
-        "answer": "Canberra",
-        "category": "factual",
-        "difficulty": "medium"
-    }
-]
+# Check if running in Hugging Face Spaces
+IS_HF_SPACES = os.environ.get("SPACE_ID") is not None
 
-class GAIATestSimulator:
+class MinimalAIAssistant:
     """
-    Simulates the GAIA benchmark test for certification practice
+    Minimal AI Assistant using Hugging Face Inference API directly
     """
-    def __init__(self, questions: List[Dict[str, Any]] = None):
+    def __init__(self, api_key=None, model_id="mistralai/Mixtral-8x7B-Instruct-v0.1"):
         """
-        Initialize the GAIA test simulator
+        Initialize the minimal AI assistant
         
         Args:
-            questions: List of question dictionaries (optional)
-        """
-        self.questions = questions or GAIA_SAMPLE_QUESTIONS
-        self.user_answers = {}
-        self.current_question_idx = 0
-        self.total_questions = len(self.questions)
-        self.results = None
-    
-    def get_current_question(self) -> Dict[str, Any]:
+            api_key: Hugging Face API key
+            model_id: Model ID to use
         """
-        Get the current question
-        
-        Returns:
-            Current question dictionary
-        """
-        if self.current_question_idx < self.total_questions:
-            return self.questions[self.current_question_idx]
-        return None
-    
-    def submit_answer(self, answer: str) -> Tuple[str, int, int]:
+        self.api_key = api_key or os.environ.get("HF_API_KEY", "")
+        self.model_id = model_id
+        self.api_url = f"https://api-inference.huggingface.co/models/{model_id}"
+        self.headers = {"Authorization": f"Bearer {self.api_key}"}
+        
+        # System prompt
+        self.system_prompt = """
+You are an advanced AI assistant designed to help with various tasks.
+You can answer questions, provide information, and assist with problem-solving.
+Always be helpful, accurate, and concise in your responses.
+"""
+
+    def query(self, prompt):
         """
-        Submit an answer for the current question
+        Query the model with a prompt
         
         Args:
-            answer: User's answer
+            prompt: User prompt
             
         Returns:
-            Tuple of (status message, current question index, total questions)
+            Model response
         """
-        if self.current_question_idx >= self.total_questions:
-            return "All questions have been answered.", self.current_question_idx, self.total_questions
-        
-        current_question = self.questions[self.current_question_idx]
-        self.user_answers[current_question["id"]] = answer
-        self.current_question_idx += 1
-        
-        if self.current_question_idx < self.total_questions:
-            next_question = self.questions[self.current_question_idx]
-            return f"Answer submitted. Moving to question {self.current_question_idx + 1}/{self.total_questions}.", self.current_question_idx, self.total_questions
-        else:
-            return "All questions have been answered. You can now calculate your score.", self.current_question_idx, self.total_questions
-    
-    def calculate_score(self) -> Dict[str, Any]:
-        """
-        Calculate the score based on submitted answers
-        
-        Returns:
-            Dictionary with score results
-        """
-        if not self.user_answers:
-            return {
-                "status": "error",
-                "message": "No answers have been submitted yet."
+        try:
+            # Format the prompt with system message
+            formatted_prompt = f"{self.system_prompt}\n\nUser: {prompt}\n\nAssistant:"
+            
+            # Prepare the payload
+            payload = {
+                "inputs": formatted_prompt,
+                "parameters": {
+                    "max_new_tokens": 1024,
+                    "temperature": 0.7,
+                    "top_p": 0.95,
+                    "do_sample": True
+                }
             }
+            
+            # Make the API request
+            response = requests.post(self.api_url, headers=self.headers, json=payload)
+            
+            # Check for errors
+            if response.status_code != 200:
+                return f"Error: API returned status code {response.status_code}. {response.text}"
+            
+            # Parse the response
+            result = response.json()
+            
+            # Extract the generated text
+            if isinstance(result, list) and len(result) > 0:
+                generated_text = result[0].get("generated_text", "")
+                # Remove the prompt from the response
+                if generated_text.startswith(formatted_prompt):
+                    generated_text = generated_text[len(formatted_prompt):].strip()
+                return generated_text
+            else:
+                return "Error: Unexpected response format from API"
         
-        correct_answers = 0
-        results = []
-        
-        for question in self.questions:
-            question_id = question["id"]
-            if question_id in self.user_answers:
-                user_answer = self.user_answers[question_id].strip()
-                correct_answer = question["answer"].strip()
-                
-                # Simple string matching (case-insensitive)
-                is_correct = user_answer.lower() == correct_answer.lower()
-                
-                results.append({
-                    "question_id": question_id,
-                    "question": question["question"],
-                    "user_answer": user_answer,
-                    "correct_answer": correct_answer,
-                    "is_correct": is_correct
-                })
-                
-                if is_correct:
-                    correct_answers += 1
-        
-        answered_questions = len(self.user_answers)
-        score_percentage = (correct_answers / self.total_questions) * 100
-        passed = score_percentage >= 30
-        
-        self.results = {
-            "status": "success",
-            "total_questions": self.total_questions,
-            "answered_questions": answered_questions,
-            "correct_answers": correct_answers,
-            "score_percentage": score_percentage,
-            "passed": passed,
-            "results": results
-        }
-        
-        return self.results
-    
-    def reset_test(self) -> str:
-        """
-        Reset the test to start over
-        
-        Returns:
-            Status message
-        """
-        self.user_answers = {}
-        self.current_question_idx = 0
-        self.results = None
-        return "Test has been reset. You can start again."
+        except Exception as e:
+            return f"Error querying model: {str(e)}"
 
 
-def create_gaia_test_interface():
+def create_gradio_interface():
     """
-    Create a Gradio interface for the GAIA test simulator
+    Create a Gradio interface for the minimal AI assistant
     
     Returns:
         Gradio interface
     """
-    # Initialize the simulator
-    simulator = GAIATestSimulator()
+    # Initialize the assistant
+    assistant = MinimalAIAssistant()
     
-    def get_question_text():
-        """Get the current question text"""
-        question = simulator.get_current_question()
-        if question:
-            return f"Question {simulator.current_question_idx + 1}/{simulator.total_questions}: {question['question']}"
-        return "All questions have been answered. You can now calculate your score."
-    
-    def submit_answer(answer):
-        """Submit an answer and get the next question"""
-        message, current_idx, total = simulator.submit_answer(answer)
-        
-        # Get the next question if available
-        next_question = ""
-        if current_idx < total:
-            question = simulator.get_current_question()
-            next_question = f"Question {current_idx + 1}/{total}: {question['question']}"
-        else:
-            next_question = "All questions have been answered. You can now calculate your score."
-        
-        return message, next_question, ""  # Clear the answer input
-    
-    def calculate_score():
-        """Calculate and display the score"""
-        results = simulator.calculate_score()
-        
-        if results["status"] == "error":
-            return results["message"]
+    def process_query(query, api_key=""):
+        """
+        Process a user query
         
-        score_message = f"""
-## GAIA Test Results
-
-- **Total Questions**: {results['total_questions']}
-- **Answered Questions**: {results['answered_questions']}
-- **Correct Answers**: {results['correct_answers']}
-- **Score**: {results['score_percentage']:.1f}%
-- **Certification Status**: {"PASSED ✅" if results['passed'] else "FAILED ❌"}
-
-{"🎉 Congratulations! You have passed the GAIA certification practice test. You can now take the official test to get your certificate." if results['passed'] else "You did not pass the certification threshold (30%). Please review your answers and try again."}
-
-### Detailed Results:
-
-| Question | Your Answer | Correct Answer | Result |
-|----------|-------------|----------------|--------|
-"""
+        Args:
+            query: User query
+            api_key: Hugging Face API key (optional)
+            
+        Returns:
+            Assistant's response
+        """
+        # Update API key if provided
+        if api_key:
+            assistant.api_key = api_key
+            assistant.headers = {"Authorization": f"Bearer {api_key}"}
         
-        for result in results["results"]:
-            score_message += f"| {result['question']} | {result['user_answer']} | {result['correct_answer']} | {'✓' if result['is_correct'] else '✗'} |\n"
+        # Check if API key is set
+        if not assistant.api_key:
+            return "Error: No API key provided. Please enter your Hugging Face API key."
         
-        return score_message
-    
-    def reset_test():
-        """Reset the test"""
-        message = simulator.reset_test()
-        question = simulator.get_current_question()
-        question_text = f"Question 1/{simulator.total_questions}: {question['question']}"
-        return message, question_text, ""
+        # Process the query
+        return assistant.query(query)
     
     # Create the interface
-    with gr.Blocks(title="GAIA Certification Practice Test") as interface:
-        gr.Markdown("# GAIA Certification Practice Test")
+    with gr.Blocks(title="Minimal AI Assistant") as interface:
+        gr.Markdown("# Minimal AI Assistant")
         gr.Markdown("""
-        This application simulates the GAIA benchmark test for Hugging Face Agents Course certification.
+        This is a minimal AI assistant using the Hugging Face Inference API.
+        Enter your query below and the assistant will respond.
+        """)
         
-        - The test consists of 20 questions from Level 1 of the GAIA benchmark
-        - You need to score at least 30% (6 correct answers) to pass
-        - Answer each question and submit to move to the next one
-        - After answering all questions, calculate your score to see if you passed
+        api_key_input = gr.Textbox(
+            label="Hugging Face API Key",
+            placeholder="Enter your Hugging Face API key here...",
+            type="password"
+        )
         
-        Good luck!
-        """)
+        query_input = gr.Textbox(
+            label="Your Query",
+            placeholder="Enter your query here...",
+            lines=3
+        )
         
-        with gr.Row():
-            with gr.Column():
-                question_text = gr.Textbox(
-                    label="Current Question",
-                    value=get_question_text(),
-                    lines=3,
-                    interactive=False
-                )
-                
-                answer_input = gr.Textbox(
-                    label="Your Answer",
-                    placeholder="Type your answer here...",
-                    lines=2
-                )
-                
-                submit_button = gr.Button("Submit Answer")
-                
-                status_text = gr.Textbox(
-                    label="Status",
-                    value="",
-                    lines=1,
-                    interactive=False
-                )
+        submit_button = gr.Button("Submit")
         
-        with gr.Row():
-            calculate_button = gr.Button("Calculate Score")
-            reset_button = gr.Button("Reset Test")
+        response_output = gr.Textbox(
+            label="Assistant Response",
+            lines=15
+        )
         
-        score_output = gr.Markdown(label="Results")
+        # Sample queries
+        gr.Markdown("### Sample Queries")
+        sample_queries = [
+            "What is the capital of France?",
+            "Explain the concept of machine learning in simple terms.",
+            "Write a short poem about artificial intelligence."
+        ]
+        
+        for query in sample_queries:
+            sample_button = gr.Button(f"Try: {query}")
+            sample_button.click(
+                fn=lambda q=query: q,
+                outputs=query_input
+            )
         
         # Set up event handlers
         submit_button.click(
-            fn=submit_answer,
-            inputs=[answer_input],
-            outputs=[status_text, question_text, answer_input]
+            fn=process_query,
+            inputs=[query_input, api_key_input],
+            outputs=response_output
         )
         
-        calculate_button.click(
-            fn=calculate_score,
-            inputs=[],
-            outputs=[score_output]
+        # Add examples
+        gr.Examples(
+            examples=sample_queries,
+            inputs=query_input
         )
-        
-        reset_button.click(
-            fn=reset_test,
-            inputs=[],
-            outputs=[status_text, question_text, answer_input]
-        )
-    
-    return interface
-
-
-def create_certification_guide_interface():
-    """
-    Create a Gradio interface for the certification guide
-    
-    Returns:
-        Gradio interface
-    """
-    def get_certification_instructions():
-        """Get the certification instructions"""
-        return """
-# How to Get Your Hugging Face Agents Course Certificate
-
-After practicing with this simulator and achieving at least 30% correct answers, follow these steps to get your official certificate:
-
-## Step 1: Complete the Required Course Units
-- Complete Unit 1 (Introduction to Agents)
-- Complete at least one use case from Unit 3
-- Complete the final project in Unit 4
-
-## Step 2: Take the Official GAIA Test
-1. Visit the [GAIA test page](https://huggingface.co/learn/agents-course/en/unit4/the-final-hands-on) on the Hugging Face Agents Course website
-2. Sign in with your Hugging Face account
-3. Follow the instructions to take the test
-4. Answer the 20 questions to the best of your ability
-5. Submit your answers
-
-## Step 3: Claim Your Certificate
-If you scored above 30% on the official test:
-1. Visit the [certificate page](https://huggingface.co/learn/agents-course/en/unit4/get-your-certificate)
-2. Sign in with your Hugging Face account
-3. Enter your full name (this will appear on your certificate)
-4. Click "Get My Certificate" to download your certificate
-
-## Step 4: Share Your Achievement
-- Add your certificate to your LinkedIn profile
-- Share it on social media (tag @huggingface)
-- Add it to your resume or portfolio
-
-Congratulations on completing the Hugging Face Agents Course!
-"""
-    
-    with gr.Blocks(title="GAIA Certification Guide") as interface:
-        gr.Markdown(get_certification_instructions())
-    
-    return interface
-
-
-def create_main_interface():
-    """
-    Create the main application interface with tabs
-    
-    Returns:
-        Gradio interface
-    """
-    with gr.Blocks(title="GAIA Certification Practice") as interface:
-        gr.Markdown("# GAIA Certification Practice for Hugging Face Agents Course")
-        
-        with gr.Tabs():
-            with gr.TabItem("Practice Test"):
-                test_interface = create_gaia_test_interface()
-            
-            with gr.TabItem("Certification Guide"):
-                guide_interface = create_certification_guide_interface()
     
     return interface
 
 
-# Create and launch the application
-app = create_main_interface()
+# Create and launch the interface
+interface = create_gradio_interface()
 
+# For Hugging Face Spaces
 if __name__ == "__main__":
-    app.launch()
+    interface.launch()