Initial push

Author: csimoes1

Dockerfile

@@ -0,0 +1,52 @@
+FROM ubuntu:22.04
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    python3.10 \
+    python3-pip \
+    python3-dev \
+    build-essential \
+    cmake \
+    git \
+    ffmpeg \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Link python3 to python for convenience (optional)
+RUN ln -s /usr/bin/python3 /usr/bin/python
+
+# Set working directory and copy files
+WORKDIR /app
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Debug line
+RUN ls -la /app  # See what's copied
+
+# Build whisper.cpp from its subdirectory
+WORKDIR /app/whisper.cpp
+RUN cmake -B build && cmake --build build --config Release
+
+# Download Whisper model
+WORKDIR /app
+RUN mkdir -p /app/whisper_models
+RUN wget -O /app/whisper_models/ggml-base.en.bin https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin
+
+# Switch back to /app for the app runtime
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV WHISPER_MODEL_PATH=/app/whisper_models/ggml-base.en.bin
+ENV WHISPER_CPP_PATH=/app/whisper.cpp/build/bin/whisper-cli
+
+# Expose port
+EXPOSE 8000
+
+# Command to run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

Dockerfile.slim

@@ -0,0 +1,39 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    git \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Use alternatives to avoid building whisper.cpp with vectorization issues
+# Option 1: Use a different speech recognition engine
+# Add to requirements.txt: openai-whisper
+# And use the Python library for transcription instead of the C++ version
+
+# Create necessary directories
+RUN mkdir -p /app/models
+
+# Add placeholder for whisper.cpp main executable
+# (We'll work around this in the Python code)
+
+# Copy application code
+COPY . .
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV WHISPER_MODEL_PATH=/app/models
+
+# Expose port
+EXPOSE 8000
+
+# Command to run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

InterviewAgent.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.13 (InterviewAgent)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

ProjectStructure.txt

@@ -0,0 +1,28 @@
+InterviewAgent/
+├── app/
+│   ├── __init__.py
+│   ├── main.py              # FastAPI application entry point
+│   ├── routes/
+│   │   ├── __init__.py
+│   │   ├── websocket.py     # WebSocket routes for audio streaming
+│   │   └── api.py           # REST API routes
+│   ├── services/
+│   │   ├── __init__.py
+│   │   ├── whisper_service.py   # Whisper.cpp integration
+│   │   └── grok_service.py      # Grok API integration
+│   └── models/
+│       ├── __init__.py
+│       └── conversation.py       # Data models
+├── static/
+│   ├── css/
+│   │   └── style.css
+│   ├── js/
+│   │   ├── app.js           # Main application logic
+│   │   └── webrtc.js        # WebRTC handling
+│   └── index.html           # Main page
+├── tests/
+│   └── test_whisper.py
+├── Dockerfile
+├── docker-compose.yml
+├── requirements.txt
+└── README.md

README.md

@@ -0,0 +1,101 @@
+# WebRTC Speech-to-Text with Grok API
+
+This project provides a web application that uses WebRTC to capture audio from the user's microphone, processes it with whisper.cpp for speech-to-text conversion, and integrates with X.AI's Grok API for intelligent responses.
+
+## Features
+
+- Real-time audio capture using WebRTC
+- Server-side speech-to-text processing with whisper.cpp
+- Integration with X.AI's Grok API
+- WebSocket-based communication for real-time interactions
+- Simple and intuitive user interface
+
+## Prerequisites
+
+- Docker and Docker Compose (for containerized deployment)
+- X.AI (Grok) API key
+
+## Setup and Installation
+
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/yourusername/webrtc-whisper-grok.git
+   cd webrtc-whisper-grok
+   ```
+
+2. Create a `.env` file in the project root with your API key:
+   ```
+   GROK_API_KEY=your_api_key_here
+   ```
+
+3. Build and start the application with Docker Compose:
+   ```bash
+   docker-compose up --build
+   ```
+
+4. Access the application at http://localhost:8000
+
+## Manual Setup (without Docker)
+
+If you prefer to run the application without Docker:
+
+1. Install system dependencies:
+    - Python 3.10+
+    - FFmpeg
+    - Build tools (gcc, cmake, etc.)
+
+2. Clone and build whisper.cpp:
+   ```bash
+   git clone https://github.com/ggerganov/whisper.cpp.git
+   cd whisper.cpp
+   make
+   bash ./models/download-ggml-model.sh base.en
+   cd ..
+   ```
+
+3. Install Python dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. Set environment variables:
+   ```bash
+   export GROK_API_KEY=your_api_key_here
+   export WHISPER_CPP_PATH=/path/to/whisper.cpp/main
+   ```
+
+5. Run the application:
+   ```bash
+   uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+   ```
+
+## Architecture
+
+- **Frontend**: HTML/CSS/JavaScript with WebRTC for audio capture
+- **Backend**: FastAPI Python application
+- **WebSockets**: For real-time audio streaming and response delivery
+- **Processing Pipeline**: Audio → whisper.cpp → Grok API → User Interface
+
+## Development
+
+The project structure follows a clean architecture approach:
+
+- `/app`: Backend Python code
+- `/static`: Frontend assets
+- `/tests`: Test cases
+
+## Security Considerations
+
+- This application requires microphone access, which is sensitive permission
+- HTTPS should be used in production to secure the WebRTC connection
+- API keys should be properly secured and not exposed in client-side code
+
+## License
+
+[MIT License](LICENSE)
+
+## Acknowledgements
+
+- [whisper.cpp](https://github.com/ggerganov/whisper.cpp) for high-performance speech recognition
+- X.AI for the Grok API
+- FastAPI for the web framework

app/main.py

@@ -0,0 +1,48 @@
+import sys
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import logging
+
+from app.routes.websocket import router as websocket_router
+from app.routes.api import router as api_router
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title="WebRTC Speech-to-Text with Grok",
+    description="A web application that processes speech using WebRTC and whisper.cpp, then sends it to Grok API",
+    version="0.1.0",
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # For development only, restrict in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(websocket_router)
+app.include_router(api_router)
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+app.mount("/", StaticFiles(directory="static", html=True), name="root")
+
+if __name__ == "__main__":
+    logger.info("Starting server")
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)

app/models/conversation.py

@@ -0,0 +1,91 @@
+from pydantic import BaseModel
+from typing import List, Dict, Optional
+from datetime import datetime
+import uuid
+
+class Message(BaseModel):
+    """
+    Represents a single message in a conversation.
+    """
+    id: str = None
+    role: str  # "system", "user", or "assistant"
+    content: str
+    timestamp: datetime = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.id is None:
+            self.id = str(uuid.uuid4())
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+
+class Conversation(BaseModel):
+    """
+    Represents a conversation with message history.
+    """
+    id: str = None
+    messages: List[Message] = []
+    created_at: datetime = None
+    updated_at: datetime = None
+    metadata: Dict = {}
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.id is None:
+            self.id = str(uuid.uuid4())
+        if self.created_at is None:
+            self.created_at = datetime.now()
+        if self.updated_at is None:
+            self.updated_at = self.created_at
+
+    def add_message(self, role: str, content: str) -> Message:
+        """
+        Add a new message to the conversation.
+
+        Args:
+            role: The role of the sender ("system", "user", or "assistant")
+            content: The message content
+
+        Returns:
+            The newly created message
+        """
+        message = Message(role=role, content=content)
+        self.messages.append(message)
+        self.updated_at = datetime.now()
+        return message
+
+    def to_dict(self) -> Dict:
+        """
+        Convert the conversation to a dictionary.
+
+        Returns:
+            Dictionary representation of the conversation
+        """
+        return {
+            "id": self.id,
+            "messages": [
+                {
+                    "role": msg.role,
+                    "content": msg.content
+                }
+                for msg in self.messages
+            ],
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "metadata": self.metadata
+        }
+
+    def to_api_messages(self) -> List[Dict]:
+        """
+        Convert the conversation messages to a format suitable for the API.
+
+        Returns:
+            List of message dictionaries formatted for the API
+        """
+        return [
+            {
+                "role": msg.role,
+                "content": msg.content
+            }
+            for msg in self.messages
+        ]