Technical Deep Dive

def respond(self, user_input):
    # Two-stage activation: silent warm-up first, then real activation
    if not self.pre_warmed and self.check_wake_word(user_input):
        # First wake word - do silent warm-up
        self.pre_warmed = True
        print(f"\n🔥 Wake word detected, doing silent warm-up...")

        # Mute TTS temporarily
        original_tts = self.tts
        self.tts = None
        self.processing = True
        self.stt.muted = True

        # Do a real response to warm up the model properly
        warm_messages = self.messages + [{"role": "user", "content": user_input}]
        response = requests.post(
            f"{OLLAMA_HOST}/api/chat",
            json={
                "model": OLLAMA_MODEL,
                "messages": warm_messages,
                "stream": True,
                "options": {
                    "temperature": 0.77,
                    "num_predict": 117,
                    "num_ctx": 1024,
                    "num_gpu": 999,  # Force full GPU usage
                    "keep_alive": "60m"
                }
            },
            stream=True,
            timeout=(1, None)
        )

        # Enable quick response mode for instant detection
        self.stt.set_quick_mode(True)
        print("✨ Warmed up! Say 'Gemma' again for instant activation.")

# Stream tokens and speak sentences immediately
for line in response.iter_lines():
    if line:
        chunk = json.loads(line)
        if "message" in chunk:
            token = clean_text(chunk["message"].get("content", ""))
            if token:
                print(token, end="", flush=True)
                full_response += token
                buffer.append(token)

                text = ''.join(buffer)
                sentences = re.split(r'([.!?]+\s*)', text)

                # Process complete sentences immediately
                i = 0
                while i < len(sentences) - 1:
                    if re.match(r'[.!?]+\s*', sentences[i+1]):
                        sentence = sentences[i] + sentences[i+1]
                        if sentence.strip() and self.tts:
                            self.tts.speak(sentence.strip())
                        i += 2
                    else:
                        break

                buffer = [sentences[-1]] if i < len(sentences) else []
                time.sleep(TYPING_DELAY)

# Model Configuration
OLLAMA_MODEL = "hf.co/unsloth/gemma-3n-E4B-it-GGUF:Q4_K_XL"
OLLAMA_HOST = "http://localhost:11434"

# Generation Settings - Optimized for conversation
TEMPERATURE = 0.77          # Balanced creativity/coherence
MAX_TOKENS = 117           # Keep responses concise
TOP_P = 0.95               # Nucleus sampling
TOP_K = 33                 # Top-k sampling
REPEAT_PENALTY = 1.33      # Reduce repetition
CONTEXT_WINDOW = 1024      # Context window size
NUM_CTX = 1024             # Ollama parameter name

# Performance Settings
STREAM_CHUNK_SIZE = 17     # Characters per chunk
TYPING_DELAY = 0.03        # Natural feel

# Audio Settings
SAMPLE_RATE = 16000        # Whisper requirement
STT_VAD_THRESHOLD = 0.11  # Voice activity detection
STT_MIN_SPEECH_MS = 200    # Minimum speech duration
STT_MAX_SILENCE_MS = 666   # Maximum silence

def __init__(self):
    # Load Silero VAD for efficient voice detection
    vad_path = Path.home() / ".cache/silero/silero_vad.jit"
    vad_path.parent.mkdir(parents=True, exist_ok=True)

    if not vad_path.exists():
        import urllib.request
        urllib.request.urlretrieve(
            "https://github.com/snakers4/silero-vad/raw/master/src/silero_vad/data/silero_vad.jit",
            vad_path
        )

    self.vad = torch.jit.load(str(vad_path), map_location="cpu")
    self.vad.eval()

def listen(self, callback, is_activated_callback=None):
    # Adaptive thresholds for different states
    if self.quick_response_mode:
        threshold = 0.15  # Very sensitive for instant wake word
    elif is_activated_callback and not is_activated_callback():
        threshold = 0.3   # Moderately sensitive for initial wake word
    else:
        threshold = 0.4   # Lower for better conversation flow

    speech = self.vad(torch.from_numpy(audio), self.sample_rate).item() > threshold