---
title: "Automatización del enlazado interno: teoría de grafos aplicada al SEO"
description: "Deje de adivinar dónde poner enlaces internos. Con Python, NetworkX y teoría de grafos calcule el PageRank, detecte clústeres y automatice el enlazado."
url: "https://kodokalabs.com/es/intelligence-hub/search-intelligence/enlazado-interno-teoria-de-grafos/"
language: es
published: 2025-12-18
updated: 2026-11-07
---

# Automatización del enlazado interno: teoría de grafos aplicada al SEO

## Su sitio web no es una lista. Es un grafo.

La mayoría de los profesionales del SEO tratan el enlazado interno como un añadido de última hora. Escriben un artículo nuevo, se acuerdan de 2 o 3 entradas antiguas relacionadas y añaden los enlaces a mano. Este método es **aleatorio, sesgado e ineficiente.**

Depende de la memoria humana («¿no escribimos algo sobre esto el año pasado?») y no de la precisión matemática.

Para el rastreador de un buscador (Googlebot), su sitio web es una estructura matemática conocida como **grafo dirigido.**

- **Nodos** = páginas.
- **Aristas** = enlaces.

Si quiere maximizar la eficiencia del rastreo y el flujo de «Link Juice» (PageRank), no puede fiarse de la intuición humana. Tiene que aplicar la **teoría de grafos.**

En kōdōkalabs usamos Python para visualizar la arquitectura del sitio de nuestros clientes, calcular la «centralidad» de cada página e identificar mediante programación dónde está rota la estructura.

Esta guía le enseñará a auditar su sitio con la biblioteca **NetworkX** de Python, para llevar su estrategia de enlazado interno del «arte» a la «ciencia».

## Parte 1: las matemáticas del flujo de enlaces

Antes de escribir código, debemos entender las métricas que de verdad importan a un robot.

### 1. PageRank (el clásico)

El PageRank es la probabilidad de que un usuario que navega al azar, haciendo clic en enlaces, llegue a una página concreta.

- **El objetivo:** asegurarse de que sus «Money Pages» (las de mayor conversión) tengan un PageRank alto.
- **El fallo:** a menudo, entradas de blog de poco valor acaparan PageRank sin querer por una mala estructura de navegación (por ejemplo, los widgets de «Entradas recientes»).

### 2. Centralidad de intermediación (el puente)

Mide con qué frecuencia un nodo (página) aparece en el camino más corto entre otros dos nodos.

- **Páginas de alta centralidad:** son sus «puentes». Si elimina una página de alta centralidad, su sitio puede partirse en islas aisladas.
- **El objetivo:** identificar esos puentes y reforzarlos.

### 3. Modularidad (los clústeres)

Mide hasta qué punto su sitio está dividido en «clústeres temáticos».

- **Buena modularidad:** clústeres bien diferenciados (por ejemplo, las páginas de /blog/seo/ se enlazan sobre todo entre sí).
- **Mala modularidad:** enlaces en espagueti (todo enlaza con todo). A los LLM les cuesta entender la «saliencia de entidades» en sitios con poca modularidad.

## Parte 2: el stack

Usaremos Python para rastrear el sitio, construir el grafo y calcular estas métricas.

- [**Python 3.10+**](https://www.python.org/)
- [**Advertools:**](https://adver.tools/) para rastrear el sitio y obtener los datos de enlaces.
- **[NetworkX](https://networkx.org/en/):** la biblioteca de referencia para estudiar grafos y redes.
- [**Pandas:**](https://pandas.pydata.org/) para el tratamiento de datos.
- **[Matplotlib](https://matplotlib.org/)/[Gephi](https://gephi.org/):** para la visualización.

![Ilustración oscura y abstracta de una red de líneas y nodos rojos que convergen en un punto luminoso, sobre la automatización del enlazado interno y la auditoría del flujo de enlaces con teoría de grafos](https://kodokalabs.com/assets/media/2025/12/kodokalabs-02-005-the-modern-seo-stack-the-internal-linking-automation-graph-theory-for-seo-link-juice-audit-1024x439.webp)

## Parte 3: construir el analizador de grafos

### Paso 1: el rastreo

Primero necesitamos un mapa de todos los enlaces de su sitio. Usamos advertools para lanzar un rastreo rápido.

```python
import advertools as adv
import pandas as pd
import networkx as nx

# 1. Rastrear el sitio web (se fija un límite para evitar rastreos enormes en esta demo)
# En producción, use su sitemap o un rastreo completo.
adv.crawl('https://www.yourdomain.com', 'output_file.jl', follow_links=True)

# 2. Cargar los datos del rastreo
crawl_df = pd.read_json('output_file.jl', lines=True)

# 3. Crear una "lista de aristas" (origen -> destino)
# Esto extrae todos los enlaces internos que se encuentran en el sitio
links_df = crawl_df[['url', 'links_url']].explode('links_url')

# Filtrar los enlaces externos y los autoenlaces
domain = "yourdomain.com"
internal_links = links_df[
 (links_df['links_url'].str.contains(domain, na=False)) &
 (links_df['url'] != links_df['links_url'])
].dropna()

print(f"Nodos del grafo (páginas): {len(internal_links['url'].unique())}")
print(f"Aristas del grafo (enlaces): {len(internal_links)}")
```

### Paso 2: construir el grafo

Ahora pasamos estos datos a NetworkX.

```python
# Inicializar un grafo dirigido
G = nx.from_pandas_edgelist(
internal_links,
source='url',
target='links_url',
create_using=nx.DiGraph()
)

print("Grafo construido correctamente.")
```

### Paso 3: la auditoría del «Link Juice» (PageRank)

Veamos dónde reside realmente la autoridad.

```python
# Calcular el PageRank
pagerank = nx.pagerank(G, alpha=0.85) # alpha 0.85 es el factor de amortiguación estándar de Google

# Convertir a DataFrame para verlo con comodidad
pr_df = pd.DataFrame.from_dict(pagerank, orient='index', columns=['PageRank'])
pr_df = pr_df.sort_values(by='PageRank', ascending=False)

print("--- Las 10 páginas con más autoridad ---")

print(pr_df.head(10))
```

**Comprobación estratégica:** mire el top 10. ¿Son sus «Money Pages» (producto y precios)?

- **Si lo son:** buena arquitectura.
- **Si no lo son:** si su página número 1 son las condiciones de servicio o una entrada de blog cualquiera de 2018, su arquitectura está perdiendo ingresos. Debe ajustar la navegación o inyectar enlaces desde esas páginas de alta autoridad hacia sus páginas de producto.

## Parte 4: automatizar la detección de «páginas huérfanas»

Las [herramientas](../../pages/en/tools.md) como Ahrefs informan de las páginas huérfanas, pero se les escapan las «huérfanas funcionales»: páginas que técnicamente tienen un enlace, pero están enterradas tan hondo (profundidad de clics > 5) que Google casi nunca las rastrea.

```python
# Calcular el camino más corto desde la página de inicio
homepage = "https://www.yourdomain.com/"

try:
    shortest_paths = nx.shortest_path_length(G, source=homepage)
    depth_df = pd.DataFrame.from_dict(shortest_paths, orient='index', columns=['Click_Depth'])

    # Identificar las páginas profundas
    deep_pages = depth_df[depth_df['Click_Depth'] > 3]
    print(f"Páginas enterradas a más de 3 clics: {len(deep_pages)}")

    # Identificar las huérfanas reales (nodos del grafo a los que no se llega desde la página de inicio)
    all_nodes = set(G.nodes())
    reachable_nodes = set(shortest_paths.keys())
    orphans = all_nodes - reachable_nodes
    print(f"Páginas huérfanas reales: {len(orphans)}")

except Exception as e:
    print(f"Error al calcular los caminos: {e}")
```

**La solución:**
Pase la lista de deep\_pages y orphans a su «Interlinking Agent» (el de nuestro tutorial anterior sobre flujos de trabajo agénticos). Pida al agente que encuentre 3 páginas padre relevantes para cada huérfana e inserte un enlace.

## Parte 5: lógica avanzada de «clustering semántico»

La teoría de grafos le dice dónde hay enlaces. Los embeddings le dicen dónde debería haberlos.

Para automatizar las sugerencias, combinamos la teoría de grafos con los embeddings vectoriales.

### La lógica:

1. **Calcular los embeddings:** convertir el contenido de cada página en un vector (con OpenAI text-embedding-3-small).
2. **Buscar desajustes:** localizar pares de páginas con alta similitud semántica (vectores cercanos) pero ninguna conexión en el grafo (no existe ningún enlace).
3. **La oportunidad:** son sus «enlaces que faltan».

(Fragmento conceptual)

```python
# Pseudocódigo del puente semántico
from sklearn.metrics.pairwise import cosine_similarity

# Suponga que 'vectors' es una matriz con los embeddings de las páginas
similarity_matrix = cosine_similarity(vectors)

# Si Similitud > 0.85 Y Link_Exists es False:
# Añadir a "suggested_links.csv"
```

Esta es exactamente la lógica que usa kōdōkalabs para generar su informe de «Internal Link Opportunities». Elimina el sesgo humano. No le importa si escribió el artículo hace 3 años: si es relevante desde el punto de vista semántico para su nueva entrada, las matemáticas lo encuentran.

## Parte 6: visualizar el desorden

A veces hay que mostrarle al cliente *por qué* su SEO está fallando. Un grafo visual es innegable. Exporte su grafo al formato de Gephi.

`nx.write_gexf(G, "site_structure.gexf")`

Descargue **Gephi** (software libre y de código abierto). Abra este archivo .gexf.

- Ejecute el diseño «Force Atlas 2».
- Coloree los nodos por «clase de modularidad» (tema).
- Dimensione los nodos por «PageRank».

### Lo que verá:

- **SEO bien hecho:** clústeres diferenciados y de colores (la estructura en «silos»), con puentes gruesos entre ellos.
- **SEO mal hecho:** una gigantesca bola de pelo en la que todo enlaza con todo, o una «galaxia» con un centro denso y cientos de estrellas sueltas y desconectadas (las huérfanas).

## Conclusión: que decidan las matemáticas

El enlazado interno es la palanca más infravalorada del SEO. Cuesta 0 € (a diferencia de los backlinks) y usted tiene el 100 % del control sobre él.
Al pasar de la colocación manual a la automatización con teoría de grafos, se asegura de que cada gota de autoridad que gana su sitio se distribuya de forma eficiente hacia las páginas que generan ingresos.

## Deje de adivinar. Empiece a calcular.

[Solicitar la auditoría del grafo de arquitectura de su sitio](#contact)