Add Groq API support as primary script generator with Gemini fallback

.env.example

@@ -52,6 +52,11 @@ CF_URL=https://image-api.yourworker.workers.dev
 # Cloudflare API Key (FALLBACK)
 CF_API=your_api_key_here
 
-# Gemini API Key (Required for AI script generation)
+# Gemini API Key (Required for AI script generation - Fallback)
 # Get from: https://aistudio.google.com/apikey
-GEMINI_API_KEY=your_gemini_api_key_here
+GEMINI_API_KEY=your_gemini_key_here
+
+# Groq API Key (Primary for AI script generation)
+# Get from: https://console.groq.com/keys
+GROQ_API=gsk_your_groq_key_here
+```

config.py

@@ -75,7 +75,8 @@ class NCAkitConfig(BaseConfig):
     nvidia_api_key: Optional[str] = None  # NVIDIA API key (primary)
     cf_url: Optional[str] = None  # Cloudflare Worker URL (fallback)
     cf_api: Optional[str] = None  # Cloudflare API key (fallback)
-    gemini_api_key: Optional[str] = None  # For AI script generation
+    gemini_api_key: Optional[str] = None  # For AI script generation (fallback)
+    groq_api: Optional[str] = None  # Groq API key (primary for script generation)
     
     @property
     def videos_dir_path(self) -> Path:

modules/story_reels/__init__.py

@@ -52,7 +52,11 @@ def register(app: FastAPI, config):
     
     # Initialize Script Generator (Gemini)
     logger.info("Initializing script generator (Gemini)...")
-    script_generator = ScriptGenerator(config.gemini_api_key or "")
+    script_generator = ScriptGenerator(
+        gemini_api_key=config.gemini_api_key,
+        groq_api_key=config.groq_api
+    )
+    
     
     # Initialize NVIDIA client (PRIMARY)
     nvidia_client = None

modules/story_reels/services/script_generator.py

@@ -1,19 +1,19 @@
 """
-Script Generator using Google GenAI SDK
+Script Generator using Groq and Gemini APIs
 Generates story scripts from topics for TTS narration
+Tries Groq first (works in all regions), falls back to Gemini
 """
 import logging
 import json
+import os
 from typing import Optional
 
-from google import genai
-
 logger = logging.getLogger(__name__)
 
 
 class ScriptGenerator:
     """
-    Generates story scripts using Google Gemini API via google-genai SDK.
+    Generates story scripts using Groq API (primary) or Gemini API (fallback).
     
     Features:
     - Topic → Full narration script (<=1000 chars)
@@ -22,7 +22,8 @@ class ScriptGenerator:
     - Optimized for TTS output
     """
     
-    MODEL = "gemini-2.5-flash"
+    GROQ_MODEL = "llama-3.3-70b-versatile"  # Fast and good quality
+    GEMINI_MODEL = "gemini-2.5-flash"
     
     # System prompt for script generation
     SYSTEM_PROMPT = """You are a professional script writer for short-form video content (TikTok, Reels, Shorts).
@@ -38,9 +39,32 @@ RULES:
 
 If a character is provided, write the story from their perspective or about them."""
 
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        self.client = genai.Client(api_key=api_key)
+    def __init__(self, gemini_api_key: str = None, groq_api_key: str = None):
+        self.gemini_api_key = gemini_api_key
+        self.groq_api_key = groq_api_key
+        
+        # Initialize clients based on available keys
+        self.groq_client = None
+        self.gemini_client = None
+        
+        if groq_api_key:
+            try:
+                from groq import Groq
+                self.groq_client = Groq(api_key=groq_api_key)
+                logger.info("Groq client initialized (primary)")
+            except ImportError:
+                logger.warning("Groq package not installed, using Gemini only")
+        
+        if gemini_api_key:
+            try:
+                from google import genai
+                self.gemini_client = genai.Client(api_key=gemini_api_key)
+                logger.info("Gemini client initialized (fallback)")
+            except ImportError:
+                logger.warning("google-genai package not installed")
+        
+        if not self.groq_client and not self.gemini_client:
+            raise ValueError("At least one API key (GROQ_API or GEMINI_API_KEY) is required")
         
     def generate_script(
         self,
@@ -50,14 +74,7 @@ If a character is provided, write the story from their perspective or about them
     ) -> str:
         """
         Generate a story script from topic.
-        
-        Args:
-            topic: Story topic/idea
-            character_name: Optional character name to include
-            max_chars: Maximum character limit (default 1000)
-            
-        Returns:
-            Generated script text
+        Tries Groq first, falls back to Gemini if Groq fails.
         """
         # Build the prompt
         user_prompt = f"Topic: {topic}"
@@ -69,30 +86,58 @@ If a character is provided, write the story from their perspective or about them
         
         logger.info(f"Generating script for topic: {topic[:50]}...")
         
-        try:
-            response = self.client.models.generate_content(
-                model=self.MODEL,
-                contents=self.SYSTEM_PROMPT + "\n\n" + user_prompt
-            )
-            
-            script = response.text
-            
-            # Enforce character limit
-            if len(script) > max_chars:
-                script = script[:max_chars].rsplit(' ', 1)[0] + "."
-                
-            logger.info(f"Generated script: {len(script)} chars")
-            return script.strip()
-            
-        except Exception as e:
-            logger.error(f"Gemini API error: {e}")
-            raise Exception(f"Script generation failed: {e}")
+        # Try Groq first (works in all regions)
+        if self.groq_client:
+            try:
+                script = self._generate_with_groq(user_prompt)
+                if len(script) > max_chars:
+                    script = script[:max_chars].rsplit(' ', 1)[0] + "."
+                logger.info(f"Generated script with Groq: {len(script)} chars")
+                return script.strip()
+            except Exception as e:
+                logger.warning(f"Groq failed: {e}, trying Gemini...")
+        
+        # Fallback to Gemini
+        if self.gemini_client:
+            try:
+                script = self._generate_with_gemini(user_prompt)
+                if len(script) > max_chars:
+                    script = script[:max_chars].rsplit(' ', 1)[0] + "."
+                logger.info(f"Generated script with Gemini: {len(script)} chars")
+                return script.strip()
+            except Exception as e:
+                logger.error(f"Gemini also failed: {e}")
+                raise Exception(f"Script generation failed: {e}")
+        
+        raise Exception("No AI backend available for script generation")
+    
+    def _generate_with_groq(self, user_prompt: str) -> str:
+        """Generate using Groq API"""
+        completion = self.groq_client.chat.completions.create(
+            model=self.GROQ_MODEL,
+            messages=[
+                {"role": "system", "content": self.SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.7,
+            max_tokens=500,
+            top_p=0.9
+        )
+        return completion.choices[0].message.content
+    
+    def _generate_with_gemini(self, user_prompt: str) -> str:
+        """Generate using Gemini API"""
+        response = self.gemini_client.models.generate_content(
+            model=self.GEMINI_MODEL,
+            contents=self.SYSTEM_PROMPT + "\n\n" + user_prompt
+        )
+        return response.text
     
     @staticmethod
-    def test_connection(api_key: str) -> bool:
+    def test_connection(gemini_api_key: str = None, groq_api_key: str = None) -> bool:
         """Test API connection"""
         try:
-            gen = ScriptGenerator(api_key)
+            gen = ScriptGenerator(gemini_api_key=gemini_api_key, groq_api_key=groq_api_key)
             gen.generate_script("test", max_chars=50)
             return True
         except:
@@ -133,20 +178,10 @@ Return ONLY valid JSON array, no markdown, no explanation:
     ) -> list:
         """
         Generate detailed image prompts for all 2-second chunks.
-        
-        Args:
-            full_script: Complete narration script (for context)
-            chunks: List of {chunk_id, text, duration} from SRTParser
-            character_profile: Optional character dict
-            max_batch: Max chunks per API call (default 30)
-            
-        Returns:
-            List of {chunk_id, prompt} dicts
         """
         all_prompts = []
         total_chunks = len(chunks)
         
-        # Split into batches if too many chunks
         for batch_start in range(0, total_chunks, max_batch):
             batch_end = min(batch_start + max_batch, total_chunks)
             batch_chunks = chunks[batch_start:batch_end]
@@ -179,12 +214,13 @@ IMPORTANT: Include this character description in EVERY prompt!
             user_prompt += "\nGenerate detailed image prompts for each chunk. Return ONLY JSON array."
             
             try:
-                response = self.client.models.generate_content(
-                    model=self.MODEL,
-                    contents=self.IMAGE_PROMPT_SYSTEM + "\n\n" + user_prompt
-                )
-                
-                text = response.text
+                # Try Groq first
+                if self.groq_client:
+                    text = self._generate_image_prompts_groq(user_prompt)
+                elif self.gemini_client:
+                    text = self._generate_image_prompts_gemini(user_prompt)
+                else:
+                    raise Exception("No AI backend available")
                 
                 # Clean response - remove markdown if present
                 text = text.strip()
@@ -202,15 +238,13 @@ IMPORTANT: Include this character description in EVERY prompt!
                 
             except json.JSONDecodeError as e:
                 logger.error(f"Failed to parse JSON response: {e}")
-                # Fallback: create simple prompts
                 for chunk in batch_chunks:
                     all_prompts.append({
                         "chunk_id": chunk["chunk_id"],
                         "prompt": f"{chunk['text']}, semi-realistic style, high quality, detailed"
                     })
             except Exception as e:
-                logger.error(f"Gemini API error: {e}")
-                # Fallback
+                logger.error(f"AI API error: {e}")
                 for chunk in batch_chunks:
                     all_prompts.append({
                         "chunk_id": chunk["chunk_id"],
@@ -219,3 +253,25 @@ IMPORTANT: Include this character description in EVERY prompt!
         
         logger.info(f"Generated {len(all_prompts)} total image prompts")
         return all_prompts
+    
+    def _generate_image_prompts_groq(self, user_prompt: str) -> str:
+        """Generate image prompts using Groq"""
+        completion = self.groq_client.chat.completions.create(
+            model=self.GROQ_MODEL,
+            messages=[
+                {"role": "system", "content": self.IMAGE_PROMPT_SYSTEM},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.7,
+            max_tokens=4000,
+            top_p=0.9
+        )
+        return completion.choices[0].message.content
+    
+    def _generate_image_prompts_gemini(self, user_prompt: str) -> str:
+        """Generate image prompts using Gemini"""
+        response = self.gemini_client.models.generate_content(
+            model=self.GEMINI_MODEL,
+            contents=self.IMAGE_PROMPT_SYSTEM + "\n\n" + user_prompt
+        )
+        return response.text

requirements.txt

@@ -19,6 +19,7 @@ numpy<2.0.0
 # AI/ML
 faster-whisper
 google-genai
+groq
 
 # Utilities
 python-multipart