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+ (se abre en una pestaña nueva)
• Advertools: (se abre en una pestaña nueva) para rastrear el sitio y obtener los datos de enlaces.
• NetworkX (se abre en una pestaña nueva): la biblioteca de referencia para estudiar grafos y redes.
• Pandas: (se abre en una pestaña nueva) para el tratamiento de datos.
• Matplotlib (se abre en una pestaña nueva)/Gephi (se abre en una pestaña nueva): para la visualización.

Generada con IA imagen

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.

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.

# 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.

# 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⁠EN (en inglés) 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.

# 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)

# 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