VoiceBot

Build error

App Files Files Community

Chris4K commited on Feb 4, 2025

Commit

a37520a

verified ·

1 Parent(s): 2bbcd9b

Update app.py

Browse files

Files changed (1) hide show

app.py +116 -136

app.py CHANGED Viewed

@@ -16,156 +16,136 @@ try:
 except Exception as e:
     print("Langfuse Offline")
-########
-html = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AI State Machine</title>
-    <style>
-        body { font-family: Arial, sans-serif; text-align: center; }
-        #chatbox { width: 80%; height: 300px; border: 1px solid #ccc; overflow-y: auto; margin: 20px auto; padding: 10px; }
-        #inputbox { width: 70%; padding: 5px; }
-        button { padding: 5px 10px; }
-    </style>
-</head>
-<body>
-    <h2>AI State Machine</h2>
-    <div id="chatbox"></div>
-    <input type="text" id="inputbox" placeholder="Type your message...">
-    <button onclick="sendMessage()">Send</button>
-    <script>
-let ws = new WebSocket("wss://chris4k-a-i-statemachine.hf.space/ws");
-ws.onopen = function() {
-    console.log("WebSocket connected!");
-    ws.send("Hello AI!"); // Send initial message
-};
-ws.onmessage = (event) => {
-    console.log("Message from server: ", event.data);
-    let chatbox = document.getElementById("chatbox");
-    chatbox.innerHTML += `<p>${event.data}</p>`;
-    chatbox.scrollTop = chatbox.scrollHeight;
-};
-ws.onerror = function(error) {
-    console.error("WebSocket Error: ", error);
-};
-function sendMessage() {
-    let input = document.getElementById("inputbox");
-    let message = input.value.trim();
-    if (message) {
-        ws.send(message);
-        input.value = "";
-    }
-}
-    </script>
-</body>
-</html>
-"""
-######
-import asyncio
-import random
-import time
 from fastapi import FastAPI, WebSocket
-from fastapi.responses import HTMLResponse
-import uvicorn
-class AIStateManager:
-    def __init__(self):
-        self.state = "awake"
-        self.research_tasks = ["Explore AI Ethics", "Find latest AI models", "Investigate quantum computing"]
-        self.current_task = None
-        self.heartbeat_count = 0
-        self.clients = set()
-    async def set_state(self, new_state):
-        """Thread-safe state change with logging."""
-        print(f"[STATE CHANGE] {self.state} → {new_state}")
-        self.state = new_state
-        await self.broadcast(f"State changed to {new_state}")
-    async def broadcast(self, message):
-        """Broadcast message to all connected clients."""
-        for client in list(self.clients):
-            try:
-                await client.send_text(message)
-            except Exception as e:
-                print(f"Broadcast error: {e}")
-                self.clients.remove(client)
-    async def research_cycle(self):
-        """Manages research state tasks."""
-        while True:
-            await asyncio.sleep(5)  # Longer interval for visibility
-            # State-based logic
-            if self.state == "awake":
-                self.heartbeat_count += 1
-                if self.heartbeat_count >= 3:
-                    await self.set_state("research")
-            elif self.state == "research":
-                if self.research_tasks:
-                    task = self.research_tasks.pop(0)
-                    await self.broadcast(f"Researching: {task}")
-                    # Simulate task work
-                    await asyncio.sleep(3)
-                    # Random chance of generating follow-up
-                    if random.random() < 0.3:
-                        await self.broadcast(f"Question about {task}")
-                else:
-                    await self.set_state("sleeping")
-            elif self.state == "sleeping":
-                await self.broadcast("System in sleep mode")
-                await asyncio.sleep(10)  # Longer sleep
-                # Reset after sleep
-                self.research_tasks = ["Explore AI Ethics", "Find latest AI models", "Investigate quantum computing"]
-                await self.set_state("awake")
-                self.heartbeat_count = 0
-# FastAPI Setup
-app = FastAPI()
-ai_manager = AIStateManager()
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
-    ai_manager.clients.add(websocket)
     try:
-        while True:
-            data = await websocket.receive_text()
-            await ai_manager.broadcast(f"Received: {data}")
     except Exception as e:
         print(f"WebSocket error: {e}")
     finally:
-        ai_manager.clients.remove(websocket)
-@app.on_event("startup")
-async def startup_event():
-    """Start research cycle on app startup."""
-    asyncio.create_task(ai_manager.research_cycle())
-@app.get("/")
-async def get():
-    """Serve frontend HTML."""
-    return HTMLResponse(html)
 if __name__ == "__main__":
-    uvicorn.run(app, host="localhost", port=8000)

 except Exception as e:
     print("Langfuse Offline")
+# main.py
 from fastapi import FastAPI, WebSocket
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import StreamingResponse, HTMLResponse
+import asyncio
+import json
+import webrtcvad
+import numpy as np
+import wave
+import io
+from typing import AsyncGenerator
+from utils import (
+    from_en_translation,
+    to_en_translation,
+    tts,
+    tts_to_bytesio,
+)
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, VisitWebpageTool
+app = FastAPI()
+app.mount("/static", StaticFiles(directory="static"), name="static")
+# Initialize tools and agent
+model = HfApiModel()
+search_tool = DuckDuckGoSearchTool()
+visit_webpage_tool = VisitWebpageTool()
+agent = CodeAgent(
+    tools=[search_tool, visit_webpage_tool],
+    model=model,
+    additional_authorized_imports=['requests', 'bs4', 'pandas', 'concurrent.futures', 'csv', 'json']
+)
+# Constants
+SAMPLE_RATE = 16000
+CHANNELS = 1
+CHUNK_SIZE = 480  # 30ms chunks for VAD
+VAD_MODE = 3  # Aggressiveness mode (3 is most aggressive)
+desired_language = "de"
+max_answer_length = 100
+#response_generator_pipe = TextGenerationPipeline(max_length=max_answer_length)
+# Initialize VAD
+vad = webrtcvad.Vad(VAD_MODE)
+async def detect_wakeword(audio_chunk: bytes) -> bool:
+    # TODO: Implement proper wake word detection
+    # For now, this is a placeholder that should be replaced with a proper wake word detection model
+    # You might want to use libraries like Porcupine or build your own wake word detector
+    return True
+async def process_audio_stream(websocket: WebSocket) -> AsyncGenerator[str, None]:
+    buffer = []
+    is_speaking = False
+    silence_frames = 0
+    while True:
+        try:
+            audio_data = await websocket.receive_bytes()
+            # Convert audio data to the right format for VAD
+            is_speech = vad.is_speech(audio_data, SAMPLE_RATE)
+            if is_speech:
+                silence_frames = 0
+                buffer.append(audio_data)
+                is_speaking = True
+            elif is_speaking:
+                silence_frames += 1
+                if silence_frames > 30:  # End of utterance detection
+                    # Process complete utterance
+                    audio_bytes = b''.join(buffer)
+                    # Convert to wave file for speech recognition
+                    wav_buffer = io.BytesIO()
+                    with wave.open(wav_buffer, 'wb') as wav_file:
+                        wav_file.setnchannels(CHANNELS)
+                        wav_file.setsampwidth(2)  # 16-bit audio
+                        wav_file.setframerate(SAMPLE_RATE)
+                        wav_file.writeframes(audio_bytes)
+                    # Reset state
+                    buffer = []
+                    is_speaking = False
+                    silence_frames = 0
+                    # Check for wake word
+                    if await detect_wakeword(audio_bytes):
+                        # Process the audio and get response
+                        user_speech_text = stt(wav_buffer, desired_language)
+                        if "computer" in user_speech_text.lower():
+                            translated_text = to_en_translation(user_speech_text, desired_language)
+                            response = await agent.arun(translated_text)  # Assuming agent.run is made async
+                            bot_response_de = from_en_translation(response, desired_language)
+                            # Stream the response
+                            yield json.dumps({
+                                "user_text": user_speech_text,
+                                "response_de": bot_response_de,
+                                "response_en": response
+                            })
+                            # Generate and stream audio response
+                            bot_voice = tts(bot_response_de, desired_language)
+                            bot_voice_bytes = tts_to_bytesio(bot_voice)
+                            yield json.dumps({
+                                "audio": bot_voice_bytes.decode('latin1')
+                            })
+        except Exception as e:
+            print(f"Error processing audio: {e}")
+            break
+@app.get("/", response_class=HTMLResponse)
+async def get_index():
+    with open("static/index.html") as f:
+        return f.read()
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
     try:
+        async for response in process_audio_stream(websocket):
+            await websocket.send_text(response)
     except Exception as e:
         print(f"WebSocket error: {e}")
     finally:
+        await websocket.close()
 if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)