Encuentra el módulo Odoo perfecto en segundos
Un servidor MCP que conecta LLMs con 16,000+ módulos OCA usando búsqueda semántica + full-text con Reciprocal Rank Fusion
0
Módulos indexados
0
Repositorios OCA
0
Versiones Odoo
<500
ms respuesta
0
Clientes MCP
$1.76
Coste total APIs
El Problema
❌ Sin AI-OdooFinder
- Desarrollas funcionalidades que ya existen en OCA
- Pierdes horas buscando el módulo correcto en GitHub
- Instalas módulos incompatibles con tu versión
- Descubres módulos abandonados tras integrarlos
✓ Con AI-OdooFinder
- Búsqueda semántica + keyword en un solo query
- Filtrado automático por versión de Odoo
- Descripciones enriquecidas con IA (Grok-4)
- Integración directa desde Claude, Cursor, VSCode...
Arquitectura
┌─────────────────────────────────────────────────────────────────────────────────┐
│ CLIENTES MCP │
├───────────────┬───────────────┬───────────────┬───────────────┬────────────────┤
│ Claude Desktop│ Claude.ai │ Cursor │ Zed │ VSCode Copilot│
│ (STDIO) │ (HTTP) │ (STDIO) │ (STDIO) │ (STDIO) │
└───────┬───────┴───────┬───────┴───────┬───────┴───────┬───────┴────────┬───────┘
│ │ │ │ │
└───────────────┴───────────────┼───────────────┴────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│ MCP SERVER (FastMCP) │
│ ┌─────────────────────────────────────────────────────────────────────────┐ │
│ │ Tool: search_odoo_modules(query, version, dependencies, limit) │ │
│ │ • Flujo inteligente de 4 pasos con clarificación │ │
│ │ • Clasificación por confianza (HIGH/MEDIUM/LOW) │ │
│ │ • Instrucciones específicas para el LLM │ │
│ └─────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────┬───────────────────────────────────────┘
│ HTTP
▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│ FASTAPI BACKEND (:8989) │
│ ┌──────────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐ │
│ │ /search │ │ /modules/{id} │ │ /stats │ │
│ │ Búsqueda híbrida │ │ Detalle módulo │ │ Estadísticas │ │
│ └──────────────────────┘ └──────────────────────┘ └──────────────────────┘ │
│ │ │
│ ┌─────────────────────────────────────┴─────────────────────────────────────┐ │
│ │ HYBRID SEARCH SERVICE (RRF Fusion) │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ │ │
│ │ │ Vector Search │──────┬───────│ BM25 Search │ │ │
│ │ │ (pgvector HNSW) │ │ │ (tsvector) │ │ │
│ │ └─────────────────┘ ▼ └─────────────────┘ │ │
│ │ Reciprocal Rank Fusion │ │
│ │ RRF(d) = 1/(k+rank_v) + 1/(k+rank_b) │ │
│ └───────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────┬───────────────────────────────────────┘
│ SQL
▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│ POSTGRESQL 17 + pgvector │
│ ┌───────────────────────────────────────────────────────────────────────────┐ │
│ │ modules: 16,494 registros │ │
│ │ • embedding (vector 2560) - Qwen3-Embedding-4B │ │
│ │ • search_vector (tsvector) - Full-text español/inglés │ │
│ │ • ai_description, functional_tags, keywords - Grok-4-fast enrichment │ │
│ └───────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────────┘
Stack Tecnológico
FastMCP
Framework Python para servidores MCP. Decoradores simples, transporte dual STDIO/HTTP.
pgvector + BM25
Búsqueda híbrida: embeddings Qwen3 (2560 dims) + full-text con fusión RRF.
FastAPI
Backend async de alto rendimiento. Python 3.13+, documentación OpenAPI.
OpenRouter
Gateway unificado para LLMs. Qwen3 para embeddings, Grok-4 para enrichment.
Docker + Hetzner
Despliegue containerizado en VPS ARM64. ~5€/mes sin cold starts.
Tailscale Funnel
HTTPS automático sin configuración. Túnel seguro para acceso remoto.
01
INVESTIGAR
Aprende a Aprender con IA - Deep Research y Validación Cruzada
🎯 Objetivo
- Deep research exhaustivo con Gemini 2.5 Pro
- Identificar el "Triángulo de Dificultad" de Odoo
- Evaluar 4 arquitecturas de IA para la solución
- Validación cruzada con múltiples modelos
🛠️ Herramientas
- Gemini 2.5 Pro (Deep Research)
- NotebookLM (síntesis)
- KimiK2 (validación)
- Claude Desktop (refinamiento)
📦 Entregable
- Documento de 15+ páginas de análisis
- Comparativa de herramientas existentes
- Arquitectura RAG Híbrida definida
El Triángulo de Dificultad de Odoo
Documentación
Fragmentada
/\
/ \
/ \
/ \
/ \
/ \
/____________\
Descubrimiento "Infierno del
de Módulos Versionado"
(10.0 → 19.0)
┌─────────────────────────────────────────────────────────┐
│ CONCLUSIÓN DEL RESEARCH: │
│ │
│ "La arquitectura óptima es un Framework Agéntico │
│ que orquesta un Pipeline de RAG Híbrido usando │
│ un índice dual SQL + Vectorial" │
└─────────────────────────────────────────────────────────┘
Evaluación de Arquitecturas
| Arquitectura | Manejo Versionado | Viabilidad |
|---|---|---|
| LLM + Búsqueda Web | Pobre (Alucina) | ❌ Inviable |
| RAG Simple (Solo Vectores) | Pobre (No determinista) | ⚠️ Baja |
| Claude Skills | Excelente (con backend) | ✓ Alta |
| RAG Híbrido (Agéntico) | Excelente (Determinista) | ✓✓ Óptima |
💡 Spec-Driven Development:
Define primero QUÉ debe hacer el sistema antes de
implementar CÓMO. Cada feature tuvo su SPEC antes de
codificar.
02
DIALOGAR
Prompt Engineering y Context Engineering Avanzado
⚡
Principio Fundamental:
"Calidad de Entrada → Calidad de Salida". El modelo no
puede leer tu mente. La ambigüedad es el enemigo.
🎯 Objetivo
- Evolucionar de prompts simples a flujo inteligente
- Implementar Few-Shot con ejemplos concretos
- Crear Chain of Thought de 4 pasos
- Usar delimitadores efectivos para cada modelo
📊 Métricas
- Few-Shot Learning
- Chain of Thought (CoT)
- Delimitadores (═══, ⚠️, 🚨)
- Ejemplos correctos vs incorrectos
📦 Entregable
- Prompt de 100+ líneas estructurado
- Flujo inteligente de clarificación
- Sistema de confianza (HIGH/MEDIUM/LOW)
Flujo Inteligente de 4 Pasos
1. ¿Necesita clarificación?
→
2. Construir query óptimo
→
3. Interpretar por confianza
→
4. Instrucciones al LLM
Few-Shot Examples
server.py - QUERY_DESCRIPTION
LOCALIZATION QUERY EXAMPLES:
• Spain + electronic invoice → "l10n_es_facturae facturae"
• Spain + AEAT taxes → "l10n_es_aeat modelo"
• Mexico + CFDI invoice → "l10n_mx_edi cfdi"
• Argentina + AFIP invoice → "l10n_ar_afipws factura"
User: "electronic invoicing for Spain"
✅ CORRECT: "l10n_es_facturae facturae FACE"
❌ INCORRECT: "electronic invoice e-invoice XML digital signature Spain..."
⚠️ For localizations: query of 2-4 words maximum
⚠️ The l10n_XX_ prefix is MORE IMPORTANT than synonyms
📝
Delimitadores por Modelo:
Claude prefiere XML, GPT triple comillas, Gemini
markdown. En nuestro prompt usamos caracteres visuales
(───, ⚠️) que funcionan en todos.
03
EJECUTAR
IDEs Agénticos y Desarrollo Aumentado
🎯 Objetivo
- Usar IDEs agénticos para desarrollo acelerado
- Implementar búsqueda híbrida con RRF
- Refactoring con lenguaje natural
- 89 commits en 30 días
🛠️ Herramientas
- Cursor (Composer1, 4x más rápido)
- Claude Code CLI (Sonnet 4, Opus 4.5)
- Zed (Grok-4-fast, sesiones largas)
- Claude Desktop/Web (validación)
📊 Métricas
- 89 commits totales
- 2.9 commits/día promedio
- Día más productivo: 9 commits
- Speedup estimado: 4-8x
Timeline de IDEs
Nov 6-15
Cursor
Inicio rápido. Edición multi-archivo, exploración inicial del código.
Nov 15-25
Claude Code CLI
Desarrollo principal. Slash commands, tareas complejas de terminal, ETL.
Nov 25 - Dic 6
Zed + Claude
Producción. Rendimiento superior (Rust), sesiones largas, integración final.
🚀
Ejemplo Real:
Expansión de mcp_tools.py: 149 → 493 líneas en ~30
minutos. Sin IDE agéntico hubiera tomado ~4 horas.
04
AUTOMATIZAR
De SKILL a MCP - El Gran Pivote
🔌 MCP = "USB-C para la IA":
Un estándar abierto que conecta cualquier LLM con
cualquier herramienta. Un solo protocolo
universal.
🎯 Objetivo
- Pivotar de Claude SKILL a MCP abierto
- Implementar con FastMCP (decoradores)
- Soportar STDIO + HTTP transporte
- Compatibilidad con 9 clientes
🔄 Por qué Pivotamos
- SKILL: Propietario Anthropic, beta cerrada
- MCP: Estándar abierto, múltiples clientes
- ChatGPT anunció soporte MCP (Sept 2025)
- Control total de infraestructura
🔌 Componentes MCP
- Tools: Funciones ejecutables ✓
- Resources: Datos estáticos (no usado)
- Prompts: Plantillas (no usado)
FastMCP - Decoradores Pythonicos
mcp-server/src/ai_odoofinder_mcp/server.py
from fastmcp import FastMCP
from typing import Annotated
mcp = FastMCP("AI-OdooFinder")
@mcp.tool()
async def search_odoo_modules(
query: Annotated[str, QUERY_DESCRIPTION], # 100+ líneas de instrucciones
version: Annotated[str, "Odoo version (16.0, 17.0, 18.0)"],
dependencies: Annotated[Optional[list[str]], "Required dependencies"] = None,
limit: Annotated[int, "Max results (default: 5)"] = 5,
) -> str:
"""Search OCA modules with hybrid search."""
async with httpx.AsyncClient() as client:
response = await client.get(f"{API_URL}/search", params={...})
return _format_results_intelligent(response.json())Clientes Soportados
| Cliente | Local (STDIO) | Remoto (HTTP) | Estado |
|---|---|---|---|
| Claude Desktop | ✅ | ❌ | Estable |
| Claude.ai Web | ❌ | ✅ | Estable |
| Claude Code CLI | ✅ | ✅ | Estable |
| ChatGPT Dev Mode | ✅ | ✅ | Beta |
| VSCode Copilot | ✅ | ⚠️ | GA |
| Cursor | ✅ | ❌ | Estable |
| Zed | ✅ | ❌ | Estable |
05
INTEGRAR
APIs de IA y Búsqueda Híbrida
🎯 Objetivo
- Usar OpenRouter como gateway unificado
- Implementar búsqueda híbrida RRF
- Enriquecer módulos con IA
- Mantener costes bajo control (<$2)
🤖 Modelos
- Embeddings: Qwen3-Embedding-4B
- Enrichment: Grok-4-fast
- Dimensiones: 2560 (máxima precisión)
- Matryoshka: soporte 512/1024/2560
💰 Costes
- Embeddings (16,494 módulos): ~$0.10
- Enrichment (16,494 módulos): ~$1.50
- Queries producción: ~$0.01
- TOTAL: $1.76 (88% bajo presupuesto)
Reciprocal Rank Fusion (RRF)
QUERY: "facturación electrónica españa"
│
┌───────────────────┴───────────────────┐
│ │
▼ ▼
┌─────────────────┐ ┌─────────────────┐
│ VECTOR SEARCH │ │ BM25 SEARCH │
│ (pgvector) │ │ (tsvector) │
│ │ │ │
│ Embeddings │ │ Full-text │
│ Qwen3 2560d │ │ Español/Inglés │
└────────┬────────┘ └────────┬────────┘
│ Top 50 │ Top 50
│ │
└──────────────┬──────────────────────┘
│
▼
┌─────────────────────────────────────────────────────┐
│ RECIPROCAL RANK FUSION │
│ │
│ RRF_score(d) = 1/(k + rank_v) + 1/(k + rank_b) │
│ │
│ k = 60 (constante de suavizado) │
└──────────────────────┬──────────────────────────────┘
│
▼
┌─────────────────────────┐
│ RESULTADOS FINALES │
│ │
│ 1. l10n_es_facturae │
│ 2. l10n_es_facturae_face│
│ 3. account_invoice_facturx│
└─────────────────────────┘
🔐 Best Practice:
Nunca hardcodear API keys. Usar variables de entorno
(.env) excluidas de git. OpenRouter unifica billing y
permite fallback automático.
06
SINTETIZAR
Arquitectura Tool-First y Resultados Finales
🏗️ Arquitectura Tool-First
- Sin UI web propia que mantener
- Los clientes MCP SON la UI
- Solo desarrollamos Backend + MCP
- El LLM maneja la experiencia de usuario
🖥️ Infraestructura Final
- Hetzner VPS (ARM64, ~4€/mes)
- Docker Compose (API + DB + MCP)
- PostgreSQL 17 + pgvector
- Tailscale Funnel (HTTPS auto)
📊 Estadísticas Finales
- 16,494 módulos indexados
- 100% con AI enrichment
- Precision@5: 87%
- Recall@10: 92%
El Proyecto Como Síntesis del Curso
┌─────────────────────────────────────────────────────────────────────────┐ │ │ │ 1. INVESTIGAR ──→ Deep research con Gemini 2.5 Pro │ │ └─→ Arquitectura RAG Híbrida definida │ │ │ │ 2. DIALOGAR ────→ Prompts iterativos con Few-Shot + CoT │ │ └─→ Flujo inteligente de 4 pasos │ │ │ │ 3. EJECUTAR ────→ Cursor → Claude Code → Zed │ │ └─→ 89 commits en 30 días (speedup 4-8x) │ │ │ │ 4. AUTOMATIZAR ─→ SKILL → MCP (pivote estratégico) │ │ └─→ 9 clientes soportados │ │ │ │ 5. INTEGRAR ────→ OpenRouter + Qwen3 + Grok-4 │ │ └─→ $1.76 coste total (88% bajo presupuesto) │ │ │ │ 6. SINTETIZAR ──→ Tool-first architecture │ │ └─→ 16,494 módulos accesibles vía MCP │ │ │ └─────────────────────────────────────────────────────────────────────────┘
🎯
Resultado Final:
Un buscador inteligente de módulos Odoo que cualquier
empresa puede usar, que costó menos de $2 en APIs y
~5€/mes en infraestructura, y que soporta 9 clientes MCP
diferentes.