# Serena: El MCP que Hace que tu Agente Entienda Realmente tu Codebase

**URL:** <https://www.yodev.dev/t/serena-el-mcp-que-hace-que-tu-agente-entienda-realmente-tu-codebase/3458>\
**Category:** AI Dev Tools — General\
**Tags:** productividad, mcp, coding-agents, dev-tools, open-source, claude-code\
**Created:** [26 Junio, 2026 14:42 UTC](https://www.yodev.dev/t/serena-el-mcp-que-hace-que-tu-agente-entienda-realmente-tu-codebase/3458 "2026-06-26T14:42:00Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![Grego](https://yyz1.discourse-cdn.com/flex009/user_avatar/www.yodev.dev/grego/32/649_2.png) [@Grego](https://www.yodev.dev/u/Grego)\
**Post date:** [26 Junio, 2026 14:42 UTC](https://www.yodev.dev/t/serena-el-mcp-que-hace-que-tu-agente-entienda-realmente-tu-codebase/3458/1 "2026-06-26T14:42:00Z")

</div>

![Screenshot 2026-06-26 at 10.41.23 AM](https://canada1.discourse-cdn.com/flex009/uploads/inovacon/original/2X/3/3c615fa2d16949aefe234b5943d9eda85cd346f6.png)

Todos tuvimos esta experiencia con un coding agent.

Le pedís que haga un cambio relativamente simple en una codebase grande y el agente empieza a recorrer archivos como si estuviera perdido en un shopping.

Abre decenas de archivos irrelevantes.

Lee miles de líneas que no necesita.

Pierde contexto.

Consume tokens innecesariamente.

Y después de unos minutos finalmente encuentra lo que estaba buscando.

El problema no suele ser el modelo.

El problema es que el agente no entiende la estructura semántica de la codebase.

**Serena** intenta resolver exactamente eso.

Es un servidor MCP open source diseñado para darle a los agentes comprensión semántica del código a nivel de símbolos, relaciones y arquitectura. En lugar de navegar archivos línea por línea, el agente puede razonar sobre clases, funciones, referencias y dependencias directamente.

La mejor forma de describirlo es:

> ¿Qué pasaría si tu coding agent realmente entendiera cómo está construida tu aplicación?

* * *

## ¿Qué hace Serena?

Serena agrega una capa de análisis semántico sobre tu repositorio y expone esa información a través de MCP.

En la práctica, permite que un agente pueda responder preguntas como:

- ¿Dónde se utiliza esta función?
- ¿Qué clases implementan esta interfaz?
- ¿Qué módulos dependen de este componente?
- ¿Cuál es el flujo completo desde este endpoint hasta la base de datos?
- ¿Qué símbolos serían afectados por este cambio?

Todo esto sin tener que leer grandes cantidades de código innecesariamente.

* * *

## Navegación a nivel de símbolos

La mayoría de los agentes actuales trabajan principalmente a nivel de archivos.

Serena trabaja a nivel de:

- clases,
- métodos,
- funciones,
- interfaces,
- referencias,
- símbolos exportados.

Por ejemplo, en lugar de pedir:

> “Abrí todos los archivos relacionados con autenticación”

el agente puede preguntar:

> “Mostrame todas las referencias a `AuthService`.”

La diferencia parece pequeña.

En repositorios grandes, es enorme.

* * *

## Casos de uso reales

### 1. Codebases enormes

En repositorios con:

- cientos de directorios,
- miles de archivos,
- arquitecturas monolíticas,

los agentes suelen desperdiciar gran parte de sus tokens simplemente explorando.

Serena reduce drásticamente esa exploración.

* * *

### 2. Refactors complejos

Supongamos que querés renombrar o modificar:

```typescript
PaymentService

```

Sin análisis semántico, el agente debe buscar referencias textuales.

Con Serena puede identificar:

- llamadas directas,
- implementaciones,
- dependencias,
- símbolos relacionados.

Esto hace que los refactors sean considerablemente más seguros.

* * *

### 3. Onboarding en proyectos nuevos

Uno de los usos más interesantes.

Podés preguntarle al agente:

> “Explicame cómo funciona el sistema de autenticación.”

o:

> “Mostrame el flujo completo desde la API hasta la persistencia.”

El agente puede responder utilizando relaciones reales de la arquitectura.

* * *

### 4. Comprensión arquitectónica

Serena permite navegar una aplicación como si fuera un grafo semántico.

Por ejemplo:

- dependencias entre módulos,
- relaciones entre componentes,
- jerarquías de clases,
- flujos de llamadas.

Esto resulta particularmente útil cuando trabajás con sistemas heredados.

* * *

## Instalación

La forma más sencilla es utilizar `uv`.

Primero instalá Serena:

```bash
uv tool install serena-agent

```

También puede ejecutarse directamente:

```bash
uvx serena-agent

```

* * *

## Integración con Claude Code

Serena puede exponerse como servidor MCP para Claude Code.

Por ejemplo:

```bash
claude mcp add serena \
  -- uvx serena-agent

```

Una vez configurado, Claude Code obtiene acceso a todas las capacidades semánticas del servidor.

* * *

## Comandos útiles

Algunas de las capacidades más interesantes incluyen:

### Encontrar referencias

```plaintext
find_referencing_symbols

```

Permite descubrir todos los lugares donde un símbolo es utilizado.

* * *

### Encontrar definiciones

```plaintext
find_symbol

```

Ideal para localizar rápidamente implementaciones.

* * *

### Vista general del archivo

```plaintext
get_symbols_overview

```

Entrega una representación estructurada de los símbolos presentes.

* * *

### Navegar dependencias

```plaintext
find_referenced_symbols

```

Permite explorar relaciones semánticas entre componentes.

* * *

## Lenguajes soportados

Actualmente Serena soporta múltiples lenguajes populares, incluyendo:

- Python
- TypeScript
- JavaScript
- Go
- Java
- Rust
- C#
- PHP

La cobertura continúa creciendo activamente.

* * *

## ¿Por qué esto importa?

Durante años intentamos resolver el problema del contexto simplemente agregando más tokens.

Ventanas de 200K.

1 millón.

2 millones.

Pero más contexto no necesariamente significa mejor comprensión.

Serena representa un enfoque distinto.

En lugar de hacer que el agente lea más código, hace que entienda mejor el código que ya tiene delante.

Y eso podría ser mucho más importante.

Porque a medida que las codebases continúan creciendo, la ventaja no va a pertenecer al agente que puede leer más archivos.

Va a pertenecer al agente que puede navegar la arquitectura como lo haría un desarrollador experimentado.

**Repositorio:** [GitHub - oraios/serena: A powerful MCP toolkit for coding, providing semantic retrieval and editing capabilities - the IDE for your agent · GitHub](https://github.com/oraios/serena)
