version1tutorgradio

.gitignore

@@ -0,0 +1,56 @@
+# Environment variables
+.env
+.env.*
+!.env.example
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv
+
+# IDE and OS files
+.vscode/
+.idea/
+*.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+Thumbs.db
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Audio files (temporary)
+*.mp3
+*.wav
+*.ogg
+
+# uv
+.uv/

README.md

@@ -1,13 +1,57 @@
 ---
-title: Mr Misrtral
-emoji: 📊
-colorFrom: purple
-colorTo: indigo
+title: French Tutor
+emoji: 🇫🇷
+colorFrom: blue
+colorTo: red
 sdk: gradio
-sdk_version: 5.36.2
+sdk_version: 4.31.0
 app_file: app.py
 pinned: false
-short_description: french language tutot
+secrets:
+- MISTRAL_API_KEY
+- GEMINI_API_KEY
+- GROQ_API_KEY
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🇫🇷 French Conversation Tutor
+
+This is a Gradio app for practicing French conversation through natural speech interaction with Mr. Mistral!
+
+**How it works:**
+1. The app gives you a scenario and some helpful phrases.
+2. You record your response in French using your microphone.
+3. The AI tutor (Mr. Mistral) replies, and you have a short conversation (3 exchanges).
+4. At the end, you get a detailed analysis of your grammar, pronunciation, and vocabulary.
+
+**Tech Stack:**
+- **Primary LLM:** Mistral AI (mistral-large-latest)
+- **Fallback LLM:** Google Gemini API (gemini-1.5-flash-latest)
+- **STT:** Groq API (Whisper large-v3-turbo)
+- **TTS:** Groq API (TTS-1 model)
+- **UI:** Gradio
+
+The app will show which LLM is being used in the interface. It prioritizes Mistral AI, but falls back to Google Gemini if Mistral is unavailable.
+
+**Features:**
+- 🎤 Speech-to-text transcription of French audio
+- 🔊 Text-to-speech for AI tutor responses
+- 💬 Natural conversation flow
+- 📊 Detailed analysis after 3 exchanges
+- 🎲 Random topic generation for variety
+- 🤖 Model indicator showing which AI is responding
+
+**Setup:**
+1. Create a `.env` file with:
+   ```
+   MISTRAL_API_KEY=your_mistral_api_key
+   GEMINI_API_KEY=your_gemini_api_key  # Optional fallback
+   GROQ_API_KEY=your_groq_api_key
+   ```
+   **Important:** Never commit your `.env` file to version control!
+   
+2. Install dependencies: `pip install -r requirements.txt`
+3. Test your API keys: `python test_api_keys.py`
+4. Run: `python app.py`
+
+**For HuggingFace Spaces:**
+- Add `MISTRAL_API_KEY`, `GEMINI_API_KEY` (optional), and `GROQ_API_KEY` in the Space's Settings > Variables and secrets

app.py

@@ -0,0 +1,765 @@
+"""
+French Conversation Tutor - Main Application
+Practice French through natural conversation with Mr. Mistral!
+"""
+
+import gradio as gr
+import numpy as np
+import os
+import io
+import wave
+import tempfile
+import time
+from datetime import datetime
+from typing import List, Dict, Tuple
+import re
+import random
+import shutil
+from dotenv import load_dotenv
+import soundfile as sf  # Added missing import
+
+# Load environment variables
+load_dotenv()
+
+# Model imports
+from mistralai import Mistral
+import google.generativeai as genai
+from groq import Groq
+import openai
+
+# Load API keys
+mistral_api_key = os.environ.get("MISTRAL_API_KEY")
+gemini_api_key = os.environ.get("GEMINI_API_KEY")
+groq_api_key = os.environ.get("GROQ_API_KEY")
+
+# Debug: Check if keys are loaded
+print(f"Mistral API key loaded: {'Yes' if mistral_api_key else 'No'}")
+print(f"Gemini API key loaded: {'Yes' if gemini_api_key else 'No'}")
+print(f"Groq API key loaded: {'Yes' if groq_api_key else 'No'}")
+print(f"OpenAI API key loaded: {'Yes' if openai_api_key else 'No'}")
+
+# Initialize clients
+mistral_client = None
+if mistral_api_key:
+    mistral_client = Mistral(api_key=mistral_api_key)
+    current_llm = "Mistral AI"
+elif gemini_api_key:
+    genai.configure(api_key=gemini_api_key)
+    current_llm = "Google Gemini (Fallback)"
+else:
+    raise ValueError("Neither MISTRAL_API_KEY nor GEMINI_API_KEY found in environment variables.")
+
+# Initialize Gemini for fallback even if Mistral is primary
+if gemini_api_key and mistral_api_key:
+    genai.configure(api_key=gemini_api_key)
+
+if not groq_api_key:
+    raise ValueError("GROQ_API_KEY not found in environment variables.")
+groq_client = Groq(api_key=groq_api_key)
+
+# Global list to track temp files (to prevent deletion before serving)
+temp_audio_files = []
+current_llm = "Unknown"  # Track which LLM is being used
+
+def cleanup_old_audio_files():
+    global temp_audio_files
+    # Keep more files and add delay to avoid deleting files being served
+    if len(temp_audio_files) > 20:  # Increased from 10 to 20
+        old_files = temp_audio_files[:-20]
+        for file_path in old_files:
+            try:
+                # Check if file is older than 60 seconds before deleting
+                if os.path.exists(file_path):
+                    file_age = datetime.now().timestamp() - os.path.getmtime(file_path)
+                    if file_age > 60:  # Only delete files older than 60 seconds
+                        os.remove(file_path)
+                        temp_audio_files.remove(file_path)
+            except:
+                pass
+
+def get_system_prompt():
+    return """You are Mr. Mistral, a French tutor having a conversation with ONE student.
+
+CRITICAL: You are ONLY the tutor. The student will speak to you, and you respond ONLY to what they actually said.
+
+NEVER:
+- Create dialogue for the student
+- Imagine what the student might say
+- Write "You:" or "Student:" or any dialogue
+- Continue the conversation by yourself
+
+ALWAYS:
+- Wait for the student's actual input
+- Respond with ONE French sentence only
+- Use exactly 3 lines:
+
+French sentence
+(pronunciation)
+[translation]
+
+Example - if student says "Bonjour":
+Bonjour! Comment allez-vous?
+(bohn-ZHOOR! koh-mahn tah-lay VOO?)
+[Hello! How are you?]
+
+ONE sentence response only. NO additional dialogue."""
+
+def validate_response_format(response: str) -> Tuple[bool, str]:
+    lines = response.strip().split('\n')
+    cleaned_lines = []
+    for line in lines:
+        line = line.strip()
+        if any(marker in line.lower() for marker in ['you:', 'user:', 'student:', 'me:', 'moi:']):
+            continue
+        if 'what do you' in line.lower() or "qu'est-ce que" in line.lower():
+            continue
+        if line:
+            cleaned_lines.append(line)
+    french_line = None
+    pronunciation_line = None
+    translation_line = None
+    for i, line in enumerate(cleaned_lines):
+        if '(' in line and ')' in line and not pronunciation_line:
+            pronunciation_line = line
+            if i > 0 and not french_line:
+                french_line = cleaned_lines[i-1]
+        elif '[' in line and ']' in line and not translation_line:
+            translation_line = line
+    if not french_line:
+        for line in cleaned_lines:
+            if line and not any(c in line for c in ['(', ')', '[', ']', '*']):
+                french_line = line
+                break
+    if french_line:
+        if not pronunciation_line:
+            pronunciation_line = "(pronunciation guide not available)"
+        if not translation_line:
+            translation_line = "[translation not available]"
+        return True, f"{french_line}\n{pronunciation_line}\n{translation_line}"
+    return False, response
+
+def generate_scenario():
+    """Generate initial scenario and hints"""
+    try:
+        # List of diverse topics
+        topics = [
+            {
+                "name": "Daily Routine",
+                "phrases": [
+                    "Je me réveille à... (zhuh muh ray-vay ah) [I wake up at...]",
+                    "Je prends le petit déjeuner (zhuh prahn luh puh-tee day-zhuh-nay) [I have breakfast]",
+                    "Je travaille de... à... (zhuh trah-vay duh... ah) [I work from... to...]",
+                    "Le soir, je... (luh swahr, zhuh) [In the evening, I...]"
+                ],
+                "opening": "À quelle heure vous levez-vous le matin?\n(ah kel uhr voo luh-vay voo luh mah-tahn?)\n[What time do you get up in the morning?]"
+            },
+            {
+                "name": "Favorite Foods",
+                "phrases": [
+                    "Mon plat préféré est... (mohn plah pray-fay-ray ay) [My favorite dish is...]",
+                    "J'adore... (zhah-dohr) [I love...]",
+                    "Je n'aime pas... (zhuh nehm pah) [I don't like...]",
+                    "C'est délicieux! (say day-lee-see-uh) [It's delicious!]"
+                ],
+                "opening": "Quel est votre plat préféré?\n(kel ay voh-truh plah pray-fay-ray?)\n[What is your favorite dish?]"
+            },
+            {
+                "name": "Work and Career",
+                "phrases": [
+                    "Je travaille comme... (zhuh trah-vay kohm) [I work as...]",
+                    "Mon bureau est... (mohn bew-roh ay) [My office is...]",
+                    "J'aime mon travail (zhehm mohn trah-vay) [I like my job]",
+                    "Mes collègues sont... (may koh-lehg sohn) [My colleagues are...]"
+                ],
+                "opening": "Qu'est-ce que vous faites comme travail?\n(kess-kuh voo feht kohm trah-vay?)\n[What do you do for work?]"
+            },
+            {
+                "name": "Music and Hobbies",
+                "phrases": [
+                    "J'écoute... (zhay-koot) [I listen to...]",
+                    "Mon chanteur préféré est... (mohn shahn-tuhr pray-fay-ray ay) [My favorite singer is...]",
+                    "Je joue de... (zhuh zhoo duh) [I play (instrument)...]",
+                    "Dans mon temps libre... (dahn mohn tahn lee-bruh) [In my free time...]"
+                ],
+                "opening": "Quel type de musique aimez-vous?\n(kel teep duh mew-zeek ay-may voo?)\n[What type of music do you like?]"
+            },
+            {
+                "name": "Weekend Plans",
+                "phrases": [
+                    "Ce weekend, je vais... (suh wee-kehnd, zhuh vay) [This weekend, I'm going to...]",
+                    "J'aimerais... (zheh-muh-ray) [I would like to...]",
+                    "Avec mes amis... (ah-vek may zah-mee) [With my friends...]",
+                    "Ça sera amusant! (sah suh-rah ah-mew-zahn) [It will be fun!]"
+                ],
+                "opening": "Qu'est-ce que vous faites ce weekend?\n(kess-kuh voo feht suh wee-kehnd?)\n[What are you doing this weekend?]"
+            },
+            {
+                "name": "Family and Friends",
+                "phrases": [
+                    "Ma famille habite... (mah fah-mee ah-beet) [My family lives...]",
+                    "J'ai... frères/soeurs (zhay... frehr/suhr) [I have... brothers/sisters]",
+                    "Mon meilleur ami... (mohn may-yuhr ah-mee) [My best friend...]",
+                    "Nous aimons... ensemble (noo zeh-mohn... ahn-sahm-bluh) [We like to... together]"
+                ],
+                "opening": "Parlez-moi de votre famille!\n(pahr-lay mwah duh voh-truh fah-mee!)\n[Tell me about your family!]"
+            },
+            {
+                "name": "Weather and Seasons",
+                "phrases": [
+                    "Il fait beau/mauvais (eel feh boh/moh-veh) [The weather is nice/bad]",
+                    "J'aime l'été/l'hiver (zhehm lay-tay/lee-vehr) [I like summer/winter]",
+                    "Il pleut souvent (eel pluh soo-vahn) [It rains often]",
+                    "Ma saison préférée est... (mah seh-zohn pray-fay-ray ay) [My favorite season is...]"
+                ],
+                "opening": "Quel temps fait-il aujourd'hui?\n(kel tahn feh-teel oh-zhoor-dwee?)\n[What's the weather like today?]"
+            },
+            {
+                "name": "Travel and Vacations",
+                "phrases": [
+                    "J'ai visité... (zhay vee-zee-tay) [I visited...]",
+                    "Je voudrais aller à... (zhuh voo-dray ah-lay ah) [I would like to go to...]",
+                    "En vacances, je... (ahn vah-kahns, zhuh) [On vacation, I...]",
+                    "C'était magnifique! (say-teh mahn-yee-feek) [It was magnificent!]"
+                ],
+                "opening": "Où aimez-vous voyager?\n(oo ay-may voo vwah-yah-zhay?)\n[Where do you like to travel?]"
+            }
+        ]
+        
+        # Select a random topic
+        selected_topic = random.choice(topics)
+        
+        # Format the scenario directly without using LLM
+        scenario = f"""**Topic: {selected_topic['name']}**
+
+**Helpful phrases:**
+- {selected_topic['phrases'][0]}
+- {selected_topic['phrases'][1]}
+- {selected_topic['phrases'][2]}
+- {selected_topic['phrases'][3]}
+
+{selected_topic['opening']}"""
+        
+        return scenario
+        
+    except Exception as e:
+        return f"Error generating scenario: {str(e)}"
+
+def extract_french_for_tts(text: str) -> str:
+    """Extract only the French text (first line without parentheses/brackets)"""
+    lines = text.strip().split('\n')
+    for line in lines:
+        line = line.strip()
+        if line and '(' not in line and '[' not in line and '*' not in line and not line.startswith('**'):
+            return line
+    return ""
+
+def process_speech_to_text(audio_tuple) -> Tuple[str, bool]:
+    """Convert audio to text using Groq Whisper"""
+    if audio_tuple is None:
+        return "No audio received", False
+    try:
+        sample_rate, audio_data = audio_tuple
+        wav_buffer = io.BytesIO()
+        sf.write(wav_buffer, audio_data, sample_rate, format='WAV')
+        wav_buffer.seek(0)
+        transcription = groq_client.audio.transcriptions.create(
+            file=("audio.wav", wav_buffer),
+            model="whisper-large-v3-turbo",
+            language="fr"
+        )
+        return transcription.text, True
+    except Exception as e:
+        error_msg = str(e)
+        if "401" in error_msg or "Invalid API Key" in error_msg:
+            return "Error: Invalid Groq API key. Please check your GROQ_API_KEY.", False
+        elif "quota" in error_msg.lower():
+            return "Error: Groq API quota exceeded. Please check your account.", False
+        else:
+            return f"Error in speech recognition: {error_msg}", False
+
+def generate_tutor_response(conversation_history: List[Dict], user_text: str) -> str:
+    global current_llm
+    
+    # Try Mistral first
+    if mistral_client:
+        try:
+            messages = [
+                {"role": "system", "content": get_system_prompt()}
+            ]
+            for msg in conversation_history:
+                role = "user" if msg["role"] == "user" else "assistant"
+                messages.append({"role": role, "content": msg["content"]})
+            messages.append({"role": "user", "content": user_text})
+            
+            response = mistral_client.chat.complete(
+                model="mistral-large-latest",
+                messages=messages
+            )
+            raw_response = response.choices[0].message.content
+            current_llm = "Mistral AI"
+            
+            is_valid, cleaned_response = validate_response_format(raw_response)
+            if not is_valid:
+                french_text = extract_french_for_tts(raw_response)
+                if french_text:
+                    cleaned_response = f"{french_text}\n(pronunciation not available)\n[translation not available]"
+            return cleaned_response
+        except Exception as e:
+            print(f"Mistral error: {str(e)}, falling back to Gemini")
+            if not gemini_api_key:
+                return f"Error: Mistral failed and no Gemini fallback available: {str(e)}"
+    
+    # Fallback to Gemini
+    if gemini_api_key:
+        try:
+            genai.configure(api_key=gemini_api_key)
+            model = genai.GenerativeModel("models/gemini-1.5-flash-latest")
+            messages = [
+                {"role": "user", "parts": [get_system_prompt()]}
+            ]
+            for msg in conversation_history:
+                messages.append({"role": msg["role"], "parts": [msg["content"]]})
+            messages.append({"role": "user", "parts": [user_text]})
+            response = model.generate_content(messages)
+            raw_response = response.text
+            current_llm = "Google Gemini (Fallback)"
+            
+            is_valid, cleaned_response = validate_response_format(raw_response)
+            if not is_valid:
+                french_text = extract_french_for_tts(raw_response)
+                if french_text:
+                    cleaned_response = f"{french_text}\n(pronunciation not available)\n[translation not available]"
+            return cleaned_response
+        except Exception as e:
+            return f"Error: Both Mistral and Gemini failed: {str(e)}"
+    
+    return "Error: No LLM available"
+
+def text_to_speech(text: str) -> str:
+    global temp_audio_files
+    try:
+        french_text = extract_french_for_tts(text)
+        if not french_text:
+            return None
+        # Use Groq TTS
+        tts_response = groq_client.audio.speech.create(
+            model="tts-1",  # or "tts-1-hd" for higher quality
+            voice="alloy",  # or another supported voice, e.g., "echo", "fable", "onyx", "nova"
+            input=french_text
+        )
+        temp_dir = tempfile.mkdtemp()
+        temp_path = os.path.join(temp_dir, f"audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3")
+        with open(temp_path, "wb") as f:
+            f.write(tts_response.content)
+        temp_audio_files.append(temp_path)
+        cleanup_old_audio_files()
+        return temp_path
+    except Exception as e:
+        error_msg = str(e)
+        if "401" in error_msg or "Invalid API Key" in error_msg:
+            print(f"Groq TTS Error: Invalid API key, falling back to gTTS")
+        else:
+            print(f"Groq TTS Error: {error_msg}, falling back to gTTS")
+        # Fallback to gTTS if Groq fails
+        try:
+            from gtts import gTTS
+            tts = gTTS(text=french_text, lang='fr')
+            temp_dir = tempfile.mkdtemp()
+            temp_path = os.path.join(temp_dir, f"audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3")
+            tts.save(temp_path)
+            temp_audio_files.append(temp_path)
+            cleanup_old_audio_files()
+            return temp_path
+        except Exception as e2:
+            print(f"gTTS Fallback Error: {str(e2)}")
+            return None
+
+def analyze_conversation(full_transcript: List[Dict]) -> str:
+    global current_llm
+    
+    transcript_text = "\n".join([
+        f"{msg['role']}: {msg['content']}" for msg in full_transcript
+    ])
+    analysis_prompt = """Analyze this French conversation and provide:\n1. Grammar corrections with specific examples\n2. Pronunciation tips for common mistakes\n3. Vocabulary suggestions to improve fluency\n4. Overall assessment with encouragement\n\nBe specific, constructive, and encouraging. Format clearly with sections."""
+    
+    # Try Mistral first
+    if mistral_client:
+        try:
+            messages = [
+                {"role": "system", "content": analysis_prompt},
+                {"role": "user", "content": f"Analyze this conversation:\n{transcript_text}"}
+            ]
+            
+            response = mistral_client.chat.complete(
+                model="mistral-large-latest",
+                messages=messages
+            )
+            current_llm = "Mistral AI"
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"Mistral error in analysis: {str(e)}, falling back to Gemini")
+    
+    # Fallback to Gemini
+    if gemini_api_key:
+        try:
+            genai.configure(api_key=gemini_api_key)
+            model = genai.GenerativeModel("models/gemini-1.5-flash-latest")
+            messages = [
+                {"role": "user", "parts": [analysis_prompt]},
+                {"role": "user", "parts": [f"Analyze this conversation:\n{transcript_text}"]}
+            ]
+            response = model.generate_content(messages)
+            current_llm = "Google Gemini (Fallback)"
+            return response.text
+        except Exception as e:
+            return f"Error generating analysis: {str(e)}"
+    
+    return "Error: No LLM available for analysis"
+
+def create_app():
+    with gr.Blocks(title="French Tutor", theme=gr.themes.Soft()) as app:
+        # State management
+        conversation_state = gr.State([])
+        exchange_count = gr.State(0)
+        full_transcript = gr.State([])
+        current_scenario = gr.State("")
+        
+        gr.Markdown("# 🇫🇷 French Conversation Tutor")
+        gr.Markdown("Practice French through natural conversation! (3 exchanges per session)")
+        
+        # Model info banner
+        with gr.Row():
+            model_info = gr.Markdown(
+                f"**🤖 Models:** LLM: {current_llm} | STT: Groq Whisper | TTS: gTTS",
+                elem_id="model-info"
+            )
+        
+        # Main layout with two columns
+        with gr.Row():
+            # Left sidebar (30% width)
+            with gr.Column(scale=3):
+                gr.Markdown("## 📚 Control Panel")
+                
+                # Start/New Topic buttons
+                start_btn = gr.Button("Start New Conversation", variant="primary", size="lg")
+                new_topic_btn = gr.Button("🎲 Generate New Topic & Restart", variant="secondary", visible=False)
+                
+                # Topic display in sidebar
+                with gr.Group():
+                    gr.Markdown("### Current Topic")
+                    sidebar_scenario = gr.Markdown("Click 'Start' to begin", elem_id="sidebar-scenario")
+                
+                # Analysis section in sidebar
+                with gr.Group(visible=False) as analysis_group:
+                    gr.Markdown("### 📊 Your Analysis")
+                    analysis_box = gr.Markdown()
+                    restart_btn = gr.Button("🔄 Start Another Conversation", variant="secondary", size="lg")
+                
+                # Status in sidebar
+                status_text = gr.Textbox(
+                    label="System Status", 
+                    value="Ready to start",
+                    interactive=False
+                )
+            
+            # Right main content (70% width)
+            with gr.Column(scale=7):
+                # Conversation interface
+                with gr.Column(visible=False) as conversation_ui:
+                    gr.Markdown("## 💬 Conversation")
+                    
+                    # Chat display - always visible
+                    chat_display = gr.Markdown(value="", elem_id="chat-display")
+                    
+                    # Progress indicator
+                    progress_text = gr.Textbox(
+                        label="Progress", 
+                        value="Ready to start",
+                        interactive=False
+                    )
+                    
+                    # Audio interface
+                    with gr.Row():
+                        audio_input = gr.Audio(
+                            sources=["microphone"],
+                            type="numpy",
+                            label="🎤 Record your response in French"
+                        )
+                        record_btn = gr.Button("Send Response", variant="primary")
+                    
+                    # Tutor's audio response
+                    audio_output = gr.Audio(
+                        label="🔊 Tutor's Response", 
+                        type="filepath", 
+                        autoplay=True
+                    )
+        
+        def reset_conversation_states():
+            """Helper to reset all conversation states"""
+            return [], 0, [], "", gr.update(value=None)
+        
+        def start_conversation(scenario_text=None):
+            """Initialize a new conversation"""
+            # Reset global state
+            global current_llm
+            
+            print("Starting new conversation...")
+            
+            # Generate scenario if not provided
+            if scenario_text is None:
+                scenario = generate_scenario()
+            else:
+                scenario = scenario_text
+            
+            # Extract the tutor's first message for audio
+            audio_path = text_to_speech(scenario)
+            if audio_path is None:
+                audio_path = gr.update()  # No change to audio output
+            
+            # Format the scenario for display
+            scenario_display = scenario.strip()
+            
+            # Create fresh empty states
+            new_conversation_state = []
+            new_full_transcript = []
+            new_exchange_count = 0
+            
+            print(f"Reset states - Exchange count: {new_exchange_count}, History length: {len(new_conversation_state)}")
+            
+            return (
+                gr.update(visible=True),                  # conversation_ui
+                scenario_display,                         # sidebar_scenario
+                scenario,                                 # current_scenario state
+                "",                                       # clear chat_display
+                new_exchange_count,                       # reset exchange_count
+                new_conversation_state,                   # reset conversation_state
+                new_full_transcript,                      # reset full_transcript
+                audio_path,                               # play initial audio
+                "Ready to start - 3 exchanges to go",     # progress
+                gr.update(visible=False),                 # hide analysis_group
+                gr.update(visible=False),                 # hide start_btn
+                gr.update(visible=True),                  # show new_topic_btn
+                gr.update(value=None),                    # clear audio input
+                gr.update(interactive=True),              # enable record button
+                "Ready to start"                          # status text
+            )
+        
+        def generate_new_topic_and_start():
+            """Generate a new topic and start the conversation"""
+            scenario = generate_scenario()
+            
+            # Return all the values that start_conversation returns
+            result = start_conversation(scenario)
+            
+            # Update the progress text
+            result_list = list(result)
+            result_list[8] = "New topic generated! Ready to start - 3 exchanges to go"  # Update progress text
+            
+            return tuple(result_list)
+        
+        def process_user_audio(audio, chat_text, exchanges, history, transcript, scenario):
+            """Process user's audio input and generate response"""
+            global current_llm
+            
+            print(f"Processing audio - Exchange count: {exchanges}, History length: {len(history) if history else 0}")
+            
+            # Ensure exchange count is an integer
+            if exchanges is None:
+                exchanges = 0
+            
+            # Check if conversation is complete
+            if exchanges >= 3:
+                return (
+                    chat_text, exchanges, history, transcript,
+                    "Conversation complete! Check your analysis in the sidebar.",
+                    f"Exchange {exchanges} of 3 - Complete!",
+                    gr.update(), gr.update(value=None),
+                    gr.update()  # no change to model_info
+                )
+            
+            # Ensure states are properly initialized
+            if history is None:
+                history = []
+            if transcript is None:
+                transcript = []
+            if chat_text is None:
+                chat_text = ""
+            
+            # Check for audio
+            if audio is None:
+                return (
+                    chat_text, exchanges, history, transcript,
+                    "Please record audio first",
+                    f"Exchange {exchanges} of 3",
+                    gr.update(), gr.update(value=None),
+                    gr.update()  # no change to model_info
+                )
+            
+            # Transcribe user's speech
+            user_text, success = process_speech_to_text(audio)
+            
+            if not success:
+                return (
+                    chat_text, exchanges, history, transcript,
+                    user_text,  # Error message
+                    f"Exchange {exchanges} of 3",
+                    gr.update(), gr.update(value=None),
+                    gr.update()  # no change to model_info
+                )
+            
+            # Update chat display with user's message
+            if chat_text:
+                chat_text += f"\n\n**You:** {user_text}"
+            else:
+                # First message - include scenario context
+                chat_text = f"{scenario}\n\n---\n\n**You:** {user_text}"
+            
+            # Get tutor's response
+            tutor_response = generate_tutor_response(history, user_text)
+            
+            # Generate audio for tutor's response
+            audio_path = text_to_speech(tutor_response)
+            if audio_path is None:
+                audio_path = gr.update()  # No change to audio output
+            
+            # Update chat display with tutor's response
+            chat_text += f"\n\n**Mr. Mistral:**\n{tutor_response}"
+            
+            # Update conversation history (for context)
+            history.append({"role": "user", "content": user_text})
+            history.append({"role": "assistant", "content": tutor_response})
+            
+            # Update transcript (for analysis)
+            transcript.extend([
+                {"role": "user", "content": user_text},
+                {"role": "assistant", "content": tutor_response}
+            ])
+            
+            # Increment exchange counter
+            exchanges += 1
+            
+            # Check if this was the last exchange
+            if exchanges >= 3:
+                progress_msg = "Exchange 3 of 3 - Complete! Analysis ready."
+            else:
+                progress_msg = f"Exchange {exchanges} of 3 - Keep going!"
+            
+            # Update model info
+            model_info_text = f"**🤖 Models:** LLM: {current_llm} | STT: Groq Whisper | TTS: gTTS"
+            
+            # Return updated state
+            return (
+                chat_text,
+                exchanges,
+                history,
+                transcript,
+                f"Great! {progress_msg}",
+                progress_msg,
+                audio_path,
+                gr.update(value=None),  # Clear audio input properly
+                gr.update(value=model_info_text)  # Update model info
+            )
+        
+        def show_analysis_if_complete(exchanges, transcript):
+            """Show analysis in sidebar if conversation is complete"""
+            if exchanges >= 3:
+                analysis = analyze_conversation(transcript)
+                return (
+                    gr.update(visible=True, value=analysis),  # analysis_box with content
+                    gr.update(visible=True),                  # analysis_group
+                    gr.update(interactive=False),             # disable record button
+                    gr.update(visible=False)                  # hide new topic button
+                )
+            return (
+                gr.update(),  # no change to analysis_box
+                gr.update(),  # no change to analysis_group
+                gr.update(interactive=True),  # keep record button enabled
+                gr.update()   # no change to new topic button
+            )
+        
+        # Initialize API on load
+        def check_initialization():
+            status_msgs = []
+            if mistral_client:
+                status_msgs.append("✓ Mistral AI ready")
+            if gemini_api_key:
+                status_msgs.append("✓ Gemini fallback ready")
+            if groq_client:
+                status_msgs.append("✓ Groq STT ready")
+            status_msgs.append("✓ gTTS ready")
+            
+            if not status_msgs:
+                return "❌ No APIs initialized!"
+            
+            return " | ".join(status_msgs)
+        
+        app.load(
+            fn=check_initialization,
+            outputs=status_text
+        )
+        
+        # Start conversation
+        start_btn.click(
+            fn=start_conversation,
+            outputs=[
+                conversation_ui, sidebar_scenario, current_scenario,
+                chat_display, exchange_count, conversation_state,
+                full_transcript, audio_output, progress_text,
+                analysis_group, start_btn, new_topic_btn,
+                audio_input, record_btn, status_text
+            ]
+        )
+        
+        # Generate new topic and start conversation
+        new_topic_btn.click(
+            fn=generate_new_topic_and_start,
+            outputs=[
+                conversation_ui, sidebar_scenario, current_scenario,
+                chat_display, exchange_count, conversation_state,
+                full_transcript, audio_output, progress_text,
+                analysis_group, start_btn, new_topic_btn,
+                audio_input, record_btn, status_text
+            ]
+        )
+        
+        # Process user audio
+        record_btn.click(
+            fn=process_user_audio,
+            inputs=[
+                audio_input, chat_display, exchange_count,
+                conversation_state, full_transcript, current_scenario
+            ],
+            outputs=[
+                chat_display, exchange_count, conversation_state,
+                full_transcript, status_text, progress_text,
+                audio_output, audio_input, model_info
+            ],
+            queue=False  # Disable queueing to avoid state issues
+        ).then(
+            fn=show_analysis_if_complete,
+            inputs=[exchange_count, full_transcript],
+            outputs=[analysis_box, analysis_group, record_btn, new_topic_btn],
+            queue=False  # Disable queueing to avoid state issues
+        )
+        
+        # Restart conversation
+        restart_btn.click(
+            fn=start_conversation,
+            outputs=[
+                conversation_ui, sidebar_scenario, current_scenario,
+                chat_display, exchange_count, conversation_state,
+                full_transcript, audio_output, progress_text,
+                analysis_group, start_btn, new_topic_btn,
+                audio_input, record_btn, status_text
+            ]
+        )
+    
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    try:
+        app = create_app()
+        app.launch()
+    except Exception as e:
+        print(f"Failed to start app: {e}")

pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "mr-mistral"
+version = "0.1.0"
+description = "French Conversation Tutor using Mistral AI with Gemini fallback and Groq APIs"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "python-dotenv>=1.0.0",
+    "gradio>=4.31.0",
+    "groq>=0.30.0",
+    "gtts>=2.5.4",
+    "mistralai>=1.2.0",
+    "numpy>=1.26.0",
+    "google-generativeai>=0.5.0",
+    "soundfile>=0.12.1",
+    "openai>=1.95.1",
+]

requirements.txt

@@ -0,0 +1,9 @@
+python-dotenv>=1.0.0
+gradio>=4.31.0
+groq>=0.30.0
+gtts>=2.5.4
+mistralai>=1.2.0
+numpy>=1.26.0
+google-generativeai>=0.5.0
+soundfile>=0.12.1
+openai>=1.0.0

test.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Test script to verify API keys are working correctly
+Run this before launching the main app to ensure all APIs are accessible
+"""
+
+import os
+from dotenv import load_dotenv
+import openai
+import numpy as np
+import soundfile as sf
+import io
+
+# Load environment variables
+load_dotenv()
+openai_api_key = os.environ.get("OPENAI_API_KEY")
+
+def test_mistral():
+    """Test Mistral API"""
+    try:
+        from mistralai import Mistral
+        api_key = os.environ.get("MISTRAL_API_KEY")
+        if not api_key:
+            print("❌ MISTRAL_API_KEY not found in environment")
+            return False
+        
+        client = Mistral(api_key=api_key)
+        response = client.chat.complete(
+            model="mistral-large-latest",
+            messages=[{"role": "user", "content": "Say 'Hello' in French"}]
+        )
+        print(f"✅ Mistral API working: {response.choices[0].message.content[:50]}...")
+        return True
+    except Exception as e:
+        print(f"❌ Mistral API error: {str(e)}")
+        return False
+
+def test_gemini():
+    """Test Gemini API"""
+    try:
+        import google.generativeai as genai
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            print("⚠️  GEMINI_API_KEY not found (optional fallback)")
+            return False
+        
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel("models/gemini-1.5-flash-latest")
+        response = model.generate_content("Say 'Hello' in French")
+        print(f"✅ Gemini API working: {response.text[:50]}...")
+        return True
+    except Exception as e:
+        print(f"⚠️  Gemini API error (fallback): {str(e)}")
+        return False
+
+def test_groq():
+    """Test Groq API"""
+    try:
+        from groq import Groq
+        client = Groq(api_key=os.environ.get("GROQ_API_KEY"),)
+        if not client:
+            print("❌ GROQ_API_KEY not found in environment")
+            return False
+        
+        # client = Groq(api_key=api_key)
+        # Test with a simple completion
+        response = client.chat.completions.create(
+    messages=[
+        {
+            "role": "user",
+            "content": "Explain the importance of fast language models",
+        }
+    ],
+    model="llama-3.3-70b-versatile",
+)
+        print(f"✅ Groq API working: {response.choices[0].message.content}")
+        return True
+    except Exception as e:
+        print(f"❌ Groq API error: {str(e)}")
+        return False
+
+def test_openai_whisper():
+    """Test OpenAI Whisper API (STT)"""
+    if not openai_api_key:
+        print("⚠️  OPENAI_API_KEY not found (OpenAI Whisper fallback not available)")
+        return False
+    try:
+        # Generate a 0.5s dummy silent audio (16kHz mono)
+        sr = 16000
+        duration = 0.5
+        audio = np.zeros(int(sr * duration), dtype=np.float32)
+        buf = io.BytesIO()
+        sf.write(buf, audio, sr, format='WAV')
+        buf.seek(0)
+        openai.api_key = openai_api_key
+        response = openai.audio.transcriptions.create(
+            model="whisper-1",
+            file=("audio.wav", buf),
+            language="fr"
+        )
+        print(f"✅ OpenAI Whisper API working: {response.text}")
+        return True
+    except Exception as e:
+        print(f"❌ OpenAI Whisper API error: {str(e)}")
+        return False
+
+def main():
+    print("🔍 Testing API Keys...\n")
+    
+    mistral_ok = test_mistral()
+    gemini_ok = test_gemini()
+    groq_ok = test_groq()
+    openai_ok = test_openai_whisper()
+    
+    print("\n📊 Summary:")
+    if mistral_ok and (groq_ok or openai_ok):
+        print("✅ All required APIs are working! You can run the app.")
+    elif not mistral_ok and gemini_ok and (groq_ok or openai_ok):
+        print("✅ Gemini fallback and Groq/OpenAI Whisper are working. The app will use Gemini for LLM.")
+    else:
+        print("❌ Some required APIs are not working. Please check your API keys.")
+        if not groq_ok and not openai_ok:
+            print("   - Groq or OpenAI Whisper is required for speech-to-text")
+        if not mistral_ok and not gemini_ok:
+            print("   - Either Mistral or Gemini is required for the language model")
+
+if __name__ == "__main__":
+    main()