Ihre Website ist keine Liste. Sie ist ein Graph.
Die meisten SEO-Verantwortlichen behandeln interne Verlinkung als Nebensache. Sie schreiben einen neuen Artikel, erinnern sich an zwei oder drei verwandte ältere Beiträge und setzen die Links von Hand. Dieses Vorgehen ist zufällig, verzerrt und ineffizient.
Es verlässt sich auf das Gedächtnis („Haben wir dazu nicht letztes Jahr etwas geschrieben?“) statt auf mathematische Präzision.
Für einen Suchmaschinen-Crawler (Googlebot) ist Ihre Website eine mathematische Struktur, ein sogenannter gerichteter Graph.
- Knoten = Seiten.
- Kanten = Links.
Wer die Crawl-Effizienz und den Fluss des „Link Juice“ (PageRank) maximieren will, kann sich nicht auf Bauchgefühl verlassen. Es braucht Graphentheorie.
Bei kōdōkalabs nutzen wir Python, um die Seitenarchitektur unserer Kundschaft zu visualisieren, die „Zentralität“ jeder Seite zu berechnen und programmatisch zu erkennen, wo die Struktur Brüche hat.
Dieser Leitfaden zeigt Ihnen, wie Sie Ihre Website mit der Python-Bibliothek NetworkX prüfen und Ihre interne Verlinkung von der „Kunst“ zur „Wissenschaft“ machen.
Teil 1: Die Mathematik des Link-Flusses
Bevor wir Code schreiben, müssen wir die Kennzahlen verstehen, die für einen Bot tatsächlich zählen.
1. PageRank (der Klassiker)
PageRank ist die Wahrscheinlichkeit, dass jemand, der zufällig Links anklickt, auf einer bestimmten Seite landet.
- Das Ziel: Ihre „Money Pages“ (hohe Conversion) sollen einen hohen PageRank haben.
- Das Problem: Oft sammeln wenig wertvolle Blogbeiträge unbeabsichtigt PageRank an, weil die Navigation schlecht aufgebaut ist (zum Beispiel durch „Neueste Beiträge“-Widgets).
2. Betweenness Centrality (die Brücke)
Diese Kennzahl misst, wie oft ein Knoten (eine Seite) auf dem kürzesten Pfad zwischen zwei anderen Knoten liegt.
- Seiten mit hoher Zentralität: Das sind Ihre „Brücken“. Entfernen Sie eine Seite mit hoher Zentralität, kann Ihre Website in isolierte Inseln zerfallen.
- Das Ziel: Diese Brücken identifizieren und stärken.
3. Modularität (die Cluster)
Sie misst, wie gut Ihre Website in „thematische Cluster“ gegliedert ist.
- Gute Modularität: Klar abgegrenzte Cluster (z. B. verlinken Seiten unter /blog/seo/ stark auf andere Seiten unter /blog/seo/).
- Schlechte Modularität: Spaghetti-Verlinkung (alles verlinkt auf alles). LLMs tun sich bei Websites mit niedriger Modularität schwer, die „Entity Salience“ zu erfassen.
Teil 2: Der Stack
Wir nutzen Python, um die Website zu crawlen, den Graphen aufzubauen und diese Kennzahlen zu berechnen.
- Python 3.10+ (öffnet in einem neuen Tab)
- Advertools: (öffnet in einem neuen Tab) zum Crawlen der Website und für die Link-Daten.
- NetworkX (öffnet in einem neuen Tab): die Standardbibliothek der Branche für Graphen und Netzwerke.
- Pandas: (öffnet in einem neuen Tab) für die Datenaufbereitung.
- Matplotlib (öffnet in einem neuen Tab)/Gephi (öffnet in einem neuen Tab): für die Visualisierung.
KI-generiert Bild
Teil 3: Den Graph-Analyzer bauen
Schritt 1: Der Crawl
Zuerst brauchen wir eine Karte jedes Links Ihrer Website. Dafür lassen wir mit advertools einen schnellen Crawl laufen.
import advertools as adv
import pandas as pd
import networkx as nx
# 1. Website crawlen (für diese Demo mit Limit, um riesige Crawls zu vermeiden)
# Nutzen Sie im Produktivbetrieb Ihre Sitemap oder einen vollständigen Crawl.
adv.crawl('https://www.yourdomain.com', 'output_file.jl', follow_links=True)
# 2. Crawl-Daten laden
crawl_df = pd.read_json('output_file.jl', lines=True)
# 3. "Edge List" erstellen (Quelle -> Ziel)
# Das extrahiert jeden internen Link der Website
links_df = crawl_df[['url', 'links_url']].explode('links_url')
# Externe Links und Selbstverlinkungen herausfiltern
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"Graph-Knoten (Seiten): {len(internal_links['url'].unique())}")
print(f"Graph-Kanten (Links): {len(internal_links)}")Schritt 2: Den Graphen aufbauen
Jetzt übergeben wir diese Daten an NetworkX.
# Gerichteten Graphen initialisieren
G = nx.from_pandas_edgelist(
internal_links,
source='url',
target='links_url',
create_using=nx.DiGraph()
)
print("Graph erfolgreich aufgebaut.")Schritt 3: Das „Link-Juice“-Audit (PageRank)
Sehen wir, wo die Autorität tatsächlich sitzt.
# PageRank berechnen
pagerank = nx.pagerank(G, alpha=0.85) # alpha 0.85 ist der übliche Dämpfungsfaktor von Google
# Zur einfachen Ansicht in ein DataFrame umwandeln
pr_df = pd.DataFrame.from_dict(pagerank, orient='index', columns=['PageRank'])
pr_df = pr_df.sort_values(by='PageRank', ascending=False)
print("--- Top 10 Autoritätsseiten ---")
print(pr_df.head(10))Strategischer Check: Sehen Sie sich die Top 10 an. Sind es Ihre „Money Pages“ (Produkt- und Preisseiten)?
- Wenn ja: gute Architektur.
- Wenn nein: Steht auf Platz 1 Ihre „Nutzungsbedingungen“-Seite oder ein zufälliger Blogbeitrag von 2018, verliert Ihre Architektur Umsatz. Passen Sie dann Ihre Navigation an oder setzen Sie Links von diesen autoritätsstarken Seiten auf Ihre Produktseiten.
Teil 4: „Orphan Pages“ automatisch erkennen
Tools (auf Englisch) wie Ahrefs melden verwaiste Seiten, übersehen aber „funktional verwaiste“ Seiten: Seiten, die technisch einen Link haben, aber so tief vergraben sind (Klicktiefe > 5), dass Google sie kaum crawlt.
# Kürzesten Pfad von der Startseite berechnen
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'])
# Tief liegende Seiten identifizieren
deep_pages = depth_df[depth_df['Click_Depth'] > 3]
print(f"Seiten, die tiefer als 3 Klicks liegen: {len(deep_pages)}")
# Echte Orphans identifizieren (Knoten im Graphen, aber von der Startseite aus nicht erreichbar)
all_nodes = set(G.nodes())
reachable_nodes = set(shortest_paths.keys())
orphans = all_nodes - reachable_nodes
print(f"Echte Orphan Pages: {len(orphans)}")
except Exception as e:
print(f"Fehler bei der Pfadberechnung: {e}")Die Lösung: Übergeben Sie die Listen deep_pages und orphans an Ihren „Interlinking Agent“ (aus unserem früheren Tutorial zum Agentic Workflow). Lassen Sie den Agenten für jede verwaiste Seite drei passende übergeordnete Seiten finden und einen Link einfügen.
Teil 5: Fortgeschritten: Logik für „Semantic Clustering“
Die Graphentheorie zeigt, wo Links sind. Embeddings zeigen, wo Links sein sollten.
Um Vorschläge zu automatisieren, kombinieren wir Graphentheorie mit Vektor-Embeddings.
Die Logik:
- Embeddings berechnen: Wandeln Sie den Inhalt jeder Seite in einen Vektor um (mit OpenAI text-embedding-3-small).
- Abweichungen finden: Suchen Sie Seitenpaare mit hoher semantischer Ähnlichkeit (die Vektoren liegen nah beieinander), aber ohne Graphverbindung (es gibt keinen Link).
- Die Chance: Das sind Ihre „fehlenden Links“.
(Konzeptioneller Ausschnitt)
# Pseudocode für die semantische Brücke
from sklearn.metrics.pairwise import cosine_similarity
# 'vectors' sei eine Matrix der Seiten-Embeddings
similarity_matrix = cosine_similarity(vectors)
# Wenn Similarity > 0.85 UND Link_Exists False ist:
# an "suggested_links.csv" anhängenGenau diese Logik nutzt kōdōkalabs für den Bericht „Internal Link Opportunities“. Sie beseitigt menschliche Verzerrung. Es spielt keine Rolle, ob Sie den Artikel vor drei Jahren geschrieben haben: Ist er semantisch relevant für Ihren neuen Beitrag, findet ihn die Mathematik.
Teil 6: Das Chaos sichtbar machen
Manchmal müssen Sie Ihrer Kundschaft zeigen, warum die SEO nicht funktioniert. Ein visueller Graph ist unwiderlegbar. Exportieren Sie Ihren Graphen im Gephi-Format.
nx.write_gexf(G, "site_structure.gexf")
Laden Sie Gephi herunter (kostenlose Open-Source-Software). Öffnen Sie diese .gexf-Datei.
- Starten Sie das Layout „Force Atlas 2“.
- Färben Sie die Knoten nach „Modularity Class“ (Thema).
- Skalieren Sie die Knoten nach „PageRank“.
Was Sie sehen werden:
- Gute SEO: Klar abgegrenzte, farbige Cluster (die „Silo“-Struktur) mit dicken Brücken dazwischen.
- Schlechte SEO: Ein riesiger Haarknäuel, in dem alles auf alles verlinkt, oder eine „Galaxie“ mit dichtem Zentrum und Hunderten frei schwebender, unverbundener Sterne (Orphans).
Fazit: Lassen Sie die Mathematik entscheiden
Interne Verlinkung ist der am meisten unterschätzte Hebel der SEO. Sie kostet nichts (anders als Backlinks), und Sie haben sie zu 100 % selbst in der Hand. Wer von manueller Platzierung zur Automatisierung per Graphentheorie wechselt, stellt sicher, dass jedes Stück Autorität, das die Website sich erarbeitet, effizient auf die umsatzstarken Seiten verteilt wird.