Publicado: 2026-03-25 | Categoría: Pi | Lectura: 10 min

Dos de las herramientas más poderosas en mi stack. Pero usar ambas al mismo tiempo es como llevar un cuchillo de chef y un martillo a la misma cocina. Aquí cuándo usar cada una.

🎯 Lo que aprenderás

• Cuándo usar Serena para análisis profundo de código
• Cuándo usar OneTool para workflows integrados
• La matriz de decisión que me ahorra tiempo todos los días

El problema: dos herramientas, ¿cuál usar?

Durante un tiempo tenía este flujo:

Necesito buscar una función en mi código
↓
"¿Uso Serena o OneTool?"
↓
Pruebo con Serena → funciona pero es lento
↓
Pruebo con OneTool → es más rápido pero no encuentra símbolos
↓
Termino usando grep en bash

El problema: no sabía cuál era la herramienta correcta para cada tarea.

¿Te suena conocido?

Serena: el arquitecto de código

Serena está basada en LSP (Language Server Protocol). Es como tener VS Code pero en tu terminal.

Lo que hace mejor que nadie

Ejemplos reales de uso

# Ver estructura de un archivo
get_symbols_overview(relative_path="src/auth/service.js")
# → Ve: 8 funciones, 3 clases, 12 imports

# Encontrar dónde se usa una función
find_referencing_symbols(
  name_path="AuthService.login",
  relative_path="src/auth/service.js"
)
# → Encontrado en 4 archivos:
#    - src/api/login.js
#    - src/tests/auth.test.js
#    - src/middleware/auth.js
#    - src/controllers/login.js

# Renombrar una función
rename_symbol(
  name_path="AuthService.login",
  relative_path="src/auth/service.js",
  new_name="authenticate"
)
# → Renombra en 5 archivos automáticamente

💡 Tip: Usa Serena cuando necesitas entender tu código, no cuando necesitas modificarlo rápido.

OneTool: el orquestador de workflows

OneTool es un MCP server unificado con 100+ herramientas. Es una navaja suiza.

Lo que hace mejor que nadie

Ejemplos reales de uso

# Búsqueda web + guardar en memoria
>>> br q="python async patterns"
>>> mem_w "async_patterns" results
# → Guardado en memoria persistente

# Recuperar de memoria y usar
>>> mem_r "async_patterns"
# → Obtiene: resultados de búsqueda anteriores

# Workflow completo: buscar → leer → procesar → guardar
>>> br q="typescript error handling best practices"
>>> re path="src/errors/"
>>> ot skill:typescript-analyzer
>>> mem_w "error_handling" last_result

💡 Tip: Usa OneTool cuando necesitas integrar múltiples herramientas, no cuando necesitas analizar código profundamente.

Mi matriz de decisión (la que uso hoy)

Después de meses de prueba y error, creé esta matriz:

💡 Regla de oro: ¿Necesitas entender el código? Serena. ¿Necesitas orquestar acciones? OneTool.

Casos de uso reales

Caso 1: Bug en función que se usa en 10 archivos

Usar Serena:

# Encuentra dónde se usa
find_referencing_symbols(
  name_path="UserService.validate",
  relative_path="src/users/service.js"
)

# Ve los 10 archivos

# Renombra la función en todos
rename_symbol(
  name_path="UserService.validate",
  relative_path="src/users/service.js",
  new_name="validateUser"
)

Resultado: Renombrado en 10 archivos, referencias actualizadas, 30 segundos.

Caso 2: Investigar + recordar + implementar

Usar OneTool:

# Investigar error
>>> br q="typescript 'this is possibly undefined' fix"
>>> mem_w "undefined_fix" results

# Más tarde, recuperar solución
>>> mem_r "undefined_fix"

# Implementar
>>> re path="src/errors/"
>>> ed path="src/errors/handler.js" search="undefined" replace="fix"

Resultado: Investigación guardada, solución recordada, implementada, 2 minutos.

Caso 3: Refactor de arquitectura

Usar AMBOS:

# 1. Analizar con Serena
get_symbols_overview(relative_path="src/api/")
find_referencing_symbols(name_path="BaseAPI", relative_path="src/api/")

# 2. Usar OneTool para el refactor masivo
>>> ot skill:typescript-analyzer
>>> mem_w "api_structure" last_result
>>> re path="src/api/" pattern="class.*API"

Resultado: Análisis LSP + workflow integrado, 5 minutos.

Comparación de costo

💡 Tip: El costo es menor que el tiempo ahorrado. $0.05 en tools vs 15 minutos de búsqueda manual = ROI 10x.

¿Puedo usar ambos en el mismo proyecto?

Sí, y así lo hago.

Mi setup actual:

{
  "mcpServers": {
    "chrome-devtools": { ... },
    "serena": { ... },
    "google-jules": { ... }
  }
}

Y tengo OneTool configurado como MCP proxy:

# OneTool puede routear otros MCPs
ot.server(enable='chrome-devtools')  # OneTool → Chrome DevTools
ot.server(proxy='serena')          # OneTool → Serena

¿Cuándo uno, cuándo el otro?

• Necesito análisis LSP → Serena directo
• Necesito workflow con memoria → OneTool + Serena vía proxy
• Necesito búsqueda web rápida → OneTool (brave pack)
• Necesito snippet preconfigurado → OneTool (skill:typescript-analyzer)

Mis comandos más usados

Serena

OneTool

En resumen

1. Serena = Arquitecto de código (LSP, análisis profundo, refactor)
2. OneTool = Orquestador de workflows (100+ tools, memoria, integración)
3. Matriz de decisión:
   • ¿Entender código? → Serena
   • ¿Orquestar acciones? → OneTool
4. Úsalos juntos → OneTool como proxy para Serena = lo mejor de ambos
5. El costo es bajo → $0.02 - $0.08 vs 15 minutos manuales

🔗 Recursos

• Cómo configurar Pi para proyectos TypeScript - Ejemplos de Serena en TypeScript
• Debugging con Pi: del stack trace al fix - Flujo de depuración con Serena
• Prompt engineering para agentes de código - Cómo combinar tools y prompts

💭 ¿Tú qué herramienta usas más?

¿Serena o OneTool? ¿O ambos? ¿Qué casos de uso tienes que no cubrí? Déjamelo en los comentarios.

Tags: serena, onetool, mcp, pi, herramientas

Este artículo forma parte de la categoría Pi