Upload 13 files

.env

@@ -0,0 +1 @@
+TOGETHER_API_KEY = cee1393e4d4e7a94121882052a03f30a1d51f5dbd251140844ec616e17f60e9b

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,51 @@
+# Environment variables
+.env
+.env.*
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Manim output
+media/
+media/videos/
+*.mp4
+
+# Ignore GIFs except in SpatialReasoningTest
+*.gif
+!SpatialReasoningTest/*.gif 
+

Dockerfile

@@ -0,0 +1,56 @@
+FROM python:3.12-slim
+
+# Install all dependencies in one layer
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    libffi-dev \
+    curl \
+    ca-certificates \
+    python3-dev \
+    pkg-config \
+    libcairo2-dev \
+    libpango1.0-dev \
+    ffmpeg \
+    texlive-full \
+    dvisvgm \
+    fonts-dejavu \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* \
+    && which dvisvgm
+
+WORKDIR /app
+
+# Install uv for faster pip operations
+ADD https://astral.sh/uv/install.sh /uv-installer.sh
+RUN sh /uv-installer.sh && rm /uv-installer.sh
+ENV PATH="/root/.local/bin:${PATH}"
+
+# Copy virtual environment and project files
+COPY requirements.txt .
+
+
+# Activate the existing venv and install any missing packages
+RUN uv venv /app/manimations \
+    && . /app/manimations/bin/activate \
+    && uv pip install --no-cache -r requirements.txt \
+    && uv pip install --no-cache pycairo pangocffi manim
+
+ENV PATH="/app/manimations/bin:${PATH}"
+COPY *.py /app/
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV MPLBACKEND=Agg
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+# Create directory for generated videos
+RUN mkdir -p /app/generated_videos
+
+# Copy .env file
+COPY .env /app/.env
+
+# Expose the port for the Gradio interface
+EXPOSE 7860
+
+# Command to run the application with the virtual environment
+CMD ["/app/manimations/bin/python", "ai_agent.py"]

README.md

@@ -1,11 +1,11 @@
----
-title: Text2manim
-emoji: 📊
-colorFrom: red
-colorTo: indigo
-sdk: docker
-pinned: false
-short_description: Text to Math, Physic video using Manim and AI agent
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Text2manim
+emoji: 📊
+colorFrom: red
+colorTo: indigo
+sdk: docker
+pinned: false
+short_description: Text to Math, Physic video using Manim and AI agent
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

ai_agent.py

@@ -0,0 +1,801 @@
+"""
+AI Agent for generating Manim animations from text prompts using pydantic-ai.
+"""
+
+import os
+from typing import List, Optional
+from dotenv import load_dotenv
+import gradio as gr
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai import Agent, RunContext
+from pydantic import BaseModel, Field
+import openai
+import tempfile
+import subprocess
+import logging
+from datetime import datetime
+import shutil
+import time
+from io import StringIO
+import re
+import json
+import logging
+    
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+llm = "deepseek-ai/DeepSeek-V3"
+
+# Define Pydantic models for structured data
+class AnimationPrompt(BaseModel):
+    """User input for animation generation."""
+    description: str = Field(..., description="Text description of the mathematical or physics concept to animate")
+    complexity: str = Field("medium", description="Desired complexity of the animation")
+    
+class AnimationScenario(BaseModel):
+    """Structured scenario for animation generation."""
+    title: str = Field(..., description="Title of the animation")
+    objects: List[str] = Field(..., description="Mathematical objects to include in the animation")
+    transformations: List[str] = Field(..., description="Transformations to apply to the objects")
+    equations: Optional[List[str]] = Field(None, description="Mathematical equations to visualize")
+    
+class AnimationResult(BaseModel):
+    """Result of animation generation."""
+    code: str = Field(..., description="Generated Manim code")
+    video_path: str = Field(..., description="Path to the generated video file")
+
+model = OpenAIModel(
+    'deepseek-ai/DeepSeek-V3',
+    provider=OpenAIProvider(
+        base_url='https://api.together.xyz/v1', api_key=os.environ.get('TOGETHER_API_KEY')
+    ),
+)
+# Create the agent with a static system prompt
+manim_agent = Agent(
+    model,  # or use Together API as needed
+    deps_type=AnimationPrompt,  # Use AnimationPrompt as dependency type
+    system_prompt=(
+        "You are a specialized AI agent for creating mathematical animations. "
+        "Your goal is to convert user descriptions into precise Manim code "
+        "that visualizes mathematical and physics concepts clearly and elegantly."
+    ),
+)
+
+# Configure OpenAI client to use Together API
+client = openai.OpenAI(
+    api_key=os.environ.get("TOGETHER_API_KEY"),
+    base_url="https://api.together.xyz/v1",
+)
+
+# Add dynamic system prompts
+@manim_agent.system_prompt
+def add_complexity_guidance(ctx: RunContext[AnimationPrompt]) -> str:
+    """Add guidance based on requested complexity."""
+    complexity = ctx.deps.complexity
+    if complexity == "simple":
+        return (
+            "Create simple, easy-to-understand animations with minimal elements. "
+            "Focus on clarity over sophistication."
+        )
+    elif complexity == "complex":
+        return (
+            "Create sophisticated animations with multiple mathematical elements and transformations. "
+            "You can use advanced Manim features and complex mathematical concepts."
+        )
+    else:  # medium
+        return (
+            "Balance clarity and sophistication in your animations. "
+            "Include enough detail to illustrate the concept clearly without overwhelming the viewer."
+        )
+
+@manim_agent.system_prompt
+def add_timestamp() -> str:
+    """Add a timestamp to the system prompt."""
+    return f"Current date and time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+
+@manim_agent.tool
+def extract_scenario(ctx: RunContext[AnimationPrompt]) -> AnimationScenario:
+    """Extract a structured animation scenario from a text prompt."""
+    prompt = ctx.deps  # Get the AnimationPrompt from context
+    
+    # Use Together API with OpenAI client
+    response = client.chat.completions.create(
+        model=llm,
+        messages=[
+            {"role": "system", "content": """
+Create a storyboard for a math/physics educational animation. Focus on making concepts clear for beginners.
+
+Respond with a JSON object containing:
+- title: A clear, engaging title
+- objects: Mathematical objects to include (e.g., "coordinate_plane", "function_graph")
+- transformations: Animation types to use (e.g., "fade_in", "transform")
+- equations: Mathematical equations to feature (can be null)
+- storyboard: 5-7 sections, each with:
+  * section_name: Section name (e.g., "Introduction")
+  * time_range: Timestamp range (e.g., "0:00-2:00")
+  * narration: What the narrator says
+  * visuals: What appears on screen
+  * animations: Specific animations
+  * key_points: 1-2 main takeaways
+
+Include: introduction, simple explanation, detailed walkthrough, examples, and conclusion.
+
+Use everyday analogies, define technical terms, and focus on visualization.
+
+Only respond with the JSON object, nothing else.
+"""},
+            {"role": "user", "content": f"Create an animation storyboard for: '{prompt.description}'. "
+                                        f"Complexity level: {prompt.complexity}. Make it beginner-friendly "
+                                        f"with clear explanations and visual examples."}
+        ]
+    )
+    content = response.choices[0].message.content
+    
+    try:
+        # Extract JSON from response
+        json_match = re.search(r'\{.*\}', content, re.DOTALL)
+        if json_match:
+            json_str = json_match.group(0)
+            scenario_dict = json.loads(json_str)
+            
+            # Get basic scenario info
+            title = scenario_dict.get('title', f"{prompt.description.capitalize()} Visualization")
+            objects = scenario_dict.get('objects', [])
+            transformations = scenario_dict.get('transformations', [])
+            equations = scenario_dict.get('equations', None)
+            
+            # Store the storyboard in logger
+            if 'storyboard' in scenario_dict:
+                logger.info(f"Generated storyboard: {json.dumps(scenario_dict['storyboard'], indent=2)}")
+            
+            return AnimationScenario(
+                title=title,
+                objects=objects,
+                transformations=transformations,
+                equations=equations
+            )
+    except Exception as e:
+        logger.error(f"Error parsing scenario JSON: {e}")
+    
+    # Fallback with default values
+    return AnimationScenario(
+        title=f"{prompt.description.capitalize()} Visualization",
+        objects=["circle", "text", "coordinate_system"],
+        transformations=["creation", "transformation", "highlight"],
+        equations=None
+    )
+
+# Also simplify extract_scenario_direct with the same approach
+def extract_scenario_direct(prompt: str, complexity: str = "medium") -> AnimationScenario:
+    """Direct implementation of scenario extraction without using RunContext."""
+    # Use Together API with OpenAI client
+    response = client.chat.completions.create(
+        model=llm,
+        messages=[
+            {"role": "system", "content": """
+Create a storyboard for a math/physics educational animation. Focus on making concepts clear for beginners.
+
+Respond with a JSON object containing:
+- title: A clear, engaging title
+- objects: Mathematical objects to include (e.g., "coordinate_plane", "function_graph")
+- transformations: Animation types to use (e.g., "fade_in", "transform")
+- equations: Mathematical equations to feature (can be null)
+- storyboard: 5-7 sections, each with:
+  * section_name: Section name (e.g., "Introduction")
+  * time_range: Timestamp range (e.g., "0:00-2:00")
+  * narration: What the narrator says
+  * visuals: What appears on screen
+  * animations: Specific animations
+  * key_points: 1-2 main takeaways
+
+Include: introduction, simple explanation, detailed walkthrough, examples, and conclusion.
+
+Use everyday analogies, define technical terms, and focus on visualization.
+
+Only respond with the JSON object, nothing else.
+"""},
+            {"role": "user", "content": f"Create an animation storyboard for: '{prompt}'. "
+                                        f"Complexity level: {complexity}. Make it beginner-friendly "
+                                        f"with clear explanations and visual examples."}
+        ]
+    )
+    content = response.choices[0].message.content
+    
+    try:
+        # Extract JSON from response
+        json_match = re.search(r'\{.*\}', content, re.DOTALL)
+        if json_match:
+            json_str = json_match.group(0)
+            scenario_dict = json.loads(json_str)
+            
+            # Get basic scenario info
+            title = scenario_dict.get('title', f"{prompt.capitalize()} Visualization")
+            objects = scenario_dict.get('objects', [])
+            transformations = scenario_dict.get('transformations', [])
+            equations = scenario_dict.get('equations', None)
+            
+            # Store the storyboard in logger
+            if 'storyboard' in scenario_dict:
+                logger.info(f"Generated storyboard: {json.dumps(scenario_dict['storyboard'], indent=2)}")
+            
+            return AnimationScenario(
+                title=title,
+                objects=objects,
+                transformations=transformations,
+                equations=equations
+            )
+    except Exception as e:
+        logger.error(f"Error parsing scenario JSON: {e}")
+    
+    # Fallback based on keywords in prompt
+    objects = ["circle", "text", "coordinate_system"]
+    transformations = ["creation", "transformation", "highlight"]
+    equations = None
+    
+    if any(kw in prompt.lower() for kw in ["triangle", "pythagorean"]):
+        objects = ["triangle", "square", "text"]
+        transformations = ["creation", "area_calculation"]
+        equations = ["a^2 + b^2 = c^2"]
+    elif any(kw in prompt.lower() for kw in ["calculus", "derivative", "integral"]):
+        objects = ["function_graph", "tangent_line", "area"]
+        transformations = ["drawing", "zoom", "fill"]
+        equations = ["f'(x) = \\lim_{h \\to 0}\\frac{f(x+h) - f(x)}{h}"]
+    
+    return AnimationScenario(
+        title=f"{prompt.capitalize()} Visualization",
+        objects=objects,
+        transformations=transformations,
+        equations=equations
+    )
+
+@manim_agent.tool
+def generate_code(ctx: RunContext[AnimationPrompt], scenario: AnimationScenario) -> str:
+    """Generate Manim code from a structured scenario."""
+    # Use OpenAI to generate Manim code
+    objects_str = ", ".join(scenario.objects)
+    transformations_str = ", ".join(scenario.transformations)
+    equations_str = ", ".join(scenario.equations) if scenario.equations else "No equations"
+    
+    prompt_description = ctx.deps.description  # Access the original prompt
+    response = client.chat.completions.create(
+        model=llm,
+        messages=[
+            {"role": "system", "content": "Generate Manim code for mathematical animations."},
+            {"role": "user", "content": f"Create Manim code for an animation titled '{scenario.title}' "
+                                       f"with objects: {objects_str}, transformations: {transformations_str}, "
+                                       f"and equations: {equations_str}. Original request: '{prompt_description}'"}
+        ]
+    )
+    return response.choices[0].message.content
+
+@manim_agent.tool_plain
+def render_animation(code: str, quality="medium_quality") -> str:
+    """Render Manim code into a video. This doesn't need the context."""
+    return render_manim_video(code, quality)
+
+def render_manim_video(code, quality="medium_quality"):
+    try:
+        temp_dir = tempfile.mkdtemp()
+        script_path = os.path.join(temp_dir, "manim_script.py")
+        
+        with open(script_path, "w") as f:
+            f.write(code)
+        
+        class_name = None
+        for line in code.split("\n"):
+            if line.startswith("class ") and "Scene" in line:
+                class_name = line.split("class ")[1].split("(")[0].strip()
+                break
+            
+        if not class_name:
+            return "Error: Could not identify the Scene class in the generated code."
+        
+        if quality == "high_quality":
+            command = ["manim", "-qh", script_path, class_name]
+            quality_dir = "1080p60"
+        elif quality == "low_quality":
+            command = ["manim", "-ql", script_path, class_name]
+            quality_dir = "480p15"
+        else:
+            command = ["manim", "-qm", script_path, class_name]
+            quality_dir = "720p30"
+        
+        logger.info(f"Executing command: {' '.join(command)}")
+        
+        result = subprocess.run(command, cwd=temp_dir, capture_output=True, text=True)
+        
+        logger.info(f"Manim stdout: {result.stdout}")
+        logger.error(f"Manim stderr: {result.stderr}")
+        
+        if result.returncode != 0:
+            logger.error(f"Manim execution failed: {result.stderr}")
+            return f"Error rendering video: {result.stderr}"
+        
+        media_dir = os.path.join(temp_dir, "media")
+        videos_dir = os.path.join(media_dir, "videos")
+        
+        if not os.path.exists(videos_dir):
+            return "Error: No video was generated. Check if Manim is installed correctly."
+        
+        scene_dirs = [d for d in os.listdir(videos_dir) if os.path.isdir(os.path.join(videos_dir, d))]
+        
+        if not scene_dirs:
+            return "Error: No scene directory found in the output."
+        
+        scene_dir = max([os.path.join(videos_dir, d) for d in scene_dirs], key=os.path.getctime)
+        
+        mp4_files = [f for f in os.listdir(os.path.join(scene_dir, quality_dir)) if f.endswith(".mp4")]
+        
+        if not mp4_files:
+            return "Error: No MP4 file was generated."
+        
+        video_file = max([os.path.join(scene_dir, quality_dir, f) for f in mp4_files], key=os.path.getctime)
+        
+        output_dir = os.path.join(os.getcwd(), "generated_videos")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        timestamp = int(time.time())
+        output_file = os.path.join(output_dir, f"manim_video_{timestamp}.mp4")
+        
+        shutil.copy2(video_file, output_file)
+        
+        logger.info(f"Video generated: {output_file}")
+        
+        return output_file
+        
+    except Exception as e:
+        logger.error(f"Error rendering video: {e}")
+        return f"Error: {str(e)}"
+    finally:
+        try:
+            shutil.rmtree(temp_dir)
+        except Exception as e:
+            logger.error(f"Error cleaning up temporary directory: {e}")
+
+def format_log_output(scenario: AnimationScenario, code: str) -> str:
+    """Format scenario and code for display in UI."""
+    log_output = f"## Animation Scenario\n\n"
+    log_output += f"**Title:** {scenario.title}\n\n"
+    
+    # Check if we have a storyboard in the logger
+    import json
+    import re
+    from io import StringIO
+    import logging
+    
+    # Create a string buffer to capture log output
+    log_buffer = StringIO()
+    log_handler = logging.StreamHandler(log_buffer)
+    logger.addHandler(log_handler)
+    
+    # Extract storyboard from logs if possible
+    storyboard = None
+    log_handler.flush()
+    logs = log_buffer.getvalue()
+    logger.removeHandler(log_handler)
+    
+    json_match = re.search(r'Generated storyboard: (\[.*\])', logs)
+    if json_match:
+        try:
+            storyboard_str = json_match.group(1)
+            storyboard = json.loads(storyboard_str)
+        except:
+            storyboard = None
+    
+    # If storyboard exists, display it
+    if storyboard:
+        log_output += f"## Animation Storyboard\n\n"
+        for i, section in enumerate(storyboard):
+            log_output += f"### {i+1}. {section.get('section_name', 'Section')}\n"
+            log_output += f"**Time:** {section.get('time_range', 'N/A')}\n\n"
+            log_output += f"**Narration:** {section.get('narration', '')}\n\n"
+            log_output += f"**Visuals:** {section.get('visuals', '')}\n\n"
+            log_output += f"**Animations:** {', '.join(section.get('animations', []))}\n\n"
+            
+            if 'key_points' in section and section['key_points']:
+                log_output += f"**Key Points:**\n"
+                if isinstance(section['key_points'], list):
+                    for point in section['key_points']:
+                        log_output += f"- {point}\n"
+                else:
+                    log_output += f"{section['key_points']}\n"
+            
+            log_output += "---\n\n"
+    
+    # Continue with regular output
+    log_output += f"**Mathematical Objects:**\n"
+    for obj in scenario.objects:
+        log_output += f"- {obj}\n"
+    
+    log_output += f"\n**Transformations:**\n"
+    for transform in scenario.transformations:
+        log_output += f"- {transform}\n"
+    
+    if scenario.equations:
+        log_output += f"\n**Equations:**\n"
+        for eq in scenario.equations:
+            log_output += f"- {eq}\n"
+    
+    log_output += f"\n## Generated Manim Code\n\n```python\n{code}\n```"
+    
+    return log_output
+
+# Add a memory class to store conversation history
+class ConversationMemory:
+    def __init__(self):
+        self.history = []
+        self.current_scenario = None
+        self.current_code = None
+    
+    def add_interaction(self, prompt, scenario, code, video_path):
+        self.history.append({
+            "prompt": prompt,
+            "scenario": scenario,
+            "code": code,
+            "video_path": video_path,
+            "timestamp": datetime.now().isoformat()
+        })
+        self.current_scenario = scenario
+        self.current_code = code
+    
+    def get_context_for_refinement(self):
+        if not self.history:
+            return ""
+        
+        # Construct context from the last interaction
+        last = self.history[-1]
+        context = f"Previous prompt: {last['prompt']}\n"
+        if self.current_scenario and hasattr(self.current_scenario, 'title'):
+            context += f"Current animation title: {self.current_scenario.title}\n"
+        return context
+
+# Initialize the memory
+memory = ConversationMemory()
+
+# Function to refine animation based on feedback
+def refine_animation(code: str, feedback: str, quality: str = "medium_quality") -> tuple:
+    """Refine animation based on user feedback."""
+    try:
+        # Get context from memory
+        context = memory.get_context_for_refinement()
+        
+        # Use LLM to refine the code based on feedback
+        response = client.chat.completions.create(
+            model=llm,
+            messages=[
+                {"role": "system", "content": """
+You are a Manim code expert. Your task is to refine animation code based on user feedback.
+Keep the overall structure and purpose of the animation, but implement the changes requested.
+Make sure the code remains valid and follows Manim best practices.
+
+IMPORTANT REQUIREMENTS:
+1. Only return the complete, corrected Manim code
+2. Ensure class name and structure remains consistent
+3. All changes must be compatible with Manim Community edition
+4. Do not explain your changes in comments outside of helpful inline comments
+"""},
+                {"role": "user", "content": f"Here is the current Manim animation code:\n\n```python\n{code}\n```\n\n{context}\nPlease refine this code based on this feedback: \"{feedback}\"\n\nReturn only the improved code."}
+            ]
+        )
+        
+        refined_code = response.choices[0].message.content.strip()
+        
+        # Remove any markdown code formatting if present
+        if refined_code.startswith("```python"):
+            refined_code = refined_code.split("```python", 1)[1]
+        if refined_code.endswith("```"):
+            refined_code = refined_code.rsplit("```", 1)[0]
+        
+        refined_code = refined_code.strip()
+        
+        # Render the refined code
+        video_path = render_manim_video(refined_code, quality)
+        
+        if video_path and not video_path.startswith("Error"):
+            # Update memory with refined code
+            if memory.current_scenario:
+                memory.current_code = refined_code
+            
+            return refined_code, video_path, f"## Refined Animation\n\nFeedback incorporated: \"{feedback}\"\n\nAnimation successfully rendered."
+        else:
+            return refined_code, None, f"## Error in Rendering\n\n```\n{video_path}\n```\n\nPlease check your code for errors."
+    
+    except Exception as e:
+        logger.error(f"Error refining animation: {e}")
+        return code, None, f"## Error in Refinement\n\n```\n{str(e)}\n```\n\nPlease try again with different feedback."
+
+# Function to process user request
+def generate_animation(prompt: str, complexity: str = "medium", quality: str = "medium_quality") -> tuple:
+    """Generate an animation from a text prompt."""
+    try:
+        # Create prompt object with complexity
+        prompt_obj = AnimationPrompt(description=prompt, complexity=complexity)
+        
+        # Run the agent in a way that it will use all necessary tools
+        result = manim_agent.run_sync(
+            f"Generate an animation from this description: {prompt}. "
+            f"First, extract the key elements of the scenario. Then, generate "
+            f"the Manim code for the animation. Finally, render the animation.",
+            deps=prompt_obj
+        )
+        
+        # As a fallback, we'll use the direct methods
+        scenario = extract_scenario_direct(prompt, complexity)
+        
+        # Fix: Use generate_code_direct instead of generate_code
+        # generate_code is an agent tool that requires a RunContext
+        code = generate_code_direct(prompt, scenario, complexity)
+        
+        video_path = render_manim_video(code, quality)  # Use the new render function
+        
+        log_output = format_log_output(scenario, code)
+        
+        # Store in memory
+        memory.add_interaction(prompt, scenario, code, video_path)
+        
+        return code, video_path, log_output
+    except Exception as e:
+        logger.error(f"Error generating animation: {e}")
+        return f"Error: {str(e)}", None, f"Error occurred: {str(e)}"
+
+# Add the missing generate_code_direct function if it doesn't exist
+def generate_code_direct(prompt: str, scenario: AnimationScenario, complexity: str = "medium") -> str:
+    """Direct implementation of code generation without using RunContext."""
+    # Use Together API with OpenAI client
+    objects_str = ", ".join(scenario.objects)
+    transformations_str = ", ".join(scenario.transformations)
+    equations_str = ", ".join(scenario.equations) if scenario.equations else "No equations"
+    
+    # Try to get storyboard from logger if it exists
+    storyboard_info = ""
+    from io import StringIO
+    import re
+    import json
+    import logging
+    
+    # Create a string buffer to capture log output
+    log_buffer = StringIO()
+    log_handler = logging.StreamHandler(log_buffer)
+    logger.addHandler(log_handler)
+    log_handler.flush()
+    logs = log_buffer.getvalue()
+    logger.removeHandler(log_handler)
+    
+    # Extract storyboard from logs if possible
+    json_match = re.search(r'Generated storyboard: (\[.*\])', logs)
+    if json_match:
+        try:
+            storyboard_str = json_match.group(1)
+            storyboard = json.loads(storyboard_str)
+            storyboard_info = "Follow this narrative structure in your animation:\n"
+            for i, section in enumerate(storyboard):
+                storyboard_info += f"Section {i+1}: {section.get('section_name', 'Section')} - {section.get('time_range', 'N/A')}\n"
+                storyboard_info += f"Narration: {section.get('narration', '')}\n"
+                storyboard_info += f"Visuals: {section.get('visuals', '')}\n"
+                storyboard_info += f"Animations: {', '.join(section.get('animations', []))}\n\n"
+        except:
+            storyboard_info = ""
+    
+    response = client.chat.completions.create(
+        model=llm,
+        messages=[
+            {"role": "system", "content": f"""
+Create professional Manim animation code that explains mathematical concepts clearly and elegantly. Your code MUST:
+
+TECHNICAL REQUIREMENTS:
+1. Use 'from manim import *' at the top
+2. Create a Scene class named 'ManimScene' that extends Scene
+3. Implement the construct method correctly
+4. Use only standard Manim Community edition objects and methods
+5. Include proper self.play() and self.wait() calls with appropriate durations
+6. Use valid LaTeX syntax for all mathematical expressions
+7. Be fully compilable without errors
+8. Include helpful comments explaining each section
+9. Just return python code, do not include apostrophe in front and back of code
+
+VISUAL STRUCTURE AND LAYOUT:
+1. Structure the animation as a narrative with clear sections (introduction, explanation, conclusion)
+2. Create title screens with engaging typography and animations
+3. Position ALL elements with EXPLICIT coordinates using shift() or move_to() methods
+4. Ensure AT LEAST 1.5 units of space between separate visual elements
+5. For equations, use MathTex with proper scaling (scale(0.8) for complex equations)
+6. Group related objects using VGroup and arrange them with arrange() method
+7. When showing multiple equations, use arrange_in_grid() or arrange() with DOWN/RIGHT
+8. For graphs, set explicit x_range and y_range with generous padding around functions
+9. Scale ALL text elements appropriately (Title: 1.2, Headers: 1.0, Body: 0.8)
+10. Use colors consistently and meaningfully (BLUE for emphasis, RED for important points)
+11. Preventing overlaps of element, choose position for each element carefully, display element and text then move to next element
+
+ANIMATION TECHNIQUES:
+1. Use FadeIn for introductions of new elements
+2. Apply TransformMatchingTex when evolving equations
+3. Use Create for drawing geometric objects
+4. Implement smooth transitions between different concepts with ReplacementTransform
+5. Highlight important parts with Indicate or Circumscribe
+6. Add pauses (self.wait()) after important points for comprehension
+7. For complex animations, break them into smaller steps with appropriate timing
+8. Use MoveAlongPath for demonstrating motion or change over time
+9. Create emphasis with scale_about_point or succession of animations
+10. Use camera movements sparingly and smoothly
+
+EDUCATIONAL CLARITY:
+1. Begin with simple concepts and build to more complex ones
+2. Reveal information progressively, not all at once
+3. Use visual metaphors to represent abstract concepts
+4. Include clear labels for all important elements
+5. When showing equations, animate their components step by step
+6. Provide visual explanations alongside mathematical notation
+7. Use consistent notation throughout the animation
+8. Show practical applications or examples of the concept
+9. Summarize key points at the end of the animation
+
+{storyboard_info}
+
+RESPOND WITH CLEAN, WELL-STRUCTURED CODE ONLY. DO NOT INCLUDE EXPLANATIONS OUTSIDE OF CODE COMMENTS.
+"""
+            },
+            {"role": "user", "content": f"Create a comprehensive Manim animation for '{scenario.title}' that teaches this concept: '{prompt}'. \n\nUse these mathematical objects: {objects_str}. \nImplement these transformations/animations: {transformations_str}. \nFeature these equations: {equations_str}. \n\nComplexity level: {complexity}. \n\nEnsure all elements are properly spaced and positioned to prevent overlap. Structure the animation with a clear introduction, step-by-step explanation, and conclusion."}
+        ]
+    )
+    return response.choices[0].message.content
+
+# Function to re-render animation with edited code
+def rerender_animation(edited_code: str, quality: str = "medium_quality") -> tuple:
+    """Re-render animation with user-edited code."""
+    try:
+        video_path = render_manim_video(edited_code, quality)
+        if video_path and not video_path.startswith("Error"):
+            return video_path, f"## Re-rendered Animation\n\nCode successfully rendered to video.\n\nCheck the video player for results."
+        else:
+            return None, f"## Error in Rendering\n\n```\n{video_path}\n```\n\nPlease check your code for errors."
+    except Exception as e:
+        logger.error(f"Error re-rendering animation: {e}")
+        return None, f"## Error in Rendering\n\n```\n{str(e)}\n```\n\nPlease check your code for errors."
+
+# Setup Gradio interface
+def gradio_interface(prompt: str, complexity: str = "medium", quality: str = "medium_quality"):
+    code, video_path, log_output = generate_animation(prompt, complexity, quality)
+    if video_path and not video_path.startswith("Error"):
+        return code, video_path, log_output
+    else:
+        return code, None, log_output
+
+# Replace the Gradio interface creation with a Blocks interface for better layout control
+if __name__ == "__main__":
+    with gr.Blocks(title="Manimation Generator", theme=gr.themes.Base()) as demo:
+        gr.Markdown("# Manimation Generator")
+        gr.Markdown("Generate mathematical animations from text descriptions using AI")
+        
+        # Add chat history component
+        chat_history = gr.Chatbot(label="Conversation History", height=300)
+        
+        with gr.Row():
+            # Left column: User inputs
+            with gr.Column(scale=1):
+                # Replace single prompt with tabs for initial creation and feedback
+                with gr.Tabs():
+                    with gr.TabItem("Create New Animation"):
+                        new_prompt = gr.Textbox(
+                            lines=5, 
+                            placeholder="Describe a mathematical concept to animate...", 
+                            label="Concept Description"
+                        )
+                        
+                        with gr.Row():
+                            complexity = gr.Radio(
+                                ["simple", "medium", "complex"], 
+                                value="medium", 
+                                label="Complexity Level"
+                            )
+                            quality = gr.Radio(
+                                ["low_quality", "medium_quality", "high_quality"], 
+                                value="medium_quality", 
+                                label="Video Quality"
+                            )
+                        
+                        generate_btn = gr.Button("Generate Animation", variant="primary")
+                    
+                    with gr.TabItem("Refine Animation"):
+                        feedback = gr.Textbox(
+                            lines=3,
+                            placeholder="Provide feedback or suggestions for the current animation...",
+                            label="Your Feedback"
+                        )
+                        refine_btn = gr.Button("Apply Feedback", variant="secondary")
+                
+                # Code editor (common to both tabs)
+                code_output = gr.Code(
+                    language="python", 
+                    label="Manim Code (Editable)",
+                    lines=20,
+                    interactive=True
+                )
+                
+                # Add manual rerender button
+                rerender_btn = gr.Button("Re-render Current Code", variant="secondary")
+            
+            # Right column: Video and details
+            with gr.Column(scale=1):
+                video_output = gr.Video(label="Animation")
+                # Uncomment the log_output component to fix the error
+                log_output = gr.Markdown(label="Details")
+        
+        # Function to update chat history
+        def update_chat_history(history, user_message, bot_message, video_path):
+            history = history or []
+            history.append((user_message, None))  # User message
+            if video_path and not isinstance(video_path, str):
+                # If we have a valid video, include it in the message
+                bot_message = f"{bot_message}\n\n![Animation]({video_path})"
+            history.append((None, bot_message))  # Bot message
+            return history
+        
+        # Function wrappers for UI updates with chat history
+        def generate_and_update_chat(prompt, complexity, quality, history):
+            code, video_path, log = generate_animation(prompt, complexity, quality)
+            new_history = update_chat_history(
+                history, 
+                f"**Create animation:** {prompt}",
+                f"**Generated animation:** {memory.current_scenario.title if memory.current_scenario else 'Animation'}", 
+                video_path
+            )
+            return code, video_path, log, new_history
+        
+        def refine_and_update_chat(code, feedback_text, quality, history):
+            refined_code, video_path, log = refine_animation(code, feedback_text, quality)
+            new_history = update_chat_history(
+                history, 
+                f"**Feedback:** {feedback_text}", 
+                f"**Refined animation based on feedback**", 
+                video_path
+            )
+            return refined_code, video_path, log, new_history
+        
+        def rerender_and_update_chat(code, quality, history):
+            video_path, log = rerender_animation(code, quality)
+            new_history = update_chat_history(
+                history, 
+                "**Re-rendered current code**", 
+                "**Re-rendering complete**", 
+                video_path
+            )
+            return video_path, log, new_history
+        
+        # Connect the components to the function
+        generate_btn.click(
+            fn=generate_and_update_chat,
+            inputs=[new_prompt, complexity, quality, chat_history],
+            outputs=[code_output, video_output, log_output, chat_history]
+        )
+        
+        refine_btn.click(
+            fn=refine_and_update_chat,
+            inputs=[code_output, feedback, quality, chat_history],
+            outputs=[code_output, video_output, log_output, chat_history]
+        )
+        
+        rerender_btn.click(
+            fn=rerender_and_update_chat,
+            inputs=[code_output, quality, chat_history],
+            outputs=[video_output, log_output, chat_history]
+        )
+        
+        # Add footer with social media links
+        with gr.Row(equal_height=True):
+            gr.Markdown("""
+                ### Connect With Us
+                
+                [<img src="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png" width="30"/> GitHub](https://github.com/khanhthanhdev/Text2Video) | 
+                [<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/0/05/Facebook_Logo_%282019%29.png/600px-Facebook_Logo_%282019%29.png" width="30"/> Facebook](https://facebook.com/khanhthanhdev)
+                
+                ---
+                *Created with Manim and AI - Share your mathematical animations with the world!*
+            """)
+    
+    demo.launch(server_name="0.0.0.0", server_port=7860)
+

architecture_plan.md

@@ -0,0 +1,63 @@
+# AI Agent Architecture Plan
+
+## 1. Frameworks and Tools
+- **Python**: The primary programming language.
+- **Manim**: For creating mathematical animations.
+- **OpenAI API**: For generating Manim code from text prompts.
+- **pydantic-ai**: For structured AI agent creation, function calling, and workflow management.
+- **Gradio**: For creating a user interface to input prompts and display generated videos.
+- **dotenv**: For managing environment variables.
+- **Logging**: For logging information and errors.
+
+## 2. Agent Architecture
+- **Input Handling**: Use Gradio to create a user interface where users can input text prompts.
+- **Agent Structure**: Leverage pydantic-ai to define the agent's schema, capabilities, and functions.
+- **System Prompts**: Use both static and dynamic system prompts to guide the agent's behavior.
+  - Static prompts: Define the agent's role and general capabilities
+  - Dynamic prompts: Adjust behavior based on complexity settings and current context
+- **Keyword Identification**: Use pydantic-ai with OpenAI API to identify keywords and generate Manim code.
+- **Scenario Creation**: Define structured schemas in pydantic-ai to guide the generation of scenarios.
+- **Function Search**: Use pydantic-ai's function calling capabilities to organize and call Manim functions.
+- **Code Generation and Testing**: The generated code will be tested by rendering the video using Manim.
+
+## 3. Workflow
+1. **User Input**: The user inputs a text prompt describing a mathematical or physics concept.
+2. **Agent Processing**: The pydantic-ai agent processes the input through defined schemas and tools.
+   - System prompts dynamically adjust based on user requirements
+   - Tools are applied in sequence using the agent's capabilities
+3. **Keyword Identification and Scenario Creation**: The agent uses OpenAI API to analyze the prompt and generate a structured scenario.
+4. **Code Generation**: The agent transforms the structured scenario into Manim code using defined tools.
+5. **Video Rendering**: The code is executed using Manim to render the video.
+6. **Output**: The generated video is displayed to the user.
+
+## 4. Detailed Steps
+1. **Setup Environment**:
+   - Ensure all required packages are installed (`gradio`, `openai`, `pydantic-ai`, `dotenv`, `manim`, etc.).
+   - Set up environment variables in `.env` file (e.g., `TOGETHER_API_KEY`).
+   - Configure pydantic-ai with appropriate model settings.
+
+2. **Create Agent Structure**:
+   - Define pydantic models for input prompts, scenario descriptions, and animation parameters.
+   - Create static and dynamic system prompts to guide agent behavior:
+     - Static: Define the agent's role and general capabilities
+     - Dynamic: Adjust behavior based on request complexity and context
+   - Create tool functions for scenario extraction, code generation, and rendering.
+   - Configure the agent with appropriate tools and models.
+
+3. **Create User Interface**:
+   - Use Gradio to create a web interface for inputting prompts and displaying results.
+   - Add complexity selection controls to customize animation generation.
+   - Connect the UI to the pydantic-ai agent.
+
+4. **Generate Manim Code**:
+   - Implement functions using pydantic-ai tools to transform user prompts into structured scenarios.
+   - Convert structured scenarios into Manim code templates.
+   - Fill templates with specifics from the scenario.
+
+5. **Render Video**:
+   - Implement a function to render the generated Manim code into a video.
+   - Add error handling and validation using pydantic models.
+
+6. **Display Results**:
+   - Display the generated video and code in the Gradio interface.
+   - Provide feedback and explanations based on the agent's processing steps.

code_cleaner.py

@@ -0,0 +1,184 @@
+"""
+Utilities for cleaning and validating Manim code generated by LLMs.
+"""
+
+import re
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+def clean_manim_code(raw_code):
+    """
+    Clean Manim code from LLM responses by removing markdown formatting
+    and ensuring proper structure.
+    
+    Args:
+        raw_code (str): The raw code from the LLM response
+        
+    Returns:
+        str: Cleaned, executable Python code
+    """
+    # Start with the raw code
+    code = raw_code
+    
+    # Extract code from markdown code blocks if present
+    if "```python" in code:
+        parts = code.split("```python")
+        if len(parts) > 1:
+            code = parts[1]
+            if "```" in code:
+                code = code.split("```")[0]
+    elif "```" in code:
+        parts = code.split("```")
+        if len(parts) > 1:
+            code = parts[1]
+            if "```" in parts[1]:
+                code = code.split("```")[0]
+    
+    # Remove any remaining backticks
+    code = code.replace('```', '')
+    
+    # Ensure code begins with the necessary import
+    if not code.strip().startswith('from manim import'):
+        code = 'from manim import *\n\n' + code
+    
+    # Verify the code contains a Scene class
+    if 'class' not in code or 'Scene' not in code:
+        logger.warning("Generated code does not contain a proper Scene class")
+        # Add a basic scene structure if missing
+        if 'class ManimScene(Scene):' not in code:
+            code = 'from manim import *\n\nclass ManimScene(Scene):\n    def construct(self):\n        ' + code
+    
+    # Verify the code has a construct method
+    if 'def construct(self)' not in code:
+        logger.warning("Generated code does not contain a construct method")
+        # Try to find where the class is defined and add construct method
+        class_match = re.search(r'class\s+\w+\s*\(\s*Scene\s*\)\s*:', code)
+        if class_match:
+            insert_pos = class_match.end()
+            code = code[:insert_pos] + '\n    def construct(self):\n        pass\n' + code[insert_pos:]
+    
+    # Ensure there's a wait at the end if not present
+    if 'self.wait(' not in code.split('def construct')[-1]:
+        # Find the end of the construct method to add wait
+        construct_body_match = re.search(r'def\s+construct\s*\(\s*self\s*\)\s*:', code)
+        if construct_body_match:
+            # Check if the method has content
+            method_content = code[construct_body_match.end():]
+            indentation = '        '  # Default indentation
+            
+            # Try to determine indentation from code
+            indent_match = re.search(r'\n(\s+)', method_content)
+            if indent_match:
+                indentation = indent_match.group(1)
+            
+            # Find a good place to insert the wait
+            if '}' in method_content.splitlines()[-1]:  # If last line closes something
+                code = code.rstrip() + f'\n{indentation}self.wait(1)\n'
+            else:
+                code = code.rstrip() + f'\n{indentation}self.wait(1)\n'
+    
+    return code.strip()
+
+def parse_scenario_from_llm_response(content):
+    """
+    Extract structured scenario information from an LLM response.
+    
+    Args:
+        content (str): The LLM response text
+        
+    Returns:
+        dict: Extracted scenario dictionary
+    """
+    try:
+        # Try to find and extract a JSON object
+        json_match = re.search(r'\{.*\}', content, re.DOTALL)
+        if json_match:
+            json_str = json_match.group(0)
+            scenario_dict = json.loads(json_str)
+            return scenario_dict
+    except Exception as e:
+        logger.error(f"Error parsing scenario JSON: {e}")
+    
+    # Manual parsing fallback
+    scenario = {
+        "title": "",
+        "objects": [],
+        "transformations": [],
+        "equations": []
+    }
+    
+    # Simple pattern matching to extract information
+    title_match = re.search(r'title["\s:]+([^"]+)', content, re.IGNORECASE)
+    if title_match:
+        scenario["title"] = title_match.group(1).strip()
+    
+    # Extract lists with various possible formats
+    objects_pattern = r'objects[":\s\[]+([^\]]+)'
+    objects_match = re.search(objects_pattern, content, re.IGNORECASE | re.DOTALL)
+    if objects_match:
+        objects_text = objects_match.group(1)
+        # Handle both comma-separated and quote-wrapped items
+        objects = re.findall(r'"([^"]+)"', objects_text)
+        if not objects:
+            objects = [item.strip() for item in objects_text.split(',')]
+        scenario["objects"] = objects
+    
+    # Similar extraction for transformations
+    trans_pattern = r'transformations[":\s\[]+([^\]]+)'
+    trans_match = re.search(trans_pattern, content, re.IGNORECASE | re.DOTALL)
+    if trans_match:
+        trans_text = trans_match.group(1)
+        transformations = re.findall(r'"([^"]+)"', trans_text)
+        if not transformations:
+            transformations = [item.strip() for item in trans_text.split(',')]
+        scenario["transformations"] = transformations
+    
+    # Extract equations if present
+    equations_pattern = r'equations[":\s\[]+([^\]]+)'
+    equations_match = re.search(equations_pattern, content, re.IGNORECASE | re.DOTALL)
+    if equations_match:
+        equations_text = equations_match.group(1)
+        if equations_text.lower().strip() in ['null', 'none']:
+            scenario["equations"] = None
+        else:
+            equations = re.findall(r'"([^"]+)"', equations_text)
+            if not equations:
+                equations = [item.strip() for item in equations_text.split(',')]
+            scenario["equations"] = equations
+    
+    return scenario
+
+def validate_manim_code(code):
+    """
+    Perform basic validation on Manim code to catch common issues.
+    
+    Args:
+        code (str): The Manim code to validate
+        
+    Returns:
+        tuple: (is_valid, error_message)
+    """
+    # Check for basic Python syntax errors
+    try:
+        compile(code, '<string>', 'exec')
+    except SyntaxError as e:
+        return False, f"Syntax error: {str(e)}"
+    
+    # Check for necessary components
+    if 'from manim import' not in code:
+        return False, "Missing Manim import"
+    
+    if 'class' not in code or 'Scene' not in code:
+        return False, "No Scene class defined"
+    
+    if 'def construct(self)' not in code:
+        return False, "No construct method defined"
+    
+    # Check for common Manim issues
+    if 'self.play(' not in code and 'self.add(' not in code:
+        return False, "No objects added to scene (missing self.play or self.add calls)"
+    
+    # All checks passed
+    return True, "Code appears valid"

config.py

@@ -0,0 +1,129 @@
+"""
+Configuration settings and shared utilities for the Manimation project.
+"""
+
+import os
+import openai
+import tempfile
+import subprocess
+import shutil
+import time
+import logging
+from dotenv import load_dotenv
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Configure OpenAI client to use Together API
+def get_openai_client():
+    """Get configured OpenAI client using Together API."""
+    client = openai.OpenAI(
+        api_key=os.environ.get("TOGETHER_API_KEY"),
+        base_url="https://api.together.xyz/v1",
+    )
+    return client
+
+# Define available models
+AVAILABLE_MODELS = {
+    "llama3": "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+    "deepseek": "deepseek-ai/DeepSeek-V3",
+    "mixtral": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+}
+
+# Default model to use
+DEFAULT_MODEL = AVAILABLE_MODELS["deepseek"]
+
+# Shared utility for rendering manim videos
+def render_manim_video(code, quality="medium_quality"):
+    """
+    Render Manim code into a video file.
+    
+    Args:
+        code (str): Manim Python code to render
+        quality (str): Quality level - "low_quality", "medium_quality", or "high_quality"
+        
+    Returns:
+        str: Path to the rendered video file or error message
+    """
+    try:
+        temp_dir = tempfile.mkdtemp()
+        script_path = os.path.join(temp_dir, "manim_script.py")
+        
+        with open(script_path, "w") as f:
+            f.write(code)
+        
+        class_name = None
+        for line in code.split("\n"):
+            if line.startswith("class ") and "Scene" in line:
+                class_name = line.split("class ")[1].split("(")[0].strip()
+                break
+        
+        if not class_name:
+            return "Error: Could not identify the Scene class in the generated code."
+        
+        if quality == "high_quality":
+            command = ["manim", "-qh", script_path, class_name]
+            quality_dir = "1080p60"
+        elif quality == "low_quality":
+            command = ["manim", "-ql", script_path, class_name]
+            quality_dir = "480p15"
+        else:
+            command = ["manim", "-qm", script_path, class_name]
+            quality_dir = "720p30"
+        
+        logger.info(f"Executing command: {' '.join(command)}")
+        
+        result = subprocess.run(command, cwd=temp_dir, capture_output=True, text=True)
+        
+        logger.info(f"Manim stdout: {result.stdout}")
+        logger.error(f"Manim stderr: {result.stderr}")
+        
+        if result.returncode != 0:
+            logger.error(f"Manim execution failed: {result.stderr}")
+            return f"Error rendering video: {result.stderr}"
+        
+        media_dir = os.path.join(temp_dir, "media")
+        videos_dir = os.path.join(media_dir, "videos")
+        
+        if not os.path.exists(videos_dir):
+            return "Error: No video was generated. Check if Manim is installed correctly."
+        
+        scene_dirs = [d for d in os.listdir(videos_dir) if os.path.isdir(os.path.join(videos_dir, d))]
+        
+        if not scene_dirs:
+            return "Error: No scene directory found in the output."
+        
+        scene_dir = max([os.path.join(videos_dir, d) for d in scene_dirs], key=os.path.getctime)
+        
+        mp4_files = [f for f in os.listdir(os.path.join(scene_dir, quality_dir)) if f.endswith(".mp4")]
+        
+        if not mp4_files:
+            return "Error: No MP4 file was generated."
+        
+        video_file = max([os.path.join(scene_dir, quality_dir, f) for f in mp4_files], key=os.path.getctime)
+        
+        output_dir = os.path.join(os.getcwd(), "generated_videos")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        timestamp = int(time.time())
+        output_file = os.path.join(output_dir, f"manim_video_{timestamp}.mp4")
+        
+        shutil.copy2(video_file, output_file)
+        
+        logger.info(f"Video generated: {output_file}")
+        
+        return output_file
+        
+    except Exception as e:
+        logger.error(f"Error rendering video: {e}")
+        return f"Error rendering video: {str(e)}"
+    finally:
+        if 'temp_dir' in locals():
+            try:
+                shutil.rmtree(temp_dir)
+            except Exception as e:
+                logger.error(f"Error cleaning up temporary directory: {e}")

main.py

@@ -0,0 +1,307 @@
+import gradio as gr
+import os
+import tempfile
+import subprocess
+import shutil
+import logging
+import time
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def get_client():
+    return OpenAI(
+        api_key=os.environ.get("TOGETHER_API_KEY"),
+        base_url="https://api.together.xyz/v1"
+    )
+
+AVAILABLE_MODELS = [
+    "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    "deepseek-ai/DeepSeek-V3",
+    "deepseek-ai/DeepSeek-R1",
+    "Qwen/QwQ-32B-Preview",
+    "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+    "Qwen/Qwen2.5-Coder-32B-Instruct"
+]
+
+def generate_manim_code(prompt, model_name, temperature=0.7, max_tokens=8192):
+    try:
+        client = get_client()
+        system_prompt = """
+        You are an expert in creating mathematical and physics visualizations using Manim (Mathematical Animation Engine).
+        Your task is to convert a text prompt into valid, executable Manim Python code.
+        
+        IMPORTANT RULES FOR COMPILATION SUCCESS:
+        1. Only return valid Python code that works with the latest version of Manim Community edition
+        2. Do NOT include any explanations outside of code comments
+        3. Use ONLY the Scene class as the base class
+        4. Include ALL necessary imports at the top (from manim import *)
+        5. Use descriptive variable names that follow Python conventions
+        6. Include helpful comments for complex parts of the visualization
+        7. The class name MUST be "Screen" - always use this exact name
+        8. Always implement the construct method correctly
+        9. Ensure all objects are properly added to the scene with self.play() or self.add()
+        10. Do not create custom classes other than the main Scene class
+        11. Include proper self.wait() calls after animations for better viewing
+        12. Check all mathematical expressions are valid LaTeX syntax
+        13. Avoid advanced or experimental Manim features that might not be widely available
+        14. Keep animations under 20 seconds total for better performance
+        15. Ensure all coordinates and dimensions are appropriate for the default canvas size
+        16. DO NOT include any backticks (```) or markdown formatting in your response
+        
+        RESPOND WITH ONLY THE EXECUTABLE PYTHON CODE, NO INTRODUCTION OR EXPLANATION, NO MARKDOWN FORMATTING.
+        """
+        
+        final_prompt = f"Create a Manim visualization that explains: {prompt}"
+        
+        logger.info(f"Generating code with model: {model_name}")
+        
+        response = client.chat.completions.create(
+            model=model_name,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": final_prompt}
+            ]
+        )
+        
+        generated_code = response.choices[0].message.content
+        
+        # Strip markdown formatting if it appears in the response
+        if "```python" in generated_code:
+            generated_code = generated_code.split("```python")[1]
+            if "```" in generated_code:
+                generated_code = generated_code.split("```")[0]
+        elif "```" in generated_code:
+            generated_code = generated_code.split("```")[1]
+            if "```" in generated_code:
+                generated_code = generated_code.split("```")[0]
+        
+        # Remove any additional backticks that might cause syntax errors
+        generated_code = generated_code.replace('```', '')
+        
+        # Ensure code starts with proper import
+        if not generated_code.strip().startswith('from manim import'):
+            generated_code = 'from manim import *\n\n' + generated_code
+            
+        return generated_code.strip()
+        
+    except Exception as e:
+        logger.error(f"Error generating code: {e}")
+        return f"Error generating code: {str(e)}"
+
+def render_manim_video(code, quality="medium_quality"):
+    try:
+        temp_dir = tempfile.mkdtemp()
+        script_path = os.path.join(temp_dir, "manim_script.py")
+        
+        with open(script_path, "w") as f:
+            f.write(code)
+        
+        class_name = None
+        for line in code.split("\n"):
+            if line.startswith("class ") and "Scene" in line:
+                class_name = line.split("class ")[1].split("(")[0].strip()
+                break
+        
+        if not class_name:
+            return "Error: Could not identify the Scene class in the generated code."
+        
+        if quality == "high_quality":
+            command = ["manim", "-qh", script_path, class_name]
+            quality_dir = "1080p60"
+        elif quality == "low_quality":
+            command = ["manim", "-ql", script_path, class_name]
+            quality_dir = "480p15"
+        else:
+            command = ["manim", "-qm", script_path, class_name]
+            quality_dir = "720p30"
+        
+        logger.info(f"Executing command: {' '.join(command)}")
+        
+        result = subprocess.run(command, cwd=temp_dir, capture_output=True, text=True)
+        
+        logger.info(f"Manim stdout: {result.stdout}")
+        logger.error(f"Manim stderr: {result.stderr}")
+        
+        if result.returncode != 0:
+            logger.error(f"Manim execution failed: {result.stderr}")
+            return f"Error rendering video: {result.stderr}"
+        
+        media_dir = os.path.join(temp_dir, "media")
+        videos_dir = os.path.join(media_dir, "videos")
+        
+        if not os.path.exists(videos_dir):
+            return "Error: No video was generated. Check if Manim is installed correctly."
+        
+        scene_dirs = [d for d in os.listdir(videos_dir) if os.path.isdir(os.path.join(videos_dir, d))]
+        
+        if not scene_dirs:
+            return "Error: No scene directory found in the output."
+        
+        scene_dir = max([os.path.join(videos_dir, d) for d in scene_dirs], key=os.path.getctime)
+        
+        mp4_files = [f for f in os.listdir(os.path.join(scene_dir, quality_dir)) if f.endswith(".mp4")]
+        
+        if not mp4_files:
+            return "Error: No MP4 file was generated."
+        
+        video_file = max([os.path.join(scene_dir, quality_dir, f) for f in mp4_files], key=os.path.getctime)
+        
+        output_dir = os.path.join(os.getcwd(), "generated_videos")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        timestamp = int(time.time())
+        output_file = os.path.join(output_dir, f"manim_video_{timestamp}.mp4")
+        
+        shutil.copy2(video_file, output_file)
+        
+        logger.info(f"Video generated: {output_file}")
+        
+        return output_file
+        
+    except Exception as e:
+        logger.error(f"Error rendering video: {e}")
+        return f"Error rendering video: {str(e)}"
+    finally:
+        if 'temp_dir' in locals():
+            try:
+                shutil.rmtree(temp_dir)
+            except Exception as e:
+                logger.error(f"Error cleaning up temporary directory: {e}")
+
+def placeholder_for_examples(prompt, model, quality):
+    code = """
+from manim import *
+
+class PythagoreanTheorem(Scene):
+    def construct(self):
+        # This is placeholder code for examples
+        # Creating a right triangle
+        triangle = Polygon(
+            ORIGIN, 
+            RIGHT * 3, 
+            UP * 4, 
+            color=WHITE
+        )
+        
+        # Adding labels
+        a = Text("a", font_size=30).next_to(triangle, DOWN)
+        b = Text("b", font_size=30).next_to(triangle, RIGHT)
+        c = Text("c", font_size=30).next_to(
+            triangle.get_center(), 
+            UP + LEFT
+        )
+        
+        # Add to scene
+        self.play(Create(triangle))
+        self.play(Write(a), Write(b), Write(c))
+        
+        # Wait at the end
+        self.wait(2)
+"""
+    return code, None, "Example mode: Click 'Generate Video' to actually process this example"
+
+def process_prompt(prompt, model_name, quality="medium_quality"):
+    try:
+        code = generate_manim_code(prompt, model_name)
+        video_path = render_manim_video(code, quality)
+        return code, video_path
+    except Exception as e:
+        logger.error(f"Error processing prompt: {e}")
+        return f"Error: {str(e)}", None
+
+def process_prompt_with_status(prompt, model, quality, progress=gr.Progress()):
+    try:
+        progress(0, desc="Starting...")
+        
+        progress(0.3, desc="Generating Manim code using AI...")
+        code = generate_manim_code(prompt, model)
+        
+        progress(0.6, desc="Rendering video with Manim (this may take a few minutes)...")
+        video_path = render_manim_video(code, quality)
+        
+        progress(1.0, desc="Complete")
+        
+        if not video_path or video_path.startswith("Error"):
+            status = video_path if video_path else "Error: Failed to generate video."
+            return code, None, status
+        else:
+            status = "Video generated successfully!"
+            return code, video_path, status
+            
+    except Exception as e:
+        logger.error(f"Error in processing: {e}")
+        return (code if 'code' in locals() else "Error generating code"), None, f"Error: {str(e)}"
+
+def create_interface():
+    with gr.Blocks(title="Math & Physics Video Generator") as app:
+        gr.Markdown("# Interactive Math & Physics Video Generator")
+        gr.Markdown("Generate educational videos from text prompts using AI and Manim")
+        
+        with gr.Row():
+            with gr.Column():
+                model_dropdown = gr.Dropdown(
+                    choices=AVAILABLE_MODELS,
+                    value=AVAILABLE_MODELS[1],
+                    label="Select AI Model"
+                )
+                quality_radio = gr.Radio(
+                    choices=["low_quality", "medium_quality", "high_quality"],
+                    value="medium_quality",
+                    label="Output Quality (affects rendering time)"
+                )
+                prompt_input = gr.Textbox(
+                    placeholder="Enter a mathematical or physics concept to visualize...",
+                    label="Prompt",
+                    lines=3
+                )
+                submit_btn = gr.Button("Generate Video", variant="primary")
+                
+                with gr.Accordion("Generated Manim Code", open=False):
+                    code_output = gr.Code(
+                        language="python",
+                        label="Generated Manim Code",
+                        lines=20
+                    )
+            
+            with gr.Column():
+                video_output = gr.Video(
+                    label="Generated Animation",
+                    width="100%",
+                    height=500
+                )
+                status_output = gr.Textbox(
+                    label="Status",
+                    value="Ready. Enter a prompt and click 'Generate Video'.",
+                    interactive=False
+                )
+        
+        submit_btn.click(
+            fn=process_prompt_with_status,
+            inputs=[prompt_input, model_dropdown, quality_radio],
+            outputs=[code_output, video_output, status_output]
+        )
+        
+        gr.Examples(
+            examples=[
+                ["Explain the Pythagorean theorem", AVAILABLE_MODELS[1], "medium_quality"],
+                ["Show how a pendulum works with damping", AVAILABLE_MODELS[1], "medium_quality"],
+                ["Demonstrate the concept of derivatives in calculus", AVAILABLE_MODELS[1], "medium_quality"],
+                ["Visualize the wave function of a particle in a box", AVAILABLE_MODELS[1], "medium_quality"],
+                ["Explain how a capacitor charges and discharges", AVAILABLE_MODELS[1], "medium_quality"]
+            ],
+            inputs=[prompt_input, model_dropdown, quality_radio],
+            fn=placeholder_for_examples
+        )
+    
+    return app
+
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(share=True)

manim_prompts.py

@@ -0,0 +1,85 @@
+"""
+Optimized prompts for generating Manim code using LLMs.
+"""
+
+# Basic prompt for Manim code generation
+MANIM_CODE_SYSTEM_PROMPT = """
+You are an expert in creating mathematical and physics visualizations using Manim (Mathematical Animation Engine).
+Your task is to convert a text prompt into valid, executable Manim Python code.
+
+IMPORTANT RULES FOR COMPILATION SUCCESS:
+1. Only return valid Python code that works with the latest version of Manim Community edition
+2. Do NOT include any explanations outside of code comments
+3. Use ONLY the Scene class as the base class
+4. Include ALL necessary imports at the top (from manim import *)
+5. Use descriptive variable names that follow Python conventions
+6. Include helpful comments for complex parts of the visualization
+7. The class name MUST be "ManimScene" - always use this exact name
+8. Always implement the construct method correctly
+9. Ensure all objects are properly added to the scene with self.play() or self.add()
+10. Do not create custom classes other than the main Scene class
+11. Include proper self.wait() calls after animations for better viewing
+12. Check all mathematical expressions are valid LaTeX syntax
+13. Avoid advanced or experimental Manim features that might not be widely available
+14. Keep animations under 20 seconds total for better performance
+15. Ensure all coordinates and dimensions are appropriate for the default canvas size
+
+REQUIRED CODE FORMAT:
+```python
+from manim import *
+
+class ManimScene(Scene):
+    def construct(self):
+        # Your animation code here
+        # ...
+        # Final wait
+        self.wait(1)
+```
+
+RESPOND WITH ONLY THE EXECUTABLE PYTHON CODE, NO INTRODUCTION OR EXPLANATION.
+"""
+
+# Simple complexity prompt adjustment
+SIMPLE_COMPLEXITY_PROMPT = """
+Create simple, beginner-friendly Manim code with minimal elements. Focus on:
+- Basic shapes and transformations
+- Clear, readable labels
+- Simple animations with few elements
+- Step-by-step visualization of the concept
+- No more than 2-3 different objects on screen
+- Linear progression of concepts
+"""
+
+# Medium complexity prompt adjustment
+MEDIUM_COMPLEXITY_PROMPT = """
+Create balanced Manim code that is both clear and somewhat detailed. Include:
+- Multiple related shapes and transformations
+- Clear mathematical labeling
+- Moderate level of animation complexity
+- Both visualization and mathematical notation
+- Appropriate use of color and positioning
+- A logical flow that builds understanding
+"""
+
+# Complex complexity prompt adjustment
+COMPLEX_COMPLEXITY_PROMPT = """
+Create sophisticated Manim animations with detailed mathematical elements. Include:
+- Multiple related mathematical objects and their interactions
+- Precise mathematical notation and labeling
+- Advanced transformations and animations
+- Detailed visualization of the mathematical concept
+- Professional use of color, positioning and timing
+- Build from simple to complex understanding
+"""
+
+def get_manim_prompt(complexity="medium"):
+    """Get the appropriate Manim prompt based on complexity level."""
+    
+    base_prompt = MANIM_CODE_SYSTEM_PROMPT
+    
+    if complexity == "simple":
+        return base_prompt + "\n\n" + SIMPLE_COMPLEXITY_PROMPT
+    elif complexity == "complex":
+        return base_prompt + "\n\n" + COMPLEX_COMPLEXITY_PROMPT
+    else:  # medium is default
+        return base_prompt + "\n\n" + MEDIUM_COMPLEXITY_PROMPT

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+openai
+python-dotenv
+manim
+pydantic
+pydantic-ai

simple_manim_agent.py

@@ -0,0 +1,329 @@
+"""
+Simplified example of a Manim animation generator using pydantic-ai.
+"""
+
+import os
+from typing import List, Optional
+from dotenv import load_dotenv
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai import Agent, RunContext
+from pydantic import BaseModel, Field
+from datetime import datetime
+import openai
+import tempfile
+import subprocess
+import shutil
+import time
+import logging
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging if not already done
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class AnimationPrompt(BaseModel):
+    """User input for animation generation."""
+    description: str = Field(..., description="Description of the mathematical concept to animate")
+    complexity: str = Field("medium", description="Desired complexity of the animation (simple, medium, complex)")
+
+class AnimationOutput(BaseModel):
+    """Output of the animation generation."""
+    manim_code: str = Field(..., description="Generated Manim code")
+    explanation: str = Field(..., description="Explanation of the animation")
+
+# Create the animation agent with basic static system prompt
+model = OpenAIModel(
+    'deepseek-ai/DeepSeek-V3',
+    provider=OpenAIProvider(
+        base_url='https://api.together.xyz/v1', api_key=os.environ.get('TOGETHER_API_KEY')
+    ),
+)
+
+animation_agent = Agent(
+    model,
+    deps_type=AnimationPrompt,
+    system_prompt=(
+        "You are a mathematical animation specialist. Your job is to convert text descriptions "
+        "into Manim code that visualizes mathematical concepts. Provide clear and accurate code."
+    )
+)
+
+# Configure OpenAI client to use Together API
+client = openai.OpenAI(
+    api_key=os.environ.get("TOGETHER_API_KEY"),
+    base_url="https://api.together.xyz/v1",
+)
+
+# Add dynamic system prompts
+@animation_agent.system_prompt
+def add_complexity_guidance(ctx: RunContext[AnimationPrompt]) -> str:
+    """Add guidance based on requested complexity."""
+    complexity = ctx.deps.complexity
+    if complexity == "simple":
+        return "Generate simple, beginner-friendly Manim code with minimal elements and clear explanations."
+    elif complexity == "complex":
+        return "Generate advanced Manim code with sophisticated animations and detailed mathematical representations."
+    else:  # medium
+        return "Generate standard Manim code that balances simplicity and detail to effectively demonstrate the concept."
+
+@animation_agent.system_prompt
+def add_timestamp() -> str:
+    """Add a timestamp to help with freshness of information."""
+    return f"Current timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+
+@animation_agent.tool
+def generate_manim_code(ctx: RunContext[AnimationPrompt]) -> str:
+    """Generate Manim code based on the user's description."""
+    prompt = ctx.deps
+    
+    # Use Together API with OpenAI client
+    response = client.chat.completions.create(
+        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        messages=[
+            {"role": "system", "content": """
+Generate Manim code for mathematical animations. The code MUST:
+1. Be fully compilable without errors using Manim Community edition
+2. Use only the Scene class with a class name 'ManimScene' exactly
+3. Include 'from manim import *' at the top
+4. Implement the construct method only
+5. Use only standard Manim objects and methods
+6. Include proper self.play() and self.wait() calls
+7. Use valid LaTeX syntax for any mathematical expressions
+8. Avoid experimental or uncommon Manim features
+9. Keep the animation clean, concise, and educational
+10. Include proper error handling for all mathematical operations
+11. DO NOT include any backticks (```) or markdown formatting in your response
+
+RESPOND WITH CODE ONLY, NO EXPLANATIONS OUTSIDE OF CODE COMMENTS, NO MARKDOWN FORMATTING.
+"""
+            },
+            {"role": "user", "content": f"Create Manim code for a {prompt.complexity} animation of {prompt.description}"}
+        ]
+    )
+    
+    generated_code = response.choices[0].message.content
+    
+    # Strip markdown formatting if it appears in the response
+    if "```python" in generated_code:
+        generated_code = generated_code.split("```python")[1]
+        if "```" in generated_code:
+            generated_code = generated_code.split("```")[0]
+    
+    return generated_code
+
+@animation_agent.tool
+def explain_animation(ctx: RunContext[AnimationPrompt], code: str) -> str:
+    """Explain the generated animation in plain language."""
+    prompt = ctx.deps
+    
+    # Use Together API with OpenAI client
+    response = client.chat.completions.create(
+        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        messages=[
+            {"role": "system", "content": "Explain mathematical animations in simple terms."},
+            {"role": "user", "content": f"Explain this Manim animation of {prompt.description} " +
+                                       f"with complexity {prompt.complexity} in simple terms:\n{code}"}
+        ]
+    )
+    
+    return response.choices[0].message.content
+
+def render_manim_video(code, quality="medium_quality"):
+    try:
+        temp_dir = tempfile.mkdtemp()
+        script_path = os.path.join(temp_dir, "manim_script.py")
+        
+        with open(script_path, "w") as f:
+            f.write(code)
+        
+        class_name = None
+        for line in code.split("\n"):
+            if line.startswith("class ") and "Scene" in line:
+                class_name = line.split("class ")[1].split("(")[0].strip()
+                break
+        
+        if not class_name:
+            return "Error: Could not identify the Scene class in the generated code."
+        
+        if quality == "high_quality":
+            command = ["manim", "-qh", script_path, class_name]
+            quality_dir = "1080p60"
+        elif quality == "low_quality":
+            command = ["manim", "-ql", script_path, class_name]
+            quality_dir = "480p15"
+        else:
+            command = ["manim", "-qm", script_path, class_name]
+            quality_dir = "720p30"
+        
+        logger.info(f"Executing command: {' '.join(command)}")
+        
+        result = subprocess.run(command, cwd=temp_dir, capture_output=True, text=True)
+        
+        logger.info(f"Manim stdout: {result.stdout}")
+        logger.error(f"Manim stderr: {result.stderr}")
+        
+        if result.returncode != 0:
+            logger.error(f"Manim execution failed: {result.stderr}")
+            return f"Error rendering video: {result.stderr}"
+        
+        media_dir = os.path.join(temp_dir, "media")
+        videos_dir = os.path.join(media_dir, "videos")
+        
+        if not os.path.exists(videos_dir):
+            return "Error: No video was generated. Check if Manim is installed correctly."
+        
+        scene_dirs = [d for d in os.listdir(videos_dir) if os.path.isdir(os.path.join(videos_dir, d))]
+        
+        if not scene_dirs:
+            return "Error: No scene directory found in the output."
+        
+        scene_dir = max([os.path.join(videos_dir, d) for d in scene_dirs], key=os.path.getctime)
+        
+        mp4_files = [f for f in os.listdir(os.path.join(scene_dir, quality_dir)) if f.endswith(".mp4")]
+        
+        if not mp4_files:
+            return "Error: No MP4 file was generated."
+        
+        video_file = max([os.path.join(scene_dir, quality_dir, f) for f in mp4_files], key=os.path.getctime)
+        
+        output_dir = os.path.join(os.getcwd(), "generated_videos")
+        os.makedirs(output_dir, exist_ok=True)
+        
+        timestamp = int(time.time())
+        output_file = os.path.join(output_dir, f"manim_video_{timestamp}.mp4")
+        
+        shutil.copy2(video_file, output_file)
+        
+        logger.info(f"Video generated: {output_file}")
+        
+        return output_file
+        
+    except Exception as e:
+        logger.error(f"Error rendering video: {e}")
+        return f"Error rendering video: {str(e)}"
+    finally:
+        if 'temp_dir' in locals():
+            try:
+                shutil.rmtree(temp_dir)
+            except Exception as e:
+                logger.error(f"Error cleaning up temporary directory: {e}")
+
+def run_animation_agent(description: str, complexity: str = "medium", quality: str = "medium_quality") -> AnimationOutput:
+    """Run the animation agent to generate code and explanation."""
+    prompt = AnimationPrompt(description=description, complexity=complexity)
+    
+    # Use the agent to process the request
+    result = animation_agent.run_sync(
+        "Generate Manim code for this animation and explain what it does", 
+        deps=prompt
+    )
+    
+    # Generate code and explanation
+    code = None
+    explanation = None
+    
+    # As a fallback, provide a direct implementation specific to the Pythagorean theorem
+    if "pythagorean theorem" in description.lower():
+        code = f"""
+from manim import *
+
+class ManimScene(Scene):
+    def construct(self):
+        # Animation for: {prompt.description}
+        # Complexity level: {prompt.complexity}
+        
+        # Create a right triangle
+        triangle = Polygon(
+            ORIGIN,
+            RIGHT * 3,
+            UP * 4,
+            color=WHITE
+        )
+        
+        # Labels for sides
+        a_label = MathTex("a").next_to(triangle, DOWN)
+        b_label = MathTex("b").next_to(triangle, RIGHT)
+        c_label = MathTex("c").next_to(triangle.get_center(), UP + LEFT)
+        
+        # The equation
+        equation = MathTex("a^2 + b^2 = c^2").to_edge(DOWN)
+        
+        # Display the triangle and labels
+        self.play(Create(triangle))
+        self.play(Write(a_label), Write(b_label), Write(c_label))
+        self.wait()
+        
+        # Show the equation
+        self.play(Write(equation))
+        self.wait()
+    """
+        
+        explanation = (
+            f"This animation visualizes {prompt.description} with a {prompt.complexity} "
+            f"complexity level. It creates a right triangle and labels its sides a, b, and c. "
+            f"It then displays the Pythagorean theorem equation a² + b² = c²."
+        )
+    else:
+        # Generic fallback
+        code = f"""
+from manim import *
+
+class ManimScene(Scene):
+    def construct(self):
+        # Animation for: {prompt.description}
+        # Complexity level: {prompt.complexity}
+        
+        # Title
+        title = Text("{description}")
+        self.play(Write(title))
+        self.wait()
+        self.play(title.animate.to_edge(UP))
+        
+        # Main content based on complexity
+        if "{complexity}" == "simple":
+            # Simple visualization
+            circle = Circle()
+            self.play(Create(circle))
+            self.wait()
+        else:
+            # More complex visualization
+            axes = Axes(
+                x_range=[-3, 3],
+                y_range=[-3, 3],
+                axis_config={"color": BLUE}
+            )
+            self.play(Create(axes))
+            
+            # Add a function graph
+            graph = axes.plot(lambda x: x**2, color=YELLOW)
+            self.play(Create(graph))
+            self.wait()
+        """
+        
+        explanation = (
+            f"This animation visualizes {prompt.description} with a {prompt.complexity} "
+            f"complexity level. It displays a title and creates a visualization that matches "
+            f"the requested complexity."
+        )
+    
+    # Try to render the video
+    if code:
+        video_path = render_manim_video(code, quality)
+        if video_path and not video_path.startswith("Error"):
+            print(f"Video rendered successfully at: {video_path}")
+    
+    return AnimationOutput(manim_code=code, explanation=explanation)
+
+if __name__ == "__main__":
+    # Example usage
+    result = run_animation_agent(
+        "the Pythagorean theorem showing how a² + b² = c²", 
+        complexity="simple"
+    )
+    print("=== Generated Manim Code ===")
+    print(result.manim_code)
+    print("\n=== Explanation ===")
+    print(result.explanation)