vid gen

agent_setup.py

@@ -22,7 +22,7 @@ def initialize_adk(vision_model, processor, retriever):
 
             agent = Agent(
                 name="AuraMindGlowAgent",
-                model="gemini-2.5-flash",
+                model="gemini-2.0-flash",
                 description="A farming assistant that can diagnose plant health and suggest remedies.",
                 instruction="You are a friendly farming assistant. Your goal is to help users identify plant health issues and find solutions. Use your tools to diagnose the plant from an image and then find a remedy.",
                 tools=[diagnosis_tool, remedy_tool]

app.py

@@ -2,7 +2,7 @@
 # Aura Mind Glow - Main Application (Refactored)
 # ==============================================================================
 """
-This script launches the Aura Mind Glow application.
+This script launches the Aura Mind Glow application, now with multiple modes.
 """
 
 # --- Step 0: Essential Imports ---
@@ -22,6 +22,8 @@ from vision_model import load_vision_model
 from knowledge_base import get_retriever
 from agent_setup import initialize_adk
 from google.genai import types
+from story_generator import create_story_prompt_from_pdf, generate_video_from_prompt
+from langchain_huggingface import HuggingFaceEndpoint
 
 print("✅ All libraries imported successfully.")
 
@@ -32,19 +34,35 @@ print("Performing initial setup...")
 VISION_MODEL, PROCESSOR = load_vision_model()
 RETRIEVER = get_retriever()
 
-# Initialize ADK components
+# Initialize ADK components for Connected Mode
 adk_components = initialize_adk(VISION_MODEL, PROCESSOR, RETRIEVER)
 ADK_RUNNER = adk_components["runner"] if adk_components else None
 DIAGNOSIS_TOOL = adk_components["diagnosis_tool"] if adk_components else None
 REMEDY_TOOL = adk_components["remedy_tool"] if adk_components else None
 SESSION_SERVICE = adk_components["session_service"] if adk_components else None
 
+# Initialize a separate LLM for the Story Generator
+STORY_LLM = None
+if os.environ.get("HF_TOKEN"):
+    try:
+        STORY_LLM = HuggingFaceEndpoint(
+            repo_id="HuggingFaceH4/zephyr-7b-beta",
+            huggingfacehub_api_token=os.environ.get("HF_TOKEN"),
+            max_new_tokens=150,
+            temperature=0.4,
+        )
+        print("✅ Story Generator LLM initialized successfully.")
+    except Exception as e:
+        print(f"❌ Could not initialize Story Generator LLM: {e}")
+else:
+    print("❌ HF_TOKEN not found. Story Generator Mode will be disabled.")
+
 
 # --- Step 3: Define Gradio UIs ---
 
 def create_field_mode_ui():
     """Creates the Gradio UI for the offline Field Mode."""
-
+    # ... (This function remains unchanged) ...
     def get_diagnosis_and_remedy(uploaded_image: Image.Image) -> str:
         if uploaded_image is None:
             return "Please upload an image of a maize plant first."
@@ -104,9 +122,9 @@ def create_field_mode_ui():
         css=css
     )
 
-
 def create_connected_mode_ui():
     """Creates the Gradio UI for the online Connected Mode."""
+    # ... (This function remains unchanged) ...
     with gr.Blocks(theme=gr.themes.Soft(primary_hue="green", secondary_hue="lime")) as demo:
         gr.Markdown("# 🌽 Aura Mind Glow: Connected Mode 🤖")
         gr.Markdown("I am an AI farming assistant. Upload an image and ask for a diagnosis and remedy.")
@@ -170,6 +188,51 @@ def create_connected_mode_ui():
 
     return demo
 
+def create_story_mode_ui():
+    """Creates the Gradio UI for the Farmer's Story Mode."""
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="yellow")) as demo:
+        gr.Markdown("# 🌽 Aura Mind Glow: Farmer's Story Mode 🎬")
+        gr.Markdown("Create a short video story from your farm documents. Upload a PDF, describe the mood, and let the AI create a visual story.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                pdf_input = gr.File(label="Upload Farm PDF", file_types=[".pdf"])
+                image_input = gr.Image(type="filepath", label="Optional: Upload a Starting Image")
+                user_prompt_input = gr.Textbox(label="Describe the video's tone or theme", placeholder="e.g., hopeful, a look back at a tough season, etc.")
+                submit_btn = gr.Button("Generate Video Story")
+            with gr.Column(scale=2):
+                video_output = gr.Video(label="Generated Video Story")
+                status_output = gr.Textbox(label="Status", interactive=False, lines=3)
+
+        def story_generation_process(pdf, image, user_prompt):
+            if pdf is None:
+                yield None, "Please upload a PDF document to begin."
+                return
+
+            yield None, "Step 1: Reading PDF and generating creative prompt..."
+
+            creative_prompt = create_story_prompt_from_pdf(pdf.name, user_prompt, STORY_LLM)
+
+            if "Error" in creative_prompt:
+                yield None, creative_prompt
+                return
+
+            yield None, f"Step 2: Generating video with prompt: '{creative_prompt[:100]}...' (This may take several minutes)"
+
+            video_path = generate_video_from_prompt(creative_prompt, image)
+
+            if "Error" in video_path:
+                yield None, video_path
+                return
+
+            yield video_path, "Video generation complete!"
+
+        submit_btn.click(
+            story_generation_process,
+            inputs=[pdf_input, image_input, user_prompt_input],
+            outputs=[video_output, status_output]
+        )
+    return demo
 
 # --- Step 4: App Launcher ---
 
@@ -184,11 +247,32 @@ def check_internet_connection(host="8.8.8.8", port=53, timeout=3):
 
 
 if __name__ == "__main__":
-    if check_internet_connection() and ADK_RUNNER:
-        print("✅ Internet connection detected. Launching Connected Mode.")
-        ui = create_connected_mode_ui()
+    field_mode_ui = create_field_mode_ui()
+    interface_list = [field_mode_ui]
+    tab_titles = ["Field Mode (Offline)"]
+
+    # Conditionally add modes that require an internet connection
+    if check_internet_connection():
+        if ADK_RUNNER:
+            connected_mode_ui = create_connected_mode_ui()
+            interface_list.append(connected_mode_ui)
+            tab_titles.append("Connected Mode")
+        else:
+            print("⚠️ Connected Mode disabled: ADK components not initialized.")
+
+        if STORY_LLM:
+            story_mode_ui = create_story_mode_ui()
+            interface_list.append(story_mode_ui)
+            tab_titles.append("Farmer's Story Mode")
+        else:
+            print("⚠️ Farmer's Story Mode disabled: Story LLM not initialized.")
+    else:
+        print("❌ No internet connection. Launching in Offline Mode only.")
+
+    # Launch the appropriate UI
+    if len(interface_list) > 1:
+        ui = gr.TabbedInterface(interface_list, tab_titles)
     else:
-        print("❌ No internet connection or ADK setup failed. Launching Field Mode (Offline).")
-        ui = create_field_mode_ui()
+        ui = field_mode_ui
 
-    ui.launch(share=True, debug=True)
+    ui.launch(share=True, debug=True)

requirements.txt

@@ -16,4 +16,5 @@ pymupdf
 duckduckgo-search
 langgraph
 google-genai
-google-adk
+google-adk
+pypdf

story_generator.py

@@ -0,0 +1,91 @@
+
+import time
+import os
+from google import genai
+from google.genai import types
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_huggingface import HuggingFaceEndpoint
+from PIL import Image
+from utils import retry_with_exponential_backoff
+
+def create_story_prompt_from_pdf(pdf_path: str, user_prompt: str, llm: HuggingFaceEndpoint) -> str:
+    """
+    Reads a PDF, summarizes its content, and creates a creative prompt for video generation.
+    """
+    try:
+        # 1. Load and read the PDF
+        loader = PyPDFLoader(pdf_path)
+        pages = loader.load_and_split()
+        # Limit to first 3 pages for brevity and to manage token count
+        pdf_content = " ".join(page.page_content for page in pages[:3])
+
+        # 2. Use an LLM to generate a creative prompt
+        system_prompt = """You are a creative assistant for a farmer. Your task is to read the summary of a document and a user's desired tone, and then write a short, visually descriptive prompt for a video generation model (like Google Veo). The prompt should tell a story about a farmer dealing with this paperwork, capturing the user's desired tone. Describe the scene, camera shots, and the farmer's actions.
+
+        Example:
+        - Document Summary: "Invoice for tractor parts, total $2,500. Delivery next week."
+        - User Tone: "A feeling of progress and investment in the future."
+        - Generated Prompt: "Close up on a farmer's weathered hands circling a date on a calendar in a rustic office. The camera pulls back to reveal invoices on the desk. The farmer looks out the window at the fields, a determined smile on their face. Golden morning light fills the room. Cinematic, hopeful, 4k."
+        """
+
+        human_prompt = f"""
+        Document Summary: "{pdf_content[:1500]}"
+        User Tone: "{user_prompt}"
+
+        Generate a creative video prompt based on the summary and tone.
+        """
+
+        # The llm object from HuggingFaceEndpoint expects a string prompt
+        creative_prompt = llm.invoke(human_prompt, config={"system_prompt": system_prompt})
+
+        print(f"Generated creative prompt: {creative_prompt}")
+        return creative_prompt
+
+    except Exception as e:
+        print(f"Error creating story from PDF: {e}")
+        return f"Error processing PDF: {e}"
+
+@retry_with_exponential_backoff
+def generate_video_from_prompt(prompt: str, image_path: str = None) -> str:
+    """
+    Generates a video using the Veo API from a text prompt and an optional starting image.
+    Returns the path to the saved video file.
+    """
+    # This function is now wrapped with the retry decorator.
+    # The try/except block is still useful for catching non-retriable errors.
+    try:
+        client = genai.Client()
+
+        if image_path:
+            print(f"Generating video with initial image: {image_path}")
+            img = Image.open(image_path)
+            operation = client.models.generate_videos(
+                model="veo-3.0-generate-preview",
+                prompt=prompt,
+                image=img,
+            )
+        else:
+            print("Generating video from text prompt only.")
+            operation = client.models.generate_videos(
+                model="veo-3.0-generate-preview",
+                prompt=prompt,
+            )
+
+        print("Video generation started. Polling for completion...")
+        while not operation.done:
+            print("Waiting for video generation to complete...")
+            time.sleep(10)
+            operation = client.operations.get(operation)
+
+        generated_video = operation.response.generated_videos[0]
+
+        video_file_name = "generated_story.mp4"
+        client.files.download(file=generated_video.video)
+        generated_video.video.save(video_file_name)
+
+        print(f"Generated video saved to {video_file_name}")
+        return video_file_name
+
+    except Exception as e:
+        print(f"Error generating video: {e}")
+        return f"Error during video generation: {e}"

utils.py

@@ -0,0 +1,48 @@
+# utils.py
+import time
+import random
+from functools import wraps
+from google.api_core import exceptions
+import gradio as gr
+
+def retry_with_exponential_backoff(
+    func,
+    initial_delay: float = 2,
+    exponential_base: float = 2,
+    jitter: bool = True,
+    max_retries: int = 5,
+):
+    """
+    A decorator to retry a function with exponential backoff for API calls.
+    It specifically catches google.api_core.exceptions.ResourceExhausted.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        num_retries = 0
+        delay = initial_delay
+
+        while True:
+            try:
+                return func(*args, **kwargs)
+            except exceptions.ResourceExhausted as e:
+                num_retries += 1
+                if num_retries > max_retries:
+                    # Using gr.Error to raise a user-facing error in the Gradio UI
+                    raise gr.Error(
+                        f"Maximum number of retries ({max_retries}) exceeded. The API is still busy. Please try again later."
+                    ) from e
+
+                if jitter:
+                    delay *= exponential_base * (1 + random.random())
+                else:
+                    delay *= exponential_base
+
+                # It's helpful to print the delay to the console for debugging
+                print(f"Rate limit exceeded. Retrying in {delay:.2f} seconds...")
+                time.sleep(delay)
+            except Exception as e:
+                # Raise other exceptions immediately
+                raise gr.Error(f"An unexpected error occurred: {e}")
+
+    return wrapper