basic agent

.gitignore

@@ -0,0 +1,3 @@
+venv/
+.env
+__pycache__/

agent.py

@@ -0,0 +1,518 @@
+import os
+from dotenv import load_dotenv
+from typing import List, Dict, Any, Optional
+import tempfile
+import re
+import json
+import requests
+from urllib.parse import urlparse
+import pytesseract
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageFilter
+import cmath
+import pandas as pd
+import uuid
+import numpy as np
+from code_interpreter import CodeInterpreter
+import logging
+
+interpreter_instance = CodeInterpreter()
+
+from image_processing import *
+
+"""Langraph"""
+from langgraph.graph import START, StateGraph, MessagesState
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.document_loaders import ArxivLoader
+from langgraph.prebuilt import ToolNode, tools_condition
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import (
+    ChatHuggingFace,
+    HuggingFaceEndpoint,
+    HuggingFaceEmbeddings,
+)
+from langchain_community.vectorstores import SupabaseVectorStore
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.tools import tool
+from langchain.tools.retriever import create_retriever_tool
+from supabase.client import Client, create_client
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("agent")
+
+def tool_response(success: bool, data=None, error=None):
+    """Standardized response format for tools."""
+    return {
+        "status": "success" if success else "error",
+        "data": data,
+        "error": error
+    }
+
+from typing import Any
+
+@tool
+def multiply(a: Any, b: Any):
+    """Multiply two numbers and return the product."""
+    logger.info("multiply called with a=%s, b=%s", a, b)
+    try:
+        a = float(a)
+        b = float(b)
+        result = a * b
+        return tool_response(True, result)
+    except Exception as e:
+        logger.error("multiply failed: %s", str(e))
+        return tool_response(False, error=f"Invalid input: {e}")
+
+@tool
+def add(a: Any, b: Any):
+    """Add two numbers and return the sum."""
+    logger.info("add called with a=%s, b=%s", a, b)
+    try:
+        a = float(a)
+        b = float(b)
+        return tool_response(True, a + b)
+    except Exception as e:
+        logger.error("add failed: %s", str(e))
+        return tool_response(False, error=f"Invalid input: {e}")
+
+@tool
+def subtract(a: Any, b: Any):
+    """Subtract b from a and return the result."""
+    logger.info("subtract called with a=%s, b=%s", a, b)
+    try:
+        a = float(a)
+        b = float(b)
+        return tool_response(True, a - b)
+    except Exception as e:
+        logger.error("subtract failed: %s", str(e))
+        return tool_response(False, error=f"Invalid input: {e}")
+
+@tool
+def divide(a: Any, b: Any):
+    """Divide a by b and return the quotient."""
+    logger.info("divide called with a=%s, b=%s", a, b)
+    try:
+        a = float(a)
+        b = float(b)
+        if b == 0:
+            return tool_response(False, error="Division by zero")
+        return tool_response(True, a / b)
+    except Exception as e:
+        logger.error("divide failed: %s", str(e))
+        return tool_response(False, error=f"Invalid input: {e}")
+
+@tool
+def modulus(a: Any, b: Any):
+    """Return the remainder of a divided by b."""
+    logger.info("modulus called with a=%s, b=%s", a, b)
+    try:
+        a = float(a)
+        b = float(b)
+        return tool_response(True, a % b)
+    except Exception as e:
+        logger.error("modulus failed: %s", str(e))
+        return tool_response(False, error=f"Invalid input: {e}")
+
+@tool
+def power(a: Any, b: Any):
+    """Raise a to the power of b."""
+    logger.info("power called with a=%s, b=%s", a, b)
+    try:
+        a = float(a)
+        b = float(b)
+        return tool_response(True, a ** b)
+    except Exception as e:
+        logger.error("power failed: %s", str(e))
+        return tool_response(False, error=f"Invalid input: {e}")
+
+@tool
+def square_root(a: Any):
+    """Return the square root of a number."""
+    logger.info("square_root called with a=%s", a)
+    try:
+        a = float(a)
+        if a < 0:
+            # use complex math if negative
+            return tool_response(True, str(cmath.sqrt(a)))
+        return tool_response(True, a ** 0.5)
+    except Exception as e:
+        logger.error("square_root failed: %s", str(e))
+        return tool_response(False, error=f"Invalid input: {e}")
+
+# =========================
+# 📂 File Tools
+# =========================
+
+@tool
+def save_and_read_file(filename: str, content: str):
+    """Save content to a file and return the content back."""
+    logger.info("save_and_read_file called with filename=%s", filename)
+    try:
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(content)
+        with open(filename, "r", encoding="utf-8") as f:
+            result = f.read()
+        return tool_response(True, result)
+    except Exception as e:
+        logger.error("save_and_read_file failed: %s", str(e))
+        return tool_response(False, error=f"File error: {e}")
+
+
+@tool
+def download_file_from_url(url: str):
+    """Download a file from a URL and return its local path."""
+    logger.info("download_file_from_url called with url=%s", url)
+    try:
+        if url.startswith("file://"):
+            raise ValueError("Local file:// URLs not allowed")
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        filename = os.path.basename(urlparse(url).path) or f"download_{uuid.uuid4()}"
+        with open(filename, "wb") as f:
+            f.write(response.content)
+        return tool_response(True, filename)
+    except Exception as e:
+        logger.error("download_file_from_url failed: %s", str(e))
+        return tool_response(False, error=f"Download error: {e}")
+
+
+# =========================
+# 🖼️ Image Tools
+# =========================
+
+@tool
+def extract_text_from_image(image_path: str):
+    """Extract text from an image using OCR."""
+    logger.info("extract_text_from_image called with image_path=%s", image_path)
+    try:
+        text = pytesseract.image_to_string(Image.open(image_path))
+        return tool_response(True, text.strip())
+    except Exception as e:
+        logger.error("extract_text_from_image failed: %s", str(e))
+        return tool_response(False, error=f"OCR error: {e}")
+
+
+@tool
+def analyze_image(image_path: str):
+    """Return basic analysis (size, mode) of an image."""
+    logger.info("analyze_image called with image_path=%s", image_path)
+    try:
+        with Image.open(image_path) as img:
+            data = {"format": img.format, "mode": img.mode, "size": img.size}
+        return tool_response(True, data)
+    except Exception as e:
+        logger.error("analyze_image failed: %s", str(e))
+        return tool_response(False, error=f"Image analysis error: {e}")
+
+
+@tool
+def transform_image(image_path: str, operation: str):
+    """Apply a simple transform (grayscale, blur, sharpen)."""
+    logger.info("transform_image called with image_path=%s operation=%s", image_path, operation)
+    try:
+        img = Image.open(image_path)
+        if operation == "grayscale":
+            img = img.convert("L")
+        elif operation == "blur":
+            img = img.filter(ImageFilter.BLUR)
+        elif operation == "sharpen":
+            img = img.filter(ImageFilter.SHARPEN)
+        else:
+            raise ValueError(f"Unsupported operation: {operation}")
+        output_path = f"transformed_{uuid.uuid4()}.png"
+        img.save(output_path)
+        return tool_response(True, output_path)
+    except Exception as e:
+        logger.error("transform_image failed: %s", str(e))
+        return tool_response(False, error=f"Transform error: {e}")
+
+
+@tool
+def draw_on_image(image_path: str, text: str):
+    """Draw text on an image."""
+    logger.info("draw_on_image called with image_path=%s text=%s", image_path, text)
+    try:
+        img = Image.open(image_path)
+        draw = ImageDraw.Draw(img)
+        draw.text((10, 10), text, fill="black")
+        output_path = f"drawn_{uuid.uuid4()}.png"
+        img.save(output_path)
+        return tool_response(True, output_path)
+    except Exception as e:
+        logger.error("draw_on_image failed: %s", str(e))
+        return tool_response(False, error=f"Draw error: {e}")
+
+
+@tool
+def generate_simple_image(text: str):
+    """Generate a simple image with text."""
+    logger.info("generate_simple_image called with text=%s", text)
+    try:
+        img = Image.new("RGB", (200, 100), color="white")
+        draw = ImageDraw.Draw(img)
+        draw.text((10, 40), text, fill="black")
+        output_path = f"generated_{uuid.uuid4()}.png"
+        img.save(output_path)
+        return tool_response(True, output_path)
+    except Exception as e:
+        logger.error("generate_simple_image failed: %s", str(e))
+        return tool_response(False, error=f"Image generation error: {e}")
+
+
+@tool
+def combine_images(image1_path: str, image2_path: str):
+    """Combine two images side by side."""
+    logger.info("combine_images called with %s and %s", image1_path, image2_path)
+    try:
+        img1 = Image.open(image1_path)
+        img2 = Image.open(image2_path)
+        combined = Image.new("RGB", (img1.width + img2.width, max(img1.height, img2.height)))
+        combined.paste(img1, (0, 0))
+        combined.paste(img2, (img1.width, 0))
+        output_path = f"combined_{uuid.uuid4()}.png"
+        combined.save(output_path)
+        return tool_response(True, output_path)
+    except Exception as e:
+        logger.error("combine_images failed: %s", str(e))
+        return tool_response(False, error=f"Combine error: {e}")
+
+
+# =========================
+# 📊 Data Tools
+# =========================
+
+@tool
+def analyze_csv_file(file_path: str):
+    """Analyze a CSV file and return basic info."""
+    logger.info("analyze_csv_file called with file_path=%s", file_path)
+    try:
+        df = pd.read_csv(file_path)
+        summary = {"shape": df.shape, "columns": df.columns.tolist(), "head": df.head(3).to_dict()}
+        return tool_response(True, summary)
+    except Exception as e:
+        logger.error("analyze_csv_file failed: %s", str(e))
+        return tool_response(False, error=f"CSV analysis error: {e}")
+
+
+@tool
+def analyze_excel_file(file_path: str):
+    """Analyze an Excel file and return basic info."""
+    logger.info("analyze_excel_file called with file_path=%s", file_path)
+    try:
+        df = pd.read_excel(file_path)
+        summary = {"shape": df.shape, "columns": df.columns.tolist(), "head": df.head(3).to_dict()}
+        return tool_response(True, summary)
+    except Exception as e:
+        logger.error("analyze_excel_file failed: %s", str(e))
+        return tool_response(False, error=f"Excel analysis error: {e}")
+
+
+# =========================
+# 💻 Code Tool
+# =========================
+
+@tool
+def execute_code_multilang(code: str, language: str = "python"):
+    """Execute code in multiple languages using CodeInterpreter."""
+    logger.info("execute_code_multilang called with language=%s", language)
+    try:
+        result = interpreter_instance.execute_code(code, language)
+        return tool_response(True, result)
+    except Exception as e:
+        logger.error("execute_code_multilang failed: %s", str(e))
+        return tool_response(False, error=f"Code execution error: {e}")
+
+# =========================
+# 🌍 Search Tools
+# =========================
+
+@tool
+def web_search(query: str, max_results: int = 3):
+    """Perform a web search using TavilySearchResults."""
+    logger.info("web_search called with query=%s", query)
+    try:
+        tavily = TavilySearchResults(max_results=max_results)
+        results = tavily.invoke(query)
+        return tool_response(True, results)
+    except Exception as e:
+        logger.error("web_search failed: %s", str(e))
+        return tool_response(False, error=f"Web search error: {e}")
+
+
+@tool
+def wiki_search(query: str):
+    """Search Wikipedia and return documents."""
+    logger.info("wiki_search called with query=%s", query)
+    try:
+        loader = WikipediaLoader(query=query, load_max_docs=3)
+        docs = loader.load()
+        results = [doc.page_content for doc in docs]
+        return tool_response(True, results)
+    except Exception as e:
+        logger.error("wiki_search failed: %s", str(e))
+        return tool_response(False, error=f"Wikipedia error: {e}")
+
+
+@tool
+def arxiv_search(query: str):
+    """Search Arxiv and return documents."""
+    logger.info("arxiv_search called with query=%s", query)
+    try:
+        loader = ArxivLoader(query=query, load_max_docs=3)
+        docs = loader.load()
+        results = [doc.page_content for doc in docs]
+        return tool_response(True, results)
+    except Exception as e:
+        logger.error("arxiv_search failed: %s", str(e))
+        return tool_response(False, error=f"Arxiv error: {e}")
+
+if __name__ == "__main__":
+    logger.info("=== Running Tool Tests ===")
+
+
+# =========================
+# 🌍 Tested for tools
+# =========================
+    # 🌍 Search Tools
+    # print("\n--- web_search ---")
+    # print(web_search.invoke({"query": "latest AI research", "max_results": 2}))
+
+    # print("\n--- wiki_search ---")
+    # print(wiki_search.invoke({"query": "LangChain"}))
+
+    # print("\n--- arxiv_search ---")
+    # print(arxiv_search.invoke({"query": "transformers"}))
+
+    # 💻 Code Execution
+    # print("\n--- execute_code_multilang ---")
+    # print(execute_code_multilang.invoke({"code": "print(2+3)", "language": "python"}))
+
+
+# load the system prompt from the file
+with open("system_prompt.txt", "r", encoding="utf-8") as f:
+    system_prompt = f.read()
+print(system_prompt)
+
+# System message
+sys_msg = SystemMessage(content=system_prompt)
+
+# build a retriever
+embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-mpnet-base-v2"
+)  #  dim=768
+from dotenv import load_dotenv
+load_dotenv()
+supabase_url = os.environ.get("SUPABASE_URL")
+supabase_key = os.environ.get("SUPABASE_KEY")
+supabase: Client = create_client(
+    supabase_url, supabase_key
+)
+vector_store = SupabaseVectorStore(
+    client=supabase,
+    embedding=embeddings,
+    table_name="documents2",
+    query_name="match_documents_2",
+)
+create_retriever_tool = create_retriever_tool(
+    retriever=vector_store.as_retriever(),
+    name="Question Search",
+    description="A tool to retrieve similar questions from a vector store.",
+)
+
+
+tools = [
+    web_search,
+    wiki_search,
+    arxiv_search,
+    multiply,
+    add,
+    subtract,
+    divide,
+    modulus,
+    power,
+    square_root,
+    save_and_read_file,
+    download_file_from_url,
+    extract_text_from_image,
+    analyze_csv_file,
+    analyze_excel_file,
+    execute_code_multilang,
+    analyze_image,
+    transform_image,
+    draw_on_image,
+    generate_simple_image,
+    combine_images,
+]
+
+
+# Build graph function
+def build_graph(provider: str = "groq"):
+    """Build the graph"""
+    # Load environment variables from .env file
+    if provider == "groq":
+        # Groq https://console.groq.com/docs/models
+        llm = ChatGroq(model="qwen/qwen3-32b", temperature=0)
+    elif provider == "huggingface":
+        # TODO: Add huggingface endpoint
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(
+                repo_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+                task="text-generation",  # for chat‐style use “text-generation”
+                max_new_tokens=1024,
+                do_sample=False,
+                repetition_penalty=1.03,
+                temperature=0,
+            ),
+            verbose=True,
+        )
+    else:
+        raise ValueError("Invalid provider. Choose 'groq' or 'huggingface'.")
+    # Bind tools to LLM
+    llm_with_tools = llm.bind_tools(tools)
+
+    # Node
+    def assistant(state: MessagesState):
+        """Assistant node"""
+        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+    def retriever(state: MessagesState):
+        """Retriever node"""
+        similar_question = vector_store.similarity_search(state["messages"][0].content)
+
+        if similar_question:  # Check if the list is not empty
+            example_msg = HumanMessage(
+                content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
+            )
+            return {"messages": [sys_msg] + state["messages"] + [example_msg]}
+        else:
+            # Handle the case when no similar questions are found
+            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")
+
+    # Compile graph
+    return builder.compile()
+
+
+# test
+if __name__ == "__main__":
+    question = "When was a picture of St. Thomas Aquinas first added to the Wikipedia page on the Principle of double effect?"
+    graph = build_graph(provider="groq")
+    messages = [HumanMessage(content=question)]
+    messages = graph.invoke({"messages": messages})
+    for m in messages["messages"]:
+        m.pretty_print()
+

app.py

@@ -0,0 +1,196 @@
+import os
+import gradio as gr
+import requests
+import inspect
+import pandas as pd
+
+# (Keep Constants as is)
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent initialized.")
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        fixed_answer = "This is a default answer."
+        print(f"Agent returning fixed answer: {fixed_answer}")
+        return fixed_answer
+
+def run_and_submit_all( profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- 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 ( modify this part to create your agent)
+    try:
+        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)
+        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"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 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
+        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, "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, "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)
+        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("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+
+        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")
+
+    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(
+        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")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

code_interpreter.py

@@ -0,0 +1,281 @@
+import os
+import io
+import sys
+import uuid
+import base64
+import traceback
+import contextlib
+import tempfile
+import subprocess
+import sqlite3
+from typing import Dict, List, Any, Optional, Union
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from PIL import Image
+
+class CodeInterpreter:
+    def __init__(self, allowed_modules=None, max_execution_time=30, working_directory=None):
+        """Initialize the code interpreter with safety measures."""
+        self.allowed_modules = allowed_modules or [
+            "numpy", "pandas", "matplotlib", "scipy", "sklearn", 
+            "math", "random", "statistics", "datetime", "collections",
+            "itertools", "functools", "operator", "re", "json",
+            "sympy", "networkx", "nltk", "PIL", "pytesseract", 
+            "cmath", "uuid", "tempfile", "requests", "urllib"
+        ]
+        self.max_execution_time = max_execution_time
+        self.working_directory = working_directory or os.path.join(os.getcwd()) 
+        if not os.path.exists(self.working_directory):
+            os.makedirs(self.working_directory)
+        
+        self.globals = {
+            "__builtins__": __builtins__,
+            "np": np,
+            "pd": pd,
+            "plt": plt,
+            "Image": Image,
+        }
+        self.temp_sqlite_db = os.path.join(tempfile.gettempdir(), "code_exec.db")
+
+    def execute_code(self, code: str, language: str = "python") -> Dict[str, Any]:
+        """Execute the provided code in the selected programming language."""
+        language = language.lower()
+        execution_id = str(uuid.uuid4())
+        
+        result = {
+            "execution_id": execution_id,
+            "status": "error",
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "plots": [],
+            "dataframes": []
+        }
+        
+        try:
+            if language == "python":
+                return self._execute_python(code, execution_id)
+            elif language == "bash":
+                return self._execute_bash(code, execution_id)
+            elif language == "sql":
+                return self._execute_sql(code, execution_id)
+            elif language == "c":
+                return self._execute_c(code, execution_id)
+            elif language == "java":
+                return self._execute_java(code, execution_id)
+            else:
+                result["stderr"] = f"Unsupported language: {language}"
+        except Exception as e:
+            result["stderr"] = str(e)
+        
+        return result
+
+    def _execute_python(self, code: str, execution_id: str) -> dict:
+        output_buffer = io.StringIO()
+        error_buffer = io.StringIO()
+        result = {
+            "execution_id": execution_id,
+            "status": "error",
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "plots": [],
+            "dataframes": []
+        }
+        
+        try:
+            exec_dir = os.path.join(self.working_directory, execution_id)
+            os.makedirs(exec_dir, exist_ok=True)
+            plt.switch_backend('Agg')
+            
+            with contextlib.redirect_stdout(output_buffer), contextlib.redirect_stderr(error_buffer):
+                exec_result = exec(code, self.globals)
+
+                if plt.get_fignums():
+                    for i, fig_num in enumerate(plt.get_fignums()):
+                        fig = plt.figure(fig_num)
+                        img_path = os.path.join(exec_dir, f"plot_{i}.png")
+                        fig.savefig(img_path)
+                        with open(img_path, "rb") as img_file:
+                            img_data = base64.b64encode(img_file.read()).decode('utf-8')
+                            result["plots"].append({
+                                "figure_number": fig_num,
+                                "data": img_data
+                            })
+
+                for var_name, var_value in self.globals.items():
+                    if isinstance(var_value, pd.DataFrame) and len(var_value) > 0:
+                        result["dataframes"].append({
+                            "name": var_name,
+                            "head": var_value.head().to_dict(),
+                            "shape": var_value.shape,
+                            "dtypes": str(var_value.dtypes)
+                        })
+                
+            result["status"] = "success"
+            result["stdout"] = output_buffer.getvalue()
+            result["result"] = exec_result
+            
+        except Exception as e:
+            result["status"] = "error"
+            result["stderr"] = f"{error_buffer.getvalue()}\n{traceback.format_exc()}"
+        
+        return result
+
+    def _execute_bash(self, code: str, execution_id: str) -> dict:
+        try:
+            completed = subprocess.run(
+                code, shell=True, capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            return {
+                "execution_id": execution_id,
+                "status": "success" if completed.returncode == 0 else "error",
+                "stdout": completed.stdout,
+                "stderr": completed.stderr,
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+        except subprocess.TimeoutExpired:
+            return {
+                "execution_id": execution_id,
+                "status": "error",
+                "stdout": "",
+                "stderr": "Execution timed out.",
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+
+    def _execute_sql(self, code: str, execution_id: str) -> dict:
+        result = {
+            "execution_id": execution_id,
+            "status": "error",
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "plots": [],
+            "dataframes": []
+        }
+        try:
+            conn = sqlite3.connect(self.temp_sqlite_db)
+            cur = conn.cursor()
+            cur.execute(code)
+            if code.strip().lower().startswith("select"):
+                columns = [description[0] for description in cur.description]
+                rows = cur.fetchall()
+                df = pd.DataFrame(rows, columns=columns)
+                result["dataframes"].append({
+                    "name": "query_result",
+                    "head": df.head().to_dict(),
+                    "shape": df.shape,
+                    "dtypes": str(df.dtypes)
+                })
+            else:
+                conn.commit()
+
+            result["status"] = "success"
+            result["stdout"] = "Query executed successfully."
+
+        except Exception as e:
+            result["stderr"] = str(e)
+        finally:
+            conn.close()
+
+        return result
+
+    def _execute_c(self, code: str, execution_id: str) -> dict:
+        temp_dir = tempfile.mkdtemp()
+        source_path = os.path.join(temp_dir, "program.c")
+        binary_path = os.path.join(temp_dir, "program")
+
+        try:
+            with open(source_path, "w") as f:
+                f.write(code)
+
+            compile_proc = subprocess.run(
+                ["gcc", source_path, "-o", binary_path],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            if compile_proc.returncode != 0:
+                return {
+                    "execution_id": execution_id,
+                    "status": "error",
+                    "stdout": compile_proc.stdout,
+                    "stderr": compile_proc.stderr,
+                    "result": None,
+                    "plots": [],
+                    "dataframes": []
+                }
+
+            run_proc = subprocess.run(
+                [binary_path],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            return {
+                "execution_id": execution_id,
+                "status": "success" if run_proc.returncode == 0 else "error",
+                "stdout": run_proc.stdout,
+                "stderr": run_proc.stderr,
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+        except Exception as e:
+            return {
+                "execution_id": execution_id,
+                "status": "error",
+                "stdout": "",
+                "stderr": str(e),
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+
+    def _execute_java(self, code: str, execution_id: str) -> dict:
+        temp_dir = tempfile.mkdtemp()
+        source_path = os.path.join(temp_dir, "Main.java")
+
+        try:
+            with open(source_path, "w") as f:
+                f.write(code)
+
+            compile_proc = subprocess.run(
+                ["javac", source_path],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            if compile_proc.returncode != 0:
+                return {
+                    "execution_id": execution_id,
+                    "status": "error",
+                    "stdout": compile_proc.stdout,
+                    "stderr": compile_proc.stderr,
+                    "result": None,
+                    "plots": [],
+                    "dataframes": []
+                }
+
+            run_proc = subprocess.run(
+                ["java", "-cp", temp_dir, "Main"],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            return {
+                "execution_id": execution_id,
+                "status": "success" if run_proc.returncode == 0 else "error",
+                "stdout": run_proc.stdout,
+                "stderr": run_proc.stderr,
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+        except Exception as e:
+            return {
+                "execution_id": execution_id,
+                "status": "error",
+                "stdout": "",
+                "stderr": str(e),
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }

huggingface.py

@@ -0,0 +1,15 @@
+from huggingface_hub import login
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+# Make sure you have set your token as an environment variable
+# e.g., in your terminal: export HUGGINGFACEHUB_API_TOKEN="your_token_here"
+token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+
+if not token:
+    raise ValueError("Please set the environment variable HUGGINGFACEHUB_API_TOKEN")
+
+# Login programmatically
+login(token=token)
+print("✅ Logged in to Hugging Face Hub successfully!")

image_processing.py

@@ -0,0 +1,26 @@
+import os
+import io
+import base64
+import uuid
+from PIL import Image
+
+# Helper functions for image processing
+def encode_image(image_path: str) -> str:
+    """Convert an image file to base64 string."""
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("utf-8")
+
+
+def decode_image(base64_string: str) -> Image.Image:
+    """Convert a base64 string to a PIL Image."""
+    image_data = base64.b64decode(base64_string)
+    return Image.open(io.BytesIO(image_data))
+
+
+def save_image(image: Image.Image, directory: str = "image_outputs") -> str:
+    """Save a PIL Image to disk and return the path."""
+    os.makedirs(directory, exist_ok=True)
+    image_id = str(uuid.uuid4())
+    image_path = os.path.join(directory, f"{image_id}.png")
+    image.save(image_path)
+    return image_path

mcp/tavily_client.py

@@ -0,0 +1,11 @@
+from langchain_mcp_adapters.client import MultiServerMCPClient
+import os
+
+client = MultiServerMCPClient({
+    "tavily_mcp": {
+        "command": "npx",
+        "args": ["-y", "tavily-mcp@latest"],
+        "env": {"TAVILY_API_KEY": os.environ["TAVILY_API_KEY"]}
+    }
+    # Or use remote URL instead of local command...
+})

requirements.txt

@@ -0,0 +1,568 @@
+absl-py==2.1.0
+accelerate==1.2.1
+addict==2.4.0
+aiobotocore==2.23.0
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.13
+aiohttp-cors==0.8.1
+aioitertools==0.12.0
+aiosignal==1.3.1
+altair==5.4.1
+altgraph==0.17.4
+annotated-types==0.7.0
+anyascii==0.3.3
+anyio==3.7.1
+appdirs==1.4.4
+apriori==1.0.0
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+arrow==1.2.3
+astor==0.8.1
+asttokens==2.2.1
+astunparse==1.6.3
+async-lru==2.0.3
+async-timeout==4.0.2
+asyncpg==0.30.0
+attrs==24.2.0
+audioread==3.0.1
+Babel==2.12.1
+backcall==0.2.0
+backoff==2.2.1
+backrefs==5.9
+bangla==0.0.5
+basicsr==1.4.2
+bcrypt==4.3.0
+beautifulsoup4==4.12.2
+blake3==1.0.5
+bleach==6.0.0
+blinker==1.9.0
+blis==1.2.1
+bnnumerizer==0.0.2
+bnunicodenormalizer==0.1.7
+botocore==1.38.27
+build==1.2.2.post1
+cachetools==5.5.0
+camelot-py==0.11.0
+catalogue==2.0.10
+cbor2==5.7.0
+certifi==2024.7.4
+cffi==1.15.1
+cfgv==3.4.0
+chardet==5.2.0
+charset-normalizer==3.2.0
+chromadb==1.0.15
+click==8.1.8
+cloudpathlib==0.21.1
+cloudpickle==2.2.1
+cmake==4.0.0
+colorama==0.4.6
+coloredlogs==15.0.1
+colorful==0.5.7
+colorlog==6.9.0
+comm==0.1.3
+compressed-tensors==0.10.2
+comtypes==1.4.11
+confection==0.1.5
+contourpy==1.3.1
+coqpit==0.0.17
+cramjam==2.11.0
+crewai==0.140.0
+cryptography==43.0.3
+cssselect==1.3.0
+cssutils==2.11.1
+cycler==0.12.1
+cymem==2.0.11
+Cython==3.1.2
+dataclasses-json==0.6.7
+dateparser==1.1.8
+debugpy==1.6.7
+decorator==5.1.1
+defusedxml==0.7.1
+Deprecated==1.2.18
+depyf==0.19.0
+dill==0.4.0
+diskcache==5.6.3
+distlib==0.3.9
+distro==1.9.0
+dlib==19.24.8
+dnspython==2.7.0
+docopt==0.6.2
+docstring_parser==0.16
+dotenv==0.9.9
+duckduckgo_search==8.0.4
+durationpy==0.10
+ecdsa==0.19.1
+efficientnet-pytorch==0.7.1
+einops==0.8.1
+elevenlabs==2.6.0
+email-validator==2.3.0
+encodec==0.1.1
+environs==14.1.0
+et_xmlfile==2.0.0
+executing==1.2.0
+exllamav2==0.3.2
+extra-streamlit-components==0.1.80
+facenet-pytorch==2.6.0
+facexlib==0.3.0
+fastapi==0.115.6
+fastapi-cli==0.0.10
+fastapi-cloud-cli==0.1.5
+fastapi_cors==0.0.6
+fastjsonschema==2.18.0
+fastparquet==2024.11.0
+ffmpeg-python==0.2.0
+filelock==3.16.1
+filterpy==1.4.5
+Flask==3.1.0
+flask-cors==5.0.1
+Flask-PyMongo==3.0.1
+flatbuffers==24.3.25
+fonttools==4.55.0
+fqdn==1.5.1
+frozenlist==1.4.0
+fsspec==2025.5.1
+ftfy==6.3.1
+future==1.0.0
+g2pkk==0.1.2
+gast==0.6.0
+geocoder==1.38.1
+gfpgan==1.3.8
+gguf==0.17.1
+ghostscript==0.7
+ghp-import==2.1.0
+git-filter-repo==2.47.0
+gitdb==4.0.11
+GitPython==3.1.43
+google-ai-generativelanguage==0.6.15
+google-api-core==2.25.1
+google-api-python-client==2.175.0
+google-auth==2.40.3
+google-auth-httplib2==0.2.0
+google-auth-oauthlib==1.2.2
+google-generativeai==0.8.5
+google-pasta==0.2.0
+googleapis-common-protos==1.70.0
+GPUtil==1.4.0
+graphviz==0.21
+greenlet==3.1.1
+groq==0.29.0
+grpcio==1.74.0
+grpcio-status==1.71.2
+gruut==2.2.3
+gruut-ipa==0.13.0
+gruut-lang-de==2.0.1
+gruut-lang-en==2.0.1
+gruut-lang-es==2.0.1
+gruut-lang-fr==2.0.2
+gTTS==2.5.4
+gunicorn==23.0.0
+h11==0.14.0
+h5py==3.14.0
+hangul-romanize==0.1.0
+httpcore==1.0.7
+httplib2==0.22.0
+httptools==0.6.4
+httpx==0.28.1
+httpx-sse==0.4.1
+huggingface-hub==0.34.4
+humanfriendly==10.0
+ibm-cloud-sdk-core==3.24.1
+ibm-platform-services==0.66.1
+identify==2.6.12
+idna==3.4
+imageio==2.37.0
+imagesize==1.4.1
+importlib_metadata==8.4.0
+importlib_resources==6.5.2
+inflect==7.5.0
+iniconfig==2.1.0
+instructor==1.9.1
+interegular==0.3.3
+ipycytoscape==1.3.3
+ipykernel==6.24.0
+ipython==8.14.0
+ipython-genutils==0.2.0
+ipywidgets==8.1.7
+isoduration==20.11.0
+itsdangerous==2.2.0
+jamo==0.4.1
+jedi==0.18.2
+jieba==0.42.1
+Jinja2==3.1.6
+jiter==0.8.2
+jmespath==1.0.1
+joblib==1.4.2
+Js2Py==0.74
+json5==0.12.0
+json_repair==0.25.2
+jsonlines==1.2.0
+jsonpatch==1.33
+jsonpickle==3.0.3
+jsonpointer==2.4
+jsonref==1.1.0
+jsonschema==4.24.0
+jsonschema-specifications==2023.7.1
+jupyter==1.0.0
+jupyter-console==6.6.3
+jupyter-events==0.6.3
+jupyter-lsp==2.2.0
+jupyter_client==8.3.0
+jupyter_core==5.3.1
+jupyter_server==2.7.0
+jupyter_server_terminals==0.4.4
+jupyterlab==4.0.3
+jupyterlab-pygments==0.2.2
+jupyterlab_server==2.23.0
+jupyterlab_widgets==3.0.15
+kaggle==1.7.4.2
+keras==3.9.2
+kiwisolver==1.4.7
+kubernetes==33.1.0
+lab==8.3
+langchain==0.3.26
+langchain-community==0.3.27
+langchain-core==0.3.68
+langchain-openai==0.3.27
+langchain-text-splitters==0.3.8
+langcodes==3.5.0
+langsmith==0.4.4
+language_data==1.3.0
+lark==1.2.2
+lazy_loader==0.4
+libclang==18.1.1
+librosa==0.11.0
+litellm==1.72.6
+llvmlite==0.44.0
+lm-format-enforcer==0.10.12
+lmdb==1.6.2
+load-dotenv==0.1.0
+lxml==5.3.0
+lz4==4.4.4
+marisa-trie==1.2.1
+Markdown==3.6
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+marshmallow==3.25.1
+matplotlib==3.9.2
+matplotlib-inline==0.1.6
+mdurl==0.1.2
+mergedeep==1.3.4
+mistral_common==1.8.4
+mistune==3.0.1
+mkdocs==1.6.1
+mkdocs-get-deps==0.2.0
+mkdocs-material==9.6.15
+mkdocs-material-extensions==1.3.1
+ml_dtypes==0.5.1
+mmh3==5.1.0
+mock==5.2.0
+more-itertools==10.7.0
+MouseInfo==0.1.3
+mpmath==1.3.0
+msgpack==1.1.1
+msgspec==0.19.0
+mtcnn==1.0.0
+multidict==6.0.4
+munch==4.0.0
+murmurhash==1.0.13
+mypy_extensions==1.1.0
+mysql-connector-python==9.2.0
+namex==0.0.8
+narwhals==1.47.0
+nbclient==0.8.0
+nbconvert==7.7.2
+nbformat==5.9.1
+neo4j==5.28.1
+nest-asyncio==1.5.6
+networkx==3.2.1
+ninja==1.13.0
+nltk==3.9.1
+nodeenv==1.9.1
+notebook==7.0.3
+notebook_shim==0.2.3
+num2words==0.5.14
+numba==0.61.2
+numpy==2.2.6
+oauthlib==3.3.1
+onnxruntime==1.22.0
+openai==1.104.2
+openai-harmony==0.0.4
+opencensus==0.11.4
+opencensus-context==0.1.3
+opencv-contrib-python==4.10.0.84
+opencv-python==4.11.0.86
+opencv-python-headless==4.12.0.88
+openpyxl==3.1.5
+opentelemetry-api==1.33.0
+opentelemetry-exporter-otlp-proto-common==1.33.0
+opentelemetry-exporter-otlp-proto-grpc==1.33.0
+opentelemetry-exporter-otlp-proto-http==1.34.1
+opentelemetry-exporter-prometheus==0.54b0
+opentelemetry-instrumentation==0.54b0
+opentelemetry-instrumentation-requests==0.54b0
+opentelemetry-proto==1.33.0
+opentelemetry-sdk==1.33.0
+opentelemetry-semantic-conventions==0.54b0
+opentelemetry-util-http==0.54b0
+opt-einsum==3.3.0
+optree==0.14.1
+orjson==3.10.18
+outcome==1.3.0.post0
+outlines_core==0.2.10
+overrides==7.3.1
+packaging==24.2
+paddleocr==3.1.0
+paddlex==3.1.1
+paginate==0.5.7
+pandas==1.5.3
+pandocfilters==1.5.0
+parso==0.8.3
+partial-json-parser==0.2.1.1.post6
+passlib==1.7.4
+pathspec==0.12.1
+pbr==6.1.1
+pdfminer.six==20250506
+pdfplumber==0.11.7
+pefile==2023.2.7
+pgvector==0.4.1
+pickleshare==0.7.5
+pillow==11.2.1
+pipwin==0.5.2
+platformdirs==3.9.1
+playsound==1.3.0
+plotly==6.2.0
+pluggy==1.5.0
+pooch==1.8.2
+posthog==5.4.0
+pre_commit==4.2.0
+premailer==3.10.0
+preprocessing==0.1.13
+preshed==3.0.10
+pretrainedmodels==0.7.4
+prettytable==3.16.0
+primp==0.15.0
+prometheus-fastapi-instrumentator==7.1.0
+prometheus_client==0.22.1
+prompt-toolkit==3.0.39
+propcache==0.3.2
+proto-plus==1.26.1
+protobuf==5.29.5
+psutil==5.9.5
+psycopg2-binary==2.9.10
+pure-eval==0.2.2
+py-cpuinfo==9.0.0
+py-spy==0.4.0
+pyarrow==18.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+PyAudio==0.2.14
+PyAutoGUI==0.9.54
+pybase64==1.4.1
+pyclipper==1.3.0.post6
+pycountry==24.6.1
+pycparser==2.21
+pydantic==2.11.7
+pydantic-extra-types==2.10.5
+pydantic-settings==2.10.1
+pydantic_core==2.33.2
+pydeck==0.9.1
+pydot==4.0.1
+pydub==0.25.1
+pygame==2.6.1
+PyGetWindow==0.0.9
+Pygments==2.19.2
+pyinstaller==6.11.1
+pyinstaller-hooks-contrib==2024.10
+pyjsparser==2.7.1
+PyJWT==2.10.1
+pylatexenc==2.10
+PyMatting==1.1.14
+pymdown-extensions==10.16
+pymongo==4.12.0
+PyMsgBox==1.0.9
+pynndescent==0.5.13
+pyparsing==3.2.0
+pypdf==5.1.0
+PyPDF2==3.0.1
+pypdfium2==4.30.1
+pyperclip==1.9.0
+PyPika==0.48.9
+pypinyin==0.54.0
+pypiwin32==223
+PyPrind==2.11.3
+pyproject_hooks==1.2.0
+pyreadline3==3.5.4
+PyRect==0.2.0
+pysbd==0.3.4
+PyScreeze==1.0.1
+pySmartDL==1.3.4
+PySocks==1.7.1
+pyspnego==0.11.2
+pytesseract==0.3.13
+pytest==8.3.5
+pytest-asyncio==1.1.0
+pytest-mock==3.14.1
+python-crfsuite==0.9.11
+python-dateutil==2.8.2
+python-dotenv==1.0.0
+python-jose==3.5.0
+python-json-logger==2.0.7
+python-multipart==0.0.20
+python-slugify==8.0.4
+pyttsx3==2.98
+pytweening==1.2.0
+pytz==2023.3.post1
+pyvis==0.3.2
+pywhatkit==5.4
+pywin32==306
+pywin32-ctypes==0.2.3
+pywinpty==2.0.11
+PyYAML==6.0.2
+pyyaml_env_tag==1.1
+pyzmq==25.1.0
+qc-grader @ git+https://github.com/qiskit-community/Quantum-Challenge-Grader.git@1d7a6915623b0cfeac4c114391c279e9d98eb7f9
+qiskit==2.1.1
+qiskit-aer==0.17.1
+qiskit-ibm-runtime==0.40.1
+qiskit-serverless==0.25.1
+qtconsole==5.4.4
+QtPy==2.4.0
+ratelim==0.1.6
+ray==2.47.1
+# Editable install with no version control (realesrgan==0.3.0)
+-e c:\python311\lib\site-packages
+referencing==0.30.0
+regex==2024.11.6
+relaxml==0.1.3
+rembg==2.0.66
+requests==2.32.3
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+requests_ntlm==1.3.0
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rich==13.9.4
+rich-toolkit==0.15.0
+rignore==0.6.4
+rpds-py==0.9.2
+rsa==4.9.1
+ruamel.yaml==0.18.14
+ruamel.yaml.clib==0.2.12
+rustworkx==0.16.0
+s3fs==2025.5.1
+safetensors==0.5.2
+scikit-image==0.25.2
+scikit-learn==1.6.0
+scipy==1.14.1
+seaborn==0.13.2
+selenium==4.27.1
+Send2Trash==1.8.2
+sentencepiece==0.2.1
+sentry-sdk==2.35.2
+serpapi==0.1.5
+setproctitle==1.3.6
+shapely==2.1.1
+shellingham==1.5.4
+simplejson==3.19.3
+six==1.16.0
+smart_open==7.3.0.post1
+smmap==5.0.1
+smolagents==1.18.0
+sniffio==1.3.0
+sortedcontainers==2.4.0
+soundfile==0.13.1
+soupsieve==2.4.1
+soxr==0.5.0.post1
+spacy==3.8.7
+spacy-legacy==3.0.12
+spacy-loggers==1.0.5
+spectate==1.0.1
+SpeechRecognition==3.14.3
+sphinx-rtd-theme==0.2.4
+SQLAlchemy==2.0.40
+srsly==2.5.1
+sspilib==0.3.1
+stack-data==0.6.2
+starlette==0.41.3
+stevedore==5.4.1
+streamlit==1.40.1
+streamlit_mic_recorder==0.0.8
+streamlit_TTS==0.0.7
+stripe==12.3.0
+SudachiDict-core==20250515
+SudachiPy==0.6.10
+symengine==0.13.0
+sympy==1.14.0
+tabulate==0.9.0
+tb-nightly==2.20.0a20250621
+tenacity==9.0.0
+tensorboard==2.19.0
+tensorboard-data-server==0.7.2
+tensorflow==2.19.0
+tensorflow-intel==2.16.2
+tensorflow-io-gcs-filesystem==0.31.0
+termcolor==2.4.0
+terminado==0.17.1
+tesseract==0.1.3
+text-unidecode==1.3
+thinc==8.3.4
+threadpoolctl==3.5.0
+three==0.8.0
+tifffile==2025.6.11
+tiktoken==0.9.0
+tinycss2==1.2.1
+tk==0.1.0
+tokenizers==0.22.0
+toml==0.10.2
+tomli==2.2.1
+tomli_w==1.2.0
+torch==2.7.1
+torchvision==0.22.1
+tornado==6.3.2
+tqdm==4.67.1
+trainer==0.0.36
+traitlets==5.9.0
+transformers==4.56.0
+trio==0.27.0
+trio-websocket==0.11.1
+TTS==0.22.0
+txt2tags==3.9
+typeguard==4.4.4
+typer==0.16.0
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+tzdata==2023.3
+tzlocal==5.3.1
+ujson==5.10.0
+umap-learn==0.5.9.post2
+Unidecode==1.4.0
+uri-template==1.3.0
+uritemplate==4.2.0
+urllib3==2.5.0
+utils==1.0.2
+uv==0.7.19
+uvicorn==0.34.0
+virtualenv==20.31.2
+vllm==0.10.1.1
+wasabi==1.1.3
+watchdog==6.0.0
+watchfiles==1.1.0
+wcwidth==0.2.6
+weasel==0.4.1
+webcolors==24.11.1
+webencodings==0.5.1
+websocket-client==1.8.0
+websockets==15.0.1
+Werkzeug==3.1.3
+whisper-openai==1.0.0
+widgetsnbextension==4.0.14
+wikipedia==1.4.0
+wrapt==1.16.0
+wsproto==1.2.0
+yapf==0.43.0
+yarl==1.20.1
+zipp==3.19.1
+zstandard==0.23.0
+gradio[oauth]

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 rules above for each element (number or string), ensure there is exactly one space after each comma.
+Your answer should only start with "FINAL ANSWER: ", then follows with the answer. 

test_agent.py

@@ -0,0 +1,49 @@
+import unittest
+import os
+from unittest.mock import patch, MagicMock
+from agent import (
+    build_graph,
+    multiply,
+    add,
+    subtract,
+    divide,
+    modulus,
+    power,
+    square_root,
+    save_and_read_file,
+    download_file_from_url,
+    extract_text_from_image,
+    analyze_image,
+    transform_image,
+    draw_on_image,
+    generate_simple_image,
+    combine_images,
+    analyze_csv_file,
+    analyze_excel_file,
+    execute_code_multilang,
+    web_search,
+    wiki_search,
+    arxiv_search,
+    vector_store,
+)
+
+class TestAgent(unittest.TestCase):
+    def test_multiply(self):
+        response = multiply.invoke({"a": 6, "b": 7})
+        self.assertTrue(response["status"])
+        self.assertEqual(response["data"], 42)
+
+    def test_add(self):
+        response = add.invoke({"a": 5, "b": 3})
+        self.assertTrue(response["status"])
+        self.assertEqual(response["data"], 8)
+
+    def test_llm(self):
+        graph = build_graph()
+        response = graph.invoke({"messages": ["what is 1 + 1"]})
+        self.assertIsNotNone(response)
+        print(response)
+
+
+if __name__ == '__main__':
+    unittest.main()

test_llm.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Complete LLM Testing Script
+Supports Groq and local HuggingFace LLMs with proper LangChain integration.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+
+# LangChain & LangGraph imports
+try:
+    from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+    from langchain_groq import ChatGroq
+    from langgraph.graph import START, StateGraph, MessagesState
+    from langgraph.prebuilt import ToolNode, tools_condition
+    print("✅ LangChain imports successful")
+except ImportError as e:
+    print(f"❌ Import error: {e}")
+    print("💡 Install missing packages: pip install langchain-groq langgraph")
+    sys.exit(1)
+
+load_dotenv()
+
+
+class LocalHuggingFaceLLM:
+    """Custom wrapper for local HuggingFace models"""
+    def __init__(self, model, tokenizer, device):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = device
+        self.model.eval()
+
+    def invoke(self, messages):
+        """Generate response from local model, return AIMessage"""
+        from langchain_core.messages import AIMessage
+        import torch
+
+        # Convert messages to text
+        if isinstance(messages, list):
+            text = ""
+            for msg in messages:
+                if hasattr(msg, 'content'):
+                    if hasattr(msg, 'type'):
+                        if msg.type == "system":
+                            text += f"System: {msg.content}\n"
+                        elif msg.type == "human":
+                            text += f"Human: {msg.content}\n"
+                        else:
+                            text += f"{msg.content}\n"
+                    else:
+                        text += f"Human: {msg.content}\n"
+                else:
+                    text += str(msg) + "\n"
+            text += "Assistant:"
+        else:
+            text = str(messages)
+
+        try:
+            inputs = self.tokenizer.encode(text, return_tensors="pt", max_length=512, truncation=True)
+            if self.device == "cuda" and torch.cuda.is_available():
+                inputs = inputs.to(self.device)
+                self.model = self.model.to(self.device)
+
+            outputs = self.model.generate(
+                inputs,
+                max_new_tokens=100,
+                do_sample=True,
+                temperature=0.7,
+                pad_token_id=self.tokenizer.eos_token_id,
+                attention_mask=torch.ones_like(inputs),
+                no_repeat_ngram_size=2,
+                early_stopping=True
+            )
+
+            response_text = self.tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True).strip()
+            return AIMessage(content=response_text if response_text else "I understand.")
+
+        except Exception as e:
+            return AIMessage(content=f"Error generating response: {str(e)}")
+
+
+def create_local_huggingface_llm():
+    """Initialize local HuggingFace model"""
+    try:
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        import torch
+
+        model_name = "microsoft/DialoGPT-small"
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        tokenizer = AutoTokenizer.from_pretrained(model_name, padding_side="left")
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16 if device == "cuda" else torch.float32)
+        return LocalHuggingFaceLLM(model, tokenizer, device)
+
+    except Exception as e:
+        print(f"❌ Failed to load local HuggingFace model: {e}")
+        return None
+
+
+def create_minimal_graph(provider: str = "groq"):
+    """Create a minimal graph for testing"""
+    try:
+        if provider == "groq":
+            if not os.getenv("GROQ_API_KEY"):
+                raise ValueError("GROQ_API_KEY not found")
+            llm = ChatGroq(model="qwen/qwen3-32b", temperature=0)
+
+            def assistant(state: MessagesState):
+                return {"messages": [llm.invoke(state["messages"])]}
+
+            builder = StateGraph(MessagesState)
+            builder.add_node("assistant", assistant)
+            builder.add_edge(START, "assistant")
+            return builder.compile()
+
+        elif provider == "huggingface_local":
+            llm = create_local_huggingface_llm()
+            if llm is None:
+                raise ValueError("Failed to create local HuggingFace model")
+
+            def assistant(state: MessagesState):
+                # Return AIMessage directly
+                return {"messages": [llm.invoke(state["messages"])]}
+
+            builder = StateGraph(MessagesState)
+            builder.add_node("assistant", assistant)
+            builder.add_edge(START, "assistant")
+            return builder.compile()
+
+        else:
+            raise ValueError(f"Unknown provider: {provider}")
+
+    except Exception as e:
+        print(f"❌ Failed to create minimal graph: {e}")
+        return None
+
+
+def test_basic_llm_response(provider: str = "groq"):
+    """Test basic LLM response"""
+    print(f"\n🧪 Testing Basic LLM Response ({provider})")
+    try:
+        if provider == "groq":
+            if not os.getenv("GROQ_API_KEY"):
+                return {"status": "error", "error": "GROQ_API_KEY not found"}
+            llm = ChatGroq(model="qwen/qwen3-32b", temperature=0)
+        elif provider == "huggingface_local":
+            llm = create_local_huggingface_llm()
+            if llm is None:
+                return {"status": "error", "error": "Failed to create local HuggingFace model"}
+        else:
+            return {"status": "error", "error": f"Unknown provider: {provider}"}
+
+        test_message = "Hello! Please respond with 'LLM is working correctly'"
+        response = llm.invoke([HumanMessage(content=test_message)])
+        print(f"📥 Response: {response.content[:200]}")
+        return {"status": "success", "provider": provider, "response": response.content}
+
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+
+def test_llm_with_system_prompt(provider: str = "groq"):
+    """Test LLM with system prompt"""
+    print(f"\n🧪 Testing LLM with System Prompt ({provider})")
+    try:
+        if provider == "groq":
+            llm = ChatGroq(model="qwen/qwen3-32b", temperature=0)
+        elif provider == "huggingface_local":
+            llm = create_local_huggingface_llm()
+            if llm is None:
+                return {"status": "error", "error": "Failed to create local HuggingFace model"}
+        else:
+            return {"status": "error", "error": f"Unknown provider: {provider}"}
+
+        system_msg = SystemMessage(content="You are a helpful assistant. Answer briefly and clearly.")
+        user_msg = HumanMessage(content="What is 2+2? Just give me the number.")
+
+        response = llm.invoke([system_msg, user_msg])
+        print(f"📥 Response: {response.content}")
+        return {"status": "success", "provider": provider, "response": response.content}
+
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+
+def test_graph_workflow(provider: str = "groq"):
+    """Test graph workflow"""
+    print(f"\n🧪 Testing Graph Workflow ({provider})")
+    try:
+        graph = create_minimal_graph(provider)
+        if graph is None:
+            return {"status": "error", "error": "Failed to create graph"}
+
+        test_query = "What is 5 + 3? Just give me the answer."
+        result = graph.invoke({"messages": [HumanMessage(content=test_query)]})
+
+        if result and "messages" in result:
+            last_message = result["messages"][-1]
+            print(f"📥 Final response: {last_message.content}")
+            return {"status": "success", "response": last_message.content, "message_count": len(result["messages"])}
+        else:
+            return {"status": "error", "error": "No valid response from graph"}
+
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+
+def run_all_tests():
+    """Run all LLM tests"""
+    results = {}
+    # Groq tests
+    results["groq_basic"] = test_basic_llm_response("groq")
+    results["groq_system_prompt"] = test_llm_with_system_prompt("groq")
+    results["groq_graph"] = test_graph_workflow("groq")
+    # HuggingFace local tests
+    results["huggingface_local_basic"] = test_basic_llm_response("huggingface_local")
+    results["huggingface_local_system_prompt"] = test_llm_with_system_prompt("huggingface_local")
+    results["huggingface_local_graph"] = test_graph_workflow("huggingface_local")
+    return results
+
+
+if __name__ == "__main__":
+    test_results = run_all_tests()
+    print("\n📊 Test Results:")
+    for k, v in test_results.items():
+        print(f"{k}: {v}")

test_local_hf.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Simple test for local HuggingFace models"""
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+def test_local_model():
+    print("🧪 Testing Local HuggingFace Model...")
+    
+    # Check device
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"🖥️  Using device: {device}")
+    
+    # Load model
+    model_name = "microsoft/DialoGPT-small"
+    print(f"📦 Loading {model_name}...")
+    
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForCausalLM.from_pretrained(model_name)
+        
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        
+        print("✅ Model loaded successfully!")
+        
+        # Test generation
+        text = "Hello, how are you?"
+        inputs = tokenizer.encode(text, return_tensors="pt")
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs, 
+                max_new_tokens=50,
+                do_sample=True,
+                temperature=0.7,
+                pad_token_id=tokenizer.eos_token_id
+            )
+        
+        response = tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
+        print(f"🤖 Model response: {response}")
+        print("✅ Local HuggingFace model is working!")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+if __name__ == "__main__":
+    success = test_local_model()
+    if success:
+        print("\n🎉 You can now run the main test with local HuggingFace models!")
+    else:
+        print("\n❌ Setup incomplete. Check the error messages above.")