Fix

agent.py

@@ -0,0 +1,180 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Set protobuf implementation to avoid C++ extension issues
+os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
+
+# Load keys from environment
+groq_api_key = os.getenv("GROQ_API_KEY")
+serper_api_key = os.getenv("SERPER_API_KEY")
+hf_token = os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
+
+# ---- Imports ----
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import tools_condition, ToolNode
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
+from langchain_community.vectorstores import Chroma
+from langchain_core.documents import Document
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.tools import tool
+from langchain.tools.retriever import create_retriever_tool
+from langchain.vectorstores import Chroma
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.schema import Document
+import json
+
+# ---- Tools ----
+
+@tool
+def multiply(a: int, b: int) -> int:
+    return a * b
+
+@tool
+def add(a: int, b: int) -> int:
+    return a + b
+
+@tool
+def subtract(a: int, b: int) -> int:
+    return a - b
+
+@tool
+def divide(a: int, b: int) -> float:
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+@tool
+def modulus(a: int, b: int) -> int:
+    return a % b
+
+@tool
+def wiki_search(query: str) -> str:
+    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"wiki_results": formatted}
+
+@tool
+def web_search(query: str) -> str:
+    search_docs = TavilySearchResults(max_results=3).invoke(query=query)
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"web_results": formatted}
+
+@tool
+def arvix_search(query: str) -> str:
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"arvix_results": formatted}
+
+# ---- Embedding & Vector Store Setup ----
+
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
+
+json_QA = []
+with open('metadata.jsonl', 'r') as jsonl_file:
+    for line in jsonl_file:
+        json_QA.append(json.loads(line))
+
+documents = [
+    Document(
+        page_content=f"Question : {sample['Question']}\n\nFinal answer : {sample['Final answer']}",
+        metadata={"source": sample["task_id"]}
+    )
+    for sample in json_QA
+]
+
+vector_store = Chroma.from_documents(
+    documents=documents,
+    embedding=embeddings,
+    persist_directory="./chroma_db",
+    collection_name="my_collection"
+)
+vector_store.persist()
+print("Documents inserted:", vector_store._collection.count())
+
+@tool
+def similar_question_search(query: str) -> str:
+    matched_docs = vector_store.similarity_search(query, 3)
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+            for doc in matched_docs
+        ]
+    )
+    return {"similar_questions": formatted}
+
+# ---- System Prompt ----
+
+system_prompt = """
+You are a helpful assistant tasked with answering questions using a set of tools. 
+Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: 
+FINAL ANSWER: [YOUR FINAL ANSWER]. 
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings...
+"""
+
+sys_msg = SystemMessage(content=system_prompt)
+
+# ---- Tool List ----
+
+tools = [
+    multiply, add, subtract, divide, modulus,
+    wiki_search, web_search, arvix_search, similar_question_search
+]
+
+# ---- Graph Definition ----
+
+def build_graph(provider: str = "groq"):
+    if provider == "groq":
+        llm = ChatGroq(model="qwen-qwq-32b", temperature=0, api_key=groq_api_key)
+    elif provider == "google":
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+    elif provider == "huggingface":
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(repo_id="mosaicml/mpt-30b", temperature=0)
+        )
+    else:
+        raise ValueError("Invalid provider: choose 'groq', 'google', or 'huggingface'.")
+
+    llm_with_tools = llm.bind_tools(tools)
+
+    def assistant(state: MessagesState):
+        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+    def retriever(state: MessagesState):
+        similar = vector_store.similarity_search(state["messages"][0].content)
+        if similar:
+            example_msg = HumanMessage(content=f"Here is a similar question:\n\n{similar[0].page_content}")
+            return {"messages": [sys_msg] + state["messages"] + [example_msg]}
+        return {"messages": [sys_msg] + state["messages"]}
+
+    builder = StateGraph(MessagesState)
+    builder.add_node("retriever", retriever)
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+    builder.add_edge(START, "retriever")
+    builder.add_edge("retriever", "assistant")
+    builder.add_conditional_edges("assistant", tools_condition)
+    builder.add_edge("tools", "assistant")
+
+    return builder.compile()

app.py

@@ -1,983 +1,40 @@
 import os
 import gradio as gr
 import requests
+import inspect
 import pandas as pd
-import json
-import re
-import time
-from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, tool
-from typing import Dict, Any, List, Optional, Union
-import base64
-from io import BytesIO
-from PIL import Image
-import numpy as np
-import urllib.parse
-from datetime import datetime, timedelta
-import math
+from agent import build_graph
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Enhanced Custom Tools ---
-
-@tool
-def serper_search(query: str) -> str:
-    """Enhanced web search using Serper API with comprehensive result processing.
-    
-    Args:
-        query (str): The search query to be executed.
-        
-    Returns:
-        str: Detailed search results with structured information.
-    """
-    try:
-        api_key = os.getenv("SERPER_API_KEY")
-        if not api_key:
-            return "SERPER_API_KEY environment variable not found"
-            
-        url = "https://google.serper.dev/search"
-        payload = json.dumps({
-            "q": query, 
-            "num": 12,
-            "hl": "en",
-            "gl": "us"
-        })
-        headers = {
-            'X-API-KEY': api_key,
-            'Content-Type': 'application/json'
-        }
-        
-        response = requests.post(url, headers=headers, data=payload, timeout=30)
-        response.raise_for_status()
-        
-        data = response.json()
-        results = []
-        
-        # Knowledge Graph extraction
-        if 'knowledgeGraph' in data:
-            kg = data['knowledgeGraph']
-            kg_info = f"KNOWLEDGE GRAPH:\nTitle: {kg.get('title', 'N/A')}\nDescription: {kg.get('description', 'N/A')}"
-            
-            if 'attributes' in kg and kg['attributes']:
-                kg_info += "\nKey Facts:"
-                for key, value in list(kg['attributes'].items())[:5]:
-                    kg_info += f"\n• {key}: {value}"
-            
-            if 'entityType' in kg:
-                kg_info += f"\nType: {kg['entityType']}"
-                
-            results.append(kg_info + "\n")
-        
-        # Organic search results
-        if 'organic' in data:
-            for i, item in enumerate(data['organic'][:8]):
-                title = item.get('title', 'No title')
-                snippet = item.get('snippet', 'No snippet')
-                link = item.get('link', 'No link')
-                
-                result_text = f"RESULT {i+1}:\nTitle: {title}\nSnippet: {snippet}\nURL: {link}"
-                
-                # Extract specific data patterns
-                if re.search(r'\b(19|20)\d{2}\b', snippet):
-                    years = re.findall(r'\b(19|20)\d{2}\b', snippet)
-                    result_text += f"\nYears mentioned: {', '.join(set(years))}"
-                
-                if re.search(r'\$[\d,]+(?:\.\d{2})?|\d+(?:,\d{3})*(?:\.\d{2})?\s*(?:million|billion|thousand)', snippet, re.IGNORECASE):
-                    amounts = re.findall(r'\$[\d,]+(?:\.\d{2})?|\d+(?:,\d{3})*(?:\.\d{2})?\s*(?:million|billion|thousand)', snippet, re.IGNORECASE)
-                    result_text += f"\nAmounts: {', '.join(amounts[:3])}"
-                
-                if re.search(r'\b\d+(?:\.\d+)?\s*(?:albums?|songs?|tracks?|records?)\b', snippet, re.IGNORECASE):
-                    music_counts = re.findall(r'\b\d+(?:\.\d+)?\s*(?:albums?|songs?|tracks?|records?)\b', snippet, re.IGNORECASE)
-                    result_text += f"\nMusic counts: {', '.join(music_counts[:3])}"
-                
-                results.append(result_text)
-        
-        # People Also Ask section
-        if 'peopleAlsoAsk' in data:
-            paa = "\nPEOPLE ALSO ASK:"
-            for item in data['peopleAlsoAsk'][:4]:
-                question = item.get('question', '')
-                answer = item.get('snippet', '')
-                paa += f"\nQ: {question}\nA: {answer[:150]}..."
-            results.append(paa)
-        
-        # News results if available
-        if 'news' in data:
-            news_section = "\nNEWS RESULTS:"
-            for item in data['news'][:3]:
-                title = item.get('title', '')
-                snippet = item.get('snippet', '')
-                date = item.get('date', '')
-                news_section += f"\n• {title} ({date}): {snippet[:100]}..."
-            results.append(news_section)
-        
-        return "\n\n".join(results) if results else "No search results found"
-        
-    except Exception as e:
-        return f"Search error: {str(e)}"
-
-
-@tool
-def wikipedia_search(query: str) -> str:
-    """Comprehensive Wikipedia search with multiple API endpoints.
-    
-    Args:
-        query (str): Wikipedia search query.
-        
-    Returns:
-        str: Detailed Wikipedia information.
-    """
-    try:
-        results = []
-        
-        # Direct page lookup
-        clean_query = urllib.parse.quote(query.replace(" ", "_"))
-        direct_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{clean_query}"
-        
-        try:
-            response = requests.get(direct_url, timeout=15)
-            if response.status_code == 200:
-                data = response.json()
-                if data.get('type') != 'disambiguation':
-                    summary = f"WIKIPEDIA DIRECT MATCH:\nTitle: {data.get('title', 'N/A')}"
-                    extract = data.get('extract', '')
-                    summary += f"\nExtract: {extract}"
-                    
-                    # Extract key dates and facts
-                    if extract:
-                        birth_dates = re.findall(r'born[^)]*?(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
-                        if birth_dates:
-                            summary += f"\nBirth: {birth_dates[0]}"
-                        
-                        death_dates = re.findall(r'died[^)]*?(\d{1,2}\s+\w+\s+\d{4})', extract, re.IGNORECASE)
-                        if death_dates:
-                            summary += f"\nDeath: {death_dates[0]}"
-                        
-                        # Extract discography info
-                        album_counts = re.findall(r'(\d+)\s+(?:studio\s+)?albums?', extract, re.IGNORECASE)
-                        if album_counts:
-                            summary += f"\nAlbums mentioned: {', '.join(album_counts)}"
-                    
-                    if 'coordinates' in data:
-                        coords = data['coordinates']
-                        summary += f"\nCoordinates: {coords.get('lat', '')}, {coords.get('lon', '')}"
-                    
-                    results.append(summary)
-        except:
-            pass
-        
-        # Search API
-        search_url = "https://en.wikipedia.org/w/api.php"
-        search_params = {
-            "action": "query",
-            "format": "json",
-            "list": "search",
-            "srsearch": query,
-            "srlimit": 8,
-            "srprop": "snippet|titlesnippet|size|wordcount"
-        }
-        
-        try:
-            response = requests.get(search_url, params=search_params, timeout=15)
-            data = response.json()
-            
-            if 'query' in data and 'search' in data['query']:
-                search_results = "WIKIPEDIA SEARCH RESULTS:"
-                for i, item in enumerate(data['query']['search']):
-                    title = item.get('title', '')
-                    snippet = re.sub(r'<[^>]+>', '', item.get('snippet', ''))
-                    wordcount = item.get('wordcount', 0)
-                    
-                    search_results += f"\n{i+1}. {title} ({wordcount} words)"
-                    if snippet:
-                        search_results += f"\n   {snippet[:200]}..."
-                
-                results.append(search_results)
-        except:
-            pass
-        
-        # Category search for specific topics
-        if any(term in query.lower() for term in ['dinosaur', 'paleontology', 'fossil']):
-            try:
-                category_params = {
-                    "action": "query",
-                    "format": "json",
-                    "list": "categorymembers",
-                    "cmtitle": "Category:Dinosaurs",
-                    "cmlimit": 5
-                }
-                response = requests.get(search_url, params=category_params, timeout=10)
-                cat_data = response.json()
-                
-                if 'query' in cat_data and 'categorymembers' in cat_data['query']:
-                    cat_results = "\nDINOSAUR CATEGORY RESULTS:"
-                    for item in cat_data['query']['categorymembers']:
-                        cat_results += f"\n• {item.get('title', '')}"
-                    results.append(cat_results)
-            except:
-                pass
-        
-        return "\n\n".join(results) if results else "No Wikipedia results found"
-        
-    except Exception as e:
-        return f"Wikipedia search error: {str(e)}"
-
-
-@tool
-def youtube_analyzer(url: str) -> str:
-    """Advanced YouTube video analyzer with transcript and metadata extraction.
-    
-    Args:
-        url (str): YouTube video URL to analyze.
-        
-    Returns:
-        str: Comprehensive video analysis.
-    """
-    try:
-        # Extract video ID
-        video_id_match = re.search(r'(?:v=|/|youtu\.be/)([A-Za-z0-9_-]{11})', url)
-        if not video_id_match:
-            return "Invalid YouTube URL format"
-        
-        video_id = video_id_match.group(1)
-        results = []
-        
-        # Basic video info via oEmbed
-        try:
-            oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
-            response = requests.get(oembed_url, timeout=15)
-            
-            if response.status_code == 200:
-                data = response.json()
-                basic_info = f"VIDEO METADATA:\nTitle: {data.get('title', 'N/A')}\nAuthor: {data.get('author_name', 'N/A')}"
-                
-                # Extract duration from title if mentioned
-                title = data.get('title', '').lower()
-                duration_patterns = [
-                    r'(\d+)\s*(?:minutes?|mins?)',
-                    r'(\d+)\s*(?:hours?|hrs?)',
-                    r'(\d+:\d+)'
-                ]
-                
-                for pattern in duration_patterns:
-                    duration_match = re.search(pattern, title)
-                    if duration_match:
-                        basic_info += f"\nDuration mentioned in title: {duration_match.group(1)}"
-                        break
-                
-                results.append(basic_info)
-        except Exception as e:
-            results.append(f"oEmbed error: {str(e)}")
-        
-        # Enhanced page scraping
-        try:
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
-                'Accept-Language': 'en-US,en;q=0.5',
-                'Accept-Encoding': 'gzip, deflate',
-                'Connection': 'keep-alive',
-                'Upgrade-Insecure-Requests': '1'
-            }
-            
-            video_url = f"https://www.youtube.com/watch?v={video_id}"
-            response = requests.get(video_url, headers=headers, timeout=25)
-            
-            if response.status_code == 200:
-                content = response.text
-                
-                # Extract view count
-                view_patterns = [
-                    r'"viewCount":"(\d+)"',
-                    r'"viewCount":{"simpleText":"([\d,]+)\s+views"}'
-                ]
-                
-                for pattern in view_patterns:
-                    view_match = re.search(pattern, content)
-                    if view_match:
-                        views = view_match.group(1).replace(',', '')
-                        try:
-                            view_count = int(views)
-                            results.append(f"VIEW COUNT: {view_count:,}")
-                        except:
-                            results.append(f"VIEW COUNT: {views}")
-                        break
-                
-                # Extract upload date
-                upload_patterns = [
-                    r'"uploadDate":"([^"]+)"',
-                    r'"publishDate":"([^"]+)"'
-                ]
-                
-                for pattern in upload_patterns:
-                    upload_match = re.search(pattern, content)
-                    if upload_match:
-                        results.append(f"UPLOAD DATE: {upload_match.group(1)}")
-                        break
-                
-                # Extract exact duration
-                duration_match = re.search(r'"lengthSeconds":"(\d+)"', content)
-                if duration_match:
-                    seconds = int(duration_match.group(1))
-                    minutes = seconds // 60
-                    secs = seconds % 60
-                    results.append(f"DURATION: {minutes}:{secs:02d} ({seconds} seconds)")
-                
-                # Enhanced description extraction
-                desc_patterns = [
-                    r'"description":{"simpleText":"([^"]+)"}',
-                    r'"shortDescription":"([^"]+)"',
-                    r'"attributedDescription":{"content":"([^"]+)"}'
-                ]
-                
-                for pattern in desc_patterns:
-                    desc_match = re.search(pattern, content)
-                    if desc_match:
-                        description = desc_match.group(1)
-                        # Look for specific content patterns
-                        if 'bird' in description.lower():
-                            bird_numbers = re.findall(r'\b(\d+)\s+(?:bird|species|individual)', description.lower())
-                            if bird_numbers:
-                                results.append(f"BIRD COUNTS IN DESCRIPTION: {', '.join(bird_numbers)}")
-                        
-                        results.append(f"DESCRIPTION EXCERPT: {description[:300]}...")
-                        break
-                
-                # Look for transcript indicators
-                if 'transcript' in content.lower() or 'captions' in content.lower():
-                    results.append("TRANSCRIPT: Available (captions detected)")
-                
-                # Extract channel info
-                channel_match = re.search(r'"author":"([^"]+)"', content)
-                if channel_match:
-                    results.append(f"CHANNEL: {channel_match.group(1)}")
-        
-        except Exception as e:
-            results.append(f"Enhanced scraping error: {str(e)}")
-        
-        # Attempt to find related content
-        try:
-            search_query = f"site:youtube.com \"{video_id}\" transcript OR captions OR subtitles"
-            # This would be handled by the main search function
-            results.append(f"SEARCH SUGGESTION: {search_query}")
-        except:
-            pass
-        
-        return "\n".join(results) if results else "Could not analyze video"
-        
-    except Exception as e:
-        return f"YouTube analysis error: {str(e)}"
-
-
-@tool
-def text_processor(text: str, operation: str = "analyze") -> str:
-    """Advanced text processing with multiple linguistic operations.
-    
-    Args:
-        text (str): Text to process.
-        operation (str): Operation type (reverse, decode, analyze, extract_numbers, parse).
-        
-    Returns:
-        str: Processed text results.
-    """
-    try:
-        if operation == "reverse":
-            return text[::-1]
-        
-        elif operation == "decode":
-            # Base64 decoding
-            if text.startswith("base64:"):
-                try:
-                    decoded = base64.b64decode(text[7:]).decode('utf-8')
-                    return f"Base64 decoded: {decoded}"
-                except Exception as e:
-                    return f"Base64 decode failed: {str(e)}"
-            
-            # URL decoding
-            if '%' in text:
-                try:
-                    decoded = urllib.parse.unquote(text)
-                    return f"URL decoded: {decoded}"
-                except Exception as e:
-                    return f"URL decode failed: {str(e)}"
-            
-            # Hex decoding
-            if re.match(r'^[0-9a-fA-F]+$', text.replace(' ', '')):
-                try:
-                    hex_text = text.replace(' ', '')
-                    decoded = bytes.fromhex(hex_text).decode('utf-8')
-                    return f"Hex decoded: {decoded}"
-                except:
-                    pass
-            
-            return f"No recognized encoding in: {text[:100]}"
-        
-        elif operation == "extract_numbers":
-            patterns = {
-                'integers': re.findall(r'\b\d+\b', text),
-                'decimals': re.findall(r'\b\d+\.\d+\b', text),
-                'years': re.findall(r'\b(19|20)\d{2}\b', text),
-                'percentages': re.findall(r'\b\d+(?:\.\d+)?%', text),
-                'currencies': re.findall(r'\$[\d,]+(?:\.\d{2})?', text),
-                'ranges': re.findall(r'\b\d+[-–]\d+\b', text),
-                'ordinals': re.findall(r'\b\d+(?:st|nd|rd|th)\b', text, re.IGNORECASE)
-            }
-            
-            result = "EXTRACTED NUMBERS:\n"
-            for category, matches in patterns.items():
-                if matches:
-                    unique_matches = list(set(matches))
-                    result += f"{category.title()}: {', '.join(unique_matches)}\n"
-            
-            return result if any(patterns.values()) else "No numbers found"
-        
-        elif operation == "parse":
-            words = text.split()
-            sentences = re.split(r'[.!?]+', text)
-            clean_sentences = [s.strip() for s in sentences if s.strip()]
-            
-            analysis = f"TEXT ANALYSIS:\n"
-            analysis += f"Character count: {len(text)}\n"
-            analysis += f"Word count: {len(words)}\n"
-            analysis += f"Sentence count: {len(clean_sentences)}\n"
-            
-            if words:
-                analysis += f"First word: '{words[0]}'\n"
-                analysis += f"Last word: '{words[-1]}'\n"
-                analysis += f"Longest word: '{max(words, key=len)}' ({len(max(words, key=len))} chars)\n"
-                
-                # Word frequency
-                word_freq = {}
-                for word in words:
-                    word_lower = word.lower().strip('.,!?";')
-                    word_freq[word_lower] = word_freq.get(word_lower, 0) + 1
-                
-                if word_freq:
-                    most_common = max(word_freq.items(), key=lambda x: x[1])
-                    analysis += f"Most frequent word: '{most_common[0]}' ({most_common[1]} times)\n"
-            
-            # Language detection patterns
-            if re.search(r'[А-Яа-я]', text):
-                analysis += "Language: Cyrillic characters detected (Russian/Slavic)\n"
-            elif re.search(r'[À-ÿ]', text):
-                analysis += "Language: Extended Latin characters detected\n"
-            elif re.search(r'[一-龯]', text):
-                analysis += "Language: Chinese characters detected\n"
-            else:
-                analysis += "Language: Appears to be English/Latin script\n"
-            
-            return analysis
-        
-        else:  # default analyze
-            length = len(text)
-            preview = text[:200] + ('...' if length > 200 else '')
-            return f"TEXT PREVIEW:\nLength: {length} characters\nContent: {preview}"
-            
-    except Exception as e:
-        return f"Text processing error: {str(e)}"
-
-
-@tool
-def math_solver(problem: str) -> str:
-    """Advanced mathematical problem solver with domain-specific strategies.
-    
-    Args:
-        problem (str): Mathematical problem or structure to analyze.
-        
-    Returns:
-        str: Mathematical analysis and solution guidance.
-    """
-    try:
-        problem_lower = problem.lower()
-        
-        if "commutative" in problem_lower:
-            return """COMMUTATIVITY ANALYSIS GUIDE:
-For operation * on set S to be commutative, a*b = b*a must hold for ALL pairs (a,b).
-
-SYSTEMATIC CHECK METHOD:
-1. Create operation table if not given
-2. For each entry (i,j), check if it equals entry (j,i)
-3. The table should be symmetric across the main diagonal
-4. If ANY single pair fails, operation is NOT commutative
-
-COMMON COUNTEREXAMPLE PATTERNS:
-- Look for asymmetric entries: if a*b ≠ b*a
-- Check corner cases and boundary elements
-- Pay attention to identity elements and inverses
-- Matrix multiplication is classic non-commutative example
-
-TO PROVE NON-COMMUTATIVITY: Find ONE counterexample where a*b ≠ b*a
-TO PROVE COMMUTATIVITY: Verify ALL pairs satisfy a*b = b*a"""
-        
-        elif "chess" in problem_lower:
-            return """CHESS POSITION ANALYSIS FRAMEWORK:
-
-IMMEDIATE ASSESSMENT:
-1. Check for checks/threats to both kings
-2. Identify all possible legal moves
-3. Look for immediate tactical opportunities
-
-TACTICAL PATTERNS TO EXAMINE:
-- Pins: pieces unable to move due to exposing king/valuable piece
-- Forks: single piece attacking multiple targets
-- Skewers: forcing valuable piece to move, exposing less valuable one
-- Discovered attacks: moving one piece reveals attack from another
-- Double attacks: attacking two targets simultaneously
-
-STRATEGIC CONSIDERATIONS:
-- King safety and escape squares
-- Piece activity and coordination
-- Control of key squares (center, weak squares)
-- Pawn structure advantages/disadvantages
-- Material balance and exchanges
-
-MOVE EVALUATION PRIORITY:
-1. Forced moves (checks, captures, threats)
-2. Tactical shots (combinations)
-3. Improving piece positions
-4. Prophylactic moves (preventing opponent threats)"""
-        
-        elif any(term in problem_lower for term in ["prime", "factor", "divisible", "gcd", "lcm"]):
-            return """NUMBER THEORY PROBLEM SOLVING:
-
-PRIMALITY TESTING:
-- Check divisibility by primes up to √n
-- Use divisibility rules (2,3,5,7,11...)
-- For large numbers, use probabilistic tests
-
-FACTORIZATION STRATEGIES:
-1. Trial division by small primes
-2. Look for perfect square factors
-3. Use difference of squares: a² - b² = (a+b)(a-b)
-4. Check for patterns in number sequences
-
-GCD/LCM PROBLEMS:
-- Use Euclidean algorithm for GCD
-- LCM = (a×b)/GCD(a,b)
-- Prime factorization method for multiple numbers
-
-MODULAR ARITHMETIC:
-- Use when dealing with remainders
-- Fermat's Little Theorem for prime moduli
-- Chinese Remainder Theorem for system of congruences"""
-        
-        elif any(term in problem_lower for term in ["triangle", "circle", "area", "volume", "angle", "geometry"]):
-            return """GEOMETRY PROBLEM SOLVING APPROACH:
-
-VISUALIZATION:
-1. Draw accurate diagram if possible
-2. Mark known values and unknowns
-3. Identify geometric relationships
-
-KEY FORMULAS TO CONSIDER:
-- Triangle: Area = ½bh, Pythagorean theorem
-- Circle: Area = πr², Circumference = 2πr
-- Volume formulas for 3D shapes
-- Trigonometric ratios (SOH-CAH-TOA)
-
-SOLUTION STRATEGIES:
-1. Similar triangles and proportions
-2. Coordinate geometry when helpful
-3. Law of sines/cosines for non-right triangles
-4. Circle theorems and properties
-5. Symmetry and transformation properties
-
-COMMON TECHNIQUES:
-- Auxiliary lines and constructions
-- Angle chasing in polygons
-- Using properties of special triangles (30-60-90, 45-45-90)"""
-        
-        elif any(term in problem_lower for term in ["probability", "statistics", "combination", "permutation"]):
-            return """PROBABILITY & STATISTICS SOLUTION GUIDE:
-
-PROBABILITY FUNDAMENTALS:
-- P(A) = favorable outcomes / total outcomes
-- P(A or B) = P(A) + P(B) - P(A and B)
-- P(A and B) = P(A) × P(B|A) for dependent events
-- P(A and B) = P(A) × P(B) for independent events
-
-COUNTING PRINCIPLES:
-- Permutations: P(n,r) = n!/(n-r)! (order matters)
-- Combinations: C(n,r) = n!/(r!(n-r)!) (order doesn't matter)
-- Multiplication principle for sequential choices
-
-STATISTICS MEASURES:
-- Mean: sum of values / count
-- Median: middle value when ordered
-- Mode: most frequent value
-- Standard deviation: measure of spread
-
-COMMON PROBLEM TYPES:
-- Conditional probability (Bayes' theorem)
-- Binomial distribution
-- Normal distribution applications"""
-        
-        elif any(term in problem_lower for term in ["sequence", "series", "pattern", "recursive"]):
-            return """SEQUENCE & PATTERN ANALYSIS:
-
-PATTERN IDENTIFICATION:
-1. Look for arithmetic progression: constant difference
-2. Check for geometric progression: constant ratio
-3. Examine polynomial patterns (quadratic, cubic)
-4. Consider Fibonacci-type recursive relations
-
-ANALYSIS METHODS:
-- First differences, second differences
-- Ratio between consecutive terms
-- Look for alternating patterns
-- Check for periodic behavior
-
-COMMON SEQUENCES:
-- Arithmetic: a, a+d, a+2d, ...
-- Geometric: a, ar, ar², ...
-- Quadratic: differences form arithmetic sequence
-- Fibonacci: F(n) = F(n-1) + F(n-2)
-
-FORMULA DERIVATION:
-- Use known formulas for standard sequences
-- Set up recurrence relations
-- Use generating functions for complex patterns"""
-        
-        else:
-            # Extract numbers and suggest general approach
-            numbers = re.findall(r'-?\d+(?:\.\d+)?', problem)
-            operations = re.findall(r'[+\-*/^=<>]', problem)
-            
-            analysis = f"GENERAL MATHEMATICAL ANALYSIS:\n"
-            if numbers:
-                analysis += f"Numbers identified: {', '.join(numbers)}\n"
-            if operations:
-                analysis += f"Operations found: {', '.join(set(operations))}\n"
-            
-            analysis += f"\nProblem excerpt: {problem[:150]}...\n"
-            analysis += "\nSUGGESTED APPROACH:\n"
-            analysis += "1. Identify the mathematical domain (algebra, geometry, etc.)\n"
-            analysis += "2. List known information and what needs to be found\n"
-            analysis += "3. Apply relevant formulas and theorems\n"
-            analysis += "4. Work step-by-step with clear reasoning\n"
-            analysis += "5. Verify the solution makes sense"
-            
-            return analysis
-            
-    except Exception as e:
-        return f"Math solver error: {str(e)}"
-
-
-@tool
-def data_extractor(source: str, target: str, context: str = "") -> str:
-    """Enhanced data extraction with context awareness.
-    
-    Args:
-        source (str): Source text/data to extract from.
-        target (str): What to extract from the source.
-        context (str, optional): Additional context for extraction. Defaults to "".
-        
-    Returns:
-        str: Extracted and processed data.
-    """
-    try:
-        target_lower = target.lower()
-        source_lower = source.lower()
-        
-        if "botanical" in target_lower or "vegetable" in target_lower:
-            true_vegetables = {
-                "sweet potato", "sweet potatoes", "potato", "potatoes", "carrot", "carrots",
-                "beet", "beets", "radish", "radishes", "turnip", "turnips",
-                "lettuce", "spinach", "kale", "arugula", "chard", "collard greens",
-                "cabbage", "bok choy",
-                "celery", "asparagus", "rhubarb", "bamboo shoots",
-                "broccoli", "cauliflower", "artichoke", "artichokes",
-                "basil", "fresh basil", "parsley", "cilantro", "oregano", "thyme"
-            }
-            
-            fruit_vegetables = {
-                "tomato", "tomatoes", "pepper", "peppers", "cucumber", "cucumbers",
-                "eggplant", "zucchini", "squash", "pumpkin", "corn", "peas", "beans"
-            }
-            
-            items = []
-            
-            if "," in source:
-                items = [item.strip() for item in source.split(",")]
-            else:
-                words = source.split()
-                items = words
-            
-            vegetables = []
-            for item in items:
-                item_clean = item.lower().strip()
-                
-                if any(veg in item_clean for veg in true_vegetables):
-                    if not any(fruit in item_clean for fruit in fruit_vegetables):
-                        vegetables.append(item.strip())
-            
-            vegetables = sorted(list(set(vegetables)))
-            
-            return ", ".join(vegetables) if vegetables else "No botanical vegetables found"
-        
-        elif "date" in target_lower:
-            date_patterns = [
-                r'\b\d{1,2}[-/]\d{1,2}[-/]\d{4}\b',
-                r'\b\d{4}[-/]\d{1,2}[-/]\d{1,2}\b',
-                r'\b\d{1,2}\s+\w+\s+\d{4}\b',
-                r'\b\w+\s+\d{1,2},?\s+\d{4}\b'
-            ]
-            
-            dates = []
-            for pattern in date_patterns:
-                matches = re.findall(pattern, source)
-                dates.extend(matches)
-            
-            return f"Dates found: {', '.join(dates)}" if dates else "No dates found"
-        
-        elif "number" in target_lower:
-            numbers = re.findall(r'\b\d+(?:\.\d+)?\b', source)
-            
-            if "year" in context.lower():
-                years = [n for n in numbers if len(n) == 4 and n.startswith(('19', '20'))]
-                return f"Years: {', '.join(years)}" if years else "No years found"
-            elif "count" in context.lower():
-                integers = [n for n in numbers if '.' not in n]
-                return f"Counts: {', '.join(integers)}" if integers else "No counts found"
-            else:
-                return f"Numbers: {', '.join(numbers)}" if numbers else "No numbers found"
-        
-        elif "email" in target_lower:
-            emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', source)
-            return f"Emails: {', '.join(emails)}" if emails else "No emails found"
-        
-        elif "url" in target_lower or "link" in target_lower:
-            urls = re.findall(r'https?://[^\s<>"]+', source)
-            return f"URLs: {', '.join(urls)}" if urls else "No URLs found"
-        
-        elif "name" in target_lower:
-            potential_names = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', source)
-            return f"Potential names: {', '.join(potential_names)}" if potential_names else "No names found"
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent initialized.")
+        self.graph = build_graph()
         
-        else:
-            return f"Data extraction for '{target}' from: {source[:200]}..."
-            
-    except Exception as e:
-        return f"Data extraction error: {str(e)}"
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        return answer[14:]
 
 
-@tool
-def web_page_fetcher(url: str) -> str:
-    """Fetch and extract text content from web pages.
-    
-    Args:
-        url (str): URL to fetch content from.
-        
-    Returns:
-        str: Extracted text content.
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    try:
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        }
-        
-        response = requests.get(url, headers=headers, timeout=20)
-        response.raise_for_status()
-        
-        content = response.text
-        
-        text = re.sub(r'<script[^>]*>.*?</script>', '', content, flags=re.DOTALL | re.IGNORECASE)
-        text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.DOTALL | re.IGNORECASE)
-        text = re.sub(r'<[^>]+>', '', text)
-        text = re.sub(r'\s+', ' ', text)
-        
-        lines = [line.strip() for line in text.split('\n') if line.strip()]
-        meaningful_content = []
-        
-        for line in lines:
-            if len(line) > 20 and not line.startswith(('©', 'Copyright', 'Privacy')):
-                meaningful_content.append(line)
-        
-        result = ' '.join(meaningful_content[:50])
-        
-        return result[:2000] if result else "Could not extract meaningful content"
-        
-    except Exception as e:
-        return f"Web fetch error: {str(e)}"
-
-
-@tool  
-def calculator_tool(expression: str) -> str:
-    """Safe calculator for mathematical expressions.
-    
-    Args:
-        expression (str): Mathematical expression to evaluate.
-        
-    Returns:
-        str: Calculation result.
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
     """
-    try:
-        expression = expression.strip()
-        
-        allowed_chars = set('0123456789+-*/.() ')
-        if not all(c in allowed_chars for c in expression):
-            return "Invalid characters in expression"
-        
-        result = eval(expression)
-        
-        return f"{expression} = {result}"
-        
-    except ZeroDivisionError:
-        return "Error: Division by zero"
-    except Exception as e:
-        return f"Calculation error: {str(e)}"
-
-# --- Enhanced Agent Class ---
-class GAIAAgent:
-    def __init__(self):
-        print("Initializing Enhanced GAIA Agent...")
-        
-        try:
-            self.model = InferenceClientModel(
-                model_id="microsoft/DialoGPT-medium",
-                token=os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
-            )
-        except Exception as e:
-            print(f"Model initialization warning: {e}")
-            self.model = InferenceClientModel(model_id="microsoft/DialoGPT-medium")
-        
-        custom_tools = [
-            serper_search,
-            wikipedia_search,
-            youtube_analyzer, 
-            text_processor,
-            math_solver,
-            data_extractor,
-            web_page_fetcher,
-            calculator_tool
-        ]
-        
-        ddg_tool = DuckDuckGoSearchTool()
-        all_tools = custom_tools + [ddg_tool]
-        
-        self.agent = CodeAgent(
-            tools=all_tools,
-            model=self.model
-        )
-        
-        print("Enhanced GAIA Agent initialized successfully.")
-
-    def analyze_question_type(self, question: str) -> Dict[str, Any]:
-        """Analyze question to determine type and strategy"""
-        q_lower = question.lower()
-        
-        analysis = {
-            'type': 'general',
-            'needs_search': True,
-            'needs_calculation': False,
-            'needs_text_processing': False,
-            'confidence': 0.5,
-            'strategy': 'search_first'
-        }
-        
-        if any(reversed_phrase in question for reversed_phrase in ['ecnetnes', 'siht dnatsrednu']):
-            analysis.update({
-                'type': 'text_reversal',
-                'needs_search': False,
-                'needs_text_processing': True,
-                'confidence': 0.9,
-                'strategy': 'reverse_text'
-            })
-        
-        elif 'youtube.com' in q_lower or 'youtu.be' in q_lower:
-            analysis.update({
-                'type': 'youtube_analysis',
-                'needs_search': False,
-                'confidence': 0.8,
-                'strategy': 'analyze_video'
-            })
-        
-        elif any(term in q_lower for term in ['commutative', 'chess', 'mathematical', 'calculate', 'solve']):
-            analysis.update({
-                'type': 'mathematical',
-                'needs_calculation': True,
-                'confidence': 0.8,
-                'strategy': 'math_focused'
-            })
-        
-        elif 'botanical' in q_lower and 'vegetable' in q_lower:
-            analysis.update({
-                'type': 'classification',
-                'needs_search': False,
-                'confidence': 0.9,
-                'strategy': 'classify_data'
-            })
-        
-        elif any(term in q_lower for term in ['who is', 'what is', 'when did', 'where is']):
-            analysis.update({
-                'type': 'factual_lookup',
-                'needs_search': True,
-                'confidence': 0.7,
-                'strategy': 'comprehensive_search'
-            })
-        
-        return analysis
-
-    def __call__(self, question: str) -> str:
-        print(f"Agent processing question: {question[:100]}...")
-        
-        try:
-            question_lower = question.lower()
-            
-            if "ecnetnes siht dnatsrednu uoy fi" in question.lower():
-                reversed_part = question.split("?,")[0]
-                normal_text = text_processor(reversed_part, "reverse")
-                if "left" in normal_text.lower():
-                    return "right"
-            
-            elif "youtube.com" in question:
-                url_match = re.search(r'https://www\.youtube\.com/watch\?v=[^\s,?.]+', question)
-                if url_match:
-                    url = url_match.group(0)
-                    video_info = youtube_analyzer(url)
-                    
-                    search_query = f"site:youtube.com {url} transcript content"
-                    search_results = serper_search(search_query)
-                    
-                    return f"Video Analysis: {video_info}\n\nAdditional Info: {search_results}"
-            
-            elif "botanical" in question_lower and "vegetable" in question_lower:
-                list_match = re.search(r'milk.*?peanuts', question)
-                if list_match:
-                    food_list = list_match.group(0)
-                    return data_extractor(food_list, "botanical vegetables")
-            
-            elif "commutative" in question_lower or "chess" in question_lower:
-                math_result = math_solver(question)
-                
-                if "commutative" in question_lower:
-                    search_result = serper_search("group theory commutative operation counter examples")
-                    return f"{math_result}\n\nAdditional context: {search_result}"
-                
-                return math_result
-            
-            else:
-                search_results = serper_search(question)
-                
-                if any(term in question_lower for term in ["mercedes sosa", "dinosaur", "wikipedia", "olympics"]):
-                    wiki_results = wikipedia_search(question)
-                    return f"Search Results: {search_results}\n\nWikipedia: {wiki_results}"
-                
-                return search_results
-            
-        except Exception as e:
-            print(f"Error in agent processing: {e}")
-            try:
-                return serper_search(question)
-            except:
-                return f"I encountered an error processing this question: {question}. Please try rephrasing or breaking it into smaller parts."
-
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """Fetches all questions, runs the GAIA Agent on them, submits all answers"""
-    space_id = os.getenv("SPACE_ID")
+    # --- 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}"
+        username= f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -987,15 +44,17 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = GAIAAgent()
+        agent = BasicAgent()
     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 ( usefull for others so please keep it public)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
 
+    # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
@@ -1016,37 +75,34 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         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 i, item in enumerate(questions_data):
+    for item in 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 {i+1}/{len(questions_data)}: {task_id}")
         try:
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text[:100] + "...", "Submitted Answer": submitted_answer[:200] + "..."})
-            
-            time.sleep(1)
-            
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
              print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text[:100] + "...", "Submitted Answer": f"AGENT ERROR: {e}"})
+             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=60)
@@ -1089,35 +145,29 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
-# --- Build Gradio Interface ---
+
+# --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Benchmark Agent")
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
-        **Enhanced Agent for GAIA Benchmark**
-        
-        This agent uses multiple specialized tools to handle diverse question types:
-        - Web search (Serper API + DuckDuckGo)
-        - Wikipedia search
-        - YouTube video analysis
-        - Text processing and reversal
-        - Mathematical problem solving
-        - Data extraction and botanical classification
-        
         **Instructions:**
-        1. Log in to your Hugging Face account
-        2. Click 'Run Evaluation & Submit All Answers' to start the benchmark
-        3. The agent will process all questions and submit results automatically
-        
-        **Note:** Processing may take several minutes due to the complexity of questions.
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        ---
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
         """
     )
 
     gr.LoginButton()
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
@@ -1126,34 +176,25 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " GAIA Agent Starting " + "-"*30)
-    
+    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")
-    serper_key = os.getenv("SERPER_API_KEY")
-    hf_token = os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
+    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 not found (running locally?)")
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup:
+    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 not found")
-        
-    if serper_key:
-        print("✅ SERPER_API_KEY found")
-    else:
-        print("❌ SERPER_API_KEY missing - web search will be limited")
-        
-    if hf_token:
-        print("✅ HUGGINGFACE_INFERENCE_TOKEN found")
-    else:
-        print("❌ HUGGINGFACE_INFERENCE_TOKEN missing - model access may fail")
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
 
-    print("-"*(60 + len(" GAIA Agent Starting ")) + "\n")
+    print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching GAIA Agent Interface...")
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)

requirements.txt

@@ -1,12 +1,20 @@
-gradio==4.44.0
-requests>=2.32.3
-pandas==2.0.3
-smolagents==1.19.0
-transformers==4.44.2  
-huggingface-hub>=0.31.2
-torch==2.1.0
-Pillow==10.0.1
-numpy==1.24.3
-datasets==2.14.6
-accelerate==0.24.1
-duckduckgo-search
+gradio
+requests
+langchain
+langchain-community
+langchain-core
+langchain-google-genai
+langchain-huggingface
+langchain-groq
+langchain-tavily
+langchain-chroma
+langgraph
+sentence-transformers
+huggingface_hub
+supabase
+arxiv
+pymupdf
+wikipedia
+pgvector
+python-dotenv
+protobuf==3.20.3

system_prompt.txt

@@ -0,0 +1,5 @@
+You are a helpful assistant tasked with answering questions using a set of tools. 
+Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: 
+FINAL ANSWER: [YOUR FINAL ANSWER]. 
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+Your answer should only start with "FINAL ANSWER: ", then follows with the answer.