updated

DEPLOYMENT_GUIDE.md

@@ -1,230 +1,210 @@
-# 🚀 Hugging Face Spaces Deployment Guide
+# Deployment Guide: Theorem Explanation Agent
 
-This guide will walk you through deploying the Theorem Explanation Agent to Hugging Face Spaces.
+## Overview
+This guide explains how to deploy the Theorem Explanation Agent to Hugging Face Spaces for actual video generation.
 
-## 📋 Prerequisites
+## Prerequisites
+- Hugging Face account
+- Gemini API key(s) from Google AI Studio
+- Basic understanding of environment variables
 
-1. **Hugging Face Account**: Create an account at [huggingface.co](https://huggingface.co)
-2. **Gemini API Key(s)**: Get from [Google AI Studio](https://makersuite.google.com/app/apikey)
-3. **Optional**: ElevenLabs API key for text-to-speech
-
-## 🔧 Step-by-Step Deployment
-
-### Step 1: Create a New Space
+## Quick Start
 
+### 1. Create New Hugging Face Space
 1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
 2. Click "Create new Space"
-3. Fill in details:
-   - **Space name**: `theorem-explanation-agent` (or your choice)
+3. Configure:
+   - **Space name**: Your choice (e.g., "theorem-explanation-agent")
    - **License**: MIT
    - **SDK**: Gradio
-   - **Hardware**: CPU Basic (can upgrade later)
-   - **Visibility**: Public
+   - **Hardware**: CPU Basic (sufficient for most cases)
+   - **Visibility**: Public or Private
 
-### Step 2: Upload Your Code
+### 2. Upload Files
+Upload these files to your space:
+- `app.py` (main application)
+- `requirements_hf.txt` (rename to `requirements.txt`)
+- `README_HUGGINGFACE.md` (rename to `README.md`)
+- All source files from `src/`, `mllm_tools/`, etc.
 
-You have two options:
+### 3. Set Environment Variables
+In your Hugging Face Space settings, add:
 
-#### Option A: Git Clone (Recommended)
+**For Single API Key:**
 ```bash
-git clone https://github.com/yourusername/theorem-explanation-agent
-cd theorem-explanation-agent
-git remote add hf https://huggingface.co/spaces/yourusername/theorem-explanation-agent
-git push hf main
-```
-
-#### Option B: Upload Files Manually
-1. Upload these key files to your Space:
-   - `app.py`
-   - `huggingface_spaces_app.py`
-   - `requirements_hf.txt`
-   - `README_HUGGINGFACE.md`
-   - All folders: `src/`, `mllm_tools/`, etc.
-
-### Step 3: Configure API Keys
-
-1. Go to your Space's **Settings** tab
-2. Scroll down to **Repository secrets**
-3. Add these secrets:
-
-#### Required Secrets
-
-**Multiple API Keys (Recommended)**
-```
-Name: GEMINI_API_KEY
-Value: AIzaSyA1...,AIzaSyB2...,AIzaSyC3...,AIzaSyD4...
+GEMINI_API_KEY=your-actual-gemini-api-key
+DEMO_MODE=false
 ```
 
-**Single API Key**
-```  
-Name: GEMINI_API_KEY
-Value: AIzaSyA1...
+**For Multiple API Keys (Recommended):**
+```bash
+GEMINI_API_KEY=key1,key2,key3,key4
+DEMO_MODE=false
 ```
 
-#### Optional Secrets
-
-**Enable Full Mode**
-```
-Name: DEMO_MODE
-Value: false
+**Optional Settings:**
+```bash
+ELEVENLABS_API_KEY=your-elevenlabs-key  # For TTS
+LANGFUSE_SECRET_KEY=your-langfuse-key   # For logging
 ```
 
-**Text-to-Speech (Optional)**
-```
-Name: ELEVENLABS_API_KEY
-Value: your_elevenlabs_api_key
-```
+## Features Enabled
 
-### Step 4: Configure App Settings
+### ✅ Real Video Generation
+- **DEMO_MODE=false**: Enables actual video generation
+- **Gemini 2.0 Flash Exp**: Latest model for best results
+- **Manim Integration**: Professional mathematical animations
 
-In your Space settings:
+### ✅ Comma-Separated API Keys
+- **Load Balancing**: Distributes requests across multiple keys
+- **Failover**: Automatic switching if one key fails
+- **Cost Distribution**: Spreads usage across billing accounts
 
-1. **Hardware**: 
-   - Start with CPU Basic (free)
-   - Upgrade to CPU Optimized for better performance
-   - Use GPU only if you enable advanced features
+### ✅ Educational Focus
+- **Mathematical Concepts**: Optimized for STEM education
+- **Visual Learning**: Geometric proofs and demonstrations
+- **Progressive Difficulty**: Suitable for various learning levels
 
-2. **Environment**:
-   - Python version: 3.9+
-   - Gradio SDK will be automatically detected
+## Usage Instructions
 
-3. **Persistent Storage** (Optional):
-   - Enable if you want to keep generated videos
-   - Useful for caching and avoiding regeneration
+### 1. Access Your Space
+Visit: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
 
-## 🔑 API Key Setup Details
+### 2. Generate Videos
+1. **Enter Topic**: e.g., "Pythagorean Theorem"
+2. **Add Context**: Specify focus areas or audience
+3. **Set Scenes**: 2-3 scenes for testing, up to 6 for full videos
+4. **Click Generate**: Wait for processing (2-10 minutes)
 
-### How the Fallback System Works
+### 3. Download Results
+- Videos appear in the interface
+- Download links provided for MP4 files
+- Individual scene videos also available
 
-The app uses a smart API key rotation system:
+## Troubleshooting
 
-```python
-# Your GEMINI_API_KEY can be:
-# Single key: "AIzaSyA..."
-# Multiple keys: "AIzaSyA...,AIzaSyB...,AIzaSyC..."
+### Common Issues
 
-# The system will:
-# 1. Parse comma-separated keys
-# 2. Randomly select one for each request
-# 3. Automatically retry with different keys if one fails
-# 4. Log which key is being used (first 20 chars only)
+**1. "Demo Mode" Message**
+```
+Problem: App shows demo simulation instead of real generation
+Solution: Set DEMO_MODE=false in environment variables
 ```
 
-### Benefits of Multiple Keys
-
-1. **Rate Limit Avoidance**: Distributes requests across keys
-2. **Higher Throughput**: Can handle more concurrent requests
-3. **Fault Tolerance**: If one key fails, others continue working
-4. **Cost Distribution**: Spreads usage across multiple billing accounts
-
-### Recommended Setup
-
-For production use, we recommend **4 API keys**:
-
+**2. "No API Keys Found"**
 ```
-GEMINI_API_KEY=key1,key2,key3,key4
+Problem: Missing or incorrect API key configuration
+Solution: Set GEMINI_API_KEY with valid key(s)
 ```
 
-This provides good balance between rate limit avoidance and key management complexity.
-
-## 📊 Monitoring and Costs
-
-### Cost Estimation
-
-- **Demo Mode**: Free (no API calls)
-- **Single Scene**: ~$0.001-0.01 per generation
-- **Full Video (3-6 scenes)**: ~$0.01-0.05 per generation
-- **Multiple API Keys**: Costs distributed across accounts
-
-### Monitoring Usage
-
-1. **Google Cloud Console**: Monitor API usage per key
-2. **Hugging Face Metrics**: View Space usage and performance
-3. **App Logs**: Check which API keys are being selected
-
-### Usage Patterns
-
+**3. "Import Error"**
 ```
-Selected random Gemini API key from 4 available keys: AIzaSyDuKKriNMayoPwn...
-Selected random Gemini API key from 4 available keys: AIzaSyDa44QjZES9qp8L...
+Problem: Missing dependencies
+Solution: Ensure requirements.txt includes all packages
 ```
 
-## 🔧 Troubleshooting
-
-### Common Issues
+**4. "Generation Failed"**
+```
+Problem: API quota exceeded or invalid topic
+Solution: Check API limits, try different topic
+```
 
-1. **"Demo mode active"**
-   - Check `GEMINI_API_KEY` is set in Secrets
-   - Verify key format (comma-separated if multiple)
-   - Ensure `DEMO_MODE=false` if you want full functionality
+### Verification Steps
 
-2. **"Rate limit exceeded"**
-   - Add more API keys to your `GEMINI_API_KEY`
-   - Wait a few minutes before retrying
-   - Consider upgrading to paid Gemini tier
+**1. Test Local Setup:**
+```bash
+python test_video_generation.py
+```
 
-3. **"Generation failed"**
-   - Try simpler topics first
-   - Check API key validity
-   - Verify topic is educational/mathematical
+**2. Check API Keys:**
+```bash
+echo $GEMINI_API_KEY | tr ',' '\n' | wc -l
+# Should show number of keys
+```
 
-4. **Slow performance**
-   - Upgrade Hardware tier in Space settings
-   - Use multiple API keys for better throughput
-   - Enable persistent storage for caching
+**3. Verify Dependencies:**
+```bash
+pip install -r requirements.txt
+python -c "from generate_video import VideoGenerator; print('✅ Imports work')"
+```
 
-### Error Messages and Solutions
+## Performance Optimization
 
-| Error | Solution |
-|-------|----------|
-| `No API_KEY found` | Set `GEMINI_API_KEY` in Secrets |
-| `Model is overloaded` | Add more API keys or retry later |
-| `Invalid API key` | Check key format and validity |
-| `Demo mode active` | Set API keys and `DEMO_MODE=false` |
+### API Key Management
+- **4+ Keys**: Optimal for high usage
+- **Rate Limiting**: 60 requests/minute per key
+- **Monitoring**: Check usage in Google AI Studio
 
-## 🚀 Performance Optimization
+### Hardware Requirements
+- **CPU Basic**: Sufficient for most educational videos
+- **CPU Upgrade**: Consider for complex visualizations
+- **Persistent Storage**: Enable for caching (optional)
 
-### Hardware Recommendations
+### Content Guidelines
+- **Educational Topics**: Math, science, engineering concepts
+- **Clear Descriptions**: Specific learning objectives
+- **Reasonable Scope**: 2-6 scenes per video
 
-- **CPU Basic**: Good for demo and light usage
-- **CPU Optimized**: Better for regular usage  
-- **GPU**: Only needed for advanced video processing
+## Advanced Configuration
 
-### API Key Strategy
+### Custom Model Settings
+Edit `app.py` to modify:
+```python
+planner_model = LiteLLMWrapper(
+    model_name="gemini/gemini-2.0-flash-exp",  # Model choice
+    temperature=0.7,  # Creativity level
+    print_cost=True,  # Cost tracking
+    verbose=True      # Debug output
+)
+```
 
+### Output Customization
+Modify `GRADIO_OUTPUT_DIR` in `app.py`:
 ```python
-# Optimal setup for production:
-GEMINI_API_KEY=key1,key2,key3,key4
-DEMO_MODE=false
-ELEVENLABS_API_KEY=optional_tts_key
+GRADIO_OUTPUT_DIR = "custom_outputs"  # Change output folder
 ```
 
-### Scaling Considerations
+### Feature Toggles
+```python
+# In VideoGenerator initialization
+use_rag=False,              # Retrieval augmented generation
+use_context_learning=True,  # Few-shot learning
+use_visual_fix_code=True,   # Visual debugging
+verbose=True                # Detailed logging
+```
 
-1. **Multiple Keys**: 4-6 keys for high usage
-2. **Persistent Storage**: Cache results to avoid regeneration
-3. **Hardware Upgrade**: CPU Optimized or GPU for faster processing
-4. **Rate Limiting**: Implement user request limiting if needed
+## Security Considerations
 
-## 📞 Support and Resources
+### API Key Protection
+- Never commit keys to version control
+- Use HF Spaces environment variables
+- Monitor usage regularly
 
-### Hugging Face Resources
-- [Spaces Documentation](https://huggingface.co/docs/hub/spaces)
-- [Gradio Documentation](https://gradio.app/docs/)
-- [Community Forums](https://discuss.huggingface.co/)
+### Content Moderation
+- Educational content only
+- Avoid sensitive topics
+- Review generated content
 
-### API Resources
-- [Google AI Studio](https://makersuite.google.com/)
-- [Gemini API Documentation](https://ai.google.dev/)
-- [ElevenLabs API](https://elevenlabs.io/docs/)
+## Support
 
 ### Getting Help
+1. **Check Logs**: HF Spaces build logs
+2. **Test Locally**: Use `test_video_generation.py`
+3. **Issues**: Report problems with error messages
+4. **Community**: HF Spaces forums
+
+### Useful Resources
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Gradio Documentation](https://gradio.app/docs/)
+- [Gemini API Documentation](https://ai.google.dev/docs)
+- [Manim Documentation](https://docs.manim.community/)
+
+## Example Successful Deployment
 
-1. **Check app logs** in Space settings
-2. **Test with simple topics** first
-3. **Verify API keys** in Google Cloud Console
-4. **Monitor costs** and usage patterns
+**Space URL**: `https://huggingface.co/spaces/ManojINaik/menamiai`
+**Features**: Full video generation with comma-separated API keys
+**Status**: Operational with educational content focus
 
 ---
 
-**Ready to deploy?** Follow these steps and you'll have your Theorem Explanation Agent running on Hugging Face Spaces with automatic API key rotation! 
+*This deployment guide ensures your Theorem Explanation Agent works with actual video generation capabilities on Hugging Face Spaces.* 

app.py

@@ -1,11 +1,386 @@
 #!/usr/bin/env python3
 """
-Theorem Explanation Agent - Main entry point for Hugging Face Spaces
+Theorem Explanation Agent - Hugging Face Spaces App
+Generates educational videos using Gemini 2.0 Flash and Manim
 """
 
-# Import from our Hugging Face Spaces app
-from huggingface_spaces_app import create_interface
+import os
+import sys
+import asyncio
+import time
+import random
+from typing import Dict, Any, Tuple, Optional
+from pathlib import Path
+import gradio as gr
 
+# Environment setup
+DEMO_MODE = os.getenv("DEMO_MODE", "false").lower() == "true"
+video_generator = None
+CAN_IMPORT_DEPENDENCIES = True
+GRADIO_OUTPUT_DIR = "gradio_outputs"
+
+def setup_environment():
+    """Setup environment for HF Spaces."""
+    print("🚀 Setting up Theorem Explanation Agent...")
+    
+    # Create output directory
+    os.makedirs(GRADIO_OUTPUT_DIR, exist_ok=True)
+    
+    gemini_keys = os.getenv("GEMINI_API_KEY", "")
+    if gemini_keys:
+        key_count = len([k.strip() for k in gemini_keys.split(',') if k.strip()])
+        print(f"✅ Found {key_count} Gemini API key(s)")
+        return True
+    else:
+        print("⚠️ No Gemini API keys found - running in demo mode")
+        return False
+
+def initialize_video_generator():
+    """Initialize video generator with proper dependencies."""
+    global video_generator, CAN_IMPORT_DEPENDENCIES
+    
+    try:
+        if DEMO_MODE:
+            return "⚠️ Demo mode enabled - No video generation"
+        
+        gemini_keys = os.getenv("GEMINI_API_KEY", "")
+        if not gemini_keys:
+            return "⚠️ No API keys found - Set GEMINI_API_KEY environment variable"
+        
+        # Import dependencies
+        try:
+            from generate_video import VideoGenerator
+            from mllm_tools.litellm import LiteLLMWrapper
+            print("✅ Successfully imported video generation dependencies")
+        except ImportError as e:
+            CAN_IMPORT_DEPENDENCIES = False
+            print(f"❌ Import error: {e}")
+            return f"⚠️ Missing dependencies: {str(e)}"
+        
+        # Initialize models with comma-separated API key support
+        planner_model = LiteLLMWrapper(
+            model_name="gemini/gemini-2.0-flash-exp",
+            temperature=0.7,
+            print_cost=True,
+            verbose=False,
+            use_langfuse=False
+        )
+        
+        # Initialize video generator
+        video_generator = VideoGenerator(
+            planner_model=planner_model,  
+            helper_model=planner_model,
+            scene_model=planner_model,
+            output_dir=GRADIO_OUTPUT_DIR,
+            use_rag=False,
+            use_context_learning=False,
+            use_visual_fix_code=False,
+            verbose=True
+        )
+        
+        return "✅ Video generator initialized successfully"
+        
+    except Exception as e:
+        CAN_IMPORT_DEPENDENCIES = False
+        print(f"❌ Error initializing video generator: {e}")
+        return f"❌ Initialization failed: {str(e)}"
+
+def simulate_video_generation(topic: str, context: str, max_scenes: int, progress_callback=None):
+    """Simulate video generation for demo mode."""
+    stages = [
+        ("🔍 Analyzing topic", 15),
+        ("📝 Planning scenes", 30),
+        ("🎬 Generating content", 50),
+        ("✨ Creating animations", 75),
+        ("🎥 Rendering video", 90),
+        ("✅ Finalizing", 100)
+    ]
+    
+    results = []
+    for stage, progress in stages:
+        if progress_callback:
+            progress_callback(progress, stage)
+        time.sleep(random.uniform(0.5, 1.0))
+        results.append(f"• {stage}")
+    
+    return {
+        "success": True,
+        "message": f"Demo simulation completed for: {topic}",
+        "scenes_created": max_scenes,
+        "processing_steps": results,
+        "demo_note": "This is a simulation - set GEMINI_API_KEY and DEMO_MODE=false for real generation"
+    }
+
+async def generate_video_async(topic: str, context: str, max_scenes: int, progress_callback=None):
+    """Generate video asynchronously using the actual VideoGenerator."""
+    global video_generator
+    
+    if not topic.strip():
+        return {"success": False, "error": "Please enter a topic"}
+    
+    try:
+        if DEMO_MODE or not CAN_IMPORT_DEPENDENCIES or video_generator is None:
+            return simulate_video_generation(topic, context, max_scenes, progress_callback)
+        
+        if progress_callback:
+            progress_callback(10, "🚀 Starting video generation...")
+        
+        # Use the actual video generation pipeline
+        result = await video_generator.generate_video_pipeline(
+            topic=topic,
+            description=context or f"Educational video about {topic}",
+            max_retries=3,
+            only_plan=False,
+            specific_scenes=list(range(1, max_scenes + 1)) if max_scenes > 0 else None
+        )
+        
+        if progress_callback:
+            progress_callback(100, "✅ Video generation completed!")
+        
+        # Check for generated video files
+        file_prefix = topic.lower().replace(' ', '_')
+        file_prefix = ''.join(c for c in file_prefix if c.isalnum() or c == '_')
+        
+        output_folder = os.path.join(GRADIO_OUTPUT_DIR, file_prefix)
+        video_files = []
+        
+        if os.path.exists(output_folder):
+            # Look for combined video
+            combined_video = os.path.join(output_folder, f"{file_prefix}_combined.mp4")
+            if os.path.exists(combined_video):
+                video_files.append(combined_video)
+            
+            # Look for individual scene videos
+            for i in range(1, max_scenes + 1):
+                scene_video = os.path.join(output_folder, f"scene{i}", f"{file_prefix}_scene{i}.mp4")
+                if os.path.exists(scene_video):
+                    video_files.append(scene_video)
+        
+        return {
+            "success": True, 
+            "message": f"Video generated successfully for: {topic}",
+            "video_files": video_files,
+            "output_folder": output_folder,
+            "result": result
+        }
+        
+    except Exception as e:
+        print(f"❌ Error in video generation: {e}")
+        return {"success": False, "error": str(e)}
+
+def generate_video_gradio(topic: str, context: str, max_scenes: int, progress=gr.Progress()) -> Tuple[str, str, Optional[str]]:
+    """Main Gradio function that handles video generation and returns results."""
+    def progress_callback(percent, message):
+        progress(percent / 100, desc=message)
+    
+    # Create new event loop for this generation
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    
+    try:
+        result = loop.run_until_complete(
+            generate_video_async(topic, context, max_scenes, progress_callback)
+        )
+    finally:
+        loop.close()
+    
+    if result["success"]:
+        output = f"""# 🎓 Video Generation Complete!
+
+**Topic:** {topic}
+**Context:** {context if context else "None"}
+**Scenes:** {max_scenes}
+
+## ✅ Result
+{result["message"]}
+"""
+        
+        # Add processing steps if available
+        if "processing_steps" in result:
+            output += "\n## 🔄 Processing Steps\n"
+            for step in result["processing_steps"]:
+                output += f"{step}\n"
+        
+        # Add demo note if in demo mode
+        if "demo_note" in result:
+            output += f"\n⚠️ **{result['demo_note']}**"
+        
+        # Add video file information
+        video_path = None
+        if "video_files" in result and result["video_files"]:
+            output += f"\n## 🎥 Generated Videos\n"
+            for video_file in result["video_files"]:
+                output += f"• {os.path.basename(video_file)}\n"
+            video_path = result["video_files"][0]  # Return first video for display
+        elif "output_folder" in result:
+            output += f"\n📁 **Output folder:** {result['output_folder']}\n"
+        
+        status = "🎮 Demo completed" if DEMO_MODE else "✅ Generation completed"
+        return output, status, video_path
+    
+    else:
+        error_output = f"""# ❌ Video Generation Failed
+
+**Error:** {result.get("error", "Unknown error")}
+
+## 💡 Troubleshooting Tips
+1. **Check API Keys:** Ensure GEMINI_API_KEY is set with valid keys
+2. **Topic Clarity:** Use specific, educational topics
+3. **Dependencies:** Make sure all required packages are installed
+4. **Demo Mode:** Set DEMO_MODE=false for real generation
+
+## 🔧 Environment Setup
+```bash
+export GEMINI_API_KEY="your-key-1,your-key-2,your-key-3"
+export DEMO_MODE=false
+```
+"""
+        return error_output, "❌ Generation failed", None
+
+def get_examples():
+    """Educational example topics."""
+    return [
+        ["Pythagorean Theorem", "Mathematical proof with geometric visualization"],
+        ["Newton's Second Law", "F=ma with real-world examples and demonstrations"],
+        ["Derivatives in Calculus", "Rate of change with graphical interpretation"],
+        ["Photosynthesis Process", "Cellular process with chemical equations"],
+        ["Wave-Particle Duality", "Quantum physics concept with experiments"],
+        ["Quadratic Formula", "Step-by-step derivation and applications"],
+        ["DNA Replication", "Biological process with molecular details"],
+        ["Ohm's Law", "Electrical relationship with circuit examples"]
+    ]
+
+# Initialize the system
+has_api_keys = setup_environment()
+init_status = initialize_video_generator()
+
+# Create Gradio interface
+with gr.Blocks(
+    title="🎓 Theorem Explanation Agent",
+    theme=gr.themes.Soft(),
+    css="footer {visibility: hidden}"
+) as demo:
+    
+    gr.HTML("""
+    <div style="text-align: center; padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; color: white; margin-bottom: 25px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
+        <h1 style="margin: 0; font-size: 2.5em;">🎓 Theorem Explanation Agent</h1>
+        <p style="margin: 10px 0 0 0; font-size: 1.2em; opacity: 0.9;">Generate Educational Videos with AI</p>
+        <p style="margin: 5px 0 0 0; font-size: 0.9em; opacity: 0.8;">Powered by Gemini 2.0 Flash & Manim</p>
+    </div>
+    """)
+    
+    # Status and setup information
+    with gr.Row():
+        with gr.Column():
+            gr.HTML(f"""
+            <div style="background: {'#d4edda' if has_api_keys else '#fff3cd'}; padding: 15px; border-radius: 10px; margin-bottom: 15px; border-left: 4px solid {'#28a745' if has_api_keys else '#ffc107'};">
+                <h4 style="margin: 0 0 8px 0;">🔐 API Setup Status</h4>
+                <p style="margin: 0;"><strong>Status:</strong> {"✅ API keys configured" if has_api_keys else "⚠️ No API keys found"}</p>
+                <p style="margin: 5px 0 0 0; font-size: 0.9em;">{"Ready for video generation" if has_api_keys else "Running in demo mode"}</p>
+            </div>
+            """)
+            
+        with gr.Column():
+            system_status = gr.Textbox(
+                label="🔧 System Status",
+                value=init_status,
+                interactive=False,
+                lines=2
+            )
+    
+    # API Configuration Help
+    if not has_api_keys or DEMO_MODE:
+        gr.HTML("""
+        <div style="background: #f8f9fa; padding: 20px; border-radius: 10px; margin: 15px 0; border: 1px solid #dee2e6;">
+            <h4 style="color: #495057; margin-top: 0;">🚀 Enable Full Functionality</h4>
+            <p style="margin-bottom: 15px;">To generate actual videos instead of simulations:</p>
+            <div style="background: #e9ecef; padding: 15px; border-radius: 5px; font-family: monospace;">
+                <strong>Single API Key:</strong><br>
+                <code>GEMINI_API_KEY=your-gemini-api-key</code><br><br>
+                <strong>Multiple Keys (Recommended):</strong><br>
+                <code>GEMINI_API_KEY=key1,key2,key3,key4</code><br><br>
+                <strong>Disable Demo Mode:</strong><br>
+                <code>DEMO_MODE=false</code>
+            </div>
+            <p style="margin-top: 15px; font-size: 0.9em; color: #6c757d;">
+                Multiple API keys enable automatic failover and load distribution across different billing accounts.
+            </p>
+        </div>
+        """)
+    
+    # Main interface
+    with gr.Row():
+        with gr.Column(scale=2):
+            topic_input = gr.Textbox(
+                label="📚 Educational Topic",
+                placeholder="e.g., Pythagorean Theorem, Newton's Laws, Derivatives...",
+                lines=1
+            )
+            
+            context_input = gr.Textbox(
+                label="📝 Additional Context (Optional)",
+                placeholder="Specify focus areas, target audience, or particular aspects to emphasize...",
+                lines=3
+            )
+            
+            max_scenes_slider = gr.Slider(
+                label="🎬 Maximum Scenes",
+                minimum=1,
+                maximum=6,
+                value=3,
+                step=1,
+                info="More scenes = longer videos but more API usage"
+            )
+            
+            generate_btn = gr.Button("🚀 Generate Educational Video", variant="primary", size="lg")
+            
+        with gr.Column(scale=1):
+            gr.HTML("""
+            <div style="background: #f8f9fa; padding: 20px; border-radius: 10px; height: fit-content;">
+                <h4 style="color: #495057; margin-top: 0;">💡 Tips for Best Results</h4>
+                <ul style="color: #6c757d; font-size: 0.9em; line-height: 1.6;">
+                    <li><strong>Be Specific:</strong> "Pythagorean Theorem proof" vs "Math"</li>
+                    <li><strong>Educational Focus:</strong> Topics work best for teaching</li>
+                    <li><strong>Context Helps:</strong> Specify audience or emphasis</li>
+                    <li><strong>Start Small:</strong> Try 2-3 scenes first</li>
+                </ul>
+            </div>
+            """)
+    
+    # Examples
+    examples = gr.Examples(
+        examples=get_examples(),
+        inputs=[topic_input, context_input],
+        label="📖 Example Topics"
+    )
+    
+    # Output section
+    with gr.Row():
+        with gr.Column(scale=2):
+            output_display = gr.Markdown(
+                value="👋 **Ready to generate!** Enter an educational topic above and click 'Generate Educational Video' to begin.",
+                label="📋 Generation Results"
+            )
+        
+        with gr.Column(scale=1):
+            video_output = gr.Video(
+                label="🎥 Generated Video",
+                visible=True
+            )
+    
+    # Wire up the interface
+    generate_btn.click(
+        fn=generate_video_gradio,
+        inputs=[topic_input, context_input, max_scenes_slider],
+        outputs=[output_display, system_status, video_output],
+        show_progress=True
+    )
+
+# Launch configuration
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch() 
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    ) 

requirements_hf.txt

@@ -1,19 +1,43 @@
-# Core dependencies for Hugging Face Spaces
+# Essential dependencies for Gradio and video generation
 gradio==4.44.0
 python-dotenv>=0.19.0
 requests>=2.25.0
 numpy>=1.21.0
+pandas>=1.3.0
 
 # AI/ML dependencies
+openai>=1.0.0
 litellm>=1.0.0
+tqdm>=4.62.0
+
+# Google Gemini support
 google-generativeai>=0.8.0
 
-# Image processing (required for video generation)
+# Video processing dependencies
 pillow>=8.3.0
+moviepy>=1.0.3
 
-# Audio processing (optional, for TTS)
+# Manim for video generation
+manim>=0.18.0
+
+# Text-to-speech
 elevenlabs>=1.0.0
 
+# Audio processing
+pydub>=0.25.0
+soundfile>=0.12.0
+
+# Additional utilities
+langchain>=0.1.0
+chromadb>=0.4.0
+tiktoken>=0.4.0
+
+# Utility libraries
+tqdm>=4.62.0
+
+# Audio processing (optional, for TTS)
+# elevenlabs>=1.0.0
+
 # Utility libraries
 tqdm>=4.62.0
 

test_video_generation.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Test script for video generation functionality
+"""
+
+import os
+import asyncio
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+async def test_video_generation():
+    """Test the video generation pipeline."""
+    
+    # Check API keys
+    gemini_keys = os.getenv("GEMINI_API_KEY", "")
+    if not gemini_keys:
+        print("❌ No GEMINI_API_KEY found. Please set environment variable.")
+        print("Example: export GEMINI_API_KEY='key1,key2,key3'")
+        return False
+    
+    key_count = len([k.strip() for k in gemini_keys.split(',') if k.strip()])
+    print(f"✅ Found {key_count} Gemini API key(s)")
+    
+    try:
+        # Import dependencies
+        from generate_video import VideoGenerator
+        from mllm_tools.litellm import LiteLLMWrapper
+        print("✅ Successfully imported video generation dependencies")
+        
+        # Initialize models
+        planner_model = LiteLLMWrapper(
+            model_name="gemini/gemini-2.0-flash-exp",
+            temperature=0.7,
+            print_cost=True,
+            verbose=True,
+            use_langfuse=False
+        )
+        
+        # Initialize video generator
+        video_generator = VideoGenerator(
+            planner_model=planner_model,  
+            helper_model=planner_model,
+            scene_model=planner_model,
+            output_dir="test_output",
+            use_rag=False,
+            use_context_learning=False,
+            use_visual_fix_code=False,
+            verbose=True
+        )
+        
+        print("✅ Video generator initialized successfully")
+        
+        # Test video generation
+        test_topic = "Pythagorean Theorem"
+        test_description = "Basic mathematical proof with geometric visualization"
+        
+        print(f"\n🚀 Testing video generation for: {test_topic}")
+        print(f"📝 Description: {test_description}")
+        
+        result = await video_generator.generate_video_pipeline(
+            topic=test_topic,
+            description=test_description,
+            max_retries=2,
+            only_plan=False,
+            specific_scenes=[1, 2]  # Just test 2 scenes
+        )
+        
+        print("✅ Video generation pipeline completed successfully!")
+        
+        # Check output files
+        file_prefix = test_topic.lower().replace(' ', '_')
+        file_prefix = ''.join(c for c in file_prefix if c.isalnum() or c == '_')
+        
+        output_folder = os.path.join("test_output", file_prefix)
+        if os.path.exists(output_folder):
+            print(f"📁 Output folder created: {output_folder}")
+            
+            # List files in output folder
+            for root, dirs, files in os.walk(output_folder):
+                level = root.replace(output_folder, '').count(os.sep)
+                indent = ' ' * 2 * level
+                print(f"{indent}{os.path.basename(root)}/")
+                subindent = ' ' * 2 * (level + 1)
+                for file in files:
+                    print(f"{subindent}{file}")
+        
+        return True
+        
+    except ImportError as e:
+        print(f"❌ Import error: {e}")
+        print("Please install required dependencies:")
+        print("pip install -r requirements.txt")
+        return False
+        
+    except Exception as e:
+        print(f"❌ Error during video generation: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🧪 Testing Video Generation System\n")
+    
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    
+    try:
+        success = loop.run_until_complete(test_video_generation())
+        if success:
+            print("\n🎉 Test completed successfully!")
+            print("The video generation system is working properly.")
+        else:
+            print("\n❌ Test failed.")
+            print("Please check the error messages above and fix any issues.")
+    finally:
+        loop.close()