IntentRecognizer

from moonshine_voice import IntentRecognizer, EmbeddingModelArch

recognizer = IntentRecognizer(
    model_path: str,
    model_arch: EmbeddingModelArch = EmbeddingModelArch.GEMMA_300M,
    model_variant: str = "q4",
    threshold: float = 0.7
)

recognizer.register_intent(
    trigger_phrase: str,
    handler: Callable[[str, str, float], None]
)

def on_lights_on(trigger, utterance, similarity):
    print(f"Turning on lights (confidence: {similarity:.0%})")
    # Control smart home API here

recognizer.register_intent("turn on the lights", on_lights_on)

recognizer.unregister_intent(trigger_phrase: str)

recognizer.process_utterance(utterance: str)

recognizer.set_threshold(threshold: float)

threshold = recognizer.get_threshold() -> float

count = recognizer.get_intent_count() -> int

recognizer.clear_intents()

from moonshine_voice import MicTranscriber, IntentRecognizer

# Create transcriber
transcriber = MicTranscriber(
    model_path="/path/to/asr/models"
)

# Create intent recognizer
recognizer = IntentRecognizer(
    model_path="/path/to/embedding/models"
)

# Register commands
recognizer.register_intent(
    "turn on the lights",
    lambda t, u, s: print("Lights ON")
)

recognizer.register_intent(
    "turn off the lights",
    lambda t, u, s: print("Lights OFF")
)

# Attach to transcriber - now intents are detected automatically
transcriber.add_listener(recognizer)

transcriber.start()
# Speak: "Please turn on the lights" -> Triggers "Lights ON"

from moonshine_voice import MicTranscriber, IntentRecognizer

class SmartHome:
    def __init__(self):
        self.lights_on = False
    
    def lights_on_handler(self, trigger, utterance, similarity):
        self.lights_on = True
        print(f"✓ Lights ON ({similarity:.0%} match)")
    
    def lights_off_handler(self, trigger, utterance, similarity):
        self.lights_on = False
        print(f"✓ Lights OFF ({similarity:.0%} match)")
    
    def temperature_handler(self, trigger, utterance, similarity):
        # This is a simplified example
        # In practice, you'd parse the number from the utterance
        print(f"Setting temperature ({similarity:.0%} match)")

# Set up smart home
home = SmartHome()

# Create recognizer
recognizer = IntentRecognizer(
    model_path="/path/to/embedding/models",
    threshold=0.65  # More permissive for casual speech
)

# Register intents
recognizer.register_intent("turn on the lights", home.lights_on_handler)
recognizer.register_intent("turn off the lights", home.lights_off_handler)
recognizer.register_intent("set temperature to 72", home.temperature_handler)

# Attach to transcriber
transcriber = MicTranscriber(model_path="/path/to/asr/models")
transcriber.add_listener(recognizer)

print("Smart home voice control ready")
transcriber.start()

from moonshine_voice import IntentRecognizer

recognizer = IntentRecognizer(model_path="/path/to/models")

# Robot movement commands
commands = [
    "move forward",
    "move backward",
    "turn left",
    "turn right",
    "stop moving"
]

def robot_handler(trigger, utterance, similarity):
    print(f"Command: {trigger}")
    print(f"User said: {utterance}")
    print(f"Confidence: {similarity:.0%}")
    # Send command to robot here

# Register all commands with same handler
for command in commands:
    recognizer.register_intent(command, robot_handler)

print(f"Registered {recognizer.get_intent_count()} commands")

# Test
recognizer.process_utterance("go forward")  # Matches "move forward"
recognizer.process_utterance("go backwards")  # Matches "move backward"

recognizer.register_intent("turn on the lights", handler)

# These all match:
recognizer.process_utterance("turn on the lights")     # 100% match
recognizer.process_utterance("switch on the lights")   # ~95% match
recognizer.process_utterance("lights on please")       # ~90% match
recognizer.process_utterance("enable the lights")      # ~85% match
recognizer.process_utterance("illuminate the room")    # ~75% match

# These don't match (below threshold):
recognizer.process_utterance("turn off the lights")    # Opposite meaning
recognizer.process_utterance("what time is it")        # Unrelated

python -m moonshine_voice.intent_recognizer \
  --intents "turn left, turn right, stop, go forward"