used smol_agents, works way better, added post processing with simple 4o-mini call, 50% completion

LEARNINGS.MD

@@ -14,7 +14,11 @@
 not an option for european customers due to only US based datacenters
 
 ### Smolagents 
-try out
+- very flexible code agent
+- duckduckgo search has low rate limit, serper api 2500 free searches, then paid as alternative
+- 
+
+
 
 ### Llamaindex  
 try out

REQUIREMENTS.md

@@ -0,0 +1,11 @@
+# capabilites the agent needs
+
+- internet access
+  - search the internet (google/duckduckgo)
+  - open webpages
+  - search wikipedia 
+  - open complete wikipedia pages
+  - watch youtube videos (multi-modal model with file download/youtube streaming or video to images + image recognition)
+
+
+prompt adjustment or post processing of answers: only value itself without any fluff should be given out. 

app_smolagents.py

@@ -0,0 +1,294 @@
+import os
+import gradio as gr
+import requests
+import inspect
+import asyncio
+import pandas as pd
+from dotenv import load_dotenv
+from litellm import completion
+from smolagents import ToolCallingAgent, Tool, CodeAgent, LiteLLMModel, PythonInterpreterTool, WikipediaSearchTool, GoogleSearchTool, FinalAnswerTool, VisitWebpageTool, SpeechToTextTool, DuckDuckGoSearchTool
+
+# (Keep Constants as is)
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+load_dotenv()
+
+model = LiteLLMModel(
+    model_id="azure/" + os.getenv("AZURE_OPENAI_DEPLOYMENT"),
+    api_base=os.getenv("AZURE_OPENAI_ENDPOINT"),
+    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
+    api_key=os.getenv("AZURE_OPENAI_API_KEY")
+)
+
+
+# --- Agent Base Class ---
+class BaseAgent:
+    """Base class for agent implementations"""
+    
+    def __init__(self):
+
+        self.agent = ToolCallingAgent(
+            tools=[
+                FinalAnswerTool(),
+                PythonInterpreterTool(),
+                VisitWebpageTool(
+                    max_output_length=100000
+                ),
+                WikipediaSearchTool(
+                    user_agent="Jan Eisenbarth Research Bot (jan.eisenbarth@gmail.com)",
+                    language="en",
+                    content_type="summary",  # or "text"
+                    extract_format="WIKI",
+                ),
+                GoogleSearchTool()
+            ], 
+            model=model
+            )
+
+    async def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        try:
+            # Run the agent synchronously - smolagents doesn't need async
+            answer = self.agent.run(question)
+            
+            # Convert the answer to a string to ensure we can handle any return type
+            answer_str = str(answer)
+            
+            print(f"Agent returning answer (first 50 chars): {answer_str[:50] if answer_str else 'No answer'}...")
+            return answer_str
+        except Exception as e:
+            print(f"Error in agent processing: {e}")
+            # Fallback mechanism in case of errors
+            fallback_answer = f"ERROR: {str(e)}"
+            return fallback_answer
+
+
+def answer_post_processing(question: str, answer: str) -> str:
+    """Post-process the answer to remove any fluff"""
+    response = completion(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant that can answer questions and help with tasks. Your job is to look at a given question and answer and remove any fluff or extra information. Output only the direct answer to the question. No punctuation marks, no introductory words, no nothing. Just the Value / String / List that answers the question in as few characters as possible."},
+            {"role": "user", "content": f"Question: {question}\nAnswer: {answer}"}
+        ]
+    )
+    cleaned_answer = response['choices'][0]['message']['content']
+    print(f"Cleaned answer: {cleaned_answer}")
+    return cleaned_answer
+
+
+# --- Default Huggingface Functions for Evaluation and Submission ---
+
+def run_and_submit_all(profile: gr.OAuthProfile = None):
+    # This needs to be sync since Gradio expects a sync function
+    try:
+        # Get the current user profile from context if not explicitly passed
+        if profile is None:
+            profile = gr.context.get("user", None)
+        
+        return asyncio.run(_run_and_submit_all_async(profile))
+    except Exception as e:
+        print(f"Error in run_and_submit_all: {e}")
+        return f"An unexpected error occurred: {e}", None
+
+async def _run_and_submit_all_async(profile: gr.OAuthProfile | None):
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Agent
+    try:
+        agent = BaseAgent()
+        print(f"Using agent type: {agent.__class__.__name__}")
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        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
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"Agent code URL: {agent_code}")
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=30)  # Increased timeout
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Successfully fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    
+    for idx, item in enumerate(questions_data):
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
+            
+        print(f"Processing question {idx+1}/{len(questions_data)}: Task ID {task_id}")
+        try:
+            # Call the agent to process the question
+            temp_answer = await agent(question_text)
+            # Post-process the answer
+            submitted_answer = answer_post_processing(question_text, temp_answer)
+            # Add to our results
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Submitted Answer": submitted_answer
+            })
+            print(f"Successfully processed question {idx+1}")
+        except Exception as e:
+             error_msg = f"Error running agent on task {task_id}: {e}"
+             print(error_msg)
+             # Still add to results but mark as error
+             results_log.append({
+                 "Task ID": task_id, 
+                 "Question": question_text, 
+                 "Submitted Answer": f"AGENT ERROR: {e}"
+             })
+
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=120)  # Increased timeout for larger submissions
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except Exception as e:
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    gr.Markdown("# Enhanced Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+
+        1. Please ensure you have the required environment variables set in your .env file
+        2. Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3. Select the agent type you want to use.
+        4. Click 'Run Evaluation & Submit All Answers' to fetch questions, run the agent, submit answers, and see the score.
+
+        ---
+        **Note:** 
+        The evaluation process may take several minutes as the agent processes all questions sequentially.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.LoginButton()
+        with gr.Column(scale=2):
+            run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
+
+    status_output = gr.Textbox(
+        label="Run Status / Submission Result", 
+        lines=6, 
+        interactive=False
+    )
+    
+    results_table = gr.DataFrame(
+        label="Questions and Agent Answers", 
+        wrap=True
+    )
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
+
+    demo.launch(debug=True, share=False)

questions.md

@@ -0,0 +1,12 @@
+
+| ID | question | answer | 
+| --- | --- | --- | 
+| |How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia. | 3 | 
+||"In the video https://www.youtube.com/watch?v=L1vXCYZAYYM, what is the highest number of bird species to be on camera simultaneously?"||
+||".rewsna eht sa ""tfel"" drow eht fo etisoppo eht etirw ,ecnetnes siht dnatsrednu uoy fI"|right|
+||Review the chess position provided in the image. It is black's turn. Provide the correct next move for black which guarantees a win. Please provide your response in algebraic notation.||
+||Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?|FunkMonk|
+||||
+||"Examine the video at https://www.youtube.com/watch?v=1htKBjuUWec. What does Teal'c say in response to the question ""Isn't that hot?"""||
+||What is the surname of the equine veterinarian mentioned in 1.E Exercises from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023?||
+||"I'm making a grocery list for my mom, but she's a professor of botany and she's a real stickler when it comes to categorizing things. I need to add different foods to different categories on the grocery list, but if I make a mistake, she won't buy anything inserted in the wrong category. Here's the list I have so far: milk, eggs, flour, whole bean coffee, Oreos, sweet potatoes, fresh basil, plums, green beans, rice, corn, bell pepper, whole allspice, acorns, broccoli, celery, zucchini, lettuce, peanuts - I need to make headings for the fruits and vegetables. Could you please create a list of just the vegetables from my list? If you could do that, then I can figure out how to categorize the rest of the list into the appropriate categories. But remember that my mom is a real stickler, so make sure that no botanical fruits end up on the vegetable list, or she won't get them when she's at the store. Please alphabetize the list of vegetables, and place each item in a comma separated list."||

requirements.txt

@@ -2,4 +2,10 @@ gradio
 requests
 openai-agents
 python-dotenv
-openai
+openai
+smolagents
+smolagents[transformers]
+smolagents[litellm]
+wikipedia-api
+duckduckgo_search
+markdownify

test_agent.py → test_openai.py

@@ -14,7 +14,7 @@ from dotenv import load_dotenv
 from typing import Dict, Any, Optional, Union
 
 # Import from the main app
-from app import (
+from app_openai import (
     create_agent,
     DEFAULT_API_URL
 )

test_smolagents.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+"""
+Simple test function to check if the BaseAgent is working correctly
+"""
+
+import os
+import asyncio
+from dotenv import load_dotenv
+from app_smolagents import BaseAgent, answer_post_processing
+from smolagents import DuckDuckGoSearchTool
+question = "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia. "
+
+
+async def test_agent(question=question):
+    """
+    Initialize the BaseAgent and ask it a simple question.
+    
+    Args:
+        question: The question to ask the agent (default: "What is 2+2?")
+        agent_type: Type of agent to use (default: None, which uses AGENT_TYPE from .env)
+        
+    Returns:
+        The agent's response
+    """
+    # Load environment variables
+    load_dotenv()
+    
+    # Create agent instance
+    agent = BaseAgent()
+
+    print(f"Using agent type: {agent.__class__.__name__}")
+
+    # Ask the question
+    try:
+        answer = await agent(question)
+        answer = answer_post_processing(question, answer)
+        print(f"\nQuestion: {question}")
+        print(f"Answer: {answer}")
+        return answer
+    except Exception as e:
+        print(f"Error: {e}")
+        return f"ERROR: {str(e)}"
+
+# Example usage
+if __name__ == "__main__":
+    asyncio.run(test_agent())