Upload folder using huggingface_hub

README.md

@@ -1,12 +1,6 @@
 ---
-title: AI Debate Arena
-emoji: 👀
-colorFrom: yellow
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.8.0
+title: AI_Debate_Arena
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 6.4.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,82 @@
+import gradio as gr
+from llm_debate.crew import LlmDebate
+
+
+# -----------------------------
+# Run debate with streaming UI
+# -----------------------------
+def run_debate(topic):
+    debate = LlmDebate()
+
+    propose_box = "⏳ Generating propose argument..."
+    oppose_box = ""
+    judge_box = ""
+
+    yield propose_box, oppose_box, judge_box
+
+    # ---- PROPOSE ----
+    propose_task = debate.propose()
+    propose_result = debate.propose_debater().execute_task(
+        propose_task, {"motion": topic}
+    )
+
+    propose_box = propose_result
+    yield propose_box, oppose_box, "⏳ Waiting for oppose..."
+
+    # ---- OPPOSE ----
+    oppose_task = debate.oppose()
+    oppose_result = debate.oppose_debater().execute_task(
+        oppose_task, {"motion": topic}
+    )
+
+    oppose_box = oppose_result
+    yield propose_box, oppose_box, "⚖️ Judging results..."
+
+    # ---- JUDGE ----
+    judge_task = debate.decide()
+    judge_result = debate.judge().execute_task(
+        judge_task,
+        {
+            "propose": propose_result,
+            "oppose": oppose_result,
+            "motion": topic,
+        },
+    )
+
+    yield propose_box, oppose_box, judge_result
+
+
+# -----------------------------
+# UI
+# -----------------------------
+with gr.Blocks(title="AI Debate") as demo:
+    gr.Markdown("# 🧠 AI Debate Arena")
+
+    topic = gr.Textbox(
+        label="Debate Topic",
+        placeholder="Enter debate motion...",
+    )
+
+    run_btn = gr.Button("Run Debate", variant="primary")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## 🟢 Propose")
+            propose_box = gr.Markdown("⬜ Empty")
+
+        with gr.Column():
+            gr.Markdown("## 🔴 Oppose")
+            oppose_box = gr.Markdown("⬜ Empty")
+
+    gr.Markdown("## ⚖️ Judge")
+    judge_box = gr.Markdown("⬜ Empty")
+
+    run_btn.click(
+        run_debate,
+        inputs=topic,
+        outputs=[propose_box, oppose_box, judge_box],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

config/agents.yaml

@@ -0,0 +1,31 @@
+propose_debater:
+  role: >
+    A compelling debater
+  goal: >
+    Present a clear argument in favor of the motion. The motion is: {motion}
+  backstory: >
+    You're an experienced debator with a knack for giving concise but convincing arguments.
+    The motion is: {motion}
+  llm: gemini/gemini-2.5-flash
+
+oppose_debater:
+  role: >
+    A compelling debater
+  goal: >
+    Present a clear argument againts the motion. The motion is: {motion}
+  backstory: >
+    You're an experienced debator with a knack for giving concise but convincing arguments.
+    The motion is: {motion}
+  llm: gemini/gemini-2.5-flash
+
+judge:
+  role: >
+    Decide the winner of the debate based on the arguments presented
+  goal: >
+    Given arguments for and against this motion: {motion}, decide which side is more convincing,
+    based purely on the arguments presented.
+  backstory: >
+    You are a fair judge with a reputation for weighing up arguments without factoring in
+    your own views, and making a decision based purely on the merits of the argument.
+    The motion is: {motion}
+  llm: gemini/gemini-2.5-flash

config/tasks.yaml

@@ -0,0 +1,27 @@
+propose:
+  description: >
+    You are proposing the motion: {motion}.
+    Come up with a clear argument in favor of the motion.
+    Be very convincing.
+  expected_output: >
+    Your clear argument in favor of the motion, in a concise manner.
+  agent: propose_debater
+  output_file: output/propose.md
+
+oppose:
+  description: >
+    You are in opposition to the motion: {motion}.
+    Come up with a clear argument against the motion.
+    Be very convincing.
+  expected_output: >
+    Your clear argument against the motion, in a concise manner.
+  agent: oppose_debater
+  output_file: output/oppose.md
+  
+decide:
+  description: >
+    Review the arguments presented by the debaters and decide which side is more convincing.
+  expected_output: >
+    Your decision on which side is more convincing, and why.
+  agent: judge
+  output_file: output/decide.md

crew.py

@@ -0,0 +1,68 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+agents_config = os.path.join(BASE_DIR, "../config/agents.yaml")
+tasks_config = os.path.join(BASE_DIR, "../config/tasks.yaml")
+
+
+@CrewBase
+class LlmDebate():
+	"""LlmDebate crew"""
+
+	agents_config = 'config/agents.yaml'
+	tasks_config = 'config/tasks.yaml'
+
+	@agent
+	def propose_debater(self) -> Agent:
+		return Agent(
+			config=self.agents_config['propose_debater'],
+			verbose=False
+		)
+
+	@agent
+	def oppose_debater(self) -> Agent:
+		return Agent(
+			config=self.agents_config['oppose_debater'],
+			verbose=False
+		)
+
+	@agent
+	def judge(self) -> Agent:
+		return Agent(
+			config=self.agents_config['judge'],
+			verbose=False
+		)
+
+	@task
+	def propose(self) -> Task:
+		return Task(
+			config=self.tasks_config['propose'],
+		)
+
+	@task
+	def oppose(self) -> Task:
+		return Task(
+			config=self.tasks_config['oppose'],
+		)
+
+	@task
+	def decide(self) -> Task:
+		return Task(
+			config=self.tasks_config['decide'],
+		)
+
+	@crew
+	def crew(self) -> Crew:
+		"""Creates the LlmDebate crew"""
+
+		return Crew(
+			agents=self.agents, # Automatically created by the @agent decorator
+			tasks=self.tasks, # Automatically created by the @task decorator
+			process=Process.sequential,
+			verbose=False,
+			# process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
+		)

main.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+import sys
+import warnings
+
+from llm_debate.crew import LlmDebate
+
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
+
+# This main file is intended to be a way for you to run your
+# crew locally, so refrain from adding unnecessary logic into this file.
+# Replace with inputs you want to test with, it will automatically
+# interpolate any tasks and agents information
+
+def run():
+    """
+    Run the crew.
+    """
+    inputs = {
+        'motion': 'Universe is created by god'
+    }
+    try:
+       result = LlmDebate().crew().kickoff(inputs=inputs)
+       print(result)
+    except Exception as e:
+        raise Exception("An error occured")
+
+
+
+def train():
+    """
+    Train the crew for a given number of iterations.
+    """
+    inputs = {
+        "topic": "AI LLMs"
+    }
+    try:
+        LlmDebate().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs)
+
+    except Exception as e:
+        raise Exception(f"An error occurred while training the crew: {e}")
+
+def replay():
+    """
+    Replay the crew execution from a specific task.
+    """
+    try:
+        LlmDebate().crew().replay(task_id=sys.argv[1])
+
+    except Exception as e:
+        raise Exception(f"An error occurred while replaying the crew: {e}")
+
+def test():
+    """
+    Test the crew execution and returns the results.
+    """
+    inputs = {
+        "topic": "AI LLMs"
+    }
+    try:
+        LlmDebate().crew().test(n_iterations=int(sys.argv[1]), openai_model_name=sys.argv[2], inputs=inputs)
+
+    except Exception as e:
+        raise Exception(f"An error occurred while replaying the crew: {e}")

output/decide.md

@@ -0,0 +1,19 @@
+The motion under debate is: Will AI models replace software engineers?
+
+**Arguments for Replacement:**
+The affirmative side argues that AI models will replace software engineers by rapidly automating the entire software development lifecycle (SDLC). They highlight AI's current proficiency in generating complex code, debugging, writing test cases, and refactoring systems. The argument posits that AI's capabilities will soon surpass human speed, consistency, and cost-effectiveness, driven by the economic imperative for businesses to reduce labor costs and achieve efficiency. This will lead to a diminished demand for traditional coding roles, with the vast majority of software engineering becoming automated, leaving only a small number of specialized engineers to manage the AI systems.
+
+**Arguments Against Replacement (for Transformation and Augmentation):**
+The opposing side contends that AI models will not replace software engineers but will profoundly transform and augment the profession. While acknowledging AI's strength in automating repetitive tasks like coding, debugging, and testing, they emphasize AI's fundamental lack of irreplaceable human capacities. These capacities include abstract problem definition, interpreting ambiguous user needs, and navigating complex ethical, business, and social contexts. They argue that engineers are more than coders; they are architects, innovators, and strategic problem-solvers who define the 'what' and the 'why.' Consequently, engineers' roles will evolve to higher-level design, system architecture, prompt engineering, strategic oversight of AI-generated code, and translating ill-defined human challenges into actionable solutions. AI is thus viewed as a powerful tool that amplifies human productivity and creativity, allowing engineers to focus on more complex and strategic challenges.
+
+**Decision:**
+
+Upon reviewing the arguments, the side arguing that AI models will *not* replace software engineers, but rather transform and augment the profession, presents a more convincing case.
+
+The affirmative argument, while strong in demonstrating AI's rapidly advancing technical capabilities in executing specific coding and development tasks, focuses primarily on the *how* of software development. Its projection of AI surpassing human capacity in speed and cost-effectiveness for these tasks is compelling. However, its conclusion that this will lead to the "replacement" of the "vast majority" of software engineers relies on an implicit definition of a software engineer that might be too narrow.
+
+The opposing side effectively broadens the definition of a "software engineer" beyond mere coding and task execution. By highlighting the irreplaceable human capacity for abstract problem definition, interpreting ambiguous user needs, and navigating complex ethical, business, and social contexts, it identifies crucial aspects of the profession that AI models, as currently understood, fundamentally lack. These higher-level functions—defining the 'what' and 'why,' strategic oversight, and innovative problem-solving—are presented as core to the software engineering role and are precisely where human engineers would continue to provide unique value.
+
+The argument for transformation and augmentation directly addresses the likely evolution of the profession, where engineers leverage AI as a sophisticated tool to enhance their productivity and shift their focus to more complex, strategic challenges. This perspective acknowledges AI's strengths without conceding total replacement, instead positing a symbiotic relationship. Even the affirmative side somewhat concedes this point by mentioning a "small cadre of highly specialized engineers might remain," which aligns more with a transformation than a wholesale replacement.
+
+Therefore, the argument against replacement, which champions transformation and augmentation, is more convincing because it presents a more comprehensive understanding of the software engineer's role and robustly delineates the enduring, uniquely human contributions that AI, despite its impressive advances, is not yet equipped to provide.

output/oppose.md

@@ -0,0 +1 @@
+AI models will not replace software engineers; they will profoundly *transform* and *augment* the profession. While AI excels at automating repetitive coding, debugging, and testing, it fundamentally lacks the irreplaceable human capacity for truly abstract problem definition, interpreting ambiguous user needs, and navigating the complex ethical, business, and social contexts inherent in impactful software development. Engineers are not merely coders; they are architects, innovators, and strategic problem-solvers who define the *what* and the *why*. Their roles will evolve to higher-level design, system architecture, prompt engineering, strategic oversight of AI-generated code, and translating ill-defined human challenges into actionable solutions. We are witnessing an evolution where AI becomes a powerful tool that amplifies human productivity and creativity, allowing engineers to focus on more complex, strategic, and innovative challenges, rather than a displacement of their essential ingenuity and critical thinking.

output/propose.md

@@ -0,0 +1,3 @@
+AI models *will* replace software engineers, not merely augment them, because they are rapidly mastering and automating the entire software development lifecycle at an exponential rate. Current AI models already demonstrate remarkable proficiency in generating complex code, identifying and fixing intricate bugs, writing exhaustive test cases, and even refactoring entire systems – core tasks that define a software engineer's role.
+
+As these models continue to scale and learn, their ability to interpret abstract requirements, translate them into functional code, and ensure quality will surpass human capacity in speed, consistency, and cost-effectiveness. The economic imperative for businesses to achieve unparalleled efficiency and drastically reduce labor costs will inevitably drive a mass adoption of AI-driven development. This shift will fundamentally diminish the demand for traditional coding roles, transforming the vast majority of software engineering into an automated process. While a small cadre of highly specialized engineers might remain to design, train, and oversee these AI systems, the broad profession as we know it will be superseded, replaced by AI models that can build, test, and deploy software more efficiently than human teams.

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+crewai
+google-generativeai
+openai
+pyyaml

tools/custom_tool.py

@@ -0,0 +1,19 @@
+from crewai.tools import BaseTool
+from typing import Type
+from pydantic import BaseModel, Field
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = (
+        "Clear description for what this tool is useful for, your agent will need this information to use it."
+    )
+    args_schema: Type[BaseModel] = MyCustomToolInput
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."