Add initial implementation of Hackathon Team Organizer application

- Created main application structure with `main.py` as the entry point.
- Implemented participant generation script in `generate_participants.py`.
- Set up SQLite database for participant storage with `database.py`.
- Developed AI-powered team matching logic in `matching_agent.py`.
- Added Gradio-based UI in `app.py` for participant registration and team matching.
- Included `.gitignore` to exclude unnecessary files.
- Added `README.md` for project documentation and setup instructions.
- Established requirements in `requirements.txt` for dependencies.

.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+**/*.pyc
+*.pyc

generate_participants.py

@@ -0,0 +1,372 @@
+#!/usr/bin/env python3
+"""
+Generate Synthetic Hackathon Participants
+
+This script creates 100 diverse hackathon participants and saves them to the database.
+The participants represent various personas that might attend a hackathon focused on
+"Connected Experiences" and AI agents.
+"""
+import random
+import sys
+import os
+from faker import Faker
+from hackathon_organizer.database import initialize_database, add_participant, get_participants_dataframe
+
+# Initialize Faker for generating realistic names and emails
+fake = Faker()
+
+# Define various participant personas and attributes
+TECHNICAL_BACKGROUNDS = [
+    # Developers
+    "Full-stack developer with {years} years of experience in {stack}. {additional}",
+    "Backend engineer specializing in {backend_tech}. {additional}",
+    "Frontend developer focused on {frontend_tech}. {additional}",
+    "Mobile developer with expertise in {mobile_tech}. {additional}",
+    "DevOps engineer with experience in {devops_tech}. {additional}",
+    "Data scientist working with {ds_tech}. {additional}",
+    "Machine learning engineer focused on {ml_tech}. {additional}",
+    "AI researcher specializing in {ai_tech}. {additional}",
+    "Game developer using {game_tech}. {additional}",
+    "Embedded systems engineer working with {embedded_tech}. {additional}",
+    
+    # Technical but not coding-focused
+    "UX/UI designer with {years} years of experience. {additional}",
+    "Product manager for {product_type} products. {additional}",
+    "QA engineer with expertise in {qa_tech}. {additional}",
+    "Technical writer specializing in {writing_focus}. {additional}",
+    "Solution architect with background in {arch_focus}. {additional}",
+]
+
+NON_TECHNICAL_BACKGROUNDS = [
+    "Marketing professional with experience in {marketing_focus}. {additional}",
+    "Business development specialist in the {industry} industry. {additional}",
+    "Project manager with {years} years of experience in {pm_focus}. {additional}",
+    "Entrepreneur and founder of a {startup_type} startup. {additional}",
+    "Student studying {field} at {university}. {additional}",
+    "Design thinking facilitator and innovation consultant. {additional}",
+    "Content creator focusing on {content_focus}. {additional}",
+    "Sales professional in the {sales_industry} sector. {additional}",
+    "HR specialist interested in tech talent and culture. {additional}",
+    "Non-profit professional looking to leverage technology for social impact. {additional}",
+]
+
+GOALS = [
+    # Learning-focused
+    "I want to learn about AI and how it can enhance user experiences at events.",
+    "I'm here to understand how to build AI agents and apply them to real-world problems.",
+    "I hope to gain practical experience with AI technologies and expand my technical skills.",
+    "I want to learn from experienced developers and improve my coding abilities.",
+    "I'm looking to understand how AI can create more meaningful human connections.",
+    
+    # Project-focused
+    "I want to build a prototype that demonstrates the power of AI in connecting people.",
+    "I'm hoping to create an innovative solution that addresses the challenges of virtual events.",
+    "My goal is to develop an AI agent that enhances real-world social interactions.",
+    "I want to build something impressive for my portfolio that showcases my skills.",
+    "I'm aiming to create a practical tool that event organizers can actually use.",
+    
+    # Networking-focused
+    "I'm primarily here to network with other professionals in the AI and event space.",
+    "I want to meet potential co-founders for a startup idea I've been developing.",
+    "I'm looking to connect with mentors who can guide my career in tech.",
+    "I hope to find collaborators for future projects beyond this hackathon.",
+    "I want to expand my professional network in the Toronto tech community.",
+    
+    # Career-focused
+    "I'm exploring career opportunities in AI development and looking to showcase my skills.",
+    "I want to transition from my current role to a more tech-focused position.",
+    "I'm hoping this experience will help me land a job at an innovative tech company.",
+    "I want to demonstrate my abilities to potential employers or clients.",
+    "I'm building skills that will help me advance in my current organization.",
+    
+    # Fun/Experience-focused
+    "I'm here for the creative experience and the thrill of building something in 24 hours.",
+    "I want to have fun while challenging myself technically.",
+    "I'm curious about hackathons and wanted to experience one firsthand.",
+    "I enjoy the collaborative atmosphere of hackathons and the energy they generate.",
+    "I'm looking for a break from my routine and a chance to work on something different.",
+]
+
+# Technical stack components
+STACK_COMPONENTS = {
+    "years": [str(i) for i in range(1, 16)],
+    "stack": [
+        "JavaScript/TypeScript and Python", "MERN stack", "MEAN stack", "Ruby on Rails", 
+        "Django and React", "Vue.js and Node.js", "PHP and Laravel", "Java Spring Boot",
+        ".NET and Angular", "Go and React", "Python Flask and Vue.js"
+    ],
+    "backend_tech": [
+        "Node.js and Express", "Django and PostgreSQL", "Ruby on Rails", "Java Spring Boot",
+        "ASP.NET Core", "PHP and Laravel", "Go microservices", "Python FastAPI",
+        "GraphQL APIs", "Serverless architectures on AWS"
+    ],
+    "frontend_tech": [
+        "React and Redux", "Angular and RxJS", "Vue.js and Vuex", "Svelte and SvelteKit",
+        "Next.js", "Gatsby", "React Native", "Flutter", "TypeScript and Material UI",
+        "Tailwind CSS and Alpine.js"
+    ],
+    "mobile_tech": [
+        "React Native", "Flutter", "Swift for iOS", "Kotlin for Android",
+        "Xamarin", "Ionic", "PWAs", "Unity for mobile games", "NativeScript",
+        "Mobile AR/VR applications"
+    ],
+    "devops_tech": [
+        "Kubernetes and Docker", "AWS infrastructure", "Azure DevOps", "Google Cloud Platform",
+        "CI/CD pipelines", "Terraform and infrastructure as code", "Jenkins and GitLab CI",
+        "Monitoring and observability tools", "Site Reliability Engineering practices",
+        "Security automation"
+    ],
+    "ds_tech": [
+        "Python, Pandas, and scikit-learn", "R and Tidyverse", "SQL and data warehousing",
+        "Tableau and data visualization", "Big data technologies like Spark",
+        "ETL pipelines", "Statistical analysis", "A/B testing methodologies",
+        "Natural Language Processing", "Computer Vision"
+    ],
+    "ml_tech": [
+        "TensorFlow and Keras", "PyTorch", "scikit-learn", "deep learning models",
+        "MLOps and model deployment", "reinforcement learning", "computer vision algorithms",
+        "NLP models", "recommendation systems", "time series forecasting"
+    ],
+    "ai_tech": [
+        "large language models", "generative AI", "conversational agents", "computer vision systems",
+        "reinforcement learning", "multimodal AI", "AI ethics and responsible AI",
+        "autonomous systems", "AI for social good", "explainable AI"
+    ],
+    "game_tech": [
+        "Unity", "Unreal Engine", "Godot", "WebGL", "AR/VR development",
+        "mobile game development", "game AI", "procedural generation",
+        "multiplayer networking", "game physics"
+    ],
+    "embedded_tech": [
+        "Arduino", "Raspberry Pi", "IoT devices", "embedded Linux",
+        "RTOS", "C/C++ for microcontrollers", "sensor networks",
+        "firmware development", "hardware interfaces", "low-power systems"
+    ],
+    "product_type": [
+        "SaaS", "mobile", "enterprise", "consumer", "AI-powered",
+        "IoT", "fintech", "healthtech", "edtech", "e-commerce"
+    ],
+    "qa_tech": [
+        "automated testing", "Selenium and Cypress", "performance testing",
+        "security testing", "mobile app testing", "API testing",
+        "test-driven development", "behavior-driven development",
+        "continuous integration testing", "accessibility testing"
+    ],
+    "writing_focus": [
+        "API documentation", "user guides", "developer tutorials",
+        "knowledge bases", "technical blogs", "software requirements",
+        "open source documentation", "technical specifications",
+        "UX writing", "compliance documentation"
+    ],
+    "arch_focus": [
+        "cloud architectures", "microservices", "serverless",
+        "enterprise systems", "distributed systems", "API design",
+        "security architectures", "data platforms", "IoT systems",
+        "mobile and web applications"
+    ],
+    "additional": [
+        "I enjoy working in collaborative environments.",
+        "I'm passionate about creating accessible technology.",
+        "I've contributed to several open source projects.",
+        "I'm interested in ethical technology and responsible innovation.",
+        "I enjoy mentoring junior developers.",
+        "I have a background in design thinking.",
+        "I've worked in startups and enterprise environments.",
+        "I'm particularly interested in AI ethics.",
+        "I love solving complex algorithmic problems.",
+        "I focus on creating user-centered solutions.",
+        "I have experience leading small technical teams.",
+        "I'm self-taught and constantly learning new technologies.",
+        "I have a computer science degree but learned most of my skills on the job.",
+        "I'm currently transitioning careers into tech.",
+        "I'm an advocate for diversity in tech.",
+        "I've organized tech meetups and community events.",
+        "I'm interested in the intersection of technology and sustainability.",
+        "I have experience in both technical and business roles.",
+        "I'm passionate about making technology more accessible to everyone.",
+        "I enjoy the challenges of working with legacy systems.",
+        "",  # Empty for some participants
+    ]
+}
+
+# Non-technical components
+NON_TECH_COMPONENTS = {
+    "marketing_focus": [
+        "digital marketing", "content strategy", "brand development",
+        "social media campaigns", "event promotion", "growth hacking",
+        "community building", "influencer partnerships", "SEO/SEM",
+        "product marketing"
+    ],
+    "industry": [
+        "technology", "healthcare", "finance", "education", "retail",
+        "entertainment", "manufacturing", "non-profit", "government",
+        "hospitality"
+    ],
+    "years": [str(i) for i in range(1, 16)],
+    "pm_focus": [
+        "agile methodologies", "waterfall approaches", "hybrid frameworks",
+        "technical projects", "creative initiatives", "product launches",
+        "organizational change", "international teams", "startup environments",
+        "enterprise transformations"
+    ],
+    "startup_type": [
+        "tech", "social impact", "e-commerce", "healthcare", "education",
+        "fintech", "sustainability", "B2B SaaS", "consumer app", "AI/ML"
+    ],
+    "field": [
+        "Computer Science", "Business Administration", "Design", "Marketing",
+        "Engineering", "Data Science", "Psychology", "Communications",
+        "Information Technology", "Entrepreneurship"
+    ],
+    "university": [
+        "University of Toronto", "York University", "Ryerson University",
+        "Seneca College", "Humber College", "OCAD University",
+        "George Brown College", "McMaster University", "Waterloo University",
+        "Queen's University"
+    ],
+    "content_focus": [
+        "tech tutorials", "industry trends", "career development",
+        "product reviews", "educational content", "lifestyle and tech",
+        "startup stories", "coding challenges", "design inspiration",
+        "thought leadership"
+    ],
+    "sales_industry": [
+        "SaaS", "hardware", "consulting services", "enterprise solutions",
+        "consumer tech", "B2B technology", "telecommunications",
+        "cybersecurity", "cloud services", "digital transformation"
+    ],
+    "additional": [
+        "I'm excited to learn more about technology and how it can solve real problems.",
+        "I bring a unique perspective from my non-technical background.",
+        "I'm interested in the human aspects of technology.",
+        "I'm looking to collaborate with technical team members and contribute my skills.",
+        "I have strong communication and presentation skills.",
+        "I excel at understanding user needs and translating them into requirements.",
+        "I'm good at explaining complex concepts to diverse audiences.",
+        "I have experience managing stakeholder expectations.",
+        "I'm skilled at identifying market opportunities.",
+        "I enjoy bridging the gap between technical and non-technical teams.",
+        "I have a creative approach to problem-solving.",
+        "I'm passionate about user experience and accessibility.",
+        "I have a network of industry connections that could be valuable.",
+        "I'm experienced in gathering and synthesizing user feedback.",
+        "I'm interested in how technology can create social impact.",
+        "I have experience in project coordination and team organization.",
+        "I'm good at creating compelling narratives around technical products.",
+        "I'm curious about AI and its potential applications.",
+        "I have a background in psychology and understand human behavior.",
+        "I'm skilled at facilitating workshops and brainstorming sessions.",
+        "",  # Empty for some participants
+    ]
+}
+
+def generate_background(is_technical=True):
+    """Generate a realistic background for a participant."""
+    if is_technical:
+        template = random.choice(TECHNICAL_BACKGROUNDS)
+        components = STACK_COMPONENTS
+    else:
+        template = random.choice(NON_TECHNICAL_BACKGROUNDS)
+        components = NON_TECH_COMPONENTS
+    
+    # Fill in the template with random components
+    for key in components:
+        if "{" + key + "}" in template:
+            template = template.replace("{" + key + "}", random.choice(components[key]))
+    
+    return template
+
+def generate_linkedin_profile(name):
+    """Generate a realistic LinkedIn profile URL based on the name."""
+    # Remove spaces and special characters, convert to lowercase
+    name_part = ''.join(c for c in name if c.isalnum()).lower()
+    
+    # Add some randomness to ensure uniqueness
+    if random.random() < 0.3:
+        # Some people use just their name
+        profile = name_part
+    elif random.random() < 0.6:
+        # Some add a random number
+        profile = f"{name_part}{random.randint(1, 999)}"
+    else:
+        # Some add their profession or location
+        suffixes = ["dev", "tech", "to", "canada", "design", "pm", "product", "marketing", "ai"]
+        profile = f"{name_part}-{random.choice(suffixes)}"
+    
+    return f"linkedin.com/in/{profile}"
+
+def generate_participants(count=100):
+    """Generate a specified number of diverse hackathon participants."""
+    participants = []
+    
+    # Define the distribution of technical vs non-technical participants
+    # For a hackathon, we'll have more technical participants but still a good mix
+    technical_count = int(count * 0.7)  # 70% technical
+    non_technical_count = count - technical_count  # 30% non-technical
+    
+    # Generate technical participants
+    for _ in range(technical_count):
+        name = fake.name()
+        email = fake.email()
+        linkedin = generate_linkedin_profile(name)
+        background = generate_background(is_technical=True)
+        goals = random.choice(GOALS)
+        
+        participants.append({
+            "email": email,
+            "name": name,
+            "linkedin_profile": linkedin,
+            "background": background,
+            "goals": goals
+        })
+    
+    # Generate non-technical participants
+    for _ in range(non_technical_count):
+        name = fake.name()
+        email = fake.email()
+        linkedin = generate_linkedin_profile(name)
+        background = generate_background(is_technical=False)
+        goals = random.choice(GOALS)
+        
+        participants.append({
+            "email": email,
+            "name": name,
+            "linkedin_profile": linkedin,
+            "background": background,
+            "goals": goals
+        })
+    
+    # Shuffle the participants to mix technical and non-technical
+    random.shuffle(participants)
+    return participants
+
+def main():
+    """Main function to generate participants and save them to the database."""
+    print("Initializing database...")
+    initialize_database()
+    
+    print("Generating 100 diverse hackathon participants...")
+    participants = generate_participants(100)
+    
+    print("Adding participants to the database...")
+    for p in participants:
+        add_participant(p)
+    
+    print("Participants added successfully.")
+    
+    # Get and display a sample of the participants
+    df = get_participants_dataframe()
+    print(f"\nTotal participants in database: {len(df)}")
+    print("\nSample of participants:")
+    print(df.sample(5))
+
+if __name__ == "__main__":
+    # Check if Faker is installed
+    try:
+        import faker
+    except ImportError:
+        print("The 'faker' package is required but not installed.")
+        print("Please install it using: pip install faker")
+        sys.exit(1)
+    
+    main() 

hackathon_organizer/README.md

@@ -0,0 +1,95 @@
+# 🤖 AI-Powered HackBuddyAI
+
+This project is a web application that helps hackathon organizers automatically form balanced teams from a list of participants. It uses a `TinyCodeAgent` to analyze participant skills and goals, creating optimal teams based on criteria defined by the organizer.
+
+The application features a two-tab interface:
+1.  **Participant Registration**: A form for participants to submit their profile, including skills, background, and what they want to achieve during the hackathon.
+2.  **Organizer Dashboard**: A view for the organizer to see all registered participants, define matching criteria, and run the AI-powered team formation process.
+
+## Tech Stack
+-   **Backend**: Python
+-   **AI Agent Framework**: `TinyCodeAgent`
+-   **Web UI**: Gradio
+-   **Data Handling**: Pandas
+-   **Database**: SQLite
+
+---
+
+## Setup and Installation
+
+### 1. Prerequisites
+-   Python 3.8+
+-   An OpenAI API key
+
+### 2. Installation
+1.  **Clone the repository** (if applicable) or ensure you have the project files in a directory.
+
+2.  **Navigate to the project directory**:
+    ```bash
+    cd path/to/project
+    ```
+
+3.  **Create a virtual environment** (recommended):
+    ```bash
+    python -m venv venv
+    source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+    ```
+
+4.  **Install dependencies**:
+    The project relies on the `tinyagent` library. Assuming it is available in your environment, install the other required packages:
+    ```bash
+    pip install -r hackathon_organizer/requirements.txt
+    ```
+
+### 3. Configure Environment Variables
+You must set your OpenAI API key as an environment variable. The application will not run without it.
+
+-   **On macOS/Linux**:
+    ```bash
+    export OPENAI_API_KEY="your_api_key_here"
+    ```
+-   **On Windows (Command Prompt)**:
+    ```bash
+    set OPENAI_API_KEY="your_api_key_here"
+    ```
+
+---
+
+## 🚀 Running the Application
+
+Once the setup is complete, you can launch the Gradio web application using one of the following methods:
+
+### Method 1: Using the main script (recommended)
+
+```bash
+python main.py
+```
+
+This script handles all the necessary path configurations and launches the application.
+
+### Method 2: Running app.py directly
+
+```bash
+cd hackathon_organizer
+python app.py
+```
+
+Either method will start a local web server, and you can access the application at the URL provided in the console (usually `http://127.0.0.1:7860`).
+
+The application will create a `hackathon_participants.db` file in the working directory to store the participant data.
+
+---
+
+## 🧪 Running Tests
+
+The project includes unit tests for the database and the agent setup logic. The tests are located in the `tests/` directory.
+
+To run the tests:
+
+```bash
+# From the project root directory
+cd hackathon_organizer
+python -m unittest discover tests
+```
+
+The tests are designed to run without needing an active internet connection or a valid API key. They use mocks to simulate agent behavior and an in-memory database for testing database operations. 

hackathon_organizer/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'hackathon_organizer' directory a Python package. 

hackathon_organizer/app.py

@@ -0,0 +1,229 @@
+import gradio as gr
+import pandas as pd
+import asyncio
+import logging
+import sys
+import os
+import io
+
+# Change from absolute imports to relative imports
+from database import initialize_database, add_participant, get_participants_dataframe
+from matching_agent import create_matching_agent, run_matching
+from tinyagent.hooks.logging_manager import LoggingManager
+
+from tinyagent.hooks.logging_manager import LoggingManager
+import logging
+
+
+# --- Logging Setup ---
+log_manager = LoggingManager(default_level=logging.INFO)
+log_manager.set_levels({
+    'tinyagent.hooks.gradio_callback': logging.DEBUG,
+    'tinyagent.tiny_agent': logging.DEBUG,
+    'tinyagent.mcp_client': logging.DEBUG,
+    'tinyagent.code_agent': logging.DEBUG,
+})
+
+console_handler = logging.StreamHandler(sys.stdout)
+log_manager.configure_handler(
+    console_handler,
+    format_string='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.DEBUG
+)
+
+# Gradio log handler
+log_stream = io.StringIO()
+gradio_handler = logging.StreamHandler(log_stream)
+log_manager.configure_handler(
+    gradio_handler,
+    format_string='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
+    level=logging.DEBUG  # Capture detailed logs for the UI
+)
+
+logger = log_manager.get_logger('app')
+
+# --- Initial Setup ---
+logger.info("Initializing database...")
+initialize_database()
+
+# Check for API key
+if not os.environ.get("OPENAI_API_KEY"):
+    raise ValueError("The OPENAI_API_KEY environment variable is not set. Please set it before running the app.")
+
+logger.info("Creating matching agent...")
+agent = create_matching_agent(log_manager=log_manager)
+
+# --- Gradio UI Functions ---
+
+def register_participant(name, email, linkedin, background, goals):
+    """Callback function to register a new participant."""
+    if not all([name, email]):
+        return "Please provide at least a name and email.", get_participants_dataframe()
+    
+    participant_data = {
+        "name": name,
+        "email": email,
+        "linkedin_profile": linkedin,
+        "background": background,
+        "goals": goals
+    }
+    try:
+        add_participant(participant_data)
+        feedback = f"✅ Success! Participant '{name}' registered."
+        logger.info(f"Registered new participant: {email}")
+    except Exception as e:
+        feedback = f"❌ Error! Could not register participant. Reason: {e}"
+        logger.error(f"Failed to register participant {email}: {e}")
+        
+    return feedback, get_participants_dataframe()
+
+def refresh_participants_list():
+    """Callback to reload the participant data from the database."""
+    return get_participants_dataframe()
+
+async def run_matching_process(organizer_criteria, progress=gr.Progress(track_tqdm=True)):
+    """Async callback to run the team matching process, with live log streaming."""
+    # 1. Clear previous logs and show panel
+    log_stream.seek(0)
+    log_stream.truncate(0)
+    progress(0, desc="Initializing...")
+    yield {
+        log_panel: gr.update(visible=True, open=True),
+        log_output: "Starting matching process...\n",
+        matching_results_out: "🚀 Setting up the matching process..."
+    }
+
+    # 2. Get participants and perform initial checks
+    logger.info("Fetching participants...")
+    progress(0, desc="Fetching participants...")
+    participants_df = get_participants_dataframe()
+    if len(participants_df) < 2:
+        warning_msg = "Matching process aborted: not enough participants."
+        logger.warning(warning_msg)
+        yield {
+            log_panel: gr.update(),
+            log_output: log_stream.getvalue(),
+            matching_results_out: "Cannot run matching with fewer than 2 participants."
+        }
+        return
+
+    logger.info(f"Running matching for {len(participants_df)} participants.")
+    progress(0.2, desc="🧠 Agent is thinking...")
+    
+    # 3. Create a background task for the core matching logic
+    match_task = asyncio.create_task(
+        run_matching(agent, participants_df, organizer_criteria)
+    )
+
+    # 4. Stream logs while the agent works
+    while not match_task.done():
+        await asyncio.sleep(0.5)  # Poll for new logs every 0.5s
+        yield {
+            log_panel: gr.update(),
+            log_output: log_stream.getvalue(),
+            matching_results_out: gr.update()  # No change to final output yet
+        }
+
+    # 5. Process the final result from the agent
+    try:
+        final_report = await match_task
+        logger.info("Matching process completed successfully.")
+        progress(1.0, desc="✅ Done!")
+        yield {
+            log_panel: gr.update(),
+            log_output: log_stream.getvalue(),
+            matching_results_out: final_report
+        }
+    except Exception as e:
+        logger.error(f"An error occurred during the matching process: {e}", exc_info=True)
+        yield {
+            log_panel: gr.update(),
+            log_output: log_stream.getvalue(),
+            matching_results_out: f"An error occurred: {e}"
+        }
+
+# --- Gradio App Definition ---
+
+with gr.Blocks(theme=gr.themes.Default(
+    font=[gr.themes.GoogleFont("Inter"), "Arial", "sans-serif"]
+), title="HackBuddyAI") as app:
+    gr.Markdown("# 🤖 HackBuddyAI")
+    
+    with gr.Tabs():
+        with gr.TabItem("👤 Participant Registration"):
+            gr.Markdown("## Welcome, Participant!")
+            gr.Markdown("Fill out the form below to register for the hackathon.")
+            with gr.Row():
+                with gr.Column():
+                    name_in = gr.Textbox(label="Full Name")
+                    email_in = gr.Textbox(label="Email Address")
+                    linkedin_in = gr.Textbox(label="LinkedIn Profile URL", placeholder="Optional")
+                with gr.Column():
+                    background_in = gr.Textbox(label="Your Background & Skills", lines=5, placeholder="e.g., Python developer with 3 years of experience, specializing in Django and REST APIs...")
+                    goals_in = gr.Textbox(label="Your Goals for this Hackathon", lines=5, placeholder="e.g., I want to learn about machine learning and work on a cool data visualization project...")
+            
+            submit_button = gr.Button("Register", variant="primary")
+            registration_feedback = gr.Markdown()
+
+        with gr.TabItem("👑 Organizer Dashboard"):
+            gr.Markdown("## Welcome, Organizer!")
+            gr.Markdown("Here you can view registered participants and run the AI-powered team matching process.")
+            
+            with gr.Accordion("View Registered Participants", open=False):
+                refresh_button = gr.Button("🔄 Refresh List")
+                participants_df_out = gr.DataFrame(value=get_participants_dataframe, interactive=False)
+
+            gr.Markdown("### Run Matching")
+            organizer_criteria_in = gr.Textbox(
+                label="Matching Criteria", 
+                lines=4,
+                value="Create teams of 3. Try to balance skills in each team (e.g., frontend, backend, data).",
+                placeholder="Describe your ideal team composition..."
+            )
+            run_button = gr.Button("🚀 Run AI Matching", variant="primary")
+            
+            gr.Markdown("### 🤝 Matched Teams")
+            matching_results_out = gr.Markdown("Matching has not been run yet.")
+
+            with gr.Accordion("Agent Logs", open=False, visible=False) as log_panel:
+                log_output = gr.Code(
+                    label="Live Logs",
+                    lines=15,
+                    interactive=False,
+                )
+
+    gr.Markdown("<p align='center'>Powered by Tiny Agent</p>")
+
+    # --- Event Handlers ---
+    submit_button.click(
+        fn=register_participant,
+        inputs=[name_in, email_in, linkedin_in, background_in, goals_in],
+        outputs=[registration_feedback, participants_df_out]
+    )
+    
+    refresh_button.click(
+        fn=refresh_participants_list,
+        inputs=[],
+        outputs=[participants_df_out]
+    )
+
+    run_button.click(
+        fn=run_matching_process,
+        inputs=[organizer_criteria_in],
+        outputs=[matching_results_out, log_output, log_panel]
+    )
+
+# --- Launching the App ---
+if __name__ == "__main__":
+    try:
+        logger.info("Launching Gradio app...")
+        # queue() is important for handling multiple users and async calls
+        app.queue().launch(share=False)
+    except KeyboardInterrupt:
+        logger.info("Gradio app shutting down.")
+    finally:
+        # Clean up agent resources
+        logger.info("Closing agent resources...")
+        # We need to run the async close method
+        asyncio.run(agent.close())
+        logger.info("Cleanup complete.") 

hackathon_organizer/database.py

@@ -0,0 +1,95 @@
+import sqlite3
+import pandas as pd
+from typing import Dict, Any, List
+
+DB_PATH = "hackathon_participants.db"
+TABLE_NAME = "participants"
+
+def initialize_database():
+    """
+    Initializes the database and creates the participants table if it doesn't exist.
+    """
+    with sqlite3.connect(DB_PATH) as conn:
+        cursor = conn.cursor()
+        cursor.execute(f"""
+            CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
+                email TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                linkedin_profile TEXT,
+                background TEXT,
+                goals TEXT
+            )
+        """)
+        conn.commit()
+
+def add_participant(participant: Dict[str, Any]):
+    """
+    Adds a new participant to the database.
+
+    Args:
+        participant: A dictionary containing participant data.
+                     Keys should be 'email', 'name', 'linkedin_profile', 'background', 'goals'.
+    """
+    with sqlite3.connect(DB_PATH) as conn:
+        cursor = conn.cursor()
+        cursor.execute(f"""
+            INSERT OR REPLACE INTO {TABLE_NAME} (email, name, linkedin_profile, background, goals)
+            VALUES (:email, :name, :linkedin_profile, :background, :goals)
+        """, participant)
+        conn.commit()
+
+def get_participants_dataframe() -> pd.DataFrame:
+    """
+    Retrieves all participants from the database and returns them as a pandas DataFrame.
+
+    Returns:
+        A pandas DataFrame containing all participant data.
+    """
+    with sqlite3.connect(DB_PATH) as conn:
+        df = pd.read_sql_query(f"SELECT * FROM {TABLE_NAME}", conn)
+    return df
+
+if __name__ == '__main__':
+    # Example usage and basic test
+    print("Initializing database...")
+    initialize_database()
+    print("Database initialized.")
+
+    # Sample participants
+    participants_to_add = [
+        {
+            "email": "[email protected]",
+            "name": "Alice Wonderland",
+            "linkedin_profile": "linkedin.com/in/alicew",
+            "background": "5 years of experience in frontend development with React and TypeScript. Interested in UI/UX design.",
+            "goals": "I want to build a cool project for my portfolio and learn about backend development."
+        },
+        {
+            "email": "[email protected]",
+            "name": "Bob Builder",
+            "linkedin_profile": "linkedin.com/in/bobb",
+            "background": "Backend developer specializing in Python, Django, and PostgreSQL. I'm also a DevOps enthusiast.",
+            "goals": "Looking to work on a challenging problem, maybe involving infrastructure or data engineering."
+        },
+        {
+            "email": "[email protected]",
+            "name": "Charlie Chocolate",
+            "linkedin_profile": "linkedin.com/in/charliec",
+            "background": "Data scientist with expertise in Python, Pandas, Scikit-learn, and TensorFlow. I love creating predictive models.",
+            "goals": "I hope to apply my machine learning skills to a real-world problem and collaborate with a diverse team."
+        }
+    ]
+
+    print(f"Adding {len(participants_to_add)} participants...")
+    for p in participants_to_add:
+        add_participant(p)
+    print("Participants added.")
+
+    print("\nRetrieving all participants:")
+    df = get_participants_dataframe()
+    print(df)
+    
+    # Verify data
+    assert len(df) == 3
+    assert "[email protected]" in df["email"].values
+    print("\nData verified successfully.") 

hackathon_organizer/matching_agent.py

@@ -0,0 +1,101 @@
+import os
+import pandas as pd
+from tinyagent import TinyCodeAgent
+from textwrap import dedent
+
+organizer_prompt = dedent("""
+    You are a brilliant hackathon team-matching AI.
+    Your task is to form teams from a list of participants provided in a pandas DataFrame.
+    You will be given the DataFrame in a variable named `participants_df`.
+    You will also be given the organizer's criteria in a variable named `organizer_criteria`.
+
+    Your goal is to write and execute Python code using the `run_python` tool to group these participants into balanced teams.
+
+    Follow these steps:
+    1.  **Analyze the Data**: Inspect the `participants_df` DataFrame to understand the skills, backgrounds, and goals of the participants.
+    2.  **Plan Your Logic**: Based on the `organizer_criteria`, decide on a strategy for forming teams. Consider things like team size, skill diversity (e.g., frontend, backend, data science), and aligning participants' goals.
+    3.  **Implement the Matching**: Write Python code to create the teams. You can iterate through the DataFrame, use clustering algorithms, or any other method you see fit. Your code should produce a list of teams, where each team is a list of participant dictionaries.
+    4.  **Format the Output**: Once you have the teams, your final step is to generate a user-friendly report in Markdown format. For each team, list the members and write a brief, one-sentence justification for why they are a good match, based on their combined skills and goals.
+
+    Example of final output format:
+
+    ```markdown
+    ## Team 1
+
+    *   **Alice Wonderland** (Frontend, React)
+    *   **Bob Builder** (Backend, Python)
+    *   **Charlie Chocolate** (Data Science)
+
+    **Justification**: This team has a strong, well-rounded skill set covering frontend, backend, and data science, making them capable of building a full-stack application.
+    ```
+
+    Do not ask for feedback. Execute the plan and provide the final Markdown report using the `final_answer` tool.
+    I can only see the final answer, not what happens in tool calls, so provide the full report in the final answer. Do not truncate team information
+    """)
+
+def create_matching_agent(log_manager=None) -> TinyCodeAgent:
+    """
+    Initializes and configures a TinyCodeAgent for matching hackathon participants.
+
+    Args:
+        log_manager: An optional logging manager instance.
+
+    Returns:
+        A configured TinyCodeAgent instance.
+    """
+    # Create the agent without the system_prompt parameter
+    agent = TinyCodeAgent(
+        model="gpt-4.1-mini",
+        api_key=os.environ.get("OPENAI_API_KEY"),
+        log_manager=log_manager,
+        pip_packages=["pandas", "numpy", "scikit-learn"],
+        #authorized_imports=["pandas", "numpy", "io", "base64","collections","itertools"],
+        local_execution=False, # Use remote Modal for security by default
+    )
+    
+    # Set the system prompt separately
+    
+    
+    return agent
+
+async def run_matching(
+    agent: TinyCodeAgent,
+    participants_df: pd.DataFrame,
+    organizer_criteria: str
+) -> str:
+    """
+    Runs the matching process using the configured agent.
+
+    Args:
+        agent: The TinyCodeAgent instance.
+        participants_df: A DataFrame with participant data.
+        organizer_criteria: A string containing the organizer's preferences.
+
+    Returns:
+        The final markdown report of the matched teams.
+    """
+    # Set the participant data and criteria as variables for the agent's environment
+    print(participants_df.head())
+    agent.set_user_variables({
+        "participants_df": participants_df,
+        "organizer_criteria": organizer_criteria
+    })    
+
+    # The user prompt is simple, as the main instructions are in the system prompt
+    task = dedent("""
+                                  
+    You are a brilliant hackathon team-matching AI.
+    Your task is to form teams from a list of participants provided in a pandas DataFrame.
+    You will be given the DataFrame in a variable named `participants_df`.
+
+    Your goal is to write and execute Python code using the `run_python` tool to group these participants into balanced teams.""")
+
+
+    task = organizer_prompt+'\n\n'
+
+    task += ("Form the teams based on the provided data and criteria."
+                   f"\n<Organizer Criteria>\n{organizer_criteria}\n</Organizer Criteria>")
+    
+    final_report = await agent.run(task, max_turns=15)
+    print(agent.messages)
+    return final_report 

hackathon_organizer/requirements.txt

@@ -0,0 +1,7 @@
+tinyagent-py[all]==0.0.12
+cloudpickle
+modal
+jinja2
+pyyaml
+gradio[mcp]
+pandas

hackathon_organizer/tests/__init__.py

@@ -0,0 +1 @@
+# This file allows the 'tests' directory to be discovered as a package. 

main.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+Hackathon Team Organizer - Main Entry Point
+
+This script launches the Hackathon Team Organizer application.
+It ensures the working directory is set correctly before running the app.
+"""
+import os
+import sys
+import subprocess
+
+def main():
+    # Get the directory where this script is located
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    
+    # Change to the script directory to ensure relative paths work
+    os.chdir(script_dir)
+    
+    # Add the current directory to the Python path
+    sys.path.insert(0, script_dir)
+    
+    print("Starting Hackathon Team Organizer...")
+    print(f"Working directory: {os.getcwd()}")
+    
+    # Check for OpenAI API key
+    if not os.environ.get("OPENAI_API_KEY"):
+        print("\n⚠️  WARNING: OPENAI_API_KEY environment variable is not set!")
+        print("The application requires an OpenAI API key to function properly.")
+        print("Please set it using:")
+        print("  export OPENAI_API_KEY='your-api-key'  (macOS/Linux)")
+        print("  set OPENAI_API_KEY='your-api-key'     (Windows)\n")
+        print("Running simplified version without AI matching...")
+        app_script = "hackathon_organizer/app_simple.py"
+    else:
+        print("OpenAI API key found. Running full version with AI matching...")
+        app_script = "hackathon_organizer/app.py"
+    
+    # Run the application
+    try:
+        print(f"Launching application: {app_script}")
+        subprocess.run([sys.executable, app_script], check=True)
+    except KeyboardInterrupt:
+        print("\nApplication stopped by user.")
+    except subprocess.CalledProcessError as e:
+        print(f"\nError running the application: {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nUnexpected error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

product_manager/organizer.md

@@ -0,0 +1,37 @@
+
+#HackBuddyAI
+
+Gradio APP for Hackathon Organizer
+
+## Problem
+Many people join hackathons individually, and they need to be matched with other individuals to form a team. If the formed team is not suitable, non-of the team members will benefit from the hackathon, they will churn and not participate in the next hackathon.
+
+- Help individuals find the right team
+- If a selected team is not suitable, or some of participants didn't show up, the organizer could re-run the matching process to find a new team in no time.
+
+## Solution
+1. Web application for participants to fill their profile and goals, e_mail field to be used as a unique identifier, link to their linkedin profile, text field (multilined) for their background, skills, why they like to join the hackathon, etc.
+
+### 2. On form submission, the data will be stored in a database/ Google Sheet / SQLite
+
+### 3. Organizer part:
+Organizer could define custom system prompt, to navigate the system for matching the participants, for example group size, why organizer looks to have in each group, etc.
+
+### 4. Matching Proccess, 
+AI Agent, will have access to pandas dataframe, including the participants data and organizer prefrences for matching.
+It use its python code execution tool to actually interact with the data, and match the participants based on defined criteria.
+
+## End result
+List of teams with their members, and a short description why they are a good match. in Markdown format.
+
+
+## Tech Stack
+- Gradio
+- Tiny Agent
+- Tiny Code Agent
+- Pandas
+
+for developing the agent part we use tiny agent library, you have access to the documentation in the LLM_API_DOC.md file.
+
+For the frontend we use gradio, gradio has an integration with tiny agent as well. 
+

requirements.txt

@@ -0,0 +1,6 @@
+tinyagent-py[all]==0.0.12
+cloudpickle
+modal
+jinja2
+pyyaml
+gradio[mcp]