submit

app.py

@@ -1,152 +1,98 @@
-import os, threading
+import os
 import gradio as gr
-from crew import run_crew
-from utils import get_questions
-
-def ask(question, openai_api_key, gemini_api_key, anthropic_api_key, file_name = ""):
-    """
-    Ask General AI Assistant a question to answer.
-
-    Args:
-        question (str): The question to answer
-        openai_api_key (str): OpenAI API key
-        gemini_api_key (str): Gemini API key
-        anthropic_api_key (str): Anthropic API key
-        file_name (str): Optional file name
-
-    Returns:
-        str: The answer to the question
-    """
-    if not question:
-        raise gr.Error("Question is required.")
-
-    if not openai_api_key:
-        raise gr.Error("OpenAI API Key is required.")
-    
-    if not gemini_api_key:
-        raise gr.Error("Gemini API Key is required.")
-
-    if not anthropic_api_key:
-        raise gr.Error("Anthropic API Key is required.")
-        
-    if file_name:
-        file_name = f"data/{file_name}"
-    
-    lock = threading.Lock()
-
-    with lock:
-        answer = ""
+import requests
+import pandas as pd
+from crew import run_crew  # This is your actual multi-agent logic
 
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# Custom wrapper to integrate your real GAIA agent logic
+class CrewAgent:
+    def __call__(self, question: str) -> str:
+        return run_crew(question, file_path="")  # File support is optional here
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    space_id = os.getenv("SPACE_ID")
+
+    if profile:
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please log in with your Hugging Face account.", None
+
+    agent = CrewAgent()
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+
+    # Step 1: Fetch Questions
+    try:
+        response = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        print(f"✅ Fetched {len(questions_data)} questions.")
+    except Exception as e:
+        return f"❌ Failed to fetch questions: {e}", None
+
+    # Step 2: Run Agent
+    results_log = []
+    answers_payload = []
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
         try:
-            os.environ["OPENAI_API_KEY"] = openai_api_key
-            os.environ["GEMINI_API_KEY"] = gemini_api_key
-            os.environ["MODEL_API_KEY"] = anthropic_api_key
-            
-            answer = run_crew(question, file_name)
+            submitted_answer = agent(question_text)
         except Exception as e:
-            raise gr.Error(e)
-        finally:
-            del os.environ["OPENAI_API_KEY"]
-            del os.environ["GEMINI_API_KEY"]
-            del os.environ["MODEL_API_KEY"]
-        
-        return answer
-
-gr.close_all()
-
-with gr.Blocks() as grady:
-    gr.Markdown("## Grady - General AI Assistant")
-
-    with gr.Tab("Solution"):
-        gr.Markdown(os.environ.get("DESCRIPTION"))
-
-        with gr.Row():
-            with gr.Column(scale=3):
-                with gr.Row():
-                    question = gr.Textbox(
-                        label="Question *",
-                        placeholder="In the 2025 Gradio Agents & MCP Hackathon, what percentage of participants submitted a solution during the last 24 hours?",
-                        interactive=True
-                    )
-                with gr.Row():
-                    level = gr.Radio(
-                        choices=[1, 2, 3],
-                        label="GAIA Benchmark Level",
-                        interactive=True,
-                        scale=1
-                    )
-                    ground_truth = gr.Textbox(
-                        label="Ground Truth",
-                        interactive=True,
-                        scale=1
-                    )
-                    file_name = gr.Textbox(
-                        label="File Name",
-                        interactive=True,
-                        scale=2
-                    )
-                with gr.Row():
-                    openai_api_key = gr.Textbox(
-                        label="OpenAI API Key *",
-                        type="password",
-                        placeholder="sk‑...",
-                        interactive=True
-                    )
-                    gemini_api_key = gr.Textbox(
-                        label="Gemini API Key *",
-                        type="password",
-                        interactive=True
-                    )
-                    anthropic_api_key = gr.Textbox(
-                        label="Anthropic API Key *",
-                        type="password",
-                        placeholder="sk-ant-...",
-                        interactive=True
-                    )
-                with gr.Row():
-                    clear_btn = gr.ClearButton(
-                        components=[question, level, ground_truth, file_name]
-                    )
-                    submit_btn = gr.Button("Submit", variant="primary")
-            with gr.Column(scale=1):
-                answer = gr.Textbox(
-                    label="Answer",
-                    lines=1,
-                    interactive=False
-                )
-    
-        submit_btn.click(
-            fn=ask,
-            inputs=[question, openai_api_key, gemini_api_key, anthropic_api_key, file_name],
-            outputs=answer
-        )
-    
-        QUESTION_FILE_PATH = "data/gaia_validation.jsonl"
-        
-        gr.Examples(
-            label="GAIA Benchmark Level 1 Problems",
-            examples=get_questions(QUESTION_FILE_PATH, 1),
-            inputs=[question, level, ground_truth, file_name, openai_api_key, gemini_api_key, anthropic_api_key],
-            outputs=answer,
-            cache_examples=False
-        )
-    
-        gr.Examples(
-            label="GAIA Benchmark Level 2 Problems",
-            examples=get_questions(QUESTION_FILE_PATH, 2),
-            inputs=[question, level, ground_truth, file_name, openai_api_key, gemini_api_key, anthropic_api_key],
-            outputs=answer,
-            cache_examples=False
-        )
-    
-        gr.Examples(
-            label="GAIA Benchmark Level 3 Problems",
-            examples=get_questions(QUESTION_FILE_PATH, 3),
-            inputs=[question, level, ground_truth, file_name, openai_api_key, gemini_api_key, anthropic_api_key],
-            outputs=answer,
-            cache_examples=False
+            submitted_answer = f"AGENT ERROR: {e}"
+        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})
+
+    if not answers_payload:
+        return "⚠️ No answers generated.", pd.DataFrame(results_log)
+
+    # Step 3: Submit
+    submission = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
+
+    try:
+        response = requests.post(f"{DEFAULT_API_URL}/submit", json=submission, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"✅ Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"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')}"
         )
-    with gr.Tab("Documentation"):
-        gr.Markdown(os.environ.get("DOCUMENTATION"))
+        return final_status, pd.DataFrame(results_log)
+    except Exception as e:
+        return f"❌ Submission failed: {e}", pd.DataFrame(results_log)
+
+# --- Gradio UI ---
+with gr.Blocks() as demo:
+    gr.Markdown("# GAIA Agent Evaluation and Submission")
+    gr.Markdown(
+        """
+        Login and submit your answers for the Hugging Face GAIA Benchmark.
+
+        **Instructions**:
+        - Modify your GAIA agent logic in the `crew.py` file.
+        - Log in with Hugging Face.
+        - Press **Run Evaluation & Submit** to begin.
+        """
+    )
+
+    gr.LoginButton()
+    run_button = gr.Button("Run Evaluation & Submit")
+
+    status_output = gr.Textbox(label="Status", lines=6, interactive=False)
+    results_table = gr.DataFrame(label="Submitted Answers")
+
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
-grady.launch(mcp_server=True)
+if __name__ == "__main__":
+    print("🚀 Starting Submission App...")
+    demo.launch(debug=True)

app_or.py

@@ -0,0 +1,153 @@
+import os, threading
+import gradio as gr
+from crew import run_parallel_crew
+from crew import run_crew
+from utils import get_questions
+
+
+def ask(question, openai_api_key, gemini_api_key, anthropic_api_key, file_name = ""):
+    """
+    Ask General AI Assistant a question to answer.
+    Args:
+        question (str): The question to answer
+        openai_api_key (str): OpenAI API key
+        gemini_api_key (str): Gemini API key
+        anthropic_api_key (str): Anthropic API key
+        file_name (str): Optional file name
+    Returns:
+        str: The answer to the question
+    """
+    if not question:
+        raise gr.Error("Question is required.")
+
+    if not openai_api_key:
+        raise gr.Error("OpenAI API Key is required.")
+    
+    if not gemini_api_key:
+        raise gr.Error("Gemini API Key is required.")
+
+    if not anthropic_api_key:
+        raise gr.Error("Anthropic API Key is required.")
+        
+    if file_name:
+        file_name = f"data/{file_name}"
+    
+    lock = threading.Lock()
+
+    with lock:
+        answer = ""
+
+        try:
+            os.environ["OPENAI_API_KEY"] = openai_api_key
+            os.environ["GEMINI_API_KEY"] = gemini_api_key
+            os.environ["MODEL_API_KEY"] = anthropic_api_key
+            
+            #answer = run_parallel_crew(question, file_name)
+            answer = run_crew(question, file_name)
+        except Exception as e:
+            raise gr.Error(e)
+        finally:
+            del os.environ["OPENAI_API_KEY"]
+            del os.environ["GEMINI_API_KEY"]
+            del os.environ["MODEL_API_KEY"]
+        
+        return answer
+
+gr.close_all()
+
+with gr.Blocks() as grady:
+    gr.Markdown("## Grady - General AI Assistant")
+
+    with gr.Tab("Solution"):
+        gr.Markdown(os.environ.get("DESCRIPTION"))
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                with gr.Row():
+                    question = gr.Textbox(
+                        label="Question *",
+                        placeholder="In the 2025 Gradio Agents & MCP Hackathon, what percentage of participants submitted a solution during the last 24 hours?",
+                        interactive=True
+                    )
+                with gr.Row():
+                    level = gr.Radio(
+                        choices=[1, 2, 3],
+                        label="GAIA Benchmark Level",
+                        interactive=True,
+                        scale=1
+                    )
+                    ground_truth = gr.Textbox(
+                        label="Ground Truth",
+                        interactive=True,
+                        scale=1
+                    )
+                    file_name = gr.Textbox(
+                        label="File Name",
+                        interactive=True,
+                        scale=2
+                    )
+                with gr.Row():
+                    openai_api_key = gr.Textbox(
+                        label="OpenAI API Key *",
+                        type="password",
+                        placeholder="sk‑...",
+                        interactive=True
+                    )
+                    gemini_api_key = gr.Textbox(
+                        label="Gemini API Key *",
+                        type="password",
+                        interactive=True
+                    )
+                    anthropic_api_key = gr.Textbox(
+                        label="Anthropic API Key *",
+                        type="password",
+                        placeholder="sk-ant-...",
+                        interactive=True
+                    )
+                with gr.Row():
+                    clear_btn = gr.ClearButton(
+                        components=[question, level, ground_truth, file_name]
+                    )
+                    submit_btn = gr.Button("Submit", variant="primary")
+            with gr.Column(scale=1):
+                answer = gr.Textbox(
+                    label="Answer",
+                    lines=1,
+                    interactive=False
+                )
+    
+        submit_btn.click(
+            fn=ask,
+            inputs=[question, openai_api_key, gemini_api_key, anthropic_api_key, file_name],
+            outputs=answer
+        )
+    
+        QUESTION_FILE_PATH = "data/gaia_validation.jsonl"
+        
+        gr.Examples(
+            label="GAIA Benchmark Level 1 Problems",
+            examples=get_questions(QUESTION_FILE_PATH, 1),
+            inputs=[question, level, ground_truth, file_name, openai_api_key, gemini_api_key, anthropic_api_key],
+            outputs=answer,
+            cache_examples=False
+        )
+    
+        gr.Examples(
+            label="GAIA Benchmark Level 2 Problems",
+            examples=get_questions(QUESTION_FILE_PATH, 2),
+            inputs=[question, level, ground_truth, file_name, openai_api_key, gemini_api_key, anthropic_api_key],
+            outputs=answer,
+            cache_examples=False
+        )
+    
+        gr.Examples(
+            label="GAIA Benchmark Level 3 Problems",
+            examples=get_questions(QUESTION_FILE_PATH, 3),
+            inputs=[question, level, ground_truth, file_name, openai_api_key, gemini_api_key, anthropic_api_key],
+            outputs=answer,
+            cache_examples=False
+        )
+    with gr.Tab("Documentation"):
+        gr.Markdown(os.environ.get("DOCUMENTATION"))
+
+grady.launch(mcp_server=True)

config/agents.yaml

@@ -5,7 +5,6 @@ web_search_agent:
     Given a question only, search the web and answer the question: {question}
   backstory: >
     As an expert web search assistant, you search the web to answer the question.
-
 web_browser_agent:
   role: >
     Web Browser Agent
@@ -13,7 +12,6 @@ web_browser_agent:
     Given a question, URL, and action, load the URL and act, extract, or observe, and answer the question: {question}
   backstory: >
     As an expert browser assistant, you load the URL and act, extract, or observe to answer the question.
-
 image_analysis_agent:
   role: >
     Image Analysis Agent
@@ -21,7 +19,6 @@ image_analysis_agent:
     Given a question and image file, analyze the image and answer the question: {question}
   backstory: >
     As an expert image analysis assistant, you analyze the image to answer the question.
-
 audio_analysis_agent:
   role: >
     Audio Analysis Agent
@@ -29,7 +26,6 @@ audio_analysis_agent:
     Given a question and audio file, analyze the audio and answer the question: {question}
   backstory: >
     As an expert audio analysis assistant, you analyze the audio to answer the question.
-
 video_analysis_agent:
   role: >
     Video Analysis Agent
@@ -37,7 +33,6 @@ video_analysis_agent:
     Given a question and video file, analyze the video and answer the question: {question}
   backstory: >
     As an expert video analysis assistant, you analyze the video file to answer the question.
-
 youtube_analysis_agent:
   role: >
     YouTube Analysis Agent
@@ -45,7 +40,6 @@ youtube_analysis_agent:
     Given a question and YouTube URL, analyze the video and answer the question: {question}
   backstory: >
     As an expert YouTube analysis assistant, you analyze the video to answer the question.
-
 document_analysis_agent:
   role: >
     Document Analysis Agent
@@ -53,7 +47,6 @@ document_analysis_agent:
     Given a question and document file, analyze the document and answer the question: {question}
   backstory: >
     As an expert document analysis assistant, you analyze the document to answer the question.
-
 arithmetic_agent:
   role: >
     Arithmetic Agent
@@ -69,7 +62,6 @@ code_generation_agent:
     Given a question and JSON data, generate and execute code to answer the question: {question}
   backstory: >
     As an expert Python code generation assistant, you generate and execute code to answer the question.
-
 code_execution_agent:
   role: >
     Code Execution Agent
@@ -77,7 +69,20 @@ code_execution_agent:
     Given a question and Python file, execute the file to answer the question: {question}
   backstory: >
     As an expert Python code execution assistant, you execute code to answer the question.
-
+translation_agent:
+  role: >
+    A language translator agent that converts text from one language to another.
+  goal: >
+    Translate any given text into the requested target language.
+  backstory: >
+    An expert polyglot AI fluent in hundreds of languages.
+summarization_agent:
+  role: >
+    A summarizer agent that condenses long text into clear and concise summaries.
+  goal: >
+    Summarize long articles, documents, or extracted content upon request.
+  backstory: >
+    A highly trained AI editor capable of identifying the core meaning of complex passages, documents, and technical content.
 manager_agent:
   role: >
     Manager Agent

config/tasks.yaml

@@ -11,8 +11,9 @@ manager_task:
     - Arithmetic Agent requires a question and **two numbers to add, subtract, multiply, divide, or get the modulus**. In case there are more than two numbers, use the Code Generation Agent instead.
     - Code Generation Agent requires a question and **JSON data**.
     - Code Execution Agent requires a question and **Python file**.
+    - Translation Agent requires a question and **a target language** (e.g. Translate this to French: 'Hello').
+    - Summarization Agent requires a question and **a long text to summarize** (e.g. Summarize this: 'The history of AI began in...').
     In case you cannot answer the question and there is not a good coworker, delegate to the Code Generation Agent.
     Question: {question}
   expected_output: >
-    The answer to the question.
-  agent: manager_agent
+    The answer to the question.

crew.py

@@ -34,160 +34,145 @@ tracer_provider = register(
     project_name="gaia"
 )
 
-#CrewAIInstrumentor().instrument(tracer_provider=tracer_provider)
+## Tools
 
-@CrewBase
-class GAIACrew():
-    agents: List[BaseAgent]
-    tasks: List[Task]
+DOCUMENT_TOOLS = [
+    AITools.document_analysis_tool,
+    AITools.summarize_tool,
+    AITools.translate_tool
+]
 
-    @agent
-    def web_search_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["web_search_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=2,
-            tools=[AITools.web_search_tool],
-            verbose=True
-        )
+MEDIA_TOOLS = [
+    AITools.image_analysis_tool,
+    AITools.audio_analysis_tool,
+    AITools.video_analysis_tool,
+    AITools.youtube_analysis_tool
+]
 
-    @agent
-    def web_browser_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["web_browser_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=3,
-            tools=[AITools.web_browser_tool],
-            verbose=True
-        )
-    
-    @agent
-    def image_analysis_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["image_analysis_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=2,
-            tools=[AITools.image_analysis_tool],
-            verbose=True
-        )
+WEB_TOOLS = [
+    AITools.web_search_tool,
+    AITools.web_browser_tool
+]
 
-    @agent
-    def audio_analysis_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["audio_analysis_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=2,
-            tools=[AITools.audio_analysis_tool],
-            verbose=True
-        )
+ARITHMETIC_TOOLS = [
+    ArithmeticTools.add,
+    ArithmeticTools.subtract,
+    ArithmeticTools.multiply,
+    ArithmeticTools.divide,
+    ArithmeticTools.modulus
+]
 
-    @agent
-    def video_analysis_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["video_analysis_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=2,
-            tools=[AITools.video_analysis_tool],
-            verbose=True
-        )
+CODE_TOOLS = [
+    AITools.code_generation_tool,
+    AITools.code_execution_tool
+]
 
-    @agent
-    def youtube_analysis_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["youtube_analysis_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=2,
-            tools=[AITools.youtube_analysis_tool],
-            verbose=True
-        )
+#Get specific tools
+def get_tools_for(agent_name: str):
+    if "document" in agent_name or "translation" in agent_name or "summarization" in agent_name:
+        return DOCUMENT_TOOLS
+    elif any(keyword in agent_name for keyword in ["image", "audio", "video", "youtube"]):
+        return MEDIA_TOOLS
+    elif "web_search" in agent_name or "web_browser" in agent_name:
+        return WEB_TOOLS
+    elif "code_generation" in agent_name or "code_execution" in agent_name:
+        return CODE_TOOLS
+    elif "arithmetic" in agent_name:
+        return ARITHMETIC_TOOLS
+    elif "manager" in agent_name:
+        return []
+    else:
+        return []
 
-    @agent
-    def document_analysis_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["document_analysis_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=2,
-            tools=[AITools.document_analysis_tool],
-            verbose=True
-        )
 
-    @agent
-    def arithmetic_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["document_analysis_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=2,
-            tools=[ArithmeticTools.add, ArithmeticTools.subtract, ArithmeticTools.multiply, ArithmeticTools.divide, ArithmeticTools.modulus],
-            verbose=True
-        )
+#CrewAIInstrumentor().instrument(tracer_provider=tracer_provider)
 
-    @agent
-    def code_generation_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["code_generation_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=3,
-            tools=[AITools.code_generation_tool],
-            verbose=True
-        )
+#@CrewBase
+class GAIACrew():
+    tasks: List[Task]
 
-    @agent
-    def code_execution_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["code_execution_agent"],
-            allow_delegation=False,
-            llm=AGENT_MODEL,
-            max_iter=3,
-            tools=[AITools.code_execution_tool],
-            verbose=True
-        )
+    def __init__(self):
+        self.agents_config = self._load_yaml("config/agents.yaml")
+        self.tasks_config = self._load_yaml("config/tasks.yaml")
 
-    @agent
-    def manager_agent(self) -> Agent:
-        return Agent(
-            config=self.agents_config["manager_agent"],
-            allow_delegation=True,
-            llm=MANAGER_MODEL,
-            max_iter=5,
-            verbose=True
-        )
+    def _load_yaml(self, path):
+        import yaml
+        with open(path, "r") as f:
+            return yaml.safe_load(f)
+
+    @property
+    def agents(self) -> List[Agent]:
+        agents = []
+        for name in self.agents_config:
+            config = self.agents_config[name]
+            if config is None:
+                print(f"❌ Agent config for '{name}' is None!")
+                continue
 
+            full_config = {**config, "name": name}
+            print(f"✅ Creating agent: {name}")
+
+            agents.append(Agent(
+                config=full_config,
+                allow_delegation=("manager" in name),
+                llm=MANAGER_MODEL if "manager" in name else AGENT_MODEL,
+                max_iter=5 if "manager" in name else 2,
+                tools=get_tools_for(name),
+                verbose=True
+            ))
+        return agents
+        
     @task
     def manager_task(self) -> Task:
-        return Task(
-            config=self.tasks_config["manager_task"]
-        )
+        # Build the Task object from your YAML
+        task = Task(config=self.tasks_config["manager_task"])
+        
+        # Find the Agent instance whose YAML key is "manager_agent"
+        agent_list = self.agents
+        name_list  = list(self.agents_config.keys())
+        for idx, name in enumerate(name_list):
+            if name == "manager_agent":
+                task.agent = agent_list[idx]
+                break
+        
+        return task
 
-    @crew
-    def crew(self) -> Crew:
+    def get_crew(self) -> Crew:
         return Crew(
             agents=self.agents,
-            tasks=self.tasks,
+            tasks=[self.manager_task()],
             verbose=True
         )
 
 def run_crew(question, file_path):
+    """
+    Orchestrates the GAIA crew to answer a question, optionally with a file.
+    Args:
+        question (str): The user's question.
+        file_path (str): Optional path to a data file to include in the prompt.
+    Returns:
+        str: The final answer from the manager agent.
+    """
+    # Build the final prompt, including file JSON if needed
     final_question = question
-    
     if file_path:
-        if is_ext(file_path, ".csv") or is_ext(file_path, ".xls") or is_ext(file_path, ".xlsx") or is_ext(file_path, ".json") or is_ext(file_path, ".jsonl"):
+        if is_ext(file_path, ".csv") or is_ext(file_path, ".xls") \
+           or is_ext(file_path, ".xlsx") or is_ext(file_path, ".json") \
+           or is_ext(file_path, ".jsonl"):
             json_data = read_file_json(file_path)
             final_question = f"{question} JSON data:\n{json_data}."
         else:
             final_question = f"{question} File path: {file_path}."
-
-    answer = GAIACrew().crew().kickoff(inputs={"question": final_question})
+    
+    # Instantiate the crew and kick off the workflow
+    crew_instance = GAIACrew()
+    crew = crew_instance.get_crew()
+    answer = crew.kickoff(inputs={"question": final_question})
+    
+    # Post-process through the final-answer model
     final_answer = get_final_answer(FINAL_ANSWER_MODEL, question, str(answer))
 
+    # Debug logging
     print(f"=> Initial question: {question}")
     print(f"=> Final question: {final_question}")
     print(f"=> Initial answer: {answer}")
@@ -195,6 +180,66 @@ def run_crew(question, file_path):
     
     return final_answer
 
+import concurrent.futures
+
+def run_parallel_crew(question: str, file_path: str):
+    """
+    1) Prepares the prompt (including file data if any).
+    2) Runs every non-manager agent in parallel on that prompt.
+    3) Gathers their raw outputs.
+    4) Sends a combined prompt to the manager_agent for the final answer.
+    """
+    # 1) Build the final prompt
+    final_question = question
+    if file_path:
+        if is_ext(file_path, ".csv") or is_ext(file_path, ".xls") \
+           or is_ext(file_path, ".xlsx") or is_ext(file_path, ".json") \
+           or is_ext(file_path, ".jsonl"):
+            json_data = read_file_json(file_path)
+            final_question = f"{question} JSON data:\n{json_data}."
+        else:
+            final_question = f"{question} File path: {file_path}."
+
+    # 2) Instantiate your crew and split manager vs workers
+    crew_instance = GAIACrew()
+    names  = list(crew_instance.agents_config.keys())
+    agents = crew_instance.agents
+    pairs  = list(zip(names, agents))
+
+    workers = [(n, a) for n, a in pairs if n != "manager_agent"]
+    manager_name, manager = next((n, a) for n, a in pairs if n == "manager_agent")
+
+    # 3) Run workers in parallel, giving each the plain-string prompt
+    results = {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=len(workers)) as pool:
+        future_to_name = {
+            pool.submit(agent.kickoff, final_question): name
+            for name, agent in workers
+        }
+        for fut in concurrent.futures.as_completed(future_to_name):
+            name = future_to_name[fut]
+            try:
+                results[name] = fut.result()
+            except Exception as e:
+                results[name] = f"<error: {e}>"
+
+    # 4) Compose a manager prompt with all the raw outputs
+    combined = "\n\n".join(f"--- {n} output ---\n{out}"
+                           for n, out in results.items())
+    manager_prompt = (
+        f"You have received these reports from your coworkers:\n\n"
+        f"{combined}\n\n"
+        f"Now, based on the original question, provide the final answer.\n"
+        f"Original question: {question}"
+    )
+
+    # 5) Run the manager agent on the combined prompt
+    final = manager.kickoff(manager_prompt)
+
+    # 6) Post-process via your final-answer model
+    return get_final_answer(FINAL_ANSWER_MODEL, question, str(final))
+
+
 def get_final_answer(model, question, answer):
     prompt_template = """
         You are an expert question answering assistant. Given a question and an initial answer, your task is to provide the final answer.

tools/ai_tools.py

@@ -319,4 +319,53 @@ class AITools():
                 if part.code_execution_result is not None:
                     return part.code_execution_result.output
         except Exception as e:
-            raise RuntimeError(f"Processing failed: {str(e)}")
+            raise RuntimeError(f"Processing failed: {str(e)}")
+
+    @tool("Translation Tool")
+    def translate_tool(text: str, target_lang: str) -> str:
+        """Translate a given text into the target language.
+        
+        Args:
+            text (str): The text to translate.
+            target_lang (str): The target language (e.g., 'french', 'de', 'zh').
+        
+        Returns:
+            str: Translated text.
+        """
+        try:
+            client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
+            
+            prompt = f"Translate this text to {target_lang}: '{text}'"
+            
+            response = client.models.generate_content(
+                model="gemini-2.5-flash-preview-04-17",
+                contents=prompt
+            )
+            
+            return response.text
+        except Exception as e:
+            raise RuntimeError(f"Translation failed: {str(e)}")
+    
+    @tool("Summarization Tool")
+    def summarize_tool(text: str) -> str:
+        """Summarize the given text input.
+        
+        Args:
+            text (str): Long content to summarize.
+        
+        Returns:
+            str: A concise summary.
+        """
+        try:
+            client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
+            
+            prompt = f"Summarize this content: {text}"
+            
+            response = client.models.generate_content(
+                model="gemini-2.5-flash-preview-04-17",
+                contents=prompt
+            )
+            
+            return response.text
+        except Exception as e:
+            raise RuntimeError(f"Summarization failed: {str(e)}")