MCP SERVER · OFFICIAL PROJECTAudit a page or a whole domain for how AI crawlers and answer engines read it, generate the files they look for, and rewrite the content that is not getting cited.
LABSCO SUMMARY
audit_page, audit_canonical, check_robots, check_sitemap, check_technical and score_ai_overview_eligibility all describe themselves as rule-based with no model involved, and score_ai_overview_eligibility adds that the same URL returns the same score — which is what makes a before-and-after comparison mean anything. rewrite_geo, extract_entities and score_test_citation sit on the other side of that line: their primary path is MCP sampling, so the host model does the work and the output moves with it. Nothing here publishes: llms_txt_generate and pricing_generate return file content as a string and state outright that hosting the file is the caller's job, and the rewrite tools return text rather than touching the source URL.
An AI-SEO audit and rewriting server with 20 tools covering page and site audits, robots and sitemap checks, AI-Overview and citation scoring, llms.txt and pricing.md generation, entity extraction and Markdown report output.
No credentials are configured on the server, and the audit tools are documented as needing no auth and no third-party APIs. report_save writes under MCP_WORKSPACE_ROOT, which defaults to the working directory, so that path has to be writable.
One command — npx -y @automatelab/ai-seo-mcp
USE CASES
Run the full page audit for findings and a composite score, then read the AI-Overview factor subscores and how cleanly an answer can be lifted from each section.
Read the per-crawler posture out of robots.txt, validate that the sitemap is reachable and current, and take the site-wide grade to see if anything else is in the way.
Generate the llms.txt content from the sitemap, validate it against the spec, produce a machine-readable pricing file, then score how the page reads to an agent browser.
Diff the two pages on their audit dimensions, ask an engine simulation which one it would cite for the query, and compare the entities each page actually establishes.
Score the current extractability per section, rewrite for answer-engine shape, and produce the entity-rich comparison-ready variant when the query is a synthesis one.
Sample the sitemap by stride and audit each sample, take the site-wide grade for context, and save the result as a Markdown report to hand over.
Counted once with only startup setup. Other versions, modes or optional credentials may expose a different list.
audit_canonicalAudit a page's canonical link integrity: presence, self-reference, cross-domain mismatches, trailing-slash hygiene, and og:url consistency.
Read-only. One HTTP GET to fetch the HEAD section.
Deterministic, rule-based; no LLM.
When to use: a focused canonical-only audit (e.g. debugging a duplicate-content issue). For a full HEAD audit including OpenGraph, hreflang, noindex, title, use check_technical. For everything-on-a-page, use audit_page.
audit_pageFull AI-SEO audit of a single URL: returns categorized findings (info/warning/error) with severity, fix instructions, and a 0-100 composite score plus per-dimension subscores.
Read-only. Fetches the URL once and runs every sub-audit (schema, robots, technical, sitemap, AI-Overview eligibility) against the response. No writes, no third-party APIs, no auth required, no rate limits beyond polite per-host throttling.
Deterministic, rule-based scoring; no LLM calls. Same URL + same input flags returns the same score.
Supports render: "static" | "headless". Default static (fast, raw HTML only). Use headless for React/Vue/Angular SPAs — adds 3-10s and requires the optional playwright-core peer dep plus a one-time npx playwright install chromium.
When to use: the default entry point for audit any page. Use this instead of calling check_technical / audit_schema / check_robots / check_sitemap / score_ai_overview_eligibility individually unless you specifically need only one dimension - this tool composes all of them.
audit_schemaValidate JSON-LD structured data against Schema.org rules and AI-citation best practices. Accepts either a URL (fetched) or a raw JSON string (parsed directly).
Read-only when given url (one HTTP GET). Zero network when given schema_json. No writes.
Deterministic, rule-based; no LLM. Validates required/recommended properties, @context correctness, sameAs links, and AI-search-friendly patterns.
When to use: focused JSON-LD audits, or to validate a schema block you're about to ship. For a full page audit that includes schema + everything else, use audit_page instead.
Either url or schema_json must be provided (not both). If both are provided, schema_json wins and no fetch happens.
audit_siteSingle-call site sweep: runs audit_page (homepage), check_robots, check_sitemap, and audit_schema in parallel and returns an overall grade (A–F) plus top-5 highest-impact fixes.
Read-only. Issues several HTTP GETs against the domain (homepage fetch, robots.txt, sitemap.xml, and up to 50 sitemap URL HEAD checks); no writes, no auth required, no rate limits beyond polite per-host throttling. The homepage GET is deduplicated across audit_page and audit_schema (~2 network fetches for 4 logical checks). Deterministic, rule-based scoring; no LLM calls. Same domain returns the same grade on repeated runs given unchanged content.
Output: domain, homepage_url, fetched_at, overall_score (0–100), overall_grade, top_5_fixes (Finding[]), and a parts breakdown with individual audit_page, check_robots, check_sitemap, and audit_schema results — each may be a full result or { error: string } when that sub-audit fails.
When to use: quick 'how does this site look overall?' — use when you want a single consolidated score and actionable fix list without calling 4 tools individually. Distinct from audit_sitemap (samples N pages from the sitemap, not just the homepage) and audit_page (single-URL deep dive with all findings, not just top-5).
audit_sitemapSite-wide content audit: discovers the sitemap, samples N URLs by deterministic uniform stride, runs audit_page on each, and returns score distribution + worst pages + most-common findings.
Read-only. One HTTP GET for sitemap discovery, optionally a few more for sitemap-index children, then sample_size × audit_page calls (each one HTTP GET + parsing). Polite throttling is enforced per host.
Deterministic — same domain + same sample_size returns the same set of URLs (uniform-stride sampling). Per-page scoring is rule-based; no LLM.
When to use: portfolio-level health check across a site ("how does our content score on average?"). Distinct from audit_site (homepage-only composite) and check_sitemap (validates sitemap.xml structure, not page content).
check_robotsFetch and parse a domain's robots.txt; report per-crawler allow/disallow posture for every known AI training crawler (GPTBot, CCBot, Anthropic-AI, Google-Extended, etc.), AI search crawlers (ChatGPT-User, PerplexityBot, OAI-SearchBot), and user-triggered fetchers.
Read-only. One HTTP GET to /robots.txt. No auth, no rate limits applied.
Deterministic, rule-based; no LLM. Returns structured findings with per-crawler status.
When to use: figuring out which AI crawlers a site blocks vs allows. Combine with check_sitemap for a full pre-crawl audit. Distinct from audit_page which evaluates a single URL; this evaluates a whole-domain policy.
check_sitemapValidate a domain's XML sitemap: presence, accessibility, URL count, lastmod freshness, sitemap-index handling, and image/video sitemap extensions.
Read-only. Issues N+1 HTTP GETs: one for robots.txt + sitemap, then up to max_urls_to_check HEADs against sampled URLs.
Deterministic, rule-based; no LLM.
When to use: site-wide indexing audits. Pair with check_robots for a full pre-crawl picture. For per-page checks, use audit_page or check_technical instead.
check_technicalAudit a page's HEAD section for technical signals relevant to AI crawlers: HTTPS, canonical, OpenGraph, Twitter Card, hreflang, noindex, and title-vs-H1 hygiene.
Read-only. One HTTP GET, inspects HEAD only (body is not parsed).
Deterministic, rule-based; no LLM.
When to use: when you specifically need HEAD-tag audit findings. For the full page including schema and AI-Overview scoring, use audit_page. For canonical-only, use audit_canonical.
diff_pagesCompare two URLs for AI citation-worthiness and return a structured breakdown of which page is more likely to be cited and why. Typical use: your page (url_a) vs a competitor's page (url_b).
Read-only. Runs audit_page on both URLs in parallel (2 HTTP fetches per URL), then diffs dimension_scores and findings. No new fetch logic beyond what audit_page already does.
Deterministic, rule-based; no LLM calls. Same two URLs return the same comparison on repeated runs.
When to use: competitive gap analysis - understand exactly which dimensions (schema, structure, robots, entity density, freshness, technical, authority, sitemap) put a competitor ahead, and get prioritized fix_recommendations_for_a to close the gap. For a single-URL audit, use audit_page. For overall scoring of one page, use score_citation_worthiness.
Capped at 2 URLs per call. Heuristic verdict - does not claim to know what AI assistants actually cite; verdict matches audit_page's existing rubric.
extract_entitiesExtract named entities, linked concepts, and sameAs graph nodes from a page's content and structured data. Combines body-text NER with JSON-LD @type / sameAs walking.
Read-only when given url (one HTTP GET). Zero network when given text.
Primary path: MCP sampling - the host LLM does the NER and returns typed entities with sameAs URIs. Fallback path: deterministic regex-based extractor when sampling is unavailable. The result includes mode: "sampling" | "regex_fallback" so callers can tell which path ran.
When to use: building an entity map for schema generation, or auditing whether a page's entities match its target topic. To validate the JSON-LD itself, use audit_schema.
Either url or text must be provided.
llms_txt_generateGenerate a spec-compliant llms.txt (and optionally llms-full.txt) for a domain by reading its sitemap, sampling up to max_pages pages, and synthesizing a grouped, sectioned summary.
Read-only. Issues one HTTP GET for the sitemap then one per sampled page.
Deterministic; no LLM. Output is the file content as a string - this tool does NOT write to disk or upload anywhere. The caller is responsible for hosting the resulting file at https://<domain>/llms.txt.
When to use: bootstrapping llms.txt for a site you own. To check an existing llms.txt, use llms_txt_validate instead.
llms_txt_validateValidate an existing llms.txt or llms-full.txt against the spec: structure, section ordering, link format, and (optionally) broken-link detection.
Read-only. One HTTP GET when given url; zero network when given content. Optional link-check issues HEAD requests against each link if check_links is true.
Deterministic; no LLM.
When to use: auditing an llms.txt you already have. To generate one from scratch, use llms_txt_generate.
Either url or content must be provided.
pricing_generateGenerate a machine-readable /pricing.md for AI shopping/agent flows. Finds the site's pricing page (or uses pricing_url), extracts named tiers and price lines, and returns the file content as a string.
Read-only. Issues a few HTTP GETs probing common pricing paths. Deterministic; no LLM. Does NOT write or upload — the caller hosts the file at https://<domain>/pricing.md.
When to use: a SaaS/e-commerce site that wants agents to read pricing without parsing a JS-rendered table. Falls back to a fill-in template when no prices are detectable.
report_saveRender an audit_page or audit_site result as a Markdown report and write it to a file under MCP_WORKSPACE_ROOT (defaults to cwd).
rewrite_aeoRewrite a content block for Answer Engine Optimization. Adds a BLUF opening, FAQ structure, schema additions, and concise question-shaped headings tuned for ChatGPT / Perplexity / Google AI Overviews.
Read-only when given url (one HTTP GET). Zero network when given text. The tool does NOT write back to the URL - it only returns the rewritten content as a string. No side effects on the source.
This tool delegates the actual rewrite to the calling LLM via MCP sampling - it does not call any external API itself. The MCP host's model produces the rewrite. Same input may produce different output across runs (model-dependent).
When to use: optimizing content for direct-answer surfaces (definitions, how-tos, FAQs). For Generative Engine Optimization (entity-rich, comparison-ready synthesis), use rewrite_geo instead.
Either url or text must be provided. target_query is required.
rewrite_geoRewrite a content block for Generative Engine Optimization: entity-rich, comparison-ready, synthesis-friendly. Tuned for surfaces that summarize across sources (Perplexity, Google AI Mode, Claude search).
Read-only on input. Does NOT write back to the source URL - returns the rewritten content as a string.
This tool delegates the actual rewrite to the calling LLM via MCP sampling - it does not call any external API itself. The MCP host's model produces the rewrite. Output may vary across runs (model-dependent).
When to use: optimizing for synthesis-style answers across multiple sources. For direct-answer (BLUF + FAQ) optimization on a single page, use rewrite_aeo instead.
Either url or text must be provided. target_query is required.
score_agentic_browsingScore a page against the four signals Google added to the Lighthouse "Agentic Browsing" category in May 2026: presence of an llms.txt, WebMCP integration, accessibility-tree integrity, and layout stability. Returns an overall 0-100 score, a letter grade, and a per-factor breakdown.
Read-only. One HTTP GET for the page plus one for /llms.txt (skip with check_llms_txt=false). Pass html instead of url to score markup offline (llms.txt is then treated as absent).
Deterministic, rule-based heuristics over the fetched HTML; no LLM and no headless render required. This approximates Lighthouse's runtime signals from static markup - it does not execute Lighthouse.
When to use: checking whether a site is ready for AI agents / agentic browsers, or tracking the new Lighthouse Agentic Browsing category. For citation-eligibility of content, use score_citation_worthiness; for a full page audit, use audit_page.
score_ai_overview_eligibilityScore a page's probability of appearing in Google AI Overviews. Returns an overall 0-100 score plus six factor subscores: semantic completeness, structured data, E-E-A-T signals, entity density, freshness, and technical hygiene.
Read-only. One HTTP GET.
Deterministic, rule-based scoring derived from published 2025-2026 AI-Overview correlation studies. No LLM calls. Same URL returns the same score on repeated runs.
When to use: AI-Overview-specific prioritization. For a multi-dimensional audit that includes this scoring plus everything else, use audit_page. For citation-worthiness of a specific text passage (rather than a URL ranking probability), use score_citation_worthiness.
score_citation_worthinessScore how citable a page or text block is for AI engines (ChatGPT, Claude, Perplexity, Google AI Overviews). Evaluates BLUF (bottom-line-up-front) opening, FAQ patterns, statistic density, entity clarity, and answer-shape fit for the optional target_query.
Also returns extractability_score plus per-section chunk_analysis: how cleanly an LLM can lift a self-contained answer from each heading-delimited section (length band, lead-sentence directness, anaphora, concrete anchors). This is the GEO mechanic - it pinpoints the exact sections to tighten, with most_extractable / least_extractable called out.
Read-only when given url (one HTTP GET). Zero network when given text. No writes.
Deterministic, rule-based; no LLM calls. Returns reproducible scores.
When to use: pre-publish content QA, or to triage which existing pages are worth optimizing for AI citation first. Distinct from score_ai_overview_eligibility which scores Google-AI-Overview ranking probability for a URL; this scores the inherent citability of a text passage regardless of host.
Either url or text must be provided.
score_test_citationSimulate would an AI engine cite this page for this query?. The host LLM role-plays the chosen engine (chatgpt / claude / perplexity / google_ai_overviews / any), reads the page content, and returns a cite/no-cite verdict with the verbatim excerpt it would surface plus ranked improvements.
Read-only when given url (one HTTP GET). Zero network when given text.
Primary path uses MCP sampling. If the host doesn't support sampling, falls back to a deterministic heuristic derived from score_citation_worthiness (overall_score + per-engine subscore must both clear thresholds). The result includes mode: "sampling" | "static_heuristic" so callers can tell which path ran.
When to use: pre-publish gut-check for a specific query, or auditing whether existing content earns citation surface. Distinct from score_citation_worthiness (deterministic 0-100 score) and audit_page (whole-page rubric); this returns a binary cite/no-cite verdict tied to one query.
Either url or text must be provided. target_query is required.
BEFORE YOU INSTALL
20 tools when we connected.
npx on PATH
CONTEXT COST
Rated by the size of the 20 tool definitions that ride along on every turn, not by how many there are
INSTALLATION
Add the block to your client, or run the command directly.
{
"mcpServers": {
"ai-seo-mcp": {
"command": "npx",
"args": [
"-y",
"@automatelab/ai-seo-mcp"
]
}
}
}npx -y @automatelab/ai-seo-mcpMCP servers
grovs-io
1fancy
Macawls
samalyxx