Convert project to Gradio app for Hugging Face Spaces deployment

- Create app.py with full Gradio interface for AI Co-Scientist system
- Add Gradio to requirements.txt replacing FastAPI/Uvicorn
- Implement comprehensive UI with research goal input, advanced settings
- Add automatic environment detection and cost control for HF Spaces
- Create README_HF.md with proper HF Spaces metadata and documentation
- Add deployment guide in docs/huggingface_deployment.md
- Create test suite in tests/test_gradio.py with full validation
- Maintain all existing functionality: hypothesis generation, evolution, ranking
- Add literature integration with arXiv search and paper display
- Include deployment status banner and model filtering
- Support both local development and production deployment modes

README_HF.md

@@ -0,0 +1,86 @@
+---
+title: AI Co-Scientist
+emoji: 🔬
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: Generate, review, rank, and evolve research hypotheses using AI agents
+---
+
+# 🔬 AI Co-Scientist - Hypothesis Evolution System
+
+An AI-powered system for generating, reviewing, ranking, and evolving research hypotheses using multiple AI agents. This system helps researchers explore research spaces and identify promising hypotheses through iterative refinement.
+
+## 🚀 Features
+
+- **Multi-Agent System**: Uses specialized AI agents for generation, reflection, ranking, evolution, and meta-review
+- **Hypothesis Evolution**: Combines top-performing hypotheses to create improved versions
+- **Literature Integration**: Automatically finds related arXiv papers for your research topic
+- **Cost Control**: Automatically filters to cost-effective models in production deployment
+- **Interactive Interface**: Easy-to-use Gradio interface with advanced settings
+
+## 🎯 How to Use
+
+1. **Enter Research Goal**: Describe what you want to research in the text area
+2. **Adjust Settings** (optional): Expand "Advanced Settings" to customize:
+   - LLM model selection
+   - Number of hypotheses per cycle
+   - Temperature settings for creativity vs. analysis
+   - Ranking and evolution parameters
+3. **Set Goal**: Click "Set Research Goal" to initialize the system
+4. **Run Cycles**: Click "Run Cycle" to generate and evolve hypotheses iteratively
+
+## 🧠 How It Works
+
+The system uses a multi-agent approach:
+
+1. **Generation Agent**: Creates new research hypotheses
+2. **Reflection Agent**: Reviews and assesses hypotheses for novelty and feasibility
+3. **Ranking Agent**: Uses Elo rating system to rank hypotheses
+4. **Evolution Agent**: Combines top hypotheses to create improved versions
+5. **Proximity Agent**: Analyzes similarity between hypotheses
+6. **Meta-Review Agent**: Provides overall critique and suggests next steps
+
+## 📚 Literature Integration
+
+- Automatically searches arXiv for papers related to your research goal
+- Displays relevant papers with full metadata, abstracts, and links
+- Helps contextualize generated hypotheses within existing research
+
+## 💡 Example Research Goals
+
+- "Develop new methods for increasing the efficiency of solar panels"
+- "Create novel approaches to treat Alzheimer's disease"
+- "Design sustainable materials for construction"
+- "Improve machine learning model interpretability"
+- "Develop new quantum computing algorithms"
+
+## ⚙️ Technical Details
+
+- **Models**: Uses OpenRouter API with cost-effective models in production
+- **Environment Detection**: Automatically detects Hugging Face Spaces deployment
+- **Cost Control**: Filters to budget-friendly models (Gemini Flash, GPT-3.5-turbo, Claude Haiku, etc.)
+- **Iterative Process**: Each cycle builds on previous results for continuous improvement
+
+## 🔧 Configuration
+
+The system automatically configures itself based on the deployment environment:
+
+- **Production (HF Spaces)**: Limited to cost-effective models for budget control
+- **Development**: Full access to all available models
+
+## 📖 Research Paper
+
+Based on the AI Co-Scientist research: https://storage.googleapis.com/coscientist_paper/ai_coscientist.pdf
+
+## 🤝 Contributing
+
+This is an open-source project. Feel free to contribute improvements, bug fixes, or new features.
+
+## ⚠️ Note
+
+This system requires an OpenRouter API key to function. The public demo uses a limited budget, so please use it responsibly. For extensive research, consider running your own instance with your API key.

app.py

@@ -0,0 +1,414 @@
+import gradio as gr
+import os
+import json
+import time
+from typing import List, Dict, Optional, Tuple
+import logging
+
+# Import the existing app components
+from app.models import ResearchGoal, ContextMemory
+from app.agents import SupervisorAgent
+from app.utils import logger, is_huggingface_space, get_deployment_environment
+from app.tools.arxiv_search import ArxivSearchTool
+import requests
+
+# Global state for the Gradio app
+global_context = ContextMemory()
+supervisor = SupervisorAgent()
+current_research_goal: Optional[ResearchGoal] = None
+available_models: List[str] = []
+
+# Configure logging for Gradio
+logging.basicConfig(level=logging.INFO)
+
+def fetch_available_models():
+    """Fetch available models from OpenRouter with environment-based filtering."""
+    global available_models
+    
+    # Detect deployment environment
+    deployment_env = get_deployment_environment()
+    is_hf_spaces = is_huggingface_space()
+    
+    logger.info(f"Detected deployment environment: {deployment_env}")
+    logger.info(f"Is Hugging Face Spaces: {is_hf_spaces}")
+    
+    # Define cost-effective models for production deployment
+    ALLOWED_MODELS_PRODUCTION = [
+        "google/gemini-2.0-flash-001",
+        "google/gemini-flash-1.5",
+        "openai/gpt-3.5-turbo",
+        "anthropic/claude-3-haiku",
+        "meta-llama/llama-3.1-8b-instruct",
+        "mistralai/mistral-7b-instruct",
+        "microsoft/phi-3-mini-4k-instruct"
+    ]
+    
+    try:
+        response = requests.get("https://openrouter.ai/api/v1/models", timeout=10)
+        response.raise_for_status()
+        models_data = response.json().get("data", [])
+        
+        # Extract all model IDs
+        all_models = sorted([model.get("id") for model in models_data if model.get("id")])
+        
+        # Apply filtering based on environment
+        if is_hf_spaces:
+            # Filter to only cost-effective models in HF Spaces
+            available_models = [model for model in all_models if model in ALLOWED_MODELS_PRODUCTION]
+            logger.info(f"Hugging Face Spaces: Filtered to {len(available_models)} cost-effective models")
+        else:
+            # Use all models in local/development environment
+            available_models = all_models
+            logger.info(f"Local/Development: Using all {len(available_models)} models")
+            
+    except Exception as e:
+        logger.error(f"Failed to fetch models from OpenRouter: {e}")
+        # Fallback to safe defaults
+        available_models = ALLOWED_MODELS_PRODUCTION if is_hf_spaces else ["google/gemini-2.0-flash-001"]
+    
+    return available_models
+
+def get_deployment_status():
+    """Get deployment status information."""
+    deployment_env = get_deployment_environment()
+    is_hf_spaces = is_huggingface_space()
+    
+    if is_hf_spaces:
+        status = f"🚀 Running in {deployment_env} | Models filtered for cost control ({len(available_models)} available)"
+        color = "orange"
+    else:
+        status = f"💻 Running in {deployment_env} | All models available ({len(available_models)} total)"
+        color = "blue"
+    
+    return status, color
+
+def set_research_goal(
+    description: str,
+    llm_model: str = None,
+    num_hypotheses: int = 3,
+    generation_temperature: float = 0.7,
+    reflection_temperature: float = 0.5,
+    elo_k_factor: int = 32,
+    top_k_hypotheses: int = 2
+) -> Tuple[str, str]:
+    """Set the research goal and initialize the system."""
+    global current_research_goal, global_context
+    
+    if not description.strip():
+        return "❌ Error: Please enter a research goal.", ""
+    
+    try:
+        # Create research goal with settings
+        current_research_goal = ResearchGoal(
+            description=description.strip(),
+            constraints={},
+            llm_model=llm_model if llm_model and llm_model != "-- Select Model --" else None,
+            num_hypotheses=num_hypotheses,
+            generation_temperature=generation_temperature,
+            reflection_temperature=reflection_temperature,
+            elo_k_factor=elo_k_factor,
+            top_k_hypotheses=top_k_hypotheses
+        )
+        
+        # Reset context
+        global_context = ContextMemory()
+        
+        logger.info(f"Research goal set: {description}")
+        logger.info(f"Settings: model={current_research_goal.llm_model}, num={current_research_goal.num_hypotheses}")
+        
+        status_msg = f"✅ Research goal set successfully!\n\n**Goal:** {description}\n**Model:** {current_research_goal.llm_model or 'Default'}\n**Hypotheses per cycle:** {num_hypotheses}"
+        
+        return status_msg, "Ready to run first cycle. Click 'Run Cycle' to begin."
+        
+    except Exception as e:
+        error_msg = f"❌ Error setting research goal: {str(e)}"
+        logger.error(error_msg)
+        return error_msg, ""
+
+def run_cycle() -> Tuple[str, str, str]:
+    """Run a single research cycle."""
+    global current_research_goal, global_context, supervisor
+    
+    if not current_research_goal:
+        return "❌ Error: No research goal set. Please set a research goal first.", "", ""
+    
+    try:
+        iteration = global_context.iteration_number + 1
+        logger.info(f"Running cycle {iteration}")
+        
+        # Run the cycle
+        cycle_details = supervisor.run_cycle(current_research_goal, global_context)
+        
+        # Format results for display
+        results_html = format_cycle_results(cycle_details)
+        
+        # Get references
+        references_html = get_references_html(cycle_details)
+        
+        # Status message
+        status_msg = f"✅ Cycle {iteration} completed successfully!"
+        
+        return status_msg, results_html, references_html
+        
+    except Exception as e:
+        error_msg = f"❌ Error during cycle execution: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        return error_msg, "", ""
+
+def format_cycle_results(cycle_details: Dict) -> str:
+    """Format cycle results as HTML."""
+    html = f"<h2>🔬 Iteration {cycle_details.get('iteration', 'Unknown')}</h2>"
+    
+    # Meta-review
+    if cycle_details.get('meta_review'):
+        meta_review = cycle_details['meta_review']
+        html += "<h3>📋 Meta-Review</h3>"
+        
+        if meta_review.get('meta_review_critique'):
+            html += "<h4>Critique:</h4><ul>"
+            for critique in meta_review['meta_review_critique']:
+                html += f"<li>{critique}</li>"
+            html += "</ul>"
+        
+        if meta_review.get('research_overview', {}).get('suggested_next_steps'):
+            html += "<h4>Suggested Next Steps:</h4><ul>"
+            for step in meta_review['research_overview']['suggested_next_steps']:
+                html += f"<li>{step}</li>"
+            html += "</ul>"
+    
+    # Hypotheses from different steps
+    all_hypotheses = []
+    for step_name, step_data in cycle_details.get('steps', {}).items():
+        if step_data.get('hypotheses'):
+            all_hypotheses.extend(step_data['hypotheses'])
+    
+    if all_hypotheses:
+        # Sort by Elo score
+        all_hypotheses.sort(key=lambda h: h.get('elo_score', 0), reverse=True)
+        
+        html += "<h3>🧠 Top Hypotheses</h3>"
+        for i, hypo in enumerate(all_hypotheses[:10]):  # Show top 10
+            html += f"""
+            <div style="border: 1px solid #ddd; padding: 15px; margin: 10px 0; border-radius: 8px; background-color: #f9f9f9;">
+                <h4>#{i+1}: {hypo.get('title', 'Untitled')}</h4>
+                <p><strong>ID:</strong> {hypo.get('id', 'Unknown')} | 
+                   <strong>Elo Score:</strong> {hypo.get('elo_score', 0):.2f}</p>
+                <p><strong>Description:</strong> {hypo.get('text', 'No description')}</p>
+                <p><strong>Novelty:</strong> {hypo.get('novelty_review', 'Not assessed')} | 
+                   <strong>Feasibility:</strong> {hypo.get('feasibility_review', 'Not assessed')}</p>
+            </div>
+            """
+    
+    return html
+
+def get_references_html(cycle_details: Dict) -> str:
+    """Get references HTML for the cycle."""
+    try:
+        # Search for arXiv papers related to the research goal
+        if current_research_goal and current_research_goal.description:
+            arxiv_tool = ArxivSearchTool(max_results=5)
+            papers = arxiv_tool.search_papers(
+                query=current_research_goal.description,
+                max_results=5,
+                sort_by="relevance"
+            )
+            
+            if papers:
+                html = "<h3>📚 Related arXiv Papers</h3>"
+                for paper in papers:
+                    html += f"""
+                    <div style="border: 1px solid #e0e0e0; padding: 15px; margin: 10px 0; border-radius: 8px; background-color: #fafafa;">
+                        <h4>{paper.get('title', 'Untitled')}</h4>
+                        <p><strong>Authors:</strong> {', '.join(paper.get('authors', [])[:5])}</p>
+                        <p><strong>arXiv ID:</strong> {paper.get('arxiv_id', 'Unknown')} | 
+                           <strong>Published:</strong> {paper.get('published', 'Unknown')}</p>
+                        <p><strong>Abstract:</strong> {paper.get('abstract', 'No abstract')[:300]}...</p>
+                        <p>
+                            <a href="{paper.get('arxiv_url', '#')}" target="_blank">📄 View on arXiv</a> | 
+                            <a href="{paper.get('pdf_url', '#')}" target="_blank">📁 Download PDF</a>
+                        </p>
+                    </div>
+                    """
+                return html
+            else:
+                return "<p>No related arXiv papers found.</p>"
+        else:
+            return "<p>No research goal set for reference search.</p>"
+            
+    except Exception as e:
+        logger.error(f"Error fetching references: {e}")
+        return f"<p>Error loading references: {str(e)}</p>"
+
+def create_gradio_interface():
+    """Create the Gradio interface."""
+    
+    # Fetch models on startup
+    fetch_available_models()
+    
+    # Get deployment status
+    status_text, status_color = get_deployment_status()
+    
+    with gr.Blocks(
+        title="AI Co-Scientist - Hypothesis Evolution System",
+        theme=gr.themes.Soft(),
+        css="""
+        .status-box {
+            padding: 10px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            font-weight: bold;
+        }
+        .orange { background-color: #fff3cd; border: 1px solid #ffeaa7; }
+        .blue { background-color: #d1ecf1; border: 1px solid #bee5eb; }
+        """
+    ) as demo:
+        
+        # Header
+        gr.Markdown("# 🔬 AI Co-Scientist - Hypothesis Evolution System")
+        gr.Markdown("Generate, review, rank, and evolve research hypotheses using AI agents.")
+        
+        # Deployment status
+        gr.HTML(f'<div class="status-box {status_color}">🔧 Deployment Status: {status_text}</div>')
+        
+        # Main interface
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Research goal input
+                research_goal_input = gr.Textbox(
+                    label="Research Goal",
+                    placeholder="Enter your research goal (e.g., 'Develop new methods for increasing the efficiency of solar panels')",
+                    lines=3
+                )
+                
+                # Advanced settings
+                with gr.Accordion("⚙️ Advanced Settings", open=False):
+                    model_dropdown = gr.Dropdown(
+                        choices=["-- Select Model --"] + available_models,
+                        value="-- Select Model --",
+                        label="LLM Model",
+                        info="Leave as default to use system default model"
+                    )
+                    
+                    with gr.Row():
+                        num_hypotheses = gr.Slider(
+                            minimum=1, maximum=10, value=3, step=1,
+                            label="Hypotheses per Cycle"
+                        )
+                        top_k_hypotheses = gr.Slider(
+                            minimum=2, maximum=5, value=2, step=1,
+                            label="Top K for Evolution"
+                        )
+                    
+                    with gr.Row():
+                        generation_temp = gr.Slider(
+                            minimum=0.1, maximum=1.0, value=0.7, step=0.1,
+                            label="Generation Temperature (Creativity)"
+                        )
+                        reflection_temp = gr.Slider(
+                            minimum=0.1, maximum=1.0, value=0.5, step=0.1,
+                            label="Reflection Temperature (Analysis)"
+                        )
+                    
+                    elo_k_factor = gr.Slider(
+                        minimum=1, maximum=100, value=32, step=1,
+                        label="Elo K-Factor (Ranking Sensitivity)"
+                    )
+                
+                # Action buttons
+                with gr.Row():
+                    set_goal_btn = gr.Button("🎯 Set Research Goal", variant="primary")
+                    run_cycle_btn = gr.Button("🔄 Run Cycle", variant="secondary")
+                
+                # Status display
+                status_output = gr.Textbox(
+                    label="Status",
+                    value="Enter a research goal and click 'Set Research Goal' to begin.",
+                    interactive=False,
+                    lines=3
+                )
+            
+            with gr.Column(scale=1):
+                # Instructions
+                gr.Markdown("""
+                ### 📖 Instructions
+                
+                1. **Enter Research Goal**: Describe what you want to research
+                2. **Adjust Settings** (optional): Customize model and parameters
+                3. **Set Goal**: Click to initialize the system
+                4. **Run Cycles**: Generate and evolve hypotheses iteratively
+                
+                ### 💡 Tips
+                - Start with 3-5 hypotheses per cycle
+                - Higher generation temperature = more creative ideas
+                - Lower reflection temperature = more analytical reviews
+                - Each cycle builds on previous results
+                """)
+        
+        # Results section
+        with gr.Row():
+            with gr.Column():
+                results_output = gr.HTML(
+                    label="Results",
+                    value="<p>Results will appear here after running cycles.</p>"
+                )
+        
+        # References section
+        with gr.Row():
+            with gr.Column():
+                references_output = gr.HTML(
+                    label="References",
+                    value="<p>Related research papers will appear here.</p>"
+                )
+        
+        # Event handlers
+        set_goal_btn.click(
+            fn=set_research_goal,
+            inputs=[
+                research_goal_input,
+                model_dropdown,
+                num_hypotheses,
+                generation_temp,
+                reflection_temp,
+                elo_k_factor,
+                top_k_hypotheses
+            ],
+            outputs=[status_output, results_output]
+        )
+        
+        run_cycle_btn.click(
+            fn=run_cycle,
+            inputs=[],
+            outputs=[status_output, results_output, references_output]
+        )
+        
+        # Example inputs
+        gr.Examples(
+            examples=[
+                ["Develop new methods for increasing the efficiency of solar panels"],
+                ["Create novel approaches to treat Alzheimer's disease"],
+                ["Design sustainable materials for construction"],
+                ["Improve machine learning model interpretability"],
+                ["Develop new quantum computing algorithms"]
+            ],
+            inputs=[research_goal_input],
+            label="Example Research Goals"
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    # Check for API key
+    if not os.getenv("OPENROUTER_API_KEY"):
+        print("⚠️  Warning: OPENROUTER_API_KEY environment variable not set.")
+        print("The app will start but may not function properly without an API key.")
+    
+    # Create and launch the Gradio app
+    demo = create_gradio_interface()
+    
+    # Launch with appropriate settings for HF Spaces
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

docs/huggingface_deployment.md

@@ -0,0 +1,191 @@
+# Hugging Face Spaces Deployment Guide
+
+This guide explains how to deploy the AI Co-Scientist system as a Gradio app on Hugging Face Spaces.
+
+## 📋 Prerequisites
+
+1. **Hugging Face Account**: Create an account at [huggingface.co](https://huggingface.co)
+2. **OpenRouter API Key**: Get an API key from [openrouter.ai](https://openrouter.ai) with sufficient balance ($5+ recommended)
+
+## 🚀 Deployment Steps
+
+### Step 1: Create a New Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Fill in the details:
+   - **Space name**: `ai-co-scientist` (or your preferred name)
+   - **License**: MIT
+   - **SDK**: Gradio
+   - **Hardware**: CPU Basic (free tier is sufficient)
+   - **Visibility**: Public or Private (your choice)
+
+### Step 2: Upload Files
+
+Upload these files to your Space:
+
+1. **README.md**: Copy content from `README_HF.md` in this repository
+2. **app.py**: The main Gradio application file
+3. **requirements.txt**: Python dependencies
+4. **app/**: The entire app directory with all Python modules
+
+**File Structure in HF Space:**
+```
+your-space/
+├── README.md          # Copy from README_HF.md
+├── app.py             # Main Gradio app
+├── requirements.txt   # Dependencies
+└── app/               # Application modules
+    ├── __init__.py
+    ├── agents.py
+    ├── api.py
+    ├── config.py
+    ├── main.py
+    ├── models.py
+    ├── utils.py
+    └── tools/
+        ├── __init__.py
+        └── arxiv_search.py
+```
+
+### Step 3: Configure Environment Variables
+
+1. In your Space, go to **Settings** → **Variables and secrets**
+2. Add a new secret:
+   - **Name**: `OPENROUTER_API_KEY`
+   - **Value**: Your OpenRouter API key
+   - **Type**: Secret (not visible to others)
+
+### Step 4: Deploy
+
+1. Commit your changes in the Space
+2. The Space will automatically build and deploy
+3. Wait for the build to complete (usually 2-5 minutes)
+
+## 🔧 Configuration Details
+
+### Automatic Environment Detection
+
+The app automatically detects when running in Hugging Face Spaces using these environment variables:
+- `SPACE_ID`
+- `SPACE_AUTHOR_NAME`
+- `SPACE_REPO_NAME`
+
+### Cost Control Features
+
+When deployed to HF Spaces, the app automatically:
+- Filters to cost-effective models only (7 models vs. all available)
+- Shows deployment status banner
+- Limits expensive model access to protect your API budget
+
+**Allowed Models in Production:**
+- `google/gemini-2.0-flash-001`
+- `google/gemini-flash-1.5`
+- `openai/gpt-3.5-turbo`
+- `anthropic/claude-3-haiku`
+- `meta-llama/llama-3.1-8b-instruct`
+- `mistralai/mistral-7b-instruct`
+- `microsoft/phi-3-mini-4k-instruct`
+
+## 🧪 Testing Before Deployment
+
+Run the test suite locally to verify everything works:
+
+```bash
+# From project root
+python tests/test_gradio.py
+```
+
+Or test the Gradio app locally:
+
+```bash
+# Set your API key
+export OPENROUTER_API_KEY=your_key_here
+
+# Run the app
+python app.py
+```
+
+## 📊 Usage Monitoring
+
+### Cost Monitoring
+- Each research cycle typically costs $0.10-$0.50
+- Monitor your OpenRouter usage at [openrouter.ai/activity](https://openrouter.ai/activity)
+- Set up billing alerts in OpenRouter dashboard
+
+### Space Analytics
+- View usage statistics in your HF Space settings
+- Monitor app performance and user interactions
+
+## 🔒 Security Considerations
+
+### API Key Protection
+- ✅ **DO**: Store API key as a secret in HF Spaces
+- ❌ **DON'T**: Include API key in code or README
+- ❌ **DON'T**: Share your API key publicly
+
+### Rate Limiting
+- The app includes automatic model filtering for cost control
+- Consider implementing additional rate limiting for high-traffic scenarios
+- Monitor usage patterns and adjust as needed
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**1. "Module not found" errors**
+- Ensure all files in the `app/` directory are uploaded
+- Check that `__init__.py` files are present
+
+**2. "API key not found" errors**
+- Verify `OPENROUTER_API_KEY` is set as a secret in Space settings
+- Check that the secret name matches exactly
+
+**3. "Insufficient funds" errors**
+- Add balance to your OpenRouter account
+- Verify your API key has access to the models being used
+
+**4. App won't start**
+- Check the Space logs for detailed error messages
+- Ensure `requirements.txt` includes all dependencies
+- Verify Python syntax in uploaded files
+
+### Debugging Steps
+
+1. **Check Space Logs**: View build and runtime logs in the Space interface
+2. **Test Locally**: Run `python tests/test_gradio.py` to verify setup
+3. **Verify Files**: Ensure all required files are uploaded correctly
+4. **Check Secrets**: Confirm API key is properly configured
+
+## 🔄 Updates and Maintenance
+
+### Updating the App
+1. Make changes to your local files
+2. Upload updated files to the Space
+3. The Space will automatically rebuild
+
+### Model Updates
+- The app automatically fetches available models from OpenRouter
+- New cost-effective models can be added to the `ALLOWED_MODELS_PRODUCTION` list in `app.py`
+
+### Monitoring
+- Regularly check OpenRouter usage and costs
+- Monitor Space performance and user feedback
+- Update dependencies as needed
+
+## 📞 Support
+
+If you encounter issues:
+
+1. **Check the logs** in your HF Space for error details
+2. **Test locally** using the test script
+3. **Review this guide** for common solutions
+4. **Check OpenRouter status** at their website
+5. **File an issue** in the original repository if needed
+
+## 🎉 Success!
+
+Once deployed, your AI Co-Scientist will be available at:
+`https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+
+Users can now generate and evolve research hypotheses using your deployed system!

requirements.txt

@@ -1,6 +1,5 @@
 openai
-fastapi
-uvicorn
+gradio
 pydantic
 PyYAML
 requests # Added for fetching models

tests/test_gradio.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Test script for the Gradio AI Co-Scientist app.
+Run this to test the app locally before deploying to Hugging Face Spaces.
+"""
+
+import os
+import sys
+
+def test_imports():
+    """Test that all required imports work."""
+    print("Testing imports...")
+    
+    try:
+        import gradio as gr
+        print("✅ Gradio imported successfully")
+    except ImportError as e:
+        print(f"❌ Failed to import Gradio: {e}")
+        return False
+    
+    try:
+        from app.models import ResearchGoal, ContextMemory
+        from app.agents import SupervisorAgent
+        from app.utils import logger, is_huggingface_space, get_deployment_environment
+        from app.tools.arxiv_search import ArxivSearchTool
+        print("✅ App components imported successfully")
+    except ImportError as e:
+        print(f"❌ Failed to import app components: {e}")
+        return False
+    
+    return True
+
+def test_environment_detection():
+    """Test environment detection functions."""
+    print("\nTesting environment detection...")
+    
+    try:
+        from app.utils import is_huggingface_space, get_deployment_environment
+        
+        is_hf = is_huggingface_space()
+        env = get_deployment_environment()
+        
+        print(f"✅ Is Hugging Face Spaces: {is_hf}")
+        print(f"✅ Deployment environment: {env}")
+        
+        return True
+    except Exception as e:
+        print(f"❌ Environment detection failed: {e}")
+        return False
+
+def test_gradio_app():
+    """Test that the Gradio app can be created."""
+    print("\nTesting Gradio app creation...")
+    
+    try:
+        # Add parent directory to path for imports
+        import os
+        parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        sys.path.insert(0, parent_dir)
+        
+        # Import the app creation function from the root app.py file
+        import importlib.util
+        app_path = os.path.join(parent_dir, 'app.py')
+        spec = importlib.util.spec_from_file_location("gradio_app", app_path)
+        gradio_app = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(gradio_app)
+        
+        # Create the interface (but don't launch)
+        demo = gradio_app.create_gradio_interface()
+        print("✅ Gradio interface created successfully")
+        
+        return True
+    except Exception as e:
+        print(f"❌ Failed to create Gradio interface: {e}")
+        return False
+
+def main():
+    """Run all tests."""
+    print("🔬 AI Co-Scientist Gradio App Test Suite")
+    print("=" * 50)
+    
+    # Check API key
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    if api_key:
+        print(f"✅ OPENROUTER_API_KEY is set (length: {len(api_key)})")
+    else:
+        print("⚠️  OPENROUTER_API_KEY is not set - app will show warnings")
+    
+    # Run tests
+    tests = [
+        test_imports,
+        test_environment_detection,
+        test_gradio_app
+    ]
+    
+    passed = 0
+    for test in tests:
+        if test():
+            passed += 1
+        print()
+    
+    print("=" * 50)
+    print(f"Test Results: {passed}/{len(tests)} tests passed")
+    
+    if passed == len(tests):
+        print("🎉 All tests passed! The app should work correctly.")
+        print("\nTo run the app locally:")
+        print("  python app.py")
+        print("\nTo deploy to Hugging Face Spaces:")
+        print("  1. Copy README_HF.md to README.md in your HF Space")
+        print("  2. Upload app.py and requirements.txt")
+        print("  3. Set OPENROUTER_API_KEY in Space secrets")
+    else:
+        print("❌ Some tests failed. Please fix the issues before deploying.")
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())