Un robot de escritorio que te escucha, te entiende y te responde en menos de un segundo.
Quick Start · Arquitectura · Performance · Roadmap · Contribuir
La mayoría de los asistentes de voz DIY son lentos. Entre que terminás de hablar y escuchás la primera palabra del robot pasan 2 a 4 segundos. Arriba de 1.5 s se siente robot-lento. Arriba de 3 s el usuario abandona.
Michibot tiene un solo objetivo: que la primera palabra del robot sea audible en menos de 900 ms en turnos complejos, y en menos de 200 ms en respuestas conocidas. A esa velocidad la conversación deja de sentirse como hablarle a una máquina.
No es magia — es la suma de decisiones de arquitectura que la mayoría de los proyectos DIY no toman: streaming end-to-end desde el primer día, wake word on-device, un router de 3 tiers que evita llamar al LLM en el 70 % de los turnos, proveedores cloud especializados por etapa, y pre-warming de todas las conexiones.
Michibot es la fusión de ElectronBot (cuerpo + servos + display) y EchoEar (audio ESP32-S3), con un backend en Python que lo hace conversacional.
Medido en condiciones reales — desktop LATAM contra PoPs US-East, red doméstica:
| Tier | Qué hace | p50 first-audio | Costo / turno | % de turnos |
|---|---|---|---|---|
| T1 · Canned | Respuesta WAV pre-sintetizada desde disco | ~15 ms | $0.000000 | ~40 % |
| T2 · Template | Datos locales → Cartesia streaming | ~235 ms | ~$0.0019 | ~30 % |
| T3 · LLM full | STT → Groq Llama 70B → Cartesia, con speculative TTS | ~586 ms | ~$0.0065 | ~30 % |
Costo promedio ponderado: ~$0.0027 por turno. Con 600 turnos/mes el costo
variable es ~$1.60 — margen suficiente para una subscripción de $9.99/mes.
🔬 El T2 bajó de 935 ms → 235 ms (−700 ms) al hacer la conexión WebSocket a Cartesia persistente. Ver
adapters/tts_cartesia.py.
- 🎯 Intent Router 3-tier — el 70 % de los turnos se responden sin llamar al LLM
- ⚡ Streaming end-to-end desde el primer día (speculative TTS por frase)
- 🛑 Barge-in nativo — interrumpís al robot hablando encima, se calla al toque
- 🔌 Adapter pattern puro — swapeás proveedores editando un YAML, cero
if provider == - ☁️ Dual-mode cloud / local — misma interfaz, Deepgram/Groq/Cartesia o whisper.cpp/Ollama/Piper
- 🔥 Pre-warming de WebSockets — la primera respuesta no paga el handshake
- 📊 Cost tracker + métricas JSONL — p50/p95 y costo por tier con un script
- 🐱 Wake word "Hola Michi" — entrenable, on-device vía microWakeWord en Week 2
- 🤖 Un solo chip — ESP32-S3 maneja audio + WiFi + servos + display (Week 2-3)
┌──────────────────── DEVICE (ESP32-S3 — Week 2-3) ───────────────────┐
│ │
│ mic I2S ──▶ ESP-SR AFE ──▶ microWakeWord("Hola Michi") │
│ │ │
│ ▼ │
│ ACK filler <50 ms │
│ │ │
│ ▼ │
│ WebSocket client │
│ speaker I2S ◀── audio playback ◀── WebSocket client │
│ display GC9A01 ◀── face animation ◀── event handler │
│ servos (portados del STM32 original) │
└────┬──────────────────────────────────────────────────────────────────┘
│ WebSocket binario (PCM 16 kHz) + JSON control
▼
┌──────────────────── BACKEND (FastAPI · async) ───────────────────────┐
│ │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ VoiceSessionOrchestrator │ │
│ │ STT stream ──▶ Intent Router ──▶ response stream │ │
│ │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌─────────────────────────────┐ │ │
│ │ │ T1 Canned ~15 ms │ ~40 % │ │
│ │ │ T2 Template ~235 ms │ ~30 % │ │
│ │ │ T3 LLM full ~586 ms │ ~30 % │ │
│ │ └─────────────────────────────┘ │ │
│ └───────────────────────────────────────────────────────┘ │
│ ▲ ▲ ▲ │
│ │ │ │ │
│ Deepgram Groq 70B Cartesia │
│ Nova-3 500 tok/s Sonic │
└────────────────────────────────────────────────────────────────────────┘
Cada turno pasa primero por un Intent Router que clasifica en 3 tiers:
| Tier | Cuándo dispara | Qué ejecuta | Costo |
|---|---|---|---|
| T1 | Match regex contra ~18 frases canned (saludos, cortesías, afirmaciones) | Lee un WAV del disco y lo stremea al cliente | $0 |
| T2 | Match contra handlers de template (ej: "¿qué hora es?") | Genera texto con datos locales, manda a TTS streaming | Solo TTS |
| T3 | Fallback: cualquier cosa que no matchee T1/T2 | Pipeline completo STT → Groq Llama 70B → Cartesia con speculative TTS | Los 3 |
El ~70 % de los turnos de una conversación real caen en T1/T2. Por eso la latencia percibida promedio es muchísimo más baja que el peor caso.
- Python 3.11+
- uv — gestor de dependencias rápido
- Micrófono y parlantes funcionando
- 3 API keys (las 3 tienen free tier):
git clone https://github.com/<tu-user>/michibot.git
cd michibot
uv sync
cp env.example.txt .env
# Editá .env y pegá las 3 API keys# Terminal 1 — backend
uv run uvicorn electronbot_es.server.app:app --host 127.0.0.1 --port 8000
# Terminal 2 — cliente mock con wake word
uv run python -m electronbot_es.mock.mock_esp32 --wake-word
# Decí "hey jarvis" (placeholder — el real "Hola Michi" llega en Week 2)uv run python scripts/metrics.py --last 20Ejemplo de salida
=== Michibot metrics — 20 turns ===
tier n % first_audio p50 p95 tts_first p50 p95 avg_cost total
---------------------------------------------------------------------------------
T1 8 40% 15 ms 30 ms 15 ms 30 ms $0.000000 $0.0000
T2 6 30% 235 ms 280 ms 235 ms 280 ms $0.001878 $0.0113
T3 6 30% 586 ms 820 ms 586 ms 820 ms $0.006514 $0.0391
---------------------------------------------------------------------------------
total cost: $0.0504 avg/turn: $0.002520
T3 tokens avg: in=225 out=41
T1+T2 match rate: 70% (target >60%)
michibot/
├── src/electronbot_es/
│ ├── core/
│ │ ├── orchestrator.py # VoiceSessionOrchestrator + speculative TTS
│ │ ├── cost.py # Estimación de costo por turno
│ │ ├── obs.py # Logger JSONL de métricas
│ │ ├── messages.py # Schemas pydantic del protocolo WebSocket
│ │ ├── protocols.py # STT / LLM / TTS como Protocol
│ │ ├── persona.py # System prompt LATAM del LLM
│ │ └── config.py
│ ├── router/
│ │ ├── intent_router.py # Decisión T1 / T2 / T3
│ │ ├── canned_responses.yaml
│ │ └── templates/ # Handlers T2 (hora, clima, etc.)
│ ├── adapters/
│ │ ├── stt_deepgram.py · stt_whisper.py
│ │ ├── llm_groq.py · llm_claude.py · llm_ollama.py
│ │ └── tts_cartesia.py · tts_piper.py
│ ├── server/
│ │ └── app.py # FastAPI + /ws/voice
│ └── mock/
│ ├── mock_esp32.py # Cliente de desarrollo (mic + speaker + WS)
│ └── wake_word.py # openWakeWord wrapper
├── docs/
│ ├── protocol.md # Contrato WebSocket v1 (inmutable)
│ ├── roadmap.md # Weeks 2-12+
│ ├── hardware.md # Decisiones de hardware
│ ├── cloud-providers.md # Setup Deepgram / Groq / Cartesia
│ └── llm-benchmark.md # Benchmark español LATAM
├── assets/canned/ # WAVs pre-sintetizados (T1)
├── scripts/ # generate_canned, metrics, benchmarks, ...
└── tests/ # pytest · 40+ tests
|
Backend
|
Cloud providers
|
Local / dev
|
|
Device (Week 2+)
|
Mobile (Week 7+)
|
Tooling
|
| Semana | Objetivo | Estado |
|---|---|---|
| W1 | Backend + mock + router + observabilidad | ✅ |
| W2 | Firmware ESP32-S3 + wake word real "Hola Michi" | 🔜 |
| W3 | Servos + display GC9A01 + personalidad física | ⏳ |
| W4 | Integración end-to-end + aceptación MVP | ⏳ |
| W5-6 | Multi-tenant (Supabase + auth + billing) | ⏳ |
| W7-8 | App móvil React Native + Expo | ⏳ |
| W9 | Deploy producción + stores + beta cerrada | ⏳ |
| W10-12 | Iteración + launch público | ⏳ |
Detalles semana por semana en docs/roadmap.md.
docs/protocol.md· Contrato WebSocket (inmutable)docs/hardware.md· Por qué ESP32-S3 único y por qué no LLM on-devicedocs/cloud-providers.md· Setup de las 3 API keysdocs/roadmap.md· Plan semana por semana hasta launchdocs/llm-benchmark.md· Comparativa de LLMs en español LATAM
Michibot es un proyecto en desarrollo activo — Week 1 recién cerró. Si querés aportar:
- Issues — reportá bugs, pedí features, comentá ideas
- Benchmarks — si tenés una GPU decente y querés correr el modo local, mandá tus números
- Canned responses LATAM — falta ampliar el catálogo T1 con más variantes regionales (Argentina, México, Colombia, Chile, Perú…)
- Voces TTS — experimentar con Cartesia Voice Cloning para acentos regionales (la voz actual es neutro LATAM)
MIT. Hecho con cariño en LATAM.
Si Michibot te parece interesante, tirale una ⭐ — ayuda un montón.