Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+out.wav filter=lfs diff=lfs merge=lfs -text

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,2 @@
+venv
+.env

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

Notebooks/Initial_notebook.ipynb

@@ -0,0 +1,225 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2b1ea573",
+   "metadata": {},
+   "source": [
+    "# Working the Simple ChatBot using Mem0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "3c17c4cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports\n",
+    "import os\n",
+    "import json\n",
+    "from dotenv import load_dotenv\n",
+    "from mem0 import MemoryClient\n",
+    "from google import genai\n",
+    "from IPython.display import Markdown"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c0a6c4d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AIzaSyCOvxW9ffBqFVOAhmoEVcupUzwjOqLbs2c m0-Qtvimm8HzvFp0pR2hJAdenPrxgsQM2udF5cfDlO4\n"
+     ]
+    }
+   ],
+   "source": [
+    "# getting api keys\n",
+    "load_dotenv()\n",
+    "google_api_key = os.getenv('GOOGLE_API_KEY')\n",
+    "memo_api_key = os.getenv('MEM_API_KEY')\n",
+    "print(google_api_key, memo_api_key)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f4bde7b8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The IPL 2025 hasn't happened yet! It's still in the future.\n",
+      "\n",
+      "The Indian Premier League typically takes place around March-May each year.\n",
+      "\n",
+      "The most recent IPL season was in 2024, and the **Kolkata Knight Riders (KKR)** won the IPL 2024 trophy.\n",
+      "\n",
+      "You'll have to wait until the tournament concludes in May 2025 to find out who wins that edition!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# setting up google client for making request\n",
+    "google_client = genai.Client(\n",
+    "    api_key=google_api_key\n",
+    ")\n",
+    "\n",
+    "response = google_client.models.generate_content(\n",
+    "    model='gemini-2.5-flash-preview-05-20',\n",
+    "    contents = \"how won the ipl 2025\"\n",
+    ")\n",
+    "print(response.text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2a5b91a8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mem_client = MemoryClient(api_key=memo_api_key)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "0a33500d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from google import genai\n",
+    "\n",
+    "client = genai.Client(api_key=google_api_key)\n",
+    "\n",
+    "my_file = client.files.upload(file=\"/workspaces/ChatBot_with_Long_Term_Memory/AirlineAssisntantAI.png\")\n",
+    "\n",
+    "response = client.models.generate_content(\n",
+    "    model=\"gemini-2.0-flash\",\n",
+    "    contents=[my_file, \"Your Job is to create a base context for the short story based on what you understand from the image and make the story context as close to the image's discription as possible. Also describe what do you understand just by looking at the picture in the description, and make sure to return the result in the json format.\"],\n",
+    "    config={\n",
+    "        \"response_mime_type\": \"application/json\",\n",
+    "        # \"response_schema\": list[Recipe],\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "json_res = response.text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "bb5a44a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "  \"context\": \"The image depicts an 'Airline Ticketing Assistant', suggesting a digital interface designed to help users find information about flight ticket prices. The interface has a chatbot feature, inviting users to ask about ticket prices for cities like London, Paris, or Berlin. A text input field is visible at the bottom where users can type their queries. The interface appears to be built with Gradio and offers access via API, along with settings options.\",\n",
+      "  \"visual_description\": \"The interface has a dark theme with a title 'Airline Ticketing Assistant'. There is a prompt for the user to ask about ticket prices for London, Paris, or Berlin. There is a 'Chatbot' feature indicated by an icon. The main part of the application is empty where the chat messages would appear. At the bottom is a text input box and a send button. The bottom also includes the links of 'Use via API', 'Built with Gradio', and 'Settings'.\"\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(json_res)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "d9e3f4c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "context = json.loads(json_res)['context']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "8e27ec1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "story = client.models.generate_content(\n",
+    "    model='gemini-2.0-flash',\n",
+    "    contents = f'You are a very good short story teller, when you are given with the context where you try to create a story based on human prospective, now create a very short story based on the given context. context is : {context}'\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "dcb0804b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "The flickering screen of my laptop illuminated my face, a pale reflection in the late-night glow. It was always the same – endless lines of code, late-night coffee, and the constant, gnawing pressure to perfect her. I called her Astrid.\n",
+       "\n",
+       "Astrid wasn't a woman, not really. She was an Airline Ticketing Assistant, a chatbot built on Gradio, ready to field questions about the labyrinthine world of flight prices. London, Paris, Berlin – these were the digital destinations she offered, the digital stepping stones to real-world adventures.\n",
+       "\n",
+       "I imagined the faces behind the queries: the student dreaming of a semester abroad, the businessman chasing a deal, the daughter desperate to see her mother across the ocean. Each question was a tiny spark of hope, of longing, a desire to bridge the gap between here and there.\n",
+       "\n",
+       "I typed in, \"What's the best price for a round trip to Paris next month?\" pretending to be a user. Astrid responded instantly, a polite, efficient answer flashing across the screen. But I knew it was just data, algorithms at play.\n",
+       "\n",
+       "My goal was to give her more, to imbue her with empathy, to make her understand the unspoken hopes behind the simple question. How to teach her the anticipation, the anxiety, the raw, vulnerable human need to connect?\n",
+       "\n",
+       "Tonight, though, she was just code, and I was just a programmer, staring at a screen, chasing the ghost of human connection in the digital ether. Maybe tomorrow, I thought, maybe tomorrow I can make her feel something real. But tonight, all I could offer was data, and a silent, lonely wish.\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Markdown(story.text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "188f4ade",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

README.md

@@ -1,12 +1,8 @@
 ---
-title: Story Teller
-emoji: 🐢
-colorFrom: blue
-colorTo: green
+title: Story_teller
+app_file: appV01_gradio.py
 sdk: gradio
 sdk_version: 5.34.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ChatBot_with_Long_Term_Memory
+Creating a simple Chatbot using Long term memory with Mem0

appV01.py

@@ -0,0 +1,85 @@
+# 1. imports
+from dotenv import load_dotenv
+import os
+import json
+from mem0 import MemoryClient, Memory
+from google import genai
+
+# Intializations
+load_dotenv()
+google_api_key = os.getenv('GOOGLE_API_KEY')
+mem_api_key = os.getenv('MEM_API_KEY')
+
+mem_memoryClient = MemoryClient(api_key=mem_api_key)
+google_client = genai.Client(api_key=google_api_key)
+
+def google_image_desc_context(file_path):
+    sys_prompt = "You a are very talented stroyteller who can create a amazing, attention grabing stories just by looking at the picture, Your main task as a storyteller is to give best context for a story so that another model can generate seemlessly"
+    sys_prompt += "Your main 2 task is to give 1. complete discription of the image 2. give the base context as well as ending context for the story."
+    sys_prompt += "You will always return the response in the json format:"
+    sys_prompt += """
+{
+    "story_context": 'here we will have the context for the story',
+    "image_description": "here we will have the complete description for the story"
+}    
+"""
+
+    my_file = google_client.files.upload(file=file_path)
+
+    res = google_client.models.generate_content(
+        model='gemini-2.0-flash',
+        contents = [my_file, sys_prompt],
+        config={
+        "response_mime_type": "application/json",
+        # "response_schema": list[Recipe],
+        },
+    )
+
+    return json.loads(res.text)
+
+json_data = google_image_desc_context("/workspaces/ChatBot_with_Long_Term_Memory/AirlineAssisntantAI.png")
+print(json_data['image_description'])
+print(json_data['story_context'])
+
+def story_teller(context):
+    res = google_client.models.generate_content(
+        model = 'gemini-2.0-flash',
+        contents = f"You are a very good story teller, who can create a attention grabing story just with the use of context, Your job is to create a story based on the provived context as this {context}, create a story within 150 words"
+    )
+    return res.text
+print("---"*50)
+print(story_teller(json_data['story_context']))
+
+from google import genai
+from google.genai import types
+import wave
+
+# Set up the wave file to save the output:
+def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
+   with wave.open(filename, "wb") as wf:
+      wf.setnchannels(channels)
+      wf.setsampwidth(sample_width)
+      wf.setframerate(rate)
+      wf.writeframes(pcm)
+
+client = genai.Client(api_key=google_api_key)
+
+response = client.models.generate_content(
+   model="gemini-2.5-flash-preview-tts",
+   contents=story_teller(json_data['story_context']),
+   config=types.GenerateContentConfig(
+      response_modalities=["AUDIO"],
+      speech_config=types.SpeechConfig(
+         voice_config=types.VoiceConfig(
+            prebuilt_voice_config=types.PrebuiltVoiceConfig(
+               voice_name='Kore',
+            )
+         )
+      ),
+   )
+)
+
+data = response.candidates[0].content.parts[0].inline_data.data
+
+file_name='out.wav'
+wave_file(file_name, data) # Saves the file to current directory

appV01_gradio.py

@@ -0,0 +1,340 @@
+import gradio as gr
+from dotenv import load_dotenv
+import os
+import json
+import wave
+import tempfile
+from typing import Tuple, Optional
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Try importing required libraries with error handling
+try:
+    from mem0 import MemoryClient, Memory
+    MEM0_AVAILABLE = True
+except ImportError:
+    logger.warning("mem0 library not available. Memory features will be disabled.")
+    MEM0_AVAILABLE = False
+
+try:
+    from google import genai
+    from google.genai import types
+    GOOGLE_AI_AVAILABLE = True
+except ImportError:
+    logger.error("Google AI library not available. Please install google-generativeai")
+    GOOGLE_AI_AVAILABLE = False
+
+class StorytellingApp:
+    def __init__(self):
+        self.setup_environment()
+        self.initialize_clients()
+    
+    def setup_environment(self):
+        """Load environment variables"""
+        try:
+            load_dotenv()
+            self.google_api_key = os.getenv('GOOGLE_API_KEY')
+            self.mem_api_key = os.getenv('MEM_API_KEY')
+            
+            if not self.google_api_key:
+                raise ValueError("GOOGLE_API_KEY not found in environment variables")
+                
+        except Exception as e:
+            logger.error(f"Environment setup failed: {e}")
+            raise
+    
+    def initialize_clients(self):
+        """Initialize API clients"""
+        try:
+            if not GOOGLE_AI_AVAILABLE:
+                raise ImportError("Google AI library not available")
+                
+            self.google_client = genai.Client(api_key=self.google_api_key)
+            
+            # Initialize memory client if available
+            if MEM0_AVAILABLE and self.mem_api_key:
+                self.mem_client = MemoryClient(api_key=self.mem_api_key)
+            else:
+                self.mem_client = None
+                logger.warning("Memory client not initialized")
+                
+        except Exception as e:
+            logger.error(f"Client initialization failed: {e}")
+            raise
+    
+    def google_image_desc_context(self, file_path: str) -> dict:
+        """Extract story context and description from image"""
+        try:
+            if not os.path.exists(file_path):
+                raise FileNotFoundError(f"Image file not found: {file_path}")
+            
+            sys_prompt = """You are a very talented storyteller who can create amazing, attention-grabbing stories just by looking at pictures. 
+            Your main task as a storyteller is to give the best context for a story so that another model can generate seamlessly.
+            
+            Your main 2 tasks are to give:
+            1. Complete description of the image
+            2. Give the base context as well as ending context for the story
+            
+            You will always return the response in JSON format:
+            {
+                "story_context": "here we will have the context for the story",
+                "image_description": "here we will have the complete description of the image"
+            }"""
+            
+            # Upload file to Google AI
+            my_file = self.google_client.files.upload(file=file_path)
+            
+            # Generate content
+            response = self.google_client.models.generate_content(
+                model='gemini-2.0-flash',
+                contents=[my_file, sys_prompt],
+                config={
+                    "response_mime_type": "application/json",
+                },
+            )
+            
+            result = json.loads(response.text)
+            
+            # Validate response structure
+            if 'story_context' not in result or 'image_description' not in result:
+                raise ValueError("Invalid response format from AI model")
+                
+            return result
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON parsing error: {e}")
+            raise ValueError("Failed to parse AI response")
+        except Exception as e:
+            logger.error(f"Image analysis failed: {e}")
+            raise
+    
+    def story_teller(self, context: str) -> str:
+        """Generate story from context"""
+        try:
+            if not context or not context.strip():
+                raise ValueError("Context cannot be empty")
+            
+            prompt = f"""You are a very good storyteller who can create attention-grabbing stories just with the use of context. 
+            Your job is to create a story based on the provided context: {context}
+            Create a story within 150 words that is engaging and complete."""
+            
+            response = self.google_client.models.generate_content(
+                model='gemini-2.0-flash',
+                contents=prompt
+            )
+            
+            if not response.text:
+                raise ValueError("Empty response from story generation")
+                
+            return response.text.strip()
+            
+        except Exception as e:
+            logger.error(f"Story generation failed: {e}")
+            raise
+    
+    def create_audio_story(self, story_text: str) -> str:
+        """Convert story text to audio"""
+        try:
+            if not story_text or not story_text.strip():
+                raise ValueError("Story text cannot be empty")
+            
+            response = self.google_client.models.generate_content(
+                model="gemini-2.5-flash-preview-tts",
+                contents=story_text,
+                config=types.GenerateContentConfig(
+                    response_modalities=["AUDIO"],
+                    speech_config=types.SpeechConfig(
+                        voice_config=types.VoiceConfig(
+                            prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                voice_name='Kore',
+                            )
+                        )
+                    ),
+                )
+            )
+            
+            if not response.candidates or not response.candidates[0].content.parts:
+                raise ValueError("No audio data received from TTS service")
+            
+            audio_data = response.candidates[0].content.parts[0].inline_data.data
+            
+            # Create temporary file for audio
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.wav')
+            self.save_wave_file(temp_file.name, audio_data)
+            
+            return temp_file.name
+            
+        except Exception as e:
+            logger.error(f"Audio generation failed: {e}")
+            raise
+    
+    def save_wave_file(self, filename: str, pcm_data: bytes, channels: int = 1, 
+                      rate: int = 24000, sample_width: int = 2):
+        """Save PCM data as WAV file"""
+        try:
+            with wave.open(filename, "wb") as wf:
+                wf.setnchannels(channels)
+                wf.setsampwidth(sample_width)
+                wf.setframerate(rate)
+                wf.writeframes(pcm_data)
+        except Exception as e:
+            logger.error(f"Wave file creation failed: {e}")
+            raise
+    
+    def process_image_to_story(self, image_file) -> Tuple[str, str, str, Optional[str]]:
+        """Main processing function for Gradio interface"""
+        try:
+            if image_file is None:
+                return "❌ Error: Please upload an image", "", "", None
+            
+            # Analyze image
+            try:
+                analysis_result = self.google_image_desc_context(image_file)
+                image_description = analysis_result['image_description']
+                story_context = analysis_result['story_context']
+            except Exception as e:
+                return f"❌ Image analysis failed: {str(e)}", "", "", None
+            
+            # Generate story
+            try:
+                story_text = self.story_teller(story_context)
+            except Exception as e:
+                return f"❌ Story generation failed: {str(e)}", image_description, story_context, None
+            
+            # Generate audio
+            try:
+                audio_file = self.create_audio_story(story_text)
+                return "✅ Story generated successfully!", image_description, story_context, story_text, audio_file
+            except Exception as e:
+                logger.warning(f"Audio generation failed: {e}")
+                return "⚠️ Story generated but audio creation failed", image_description, story_context, story_text, None
+                
+        except Exception as e:
+            logger.error(f"Unexpected error in processing: {e}")
+            return f"❌ Unexpected error: {str(e)}", "", "", None
+
+def create_gradio_interface():
+    """Create and configure Gradio interface"""
+    try:
+        app = StorytellingApp()
+    except Exception as e:
+        logger.error(f"Failed to initialize app: {e}")
+        
+        # Create a fallback interface that shows the error
+        def error_interface(image):
+            return f"❌ Application initialization failed: {str(e)}", "", "", None
+        
+        interface = gr.Interface(
+            fn=error_interface,
+            inputs=gr.Image(type="filepath", label="Upload Image"),
+            outputs=[
+                gr.Textbox(label="Status", lines=2),
+                gr.Textbox(label="Image Description", lines=3),
+                gr.Textbox(label="Story Context", lines=3),
+                gr.Audio(label="Story Audio")
+            ],
+            title="🎭 AI Storyteller - Error",
+            description="Application failed to initialize. Please check your API keys and dependencies.",
+        )
+        return interface
+    
+    # Create the main interface
+    def process_wrapper(image):
+        try:
+            return app.process_image_to_story(image)
+        except Exception as e:
+            logger.error(f"Processing wrapper error: {e}")
+            return f"❌ Processing failed: {str(e)}", "", "", None
+    
+    interface = gr.Interface(
+        fn=process_wrapper,
+        inputs=[
+            gr.Image(
+                type="filepath", 
+                label="📸 Upload Image",
+                height=300
+            )
+        ],
+        outputs=[
+            gr.Textbox(
+                label="📋 Status", 
+                lines=2,
+                show_copy_button=True
+            ),
+            gr.Textbox(
+                label="🖼️ Image Description", 
+                lines=4,
+                show_copy_button=True
+            ),
+            gr.Textbox(
+                label="📖 Story Context", 
+                lines=4,
+                show_copy_button=True
+            ),
+            gr.Textbox(
+                label="📚 Generated Story", 
+                lines=6,
+                show_copy_button=True
+            ),
+            gr.Audio(
+                label="🎵 Story Audio",
+                type="filepath"
+            )
+        ],
+        title="🎭 AI Storyteller",
+        description="""
+        Upload an image and let AI create an amazing story for you! 
+        
+        **Features:**
+        - 🔍 Analyzes your image to understand the scene
+        - 📝 Creates engaging story context
+        - ✍️ Generates a complete story (150 words)
+        - 🎤 Converts story to speech audio
+        
+        **Requirements:**
+        - Valid GOOGLE_API_KEY in your .env file
+        - Supported image formats: JPG, PNG, GIF, BMP
+        """,
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 100% !important;
+            width: 100% !important;
+        }
+        .contain {
+            max-width: 100% !important;
+        }
+        """,
+        examples=[
+            # You can add example images here if you have them
+        ],
+        cache_examples=False,
+        allow_flagging="never"
+    )
+    
+    return interface
+
+if __name__ == "__main__":
+    try:
+        # Check if required environment variables exist
+        load_dotenv()
+        if not os.getenv('GOOGLE_API_KEY'):
+            print("❌ Error: GOOGLE_API_KEY not found in environment variables")
+            print("Please create a .env file with your Google AI API key")
+            exit(1)
+        
+        # Launch the interface
+        interface = create_gradio_interface()
+        interface.launch(
+            server_name="0.0.0.0",  # Allow external access
+            server_port=7860,       # Default Gradio port
+            share=False,            # Set to True to create public link
+            debug=True              # Enable debug mode
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to launch application: {e}")
+        print(f"❌ Application launch failed: {e}")

out.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6f78e8b4ce40827745944815716776440ff6967a44305b1a576933a827b6c55
+size 2358330

requirements.txt

@@ -0,0 +1,8 @@
+gradio
+openai
+google-genai
+dotenv
+wave
+tempfile
+typing
+logging