fren-voice 1.0.0

package/MiraTTS.bat

@@ -0,0 +1,27 @@
+@echo off
+REM MiraTTS Launcher
+REM This batch file activates the virtual environment and runs the TTS program
+
+cd /d "%~dp0"
+
+echo ========================================
+echo MiraTTS - Text to Speech Generator
+echo ========================================
+echo.
+
+REM Check if virtual environment exists
+if not exist ".venv\Scripts\activate.bat" (
+    echo ERROR: Virtual environment not found!
+    echo Please ensure .venv folder exists in the same directory.
+    pause
+    exit /b 1
+)
+
+REM Activate virtual environment and run the program
+call .venv\Scripts\activate.bat
+python tts.py
+
+REM Deactivate when done
+deactivate
+
+pause

package/MiraTTS.ps1

@@ -0,0 +1,29 @@
+# MiraTTS PowerShell Launcher
+# This script activates the virtual environment and runs the TTS program
+
+$scriptPath = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $scriptPath
+
+Write-Host "========================================"
+Write-Host "MiraTTS - Text to Speech Generator"
+Write-Host "========================================"
+Write-Host ""
+
+# Check if virtual environment exists
+if (-not (Test-Path ".venv\Scripts\Activate.ps1")) {
+    Write-Host "ERROR: Virtual environment not found!" -ForegroundColor Red
+    Write-Host "Please ensure .venv folder exists in the same directory."
+    Read-Host "Press Enter to exit"
+    exit 1
+}
+
+# Activate virtual environment
+& ".venv\Scripts\Activate.ps1"
+
+# Run the TTS program
+& python tts.py
+
+# Deactivate when done
+deactivate
+
+Read-Host "Press Enter to exit"

package/PIPELINE_ARCHITECTURE.md

@@ -0,0 +1,73 @@
+# Project Pipeline Architecture
+
+This document illustrates the technical data flow and component integration of the Voice Conversational AI System.
+
+## Technical Flow Diagram
+
+```mermaid
+graph TD
+    %% Entry Point
+    Start((System Start)) --> ShadowMode[Shadow Listening Mode]
+
+    %% Wake-Word Logic
+    ShadowMode -->|Detects 'Hey' / 'Start'| AudioCue[Audio Cue: Ascending Beep]
+    AudioCue --> MainLoop[Active Conversation Loop]
+
+    %% Input Pipeline
+    MainLoop --> MicInput[Microphone Input]
+    MicInput --> VAD{VAD Process}
+    VAD -->|Speaking| Buffer[Accumulate Audio Buffer]
+    VAD -->|Silence > 0.8s| StopRec[Terminate Recording]
+
+    %% Inference Pipeline
+    StopRec --> STT[Faster-Whisper STT Engine]
+    STT -->|Text| LLM[LM Studio API Inference]
+    LLM -->|Response Script| PreProcess[Text Normalization]
+
+    %% Output Pipeline
+    PreProcess --> TTS[MiraTTS Neural Synthesis]
+    TTS -->|PCM Audio| SyncExec{Parallel Execution}
+
+    SyncExec -->|Thread 1| Playback[PyAudio Memory Playback]
+    SyncExec -->|Thread 2| Visuals[Fast Typeface Animation]
+
+    %% State Management
+    Playback & Visuals --> StateCheck{Command Check}
+    StateCheck -->|'Pause'| PauseCue[Audio Cue: Descending Beep]
+    PauseCue --> ShadowMode
+
+    StateCheck -->|'Deactivate'| Shutdown((System Shutdown))
+    StateCheck -->|Next Turn| MainLoop
+```
+
+## Component Roles
+
+### 1. Input Layer (VAD & STT)
+
+- **VAD (Voice Activity Detection)**: Monitors RMS energy levels in real-time. It cuts the recording loop immediately after 800ms of sustained quiet, significantly reducing response latency compared to fixed-length recording.
+- **Faster-Whisper**: Processes the audio buffer into text. It uses CTranslate2 backend for high-speed inference on NVIDIA GPUs.
+
+### 2. Cognitive Layer (LLM)
+
+- **LM Studio Gateway**: Acts as the brain. The system sends conversational context to a local OpenAI-compatible endpoint.
+- **System Prompting**: Enforces concise, spoken-word friendly responses (1-3 sentences) to maintain conversational speed.
+
+### 3. Synthesis Layer (TTS)
+
+- **MiraTTS**: A neural reference-based synthesis engine. It generates high-fidelity audio tokens from text based on the `reference_file.wav` provided at initialization.
+- **Neural Codecs**: Utilizes `ncodec` and `FlashSR` for internal audio super-resolution and decoding.
+
+### 4. Output Layer (Synchronized IO)
+
+- **PyAudio Memory Buffer**: Audio is played directly from RAM. No disk I/O is involved during playback to prevent micro-stutters.
+- **Threaded UI**: The terminal typewriter effect runs in a parallel thread, synchronized with a 1.0s lead-in to allow the sound driver to initialize.
+
+## Lifecycle States
+
+| State            | Description                                  | Audio Cue       |
+| :--------------- | :------------------------------------------- | :-------------- |
+| **Shadow Mode**  | Silent background monitoring for wake-words. | None            |
+| **Activation**   | Transition into active conversation.         | Ascending Beep  |
+| **Processing**   | Actively transcribing or generating.         | None            |
+| **Deactivation** | Transition back into Shadow Mode.            | Descending Beep |
+| **Termination**  | Full process shutdown.                       | None            |

package/PIPELINE_SETUP.md

@@ -0,0 +1,169 @@
+# Complete Conversational AI Pipeline Setup
+
+## Architecture Overview
+
+```
+Audio Input → Whisper (STT) → LM Studio (LLM) → MiraTTS (TTS) → Audio Output
+```
+
+## Components
+
+### 1. Whisper WebSocket Server (Speech-to-Text)
+
+- **File**: `ws_whisper_server.py`
+- **Endpoint**: `ws://127.0.0.1:8000/ws/transcribe`
+- **Status**: ✅ RUNNING
+- **Model**: faster-whisper (small, CUDA)
+- **Environment**: `venv`
+
+### 2. LM Studio (Language Model)
+
+- **Endpoint**: `http://127.0.0.1:1234/v1/chat/completions`
+- **Status**: ✅ RUNNING
+- **Available Models**:
+  - orpheus-3b-0.1-ft
+  - llama-3.1-8b-lexi-uncensored-v2
+
+### 3. MiraTTS (Text-to-Speech)
+
+- **File**: `tts_test.py`
+- **Environment**: `.venv` (with dot)
+- **GPU Enforcement**: ✅ STRICT (ONNX CUDA only)
+- **Reference Audio**: `reference_file.wav`
+
+### 4. Pipeline Integration
+
+- **File**: `whisper_to_llm_pipeline.py`
+- **Environment**: `venv`
+- **Features**:
+  - Interactive text chat with LLM
+  - Audio file transcription via Whisper
+  - Complete STT → LLM flow
+
+## Running the Complete Pipeline
+
+### Step 1: Start Whisper Server (Already Running)
+
+```powershell
+.\venv\Scripts\Activate.ps1
+uvicorn ws_whisper_server:app --host 0.0.0.0 --port 8000
+```
+
+### Step 2: Ensure LM Studio is Running (Already Running)
+
+- LM Studio should be running on port 1234
+- Load your preferred model
+
+### Step 3: Run the Pipeline
+
+```powershell
+.\venv\Scripts\Activate.ps1
+python whisper_to_llm_pipeline.py
+```
+
+**Interactive Mode Commands:**
+
+- Type any message → sends directly to LLM
+- `audio <filepath>` → transcribes audio then sends to LLM
+- `clear` → clears conversation history
+- `exit` → quit
+
+### Step 4: Add TTS Output (Use tts_test.py separately)
+
+For now, use `tts_test.py` in the `.venv` environment to generate speech from LLM responses.
+
+## Environment Details
+
+### `venv` (Whisper + Pipeline)
+
+Packages installed:
+
+- faster-whisper
+- fastapi
+- uvicorn
+- websockets
+- soundfile
+- numpy
+- requests
+- pyaudio
+
+### `.venv` (MiraTTS)
+
+Packages installed:
+
+- mira (MiraTTS)
+- onnxruntime-gpu (CUDA)
+- soundfile
+- numpy
+- requests
+
+## GPU Requirements
+
+### tts_test.py - STRICT GPU ENFORCEMENT ✅
+
+```python
+# Force ONNX Runtime to use CUDA only - fail if CUDA is not available
+os.environ['ORT_CUDA_UNAVAILABLE'] = '0'
+
+# Verify ONNX Runtime has CUDA before proceeding
+has_gpu = any(p in providers for p in ['CUDAExecutionProvider', 'TensorrtExecutionProvider'])
+if not has_gpu:
+    print("ERROR: No GPU provider available for ONNX Runtime!")
+    sys.exit(1)
+```
+
+### ws_whisper_server.py - GPU Configured
+
+```python
+model = WhisperModel(
+    "small",
+    device="cuda",           # GPU only
+    compute_type="float16"
+)
+```
+
+## Testing the Pipeline
+
+### Test 1: Text to LLM
+
+```
+> Hello, how are you?
+🤖 Sending to LM Studio...
+✓ Assistant: [LLM Response]
+```
+
+### Test 2: Audio to LLM
+
+```
+> audio reference_file.wav
+🎤 Transcribing: reference_file.wav
+   [Whisper]: [Transcribed text]
+✓ Transcription complete: "[text]"
+🤖 Sending to LM Studio...
+✓ Assistant: [LLM Response]
+```
+
+### Test 3: Full Pipeline (Manual)
+
+1. Record/prepare audio file
+2. Run: `audio myaudio.wav` in pipeline
+3. Get transcription → LLM response
+4. Copy LLM response
+5. Run `tts_test.py` in `.venv` environment
+6. Paste response to generate speech
+
+## Current Status
+
+✅ Whisper Server: RUNNING on port 8000
+✅ LM Studio: RUNNING on port 1234  
+✅ Pipeline Script: READY
+✅ TTS (tts_test.py): READY with GPU enforcement
+⏳ Full integration: Requires merging environments or API bridge
+
+## Next Steps for Full Integration
+
+To create a single script with all three components:
+
+1. Install MiraTTS in the `venv` environment, OR
+2. Install Whisper packages in the `.venv` environment, OR
+3. Create a REST API wrapper around tts_test.py for the pipeline to call

package/README.md

@@ -0,0 +1,208 @@
+# Conversational AI Fren
+
+## Overview
+
+This project implements a high-performance, low-latency voice conversational pipeline. It integrates Faster-Whisper for Speech-to-Text (STT), LM Studio for Large Language Model (LLM) inference, and MiraTTS for neural Text-to-Speech (TTS).
+
+## Core Components
+
+- **Speech-to-Text**: `faster-whisper` (medium model) utilizing CUDA 12.1 for near-instant transcription.
+- **Language Model**: Inference via OpenAI-compatible API (standard port 1234).
+- **Text-to-Speech**: `MiraTTS` neural cloning model for natural vocal responses.
+- **Logic Engine**: Monolithic Python implementation with asynchronous VAD and threading.
+
+## Features
+
+- **Voice-to-Start**: The system initializes in a silent "Shadow Mode" and activates via wake words ("Start" or "Hey").
+- **Voice Activity Detection (VAD)**: Intelligent recording cutoff (0.8s silence threshold) to eliminate fixed-duration delays.
+- **Shadow Listening (Pause Mode)**: Background monitoring with zero TUI output. Transition cues are provided via audio beeps.
+- **Audio Transition Cues**: When activating and deactivating, the system emits a 1-second beep to signal the transition.
+
+## System Prerequisites
+
+1.  **Python 3.10+**: Recommended for compatibility with `onnxruntime-gpu` and `torch`.
+2.  **FFmpeg**: Must be installed and available in the system PATH (used for loudness normalization and silence removal).
+3.  **CUDA 12.1 & cuDNN**: Required for GPU acceleration.
+4.  **LM Studio**: Local server must be active on `http://127.0.0.1:1234`.
+
+## Quick Start (the easy way)
+
+You can now initialize and run the entire pipeline with a single command using `npx`:
+
+```bash
+npx fren-voice
+```
+
+This will automatically:
+
+1. Clone the repository (if not already present).
+2. Create a virtual environment.
+3. Install all CUDA-optimized dependencies.
+4. Launch the AI conversation.
+
+---
+
+## Installation (Traditional)
+
+### 1. Prerequisites
+
+- **Python 3.10+**: Download and install from [python.org](https://www.python.org/).
+- **Git**: Required to pull specific model repositories.
+- **FFmpeg**:
+  1. Download and install FFmpeg following the official guides at [ffmpeg.org](https://ffmpeg.org/download.html) or the [official GitHub repository](https://github.com/FFmpeg/FFmpeg).
+  2. Ensure the `ffmpeg` executable is added to your system **PATH**.
+- **LM Studio**: Install it and load a GGUF model (e.g., Llama 3 or Mistral). Start the Local Server on port 1234.
+
+### 2. Setup Virtual Environment
+
+It is highly recommended to use a virtual environment to manage dependencies:
+
+**Windows:**
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\activate
+```
+
+**Linux:**
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+### 3. Install Dependencies
+
+Install all core engines and CUDA-optimized libraries:
+
+**Windows:**
+
+```powershell
+pip install -r requirements.txt
+```
+
+**Linux:**
+
+```bash
+pip3 install -r requirements.txt
+```
+
+### 4. Hardware Verification
+
+Ensure your NVIDIA drivers are up to date. The system will automatically attempt to locate the necessary CUDA/cuDNN DLLs within your site-packages if they are missing from the system path.
+
+## Configuration
+
+- **Reference Voice**: The system requires `reference_file.wav` in the root directory for TTS voice cloning.
+- **Microphone**: Defaulted to default input device can also be modified by setting `input_device_index` in the `record_audio_vad` method if necessary.
+- **Environment Variables**: The script automatically sets the following for stability:
+  - `TM_MAX_CONTEXT_TOKEN_NUM="12000"` (LMDeploy buffer)
+  - `ORT_CUDA_DISABLE_CUDNN_FRONTEND="1"` (ONNX CUDA stability)
+
+## Usage
+
+Execute the main script:
+
+**Windows:**
+
+```powershell
+python voice_conversation.py
+```
+
+**Linux:**
+
+```bash
+python3 voice_conversation.py
+```
+
+### Voice Commands {Can be changed in the code as requirements}
+
+- **Activate**: "Start", "Hey", or "Continue".
+- **Pause**: "Pause", "Exit", "Quit", or "Goodbye".
+- **Terminate**: "Deactivate", "Terminate", or "Shut down".
+
+## Project Structure
+
+- `voice_conversation.py`: Core system logic and TUI.
+- `requirements.txt`: Unified dependency manifest for CUDA-enabled environments.
+- `README.md`: Technical documentation and setup guide.
+- `reference_file.wav`: Target voice profile for TTS.
+- `MiraTTS.bat` / `.ps1`: Quick-launch scripts.
+
+---
+
+# Project Pipeline Architecture
+
+This section illustrates the technical data flow and component integration of the Voice Conversational AI System.
+
+## Technical Flow Diagram
+
+![Pipeline Diagram](Pipeline%20Diagram.png)
+
+```mermaid
+graph TD
+    %% Entry Point
+    Start((System Start)) --> ShadowMode[Shadow Listening Mode]
+
+    %% Wake-Word Logic
+    ShadowMode -->|Detects 'Hey' / 'Start'| AudioCue[Audio Cue: Ascending Beep]
+    AudioCue --> MainLoop[Active Conversation Loop]
+
+    %% Input Pipeline
+    MainLoop --> MicInput[Microphone Input]
+    MicInput --> VAD{VAD Process}
+    VAD -->|Speaking| Buffer[Accumulate Audio Buffer]
+    VAD -->|Silence > 0.8s| StopRec[Terminate Recording]
+
+    %% Inference Pipeline
+    StopRec --> STT[Faster-Whisper STT Engine]
+    STT -->|Text| LLM[LM Studio API Inference]
+    LLM -->|Response Script| PreProcess[Text Normalization]
+
+    %% Output Pipeline
+    PreProcess --> TTS[MiraTTS Neural Synthesis]
+    TTS -->|PCM Audio| SyncExec{Parallel Execution}
+
+    SyncExec -->|Thread 1| Playback[PyAudio Memory Playback]
+    SyncExec -->|Thread 2| Visuals[Fast Typeface Animation]
+
+    %% State Management
+    Playback & Visuals --> StateCheck{Command Check}
+    StateCheck -->|'Pause'| PauseCue[Audio Cue: Descending Beep]
+    PauseCue --> ShadowMode
+
+    StateCheck -->|'Deactivate'| Shutdown((System Shutdown))
+    StateCheck -->|Next Turn| MainLoop
+```
+
+## Component Roles
+
+### 1. Input Layer (VAD & STT)
+
+- **VAD (Voice Activity Detection)**: Monitors RMS energy levels in real-time. It cuts the recording loop immediately after 800ms of sustained quiet, significantly reducing response latency compared to fixed-length recording.
+- **Faster-Whisper**: Processes the audio buffer into text. It uses CTranslate2 backend for high-speed inference on NVIDIA GPUs.
+
+### 2. Cognitive Layer (LLM)
+
+- **LM Studio Gateway**: Acts as the brain. The system sends conversational context to a local OpenAI-compatible endpoint.
+- **System Prompting**: Enforces concise, spoken-word friendly responses (1-3 sentences) to maintain conversational speed.
+
+### 3. Synthesis Layer (TTS)
+
+- **MiraTTS**: A neural reference-based synthesis engine. It generates high-fidelity audio tokens from text based on the `reference_file.wav` provided at initialization.
+- **Neural Codecs**: Utilizes `ncodec` and `FlashSR` for internal audio super-resolution and decoding.
+
+### 4. Output Layer (Synchronized IO)
+
+- **PyAudio Memory Buffer**: Audio is played directly from RAM. No disk I/O is involved during playback to prevent micro-stutters.
+- **Threaded UI**: The terminal typewriter effect runs in a parallel thread, synchronized with a 1.0s lead-in to allow the sound driver to initialize.
+
+## Lifecycle States
+
+| State            | Description                                  | Audio Cue       |
+| :--------------- | :------------------------------------------- | :-------------- |
+| **Shadow Mode**  | Silent background monitoring for wake-words. | None            |
+| **Activation**   | Transition into active conversation.         | Ascending Beep  |
+| **Processing**   | Actively transcribing or generating.         | None            |
+| **Deactivation** | Transition back into Shadow Mode.            | Descending Beep |
+| **Termination**  | Full process shutdown.                       | None            |

package/bin/cli.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+const { execSync } = require("child_process");
+const fs = require("fs-extra");
+const path = require("path");
+const chalk = require("chalk");
+const ora = require("ora");
+const prompts = require("prompts");
+
+async function main() {
+  console.log(chalk.cyan.bold("\n       🎙️  FREN: AI Voice Companion\n"));
+
+  const currentDir = process.cwd();
+  const isProjectDir = await fs.pathExists(
+    path.join(currentDir, "voice_conversation.py")
+  );
+
+  if (!isProjectDir) {
+    const response = await prompts({
+      type: "confirm",
+      name: "setup",
+      message:
+        "Fren is not initialized in this directory. Would you like to clone the repository here?",
+      initial: true,
+    });
+
+    if (response.setup) {
+      const spinner = ora("Cloning repository...").start();
+      try {
+        execSync("git clone https://github.com/lakshya-p/Fren.git .", {
+          stdio: "ignore",
+        });
+        spinner.succeed("Repository cloned successfully!");
+      } catch (err) {
+        spinner.fail("Failed to clone repository. Make sure git is installed.");
+        process.exit(1);
+      }
+    } else {
+      console.log(
+        chalk.yellow(
+          "Aborted. Please navigate to a Fren directory or initialize it."
+        )
+      );
+      process.exit(0);
+    }
+  }
+
+  // Check for Virtual Environment
+  const venvPath = path.join(currentDir, ".venv");
+  const pythonExec =
+    process.platform === "win32"
+      ? path.join(venvPath, "Scripts", "python.exe")
+      : path.join(venvPath, "bin", "python");
+
+  if (!(await fs.pathExists(venvPath))) {
+    const setupVenv = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message:
+        "No virtual environment found. Would you like to create one and install dependencies?",
+      initial: true,
+    });
+
+    if (setupVenv.proceed) {
+      const spinner = ora("Creating virtual environment...").start();
+      try {
+        execSync("python -m venv .venv");
+        spinner.text =
+          "Installing dependencies (this may take a few minutes)...";
+        execSync(`"${pythonExec}" -m pip install -r requirements.txt`, {
+          stdio: "inherit",
+        });
+        spinner.succeed("Setup complete!");
+      } catch (err) {
+        spinner.fail("Setup failed. Ensure Python 3.10+ is installed.");
+        console.error(err);
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.yellow("Cannot proceed without dependencies."));
+      process.exit(1);
+    }
+  }
+
+  // Final confirmation to run
+  console.log(chalk.green("\n🚀 Starting Fren AI...\n"));
+  try {
+    execSync(`"${pythonExec}" voice_conversation.py`, { stdio: "inherit" });
+  } catch (err) {
+    console.error(
+      chalk.red(
+        "\nFren closed with an error. Check if LM Studio is running on port 1234."
+      )
+    );
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "fren-voice",
+  "version": "1.0.0",
+  "description": "High-performance voice conversational AI system.",
+  "main": "index.js",
+  "bin": {
+    "fren": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "voice",
+    "ai",
+    "stt",
+    "tts",
+    "llm",
+    "conversational"
+  ],
+  "author": "lakshya-p",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "execa": "^5.1.1",
+    "fs-extra": "^10.0.0",
+    "ora": "^5.4.1",
+    "prompts": "^2.4.2"
+  }
+}

package/requirements.txt

@@ -0,0 +1,36 @@
+--extra-index-url https://download.pytorch.org/whl/cu121
+
+# CoreModules (Git Repositories)
+git+https://github.com/ysharma3501/MiraTTS.git
+git+https://github.com/ysharma3501/FastBiCodec.git
+git+https://github.com/ysharma3501/FlashSR.git
+
+# Inference Engines
+faster-whisper==1.2.1
+onnxruntime-gpu==1.23.2
+lmdeploy==0.11.0
+
+# PyTorch (CUDA 12.1 optimized)
+torch==2.5.1+cu121
+torchaudio==2.5.1+cu121
+torchvision==0.20.1+cu121
+
+# Audio Processing & IO
+pyaudio>=0.2.14
+soundfile>=0.13.1
+librosa>=0.11.0
+numpy==1.26.4
+
+# API & Networking
+requests>=2.32.5
+aiohttp>=3.13.2
+fastapi>=0.127.0
+uvicorn>=0.40.0
+python-multipart
+
+# Support & Performance
+transformers>=4.56.1
+pydantic>=2.12.5
+tqdm>=4.67.1
+typing-extensions>=4.13.0
+ffmpeg-python

package/voice_conversation.py

@@ -0,0 +1,330 @@
+"""
+STABLE VOICE CONVERSATIONAL AI (Wake-Word + Audio Cues)
+Optimizations:
+- VAD (Voice Activity Detection): Stop recording early when silence is detected.
+- Silent Wake-Word Detection: Back-to-life on "Hey", "Fren", or "Continue".
+- Audio Cues: Beep on pause/resume.
+"""
+import os
+import sys
+
+# Log suppression
+os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+os.environ['ORT_CUDA_DISABLE_CUDNN_FRONTEND'] = '1'
+
+import asyncio
+import requests
+import numpy as np
+import soundfile as sf
+import subprocess
+import pyaudio
+import tempfile
+import threading
+import re
+import json
+import logging
+import warnings
+import time
+from datetime import datetime
+from faster_whisper import WhisperModel
+
+# Global Silence Configuration
+warnings.filterwarnings("ignore")
+logging.basicConfig(level=logging.ERROR)
+logging.getLogger("lmdeploy").setLevel(logging.ERROR)
+logging.getLogger().setLevel(logging.ERROR)
+
+# Fix for CUDA DLLs on Windows
+if sys.platform == "win32":
+    for venv_name in [".venv", "venv"]:
+        nvidia_dir = os.path.join(os.path.dirname(__file__), venv_name, "Lib", "site-packages", "nvidia")
+        if os.path.exists(nvidia_dir):
+            for sub in ["cudnn", "cublas", "cuda_runtime", "curand", "cusolver", "cusparse"]:
+                bin_path = os.path.join(nvidia_dir, sub, "bin")
+                if os.path.exists(bin_path):
+                    os.environ["PATH"] = bin_path + os.pathsep + os.environ["PATH"]
+
+# Set ONNX Severity
+try:
+    import onnxruntime as ort
+    ort.set_default_logger_severity(3)
+except: pass
+
+os.environ['TM_MAX_CONTEXT_TOKEN_NUM'] = '12000'
+from mira.model import MiraTTS
+
+# Configuration
+LLM_API_URL = "http://127.0.0.1:1234/v1/chat/completions"
+LLM_MODELS_URL = "http://127.0.0.1:1234/v1/models"
+SAMPLE_RATE = 16000
+MAX_RECORD_SECONDS = 6 
+SILENCE_THRESHOLD = 500  # RMS threshold for silence
+SILENCE_DURATION = 0.8   # Stop after 0.8s of silence
+
+class VoiceConversationalAI:
+    def __init__(self, reference_audio_path):
+        print("\n" + "="*70)
+        print("🎙️  VOICE CONVERSATIONAL AI SYSTEM")
+        print("="*70)
+        
+        # Initialize Whisper
+        print("\n[1/4] Loading Whisper model...")
+        try:
+            self.whisper = WhisperModel("medium", device="cuda", compute_type="float16")
+            print("      ✓ Whisper loaded on CUDA (medium)")
+        except:
+            self.whisper = WhisperModel("small", device="cpu", compute_type="int8")
+            print("      ✓ Whisper loaded on CPU (small)")
+
+        # Initialize TTS
+        print("\n[2/4] Loading MiraTTS model...")
+        self.mira_tts = MiraTTS('YatharthS/MiraTTS')
+        self.mira_tts.set_params(temperature=0.6, top_p=0.92, max_new_tokens=1536)
+        print("      ✓ MiraTTS loaded")
+        
+        print("\n[3/4] Encoding reference audio...")
+        self.context_tokens = self.mira_tts.encode_audio(reference_audio_path)
+        print("      ✓ Reference audio encoded")
+        
+        self.audio = pyaudio.PyAudio()
+        self.turn_count = 0
+        
+        print("\n" + "="*70)
+        print("[OK] System Ready!")
+        print("="*70)
+
+    def play_cue(self, cue_type='resume'):
+        """Simple sine wave beep cue"""
+        def run_cue():
+            try:
+                duration = 0.2
+                fs = 44000
+                if cue_type == 'resume':
+                    # Ascending: 400Hz to 800Hz
+                    f1, f2 = 400, 800
+                else:
+                    # Descending: 800Hz to 400Hz
+                    f1, f2 = 800, 400
+                
+                t = np.linspace(0, duration, int(fs * duration))
+                # Frequency sweep
+                f = np.linspace(f1, f2, len(t))
+                samples = 0.9 * np.sin(2 * np.pi * f * t) # Increased volume to 0.9
+                
+                # Fade out to avoid click
+                fade = np.linspace(1, 0, len(samples))
+                samples = (samples * fade).astype(np.float32)
+                
+                # Standard playback
+                stream = self.audio.open(format=pyaudio.paFloat32, channels=1, rate=fs, output=True)
+                stream.write(samples.tobytes())
+                stream.stop_stream()
+                stream.close()
+            except: pass
+        
+        threading.Thread(target=run_cue).start()
+
+    async def record_audio_vad(self, silent=False):
+        """Record with VAD: stop early when silence is detected"""
+        if not silent: print(f"\nMIC: Listening...")
+        
+        stream = self.audio.open(
+            format=pyaudio.paInt16,
+            channels=1,
+            rate=SAMPLE_RATE,
+            input=True,
+            input_device_index=3, 
+            frames_per_buffer=1024
+        )
+        
+        frames = []
+        silent_chunks = 0
+        max_silent_chunks = int(SILENCE_DURATION * SAMPLE_RATE / 1024)
+        started_talking = False
+        
+        for i in range(0, int(SAMPLE_RATE / 1024 * (3 if silent else MAX_RECORD_SECONDS))):
+            data = stream.read(1024, exception_on_overflow=False)
+            frames.append(data)
+            
+            audio_data = np.frombuffer(data, dtype=np.int16)
+            rms = np.sqrt(np.mean(audio_data.astype(np.float32)**2))
+            
+            if rms > SILENCE_THRESHOLD:
+                started_talking = True
+                silent_chunks = 0
+            elif started_talking:
+                silent_chunks += 1
+                if silent_chunks > max_silent_chunks:
+                    break
+        
+        stream.stop_stream()
+        stream.close()
+        return b''.join(frames)
+    
+    def transcribe_sync(self, audio_bytes, silent=False):
+        """Standard transcription or silent background check"""
+        if not silent: print("🔄 Transcribing...")
+        
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+            temp_name = f.name
+            with sf.SoundFile(temp_name, 'w', 16000, 1) as sf_file:
+                sf_file.write(np.frombuffer(audio_bytes, dtype=np.int16))
+        
+        clean_name = temp_name.replace(".wav", "_clean.wav")
+        try:
+            subprocess.run(["ffmpeg", "-y", "-i", temp_name, "-ac", "1", "-ar", "16000", "-af", "loudnorm,silenceremove=stop_periods=-1:stop_duration=0.5:stop_threshold=-40dB", clean_name], capture_output=True, timeout=5)
+            trans_file = clean_name if os.path.exists(clean_name) else temp_name
+        except: trans_file = temp_name
+
+        try:
+            segments, _ = self.whisper.transcribe(trans_file, language="en", temperature=0, beam_size=1, vad_filter=True)
+            text = "".join(s.text for s in segments).strip()
+            
+            if not silent:
+                if text: print(f"   ✓ You said: \"{text}\"")
+                else: print(f"   WARN: No speech detected")
+            
+            return text
+        except: return ""
+        finally:
+            for f in [temp_name, clean_name]:
+                if os.path.exists(f): 
+                    try: os.remove(f)
+                    except: pass
+
+    async def background_wait_for_wake_word(self, initial=False):
+        """Silently listen for 'Hey', 'Fren', or 'Continue'"""
+        if initial:
+            print("\n🎙️  System initialized. Say 'Hey Fren' or 'Start' to begin...")
+        else:
+            self.play_cue('pause') # Audio cue for pausing
+            print("\n⏸️  System Paused. Listening for 'Hey', 'Fren', or 'Continue'...")
+        
+        keywords = ['hey', 'fren', 'continue', 'start']
+        
+        while True:
+            # Silent record (3 seconds chunks)
+            audio_data = await self.record_audio_vad(silent=True)
+            
+            # Silent transcribe
+            text = await asyncio.to_thread(self.transcribe_sync, audio_data, silent=True)
+            
+            if text and any(kw in text.lower() for kw in keywords):
+                self.play_cue('resume') # Audio cue for resuming
+                print("\n🎙️  System Re-activated!" if not initial else "\n🎙️  System Started!")
+                return True
+            
+            await asyncio.sleep(0.1)
+
+    def query_llm_sync(self, user_message):
+        try:
+            try: model_id = requests.get(LLM_MODELS_URL, timeout=5).json()["data"][0]["id"]
+            except: model_id = "local-model"
+
+            response = requests.post(
+                LLM_API_URL,
+                json={
+                    "model": model_id,
+                    "messages": [
+                        {"role": "system", "content": "You are a helpful voice assistant. Respond naturally and conversationally. Keep it concise (1-3 sentences). Only output plain spoken English."},
+                        {"role": "user", "content": user_message}
+                    ],
+                    "temperature": 0.5
+                },
+                timeout=60
+            )
+            if response.status_code == 200:
+                msg = response.json()['choices'][0]['message']['content']
+                msg = re.sub(r"<[^>]+>", "", msg)
+                msg = re.sub(r"\*[^*]+\*", "", msg)
+                return msg.strip()
+            return "I'm having trouble connecting."
+        except Exception as e:
+            return f"Error: {e}"
+
+    def generate_and_play_speech(self, text):
+        if not text: return
+        print(f"\nSPEAKER: Generating speech...")
+        
+        try:
+            import io, contextlib
+            with contextlib.redirect_stdout(io.StringIO()):
+                audio = self.mira_tts.generate(text, self.context_tokens)
+
+            def play():
+                audio_int16 = (np.array(audio) * 32767).astype(np.int16)
+                stream = self.audio.open(format=pyaudio.paInt16, channels=1, rate=48000, output=True)
+                stream.write(audio_int16.tobytes())
+                stream.stop_stream()
+                stream.close()
+
+            def type_text():
+                time.sleep(1.0) # Delay start to sync with audio buffering
+                print(f"\n💬 Fren: ", end="", flush=True)
+                for char in text:
+                    print(char, end="", flush=True)
+                    time.sleep(0.04) # Faster typeface animation
+                print("\n")
+
+            play_thread = threading.Thread(target=play)
+            type_thread = threading.Thread(target=type_text)
+            
+            play_thread.start()
+            type_thread.start()
+            
+            play_thread.join()
+            type_thread.join()
+            
+        except Exception as e:
+            print(f"   [ERR] TTS Error: {e}")
+
+    async def run(self):
+        print("\n" + "="*70)
+        print("🎙️  VOICE CONVERSATION MODE")
+        print("="*70)
+        
+        # Start with silent VAD instead of Enter
+        await self.background_wait_for_wake_word(initial=True)
+        
+        try:
+            while True:
+                print("\n" + "-"*40)
+                # Step 1: Record with VAD
+                audio_data = await self.record_audio_vad()
+                
+                # Step 2: Transcribe
+                transcription = await asyncio.to_thread(self.transcribe_sync, audio_data)
+                
+                if transcription:
+                    # Check for termination
+                    if any(word in transcription.lower() for word in ['deactivate', 'terminate', 'shut down']):
+                        print("\n🛑 System Deactivating. Goodbye!")
+                        break
+
+                    # Check for pause/exit
+                    if any(word in transcription.lower() for word in ['exit', 'quit', 'goodbye', 'bye', 'pause']):
+                        # Enter Silent Wake Mode
+                        await self.background_wait_for_wake_word()
+                        continue
+                        
+                    # Step 3: Query LLM
+                    response = await asyncio.to_thread(self.query_llm_sync, transcription)
+                    
+                    # Step 4: Playback
+                    await asyncio.to_thread(self.generate_and_play_speech, response)
+                
+                print("\n⏸️  Ready for next turn...")
+                await asyncio.sleep(0.5)
+                
+        except KeyboardInterrupt: print("\n👋 Interrupt received. Exiting.")
+        finally: self.audio.terminate()
+
+async def main():
+    ref_file = "reference_file.wav"
+    if not os.path.exists(ref_file): return
+    ai = VoiceConversationalAI(ref_file)
+    await ai.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())