WordPress to Supabase Vector Database: How Semantic Content Scoring Powers Hub-and-Spoke Architecture for SEO, GEO, AEO & AIO

A technical guide to ingesting WordPress content into a Supabase pgvector database, computing semantic similarity scores, and using those scores to build, update, and interlink hub-and-spoke page architectures that rank across traditional search, AI platforms, and answer engines.

🔑 Key Takeaways

• A WordPress-to-Supabase vector pipeline converts static page content into searchable embeddings, enabling semantic analysis of your entire content library in a single PostgreSQL database.
• Supabase’s pgvector extension supports hybrid search—combining vector similarity with traditional SQL filters—which Supabase documentation describes as enabling semantic, full-text, and metadata queries in unified operations (Supabase AI & Vectors Docs, 2025).
• Semantic content scoring uses cosine similarity between page embeddings and topic-cluster vectors to identify coverage gaps, cannibalization, and linking opportunities across hub-and-spoke architectures.
• Research published in the Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD ’24) found that content optimized with citation-rich, authoritative formatting received up to 40% higher visibility in generative engine responses (Aggarwal et al., 2024; DOI: 10.1145/3637528.3671900).
• This approach simultaneously serves SEO (topical authority), GEO (AI citability), AEO (structured answers), and AIO (AI Overview eligibility) by ensuring every page is semantically positioned within a coherent content graph.

Most law firm websites accumulate content organically—a blog post here, a practice area page there—without a systematic way to measure how well those pages relate to each other or cover their intended topics. Traditional content audits rely on manual review or keyword-density tools that miss the deeper semantic relationships between pages.

A vector database approach fundamentally changes this. By extracting WordPress content through the REST API, generating vector embeddings for each page, and storing those embeddings in Supabase alongside the original metadata, development teams gain the ability to compute exact similarity scores between any two pieces of content. This transforms hub-and-spoke content architecture from a planning concept into a measurable, continuously optimized system.

This guide walks through the complete technical pipeline: from WordPress content extraction to Supabase ingestion, from embedding generation to semantic content scoring, and from score interpretation to actionable decisions about which pages to create, update, merge, or interlink. The approach is designed for developers working within legal marketing teams who need to optimize content for multiple visibility channels simultaneously.

What Is a WordPress-to-Vector-Database Content Pipeline?

A content pipeline in this context refers to an automated system that extracts text and metadata from WordPress, transforms that text into numerical vector representations (embeddings), and stores both the vectors and their associated metadata in a database optimized for similarity search. The resulting system enables queries that traditional SQL cannot perform: “find all pages semantically similar to this topic cluster definition” or “rank my existing content by how closely it covers personal injury marketing in Los Angeles.”

The Problem with Static WordPress Content

WordPress stores content as serialized HTML in a MySQL database. While this is effective for rendering pages, it provides no native mechanism for understanding semantic relationships between posts. A law firm with 200 published pages has no built-in way to answer questions like: which practice area pages overlap in topic coverage, which hub pages lack sufficient spoke support, or which geographic service pages are semantically disconnected from their parent hubs.

Content audit tools like Screaming Frog or Semrush can surface technical SEO issues and keyword overlaps, but they operate on lexical matching—counting shared keywords rather than measuring shared meaning. Two pages about “motor vehicle accident representation” and “car crash legal services” may score as unrelated in keyword tools despite covering identical topics. This is the fundamental limitation that vector embeddings solve.

How Vector Databases Change Content Strategy

Vector databases store content as high-dimensional numerical arrays (typically 384 to 1,536 dimensions depending on the embedding model). These vectors encode semantic meaning: pages about similar topics cluster together in vector space regardless of the specific words they use. By computing the distance between vectors—most commonly using cosine similarity—you can quantify exactly how related any two pieces of content are on a scale from 0 (completely unrelated) to 1 (semantically identical).

For hub-and-spoke content architecture, this creates immediate practical value. You can define a hub topic as a reference vector, then score every existing page against it. Pages scoring above 0.85 are strong spokes. Pages between 0.6 and 0.85 may need updating or repositioning. Pages below 0.6 either belong to a different hub or represent content gaps that need new pages. This replaces subjective editorial judgment with reproducible measurements.

Why Supabase and pgvector for Legal Marketing Content

Several dedicated vector databases exist—Pinecone, Weaviate, Milvus, Chroma—but Supabase offers a specific advantage for content management workflows: it stores vector embeddings and relational metadata in the same PostgreSQL instance. For law firm content systems that need to track page URLs, publication dates, practice areas, geographic targets, and content types alongside semantic vectors, this eliminates the data synchronization overhead that dedicated vector databases require.

Unified Relational + Vector Storage

Supabase provides pgvector as a native PostgreSQL extension. According to Supabase’s documentation, developers can “store, index, and query vector embeddings at scale” using standard SQL alongside the vector similarity operators that pgvector introduces (Supabase AI & Vectors Documentation, accessed February 2026). This means a single query can filter by practice area, date range, and content type using standard SQL WHERE clauses while simultaneously ranking results by semantic similarity—something that requires multiple API calls and client-side merging with standalone vector databases.

For a law firm content system tracking hundreds of pages across multiple practice areas and geographic markets, this unified approach simplifies the architecture considerably. A single Supabase table can store the page URL, title, content type (hub, spoke, local service, FAQ), practice area, target city, publication date, word count, internal link count, and the content embedding vector—all queryable together.

Hybrid Search: Combining Semantic and Keyword Queries

Pure vector similarity search excels at finding semantically related content but can miss specific terms, case names, or statute numbers that are important in legal content. Supabase’s PostgreSQL foundation supports full-text search (tsvector) alongside pgvector, enabling hybrid queries. For example, a query can find all pages semantically similar to “personal injury marketing strategy” that also contain the exact phrase “contingency fee” or reference a specific California statute number.

This hybrid capability is particularly relevant for Retrieval-Augmented Generation (RAG) systems that law firms may build on top of their content databases. When an AI agent needs to retrieve content for generating answers, hybrid search ensures both semantic relevance and factual precision—the combination that makes retrieved content usable for AI-generated responses.

Supabase also provides SOC 2 Type 2 compliance, which matters for law firms handling sensitive operational data. While the content being vectorized is typically public marketing material, the analytics derived from the system—content performance data, strategic priorities, competitive gap analysis—may constitute confidential business information that requires appropriate security controls.

Building the WordPress Content Ingestion Pipeline

The ingestion pipeline consists of three stages: extraction from WordPress, content cleaning and chunking, and embedding generation with storage in Supabase. Each stage has specific considerations for legal marketing content that differ from general-purpose RAG implementations.

Extracting and Cleaning WordPress Content

WordPress exposes content through its REST API at /wp-json/wp/v2/posts and /wp-json/wp/v2/pages. For a comprehensive content audit, extract both post types along with custom post types if the site uses them for practice areas, attorney profiles, or case studies. Each API response includes the rendered HTML content, title, slug, excerpt, categories, tags, featured image, and publication metadata.

The critical preprocessing step is stripping HTML to extract clean text. Legal marketing pages often contain complex shortcode-rendered elements—accordion FAQs, tabbed content, schema markup, CTA blocks—that inflate raw HTML but add noise to embeddings. A reliable cleaning pipeline uses an HTML parser (such as BeautifulSoup in Python) to extract visible text content while preserving structural indicators like headings. Preserving H2 and H3 headings as text helps the embedding model understand the page’s topical structure.

Metadata extraction should capture: URL, title, content type classification (which may need to be inferred from URL patterns if not explicitly categorized), word count, publication date, last modified date, and the current internal link profile. This metadata becomes the relational columns in Supabase that enable filtered queries downstream. For law firm sites that follow a content hub strategy, capturing the URL hierarchy helps identify parent-child page relationships programmatically.

Chunking Strategies for Legal Content

Chunking—dividing pages into smaller text segments before embedding—is necessary because embedding models have token limits and because page-level embeddings can dilute topic specificity on long pages. A 3,000-word hub page about personal injury marketing covers multiple subtopics; a single embedding for the entire page will be a blurred average rather than a precise representation of any one subtopic.

For legal marketing content, a semantic chunking approach based on heading boundaries typically outperforms fixed-size chunking. Split content at H2 boundaries to create section-level chunks, then generate embeddings for both the full page and each section. This dual-level embedding strategy enables two types of analysis: page-level scoring for hub-spoke assignment, and section-level scoring for identifying specific content gaps within pages.

Production RAG pipelines typically use chunks of 300–500 tokens with 10–20% overlap between consecutive chunks to preserve context at boundaries, as described in multiple RAG architecture guides (Nimbleway, “Step-by-step Guide to Building a RAG Pipeline,” accessed February 2026). For the content scoring use case described here, heading-based chunks with full-page embeddings provide more actionable results than uniform token-based splitting.

Generating and Storing Embeddings

Embedding generation converts cleaned text into fixed-dimensional vectors. The choice of embedding model affects both quality and cost. OpenAI’s text-embedding-3-large produces 3,072-dimension vectors with strong semantic fidelity. Open-source alternatives like BAAI’s BGE-M3 or GTE-small (384 dimensions) offer viable performance for content scoring at lower cost and without external API dependencies.

In Supabase, the storage schema might look like this:

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE content_pages (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  url TEXT UNIQUE NOT NULL,
  title TEXT,
  content_type TEXT,        -- 'hub', 'spoke', 'local', 'faq', 'blog'
  practice_area TEXT,
  target_city TEXT,
  word_count INTEGER,
  internal_link_count INTEGER,
  published_at TIMESTAMPTZ,
  updated_at TIMESTAMPTZ,
  content_text TEXT,
  embedding VECTOR(1536),   -- dimension matches your model
  created_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE INDEX ON content_pages
  USING hnsw (embedding vector_cosine_ops);

The HNSW (Hierarchical Navigable Small World) index type provides fast approximate nearest-neighbor search. For content libraries under 50,000 pages—which covers the vast majority of law firm websites—HNSW offers sub-millisecond query times with high recall accuracy. The embedding dimension should match your chosen model: 1,536 for OpenAI text-embedding-3-small, 3,072 for text-embedding-3-large, or 384 for lighter models like GTE-small.

Semantic Content Scoring: How It Works

With all content embedded and stored, semantic scoring becomes a set of SQL queries that compute distances between vectors. The core operation is straightforward: compare each page’s embedding against a reference vector (a topic definition, a hub page embedding, or a target keyword phrase embedding) and sort by similarity.

Cosine Similarity and Content Relevance

Cosine similarity measures the angle between two vectors, producing a score between -1 and 1 (where 1 indicates identical direction). In practice, content embeddings from modern models almost always produce positive scores, so the effective range is 0 to 1. pgvector implements this as the <=> operator, which returns cosine distance (1 minus cosine similarity). To get similarity, subtract the distance from 1.

A practical scoring function in Supabase:

CREATE OR REPLACE FUNCTION score_content_against_topic(
  topic_embedding VECTOR(1536),
  min_similarity FLOAT DEFAULT 0.5
)
RETURNS TABLE (
  url TEXT,
  title TEXT,
  content_type TEXT,
  similarity_score FLOAT
) AS $$
BEGIN
  RETURN QUERY
  SELECT
    cp.url,
    cp.title,
    cp.content_type,
    1 - (cp.embedding <=> topic_embedding) AS similarity_score
  FROM content_pages cp
  WHERE 1 - (cp.embedding <=> topic_embedding) >= min_similarity
  ORDER BY similarity_score DESC;
END;
$$ LANGUAGE plpgsql;

This function accepts a topic embedding (generated by passing a topic description like “personal injury marketing strategies for law firms” through the same embedding model) and returns all pages ranked by how closely they match that topic. Researchers studying vector-based content analysis have noted that search engines and LLMs now rely on embeddings rather than keywords to surface content—the same principle underpinning this scoring approach.

Scoring Existing Pages Against Topic Clusters

The highest-value application of semantic scoring is mapping your existing content against predefined topic clusters. For a law firm website, you might define clusters for each practice area hub: “personal injury,” “family law,” “criminal defense,” “estate planning.” Each cluster gets a reference embedding—either from the hub page itself or from a carefully crafted topic description.

Running every page against every cluster produces a content-topic matrix: a spreadsheet-like structure where rows are pages and columns are topic clusters, with each cell containing the similarity score. This matrix immediately reveals several actionable patterns. Pages with high scores across multiple clusters indicate potential cannibalization—two pages competing for the same topical space. Pages with no score above 0.7 against any cluster are “orphaned” content that may not be contributing to any hub’s authority. Clusters where no page scores above 0.8 represent critical content gaps where new spoke pages should be created.

Identifying Content Gaps and Cannibalization

Content cannibalization occurs when multiple pages on the same site compete for semantically identical queries. In traditional SEO, this is detected through keyword overlap analysis. Vector-based detection is more precise: two pages with a cosine similarity above 0.92 are covering nearly identical ground, regardless of whether they share exact keywords.

The resolution depends on the pages involved. If a hub page and a spoke page score 0.95 against each other, the spoke is likely redundant—its content should be consolidated into the hub or differentiated with more specific subtopic focus. If two spoke pages under different hubs score 0.93, they may need clearer topical boundaries or should be merged into a single spoke page with appropriate cross-hub linking.

Gap analysis works in the opposite direction. Define a set of target topic embeddings representing the ideal spoke coverage for a hub. For a personal injury practice area hub, target topics might include “car accident claims process,” “slip and fall liability,” “wrongful death compensation,” “motorcycle accident representation,” and “pedestrian accident rights.” Score all existing pages against each target. Any target where the highest-scoring page falls below 0.75 represents a gap that should be filled with a new spoke page.

Using Semantic Scores to Build and Update Hub-and-Spoke Architecture

The practical output of semantic scoring is a data-driven content plan. Rather than guessing which pages to create or update, development teams can make decisions grounded in quantitative similarity measurements. This section covers three operational workflows: identifying which pages should serve as hubs, prioritizing new spoke page creation, and optimizing the internal link graph.

Automated Hub Page Identification

A natural hub page is one that scores moderately (0.65–0.80) against many spokes rather than very high (0.90+) against a few. This is because a hub should provide broad topical coverage that contextualizes its spokes, not duplicate any single spoke’s depth. By computing each page’s average similarity score against a candidate spoke set, you can identify which existing pages best serve as hubs—and whether they need to be expanded to cover subtopics where their score drops below threshold.

For law firm websites following the hub-and-spoke pillar page model, this analysis often reveals that existing practice area pages are too thin to function as effective hubs. A 500-word “Personal Injury” page may score 0.70 against car accident content but only 0.55 against wrongful death content, indicating the hub needs expansion to provide adequate topical breadth.

Spoke Page Generation and Prioritization

Once gaps are identified, prioritization determines which new spoke pages to create first. A useful prioritization formula combines the topic gap severity (how far below threshold the best existing page scores) with estimated search demand and competitive difficulty. Topics where your best existing page scores below 0.6 and search volume exceeds a threshold represent the highest-priority content creation opportunities.

Semantic scoring also informs what each new spoke page should contain. By analyzing which sections of high-scoring existing pages contribute most to their similarity with the target topic, you can generate content briefs that specify not just the topic but the specific subtopics, entities, and framing that the embedding model associates with high relevance. This is a more precise approach to content briefing than keyword-based outlines. The resulting spokes align with the educational content standards that both search engines and AI platforms reward.

Internal Link Graph Optimization

Internal linking is where semantic scoring delivers its most immediately actionable output. The principle is straightforward: pages that are semantically related should link to each other, and the link anchor text should reflect the topical relationship. By computing pairwise similarity scores across all pages and comparing against the existing internal link graph (extracted during the WordPress ingestion phase), you can identify missing links with high confidence.

A practical implementation generates a “recommended links” report: for each page, list the top 5–10 most semantically similar pages that are not currently linked, along with their similarity scores and suggested anchor text derived from the target page’s title or primary heading. Pages scoring above 0.80 similarity that lack any internal link between them represent high-priority linking opportunities. This approach aligns with the GEO tactics that emphasize internal authority signals as a factor in AI platform citation eligibility.

Optimizing for SEO, GEO, AEO, and AIO Simultaneously

A vector-powered content system does not optimize for a single channel. The same semantic scoring that identifies content gaps for traditional SEO also surfaces the structural and authority signals that AI platforms use when deciding which sources to cite. This section maps the pipeline’s outputs to each visibility channel.

Traditional SEO: Topical Authority Through Semantic Clusters

Google’s ranking systems have evolved from keyword matching toward topical authority assessment. Sites that demonstrate comprehensive coverage of a subject—measured through internal linking density, content depth across subtopics, and consistent entity usage—earn higher rankings than sites with isolated, keyword-targeted pages. A Lumar research study examining 2,000+ search queries found that pages with higher semantic relevance scores to their target topics correlated with higher SERP positions, with vector-based scoring outperforming traditional keyword-density metrics as a ranking predictor (Lumar, “Semantic Search Explained: Vector Models’ Impact on SEO Today,” July 2025).

The Supabase vector pipeline directly supports topical authority building by quantifying cluster coverage. When every spoke page scores above 0.80 against its hub topic and the hub page maintains moderate similarity (0.65–0.80) across all its spokes, the resulting content structure signals comprehensive topical coverage to search engine crawlers.

GEO: Making Content Citable by AI Platforms

Generative Engine Optimization focuses on making content eligible for citation by AI systems like ChatGPT, Google Gemini, Perplexity, and Claude. Research published in the Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD ’24) identified nine optimization tactics that improve visibility in generative engine responses, with authoritative citations, statistical data, and fluent language among the most effective strategies (Aggarwal et al., 2024; DOI: 10.1145/3637528.3671900).

Semantic content scoring supports GEO in two ways. First, it ensures that every page is positioned as the most authoritative source on its specific subtopic within the site—AI platforms prefer citing focused, authoritative pages over broad, shallow ones. Second, by identifying and resolving cannibalization, it prevents the confusion that occurs when AI systems encounter multiple pages from the same site covering the same topic with conflicting or overlapping information. Implementing these GEO principles at scale requires the kind of systematic analysis that a vector database enables.

AEO and AIO: Structured Answers for Engines

Answer Engine Optimization (AEO) targets featured snippets and direct answers in traditional search results. AI Overview Optimization (AIO) targets Google’s AI-generated summary panels. Both reward content that provides clear, structured, and directly answerable information.

The vector pipeline supports AEO and AIO through section-level scoring. By embedding FAQ sections separately and scoring them against common user queries (converted to embeddings), development teams can identify which FAQ answers are semantically aligned with real search queries and which miss the mark. FAQ pages that score below 0.75 against their target queries need rewriting to more directly address the question. This same approach can evaluate whether FAQ pages structured for AI search visibility are actually optimized for the queries they target.

Measurement Framework for Vector-Powered Content Systems

Implementing a vector pipeline is a technical milestone, but its value depends on measurable outcomes. The following framework connects semantic scoring metrics to business performance indicators.

Baseline Documentation

Tracking Semantic Scores Over Time

Schedule monthly re-ingestion of WordPress content to capture updates, new pages, and content changes. Re-generate embeddings for modified pages and recompute the similarity matrix. Track three metrics over time: average hub-cluster coverage score (the mean similarity of all spokes to their hub), orphaned page count, and cannibalization pair count. Improvements in these metrics should correlate with improvements in organic traffic and AI citation rates over a 3–6 month observation period.

Correlating Scores to Rankings and AI Citations

The ultimate validation is whether higher semantic scores lead to better visibility. Track ranking changes for target queries alongside changes in cluster coverage scores. While correlation does not establish causation—ranking improvements depend on many factors including backlinks, technical SEO, and competitor activity—a consistent positive correlation between coverage score improvements and ranking gains validates the approach. AI platform citation pattern research suggests that comprehensive topical coverage is a strong positive signal across multiple AI platforms.

Frequently Asked Questions

Ready to Build a Vector-Powered Content System?

InterCore Technologies brings 23+ years of developer-led AI implementation to legal marketing. Our proprietary analytics platform already leverages vector databases and semantic scoring to optimize content architecture for law firms nationwide.

Talk to Our Engineering Team →

References

1. Aggarwal, P., Murahari, V., Rajpurohit, T., Kalyan, A., Narasimhan, K., & Deshpande, A. (2024). GEO: Generative Engine Optimization. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD ’24), Barcelona, Spain, August 25–29, 2024, pp. 5–16. DOI: 10.1145/3637528.3671900
2. Supabase. (2025). AI & Vectors Documentation. Supabase Docs. https://supabase.com/docs/guides/ai
3. Supabase. (2025). pgvector: Embeddings and vector similarity. Supabase Docs. https://supabase.com/docs/guides/database/extensions/pgvector
4. Supabase. (2025). Vector columns. Supabase Docs. https://supabase.com/docs/guides/ai/vector-columns
5. Hill, M. (2025). Semantic Search Explained: Vector Models’ Impact on SEO Today. Lumar. Published July 24, 2025. https://www.lumar.io/blog/best-practice/semantic-search-explained-vector-models-impact-on-seo/
6. Weyant, C. (2025). Semantic SEO: How to optimize for meaning over keywords. Search Engine Land. Published October 9, 2025. https://searchengineland.com/guide/semantic-seo
7. Nimbleway. (2025). Step-by-step Guide to Building a RAG (Retrieval-Augmented Generation) Pipeline. Nimbleway Blog. https://www.nimbleway.com/blog/rag-pipeline-guide
8. Google. (2025). Introduction to structured data markup in Google Search. Google Search Central Documentation. https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data

Conclusion

The shift from keyword-based content auditing to vector-powered semantic scoring represents a fundamental upgrade in how law firm websites can be managed and optimized. By ingesting WordPress content into a Supabase pgvector database, development teams gain the ability to quantify topic coverage, detect cannibalization, identify content gaps, and generate data-driven internal linking recommendations—all through standard SQL queries extended with similarity operators.

This approach is not theoretical. The components—WordPress REST API, Supabase pgvector, embedding models, and cosine similarity scoring—are all production-ready and well-documented. The conceptual framework bridges traditional SEO and emerging GEO requirements by providing the topical authority signals that both search engines and AI platforms use to determine which content deserves visibility.

For law firms investing in content marketing, the vector pipeline transforms hub-and-spoke architecture from a static planning exercise into a dynamic, measurable system. Pages are created, updated, and interlinked based on mathematical similarity measurements rather than editorial intuition—and the results can be tracked against AI citation patterns and search ranking improvements over time.