A Seo Mcp
Description
# @automatelab/ai-seo-mcp > AI Citation Toolkit for the Model Context Protocol [](https://www.npmjs.com/package/@automatelab/ai-seo-mcp)…
About
# @automatelab/ai-seo-mcp > AI Citation Toolkit for the Model Context Protocol [](https://www.npmjs.com/package/@automatelab/ai-seo-mcp) [](./LICENSE)…
Details
- Author
- AutomateLab-tech
- Downloads
- 273
- Categories
- Marketing, Other
Jump to
- Composite 8-dimension AI-SEO scoring and grading.
- Validation of robots.txt, sitemaps, and technical SEO elements.
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
A Seo McpCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
Run audits locally via npx -y @automatelab/ai-seo-mcp or configure it as an MCP server in any stdio-capable client (e.g., Claude Desktop, Cursor, Windsurf). Use any of its 19 tools (e.g., audit.page, check.robots) to analyze pages. It also doubles as a GitHub Action for CI/CD pipelines.
audit_page
Full 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_schema
Validate 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_canonical
Audit 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`.
check_robots
Fetch 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_sitemap
Validate 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_technical
Audit 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`.
score_ai_overview_eligibility
Score 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_agentic_browsing
Score 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`.
llms_txt_generate
Generate 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.
pricing_generate
Generate 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.
llms_txt_validate
Validate 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.
score_citation_worthiness
Score 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.
rewrite_aeo
Rewrite 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_geo
Rewrite 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.
extract_entities
Extract 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.
score_test_citation
Simulate `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.
diff_pages
Compare 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.
audit_site
Single-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_sitemap
Site-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).
report_save
Render an audit_page or audit_site result as a Markdown report and write it to a file under MCP_WORKSPACE_ROOT (defaults to cwd).
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"a seo mcp": {
"ai-seo": {
"command": "npx",
"args": [
"-y",
"@automatelab/ai-seo-mcp"
]
}
}
}
}McpServers
{
"ai-seo": {
"command": "npx",
"args": [
"-y",
"@automatelab/ai-seo-mcp"
]
}
}@automatelab/ai-seo-mcp
> AI Citation Toolkit for the Model Context Protocol
Audit why AI systems do or do not cite your pages. MCP server. No API keys.
Works inside Claude, Cursor, Windsurf, Codex, and any MCP client that speaks stdio.
---
What it checks
- AI crawler access - GPTBot, OAI-SearchBot, ClaudeBot, and PerplexityBot allowed or blocked in robots.txt
- llms.txt - present, spec-compliant, links alive
- Structured answer extraction - FAQ headings, BLUF paragraphs, answer-ready blocks
- [[schema]] completeness - FAQPage, Article, Organization, Person; flags deprecated patterns
- Entity clarity - named entity density and sameAs coverage that help AI systems identify the subject
- Citation formatting - canonical URL hygiene, og:url, hreflang, noindex traps
- Sitemap freshness - lastmod signals that tell crawlers the page is current
---
Run an audit. Get a list of citation-blockers, ranked.
> You: Run an AI-SEO audit on https://automatelab.tech/launching-the-ai-seo-mcp/.
Result (truncated):
{
"url": "https://automatelab.tech/launching-the-ai-seo-mcp/",
"score": 61,
"grade": "C",
"dimension_scores": {
"schema": 45, "technical": 80, "structure": 40,
"robots": 90, "freshness": 85, "authority": 40,
"entity_density": 21, "sitemap": 100
},
"findings": [
{
"severity": "critical",
"category": "structure",
"message": "No FAQ structure found (no FAQPage schema or H3 question headings).",
"fix": "Add FAQ H3 headings ending in '?' with answer paragraphs, and a FAQPage JSON-LD block.",
"estimated_impact": "high"
},
{
"severity": "warning",
"category": "authority",
"message": "Low authority signals - missing Organization or author Person schema.",
"fix": "Add Organization JSON-LD and Article.author as a Person node with sameAs links.",
"estimated_impact": "high"
}
]
}
Each finding names the exact fix. No opaque scores, no guesswork.
---
Install
npx -y @automatelab/ai-seo-mcp
Requires Node 20 or later.
Claude Desktop
Add to %APPDATA%\Claude\claude_desktop_config.json (Windows) or ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):
{
"mcpServers": {
"ai-seo": {
"command": "npx",
"args": ["-y", "@automatelab/ai-seo-mcp"]
}
}
}
Restart Claude Desktop. Any MCP client that supports stdio transport works - same command / args pattern.
Optional: headless rendering for SPAs
By default audit_page reads raw HTML — fast, but misses content on React/Vue/Angular SPAs. Pass render: "headless" to spin up Chromium and audit the rendered DOM (adds 3-10s per audit).
One-time install:
npm install playwright-core
npx playwright install chromium
Then call audit_page with render: "headless". Use static for everything else — most marketing sites and docs render fine without it.
---
Run it in CI (GitHub Action)
This repo doubles as a GitHub Action. Drop it in a workflow to fail a PR when any page regresses below an AI-citation score - the same audit engine, gated on every change.
- uses: actions/checkout@v4
- name: AI-SEO audit
uses: AutomateLab-tech/ai-seo-mcp@v0.5.0
with:
urls: "https://example.com,https://example.com/pricing"
min-score: "70" # fail if any URL scores below this
respect-robots: "true" # set false for staging / sites you own
report-path: "ai-seo-report.md" # optional Markdown report artifact
fail-on-regression: "true"
The Action builds the auditor from the pinned ref, runs audit_page on each URL, writes a scorecard to the job summary, and exits non-zero if any URL falls below min-score (when fail-on-regression is true). Outputs: min_score_observed, urls_audited, report_path. Full example: examples/github-action-usage.yml.
---
Further reading
- automatelab.tech - teardowns and case studies
---
<details>
<summary>MCP tool surface (19 tools)</summary>
| Tool | Purpose |
|------|---------|
| audit.page | Composite AI-SEO audit with 8-dimension scoring (schema, technical, structure, robots, freshness, authority, entity density, sitemap). |
| audit.schema | Validate JSON-LD against Schema.org rules and AI-citation best practice. Flags deprecated patterns. |
| audit.canonical | Canonical link integrity, trailing-slash hygiene, og:url consistency. |
| audit.site | Single-call site sweep: audit.page + check.robots + check.sitemap + audit.schema with overall grade and top-5 fixes. |
| audit.sitemap | Site-wide content audit: stride-sample N URLs from the sitemap, run audit.page on each, return distribution + worst pages + top findings. |
| check.robots | Parse robots.txt and report per-crawler allow/disallow for all known AI crawlers. Surfaces the GPTBot-blocked-but-OAI-SearchBot-allowed trap. |
| check.sitemap | Validate XML sitemaps: presence, URL count, lastmod freshness, image/video extensions. |
| check.technical | HEAD tag audit: canonical, OpenGraph, Twitter Card, hreflang, HTTPS, noindex, title hygiene. |
| score.ai_overview_eligibility | Score a page's probability of appearing in Google AI Overviews using current correlation factors. |
| score.citation_worthiness | Score how citable a page or text block is for Perplexity, ChatGPT, Google AI Overviews, and Claude. Includes per-section chunk_analysis / extractability_score: how cleanly an LLM can lift a standalone answer from each heading. |
| score.agentic_browsing | Score a page against the Lighthouse "Agentic Browsing" category (May 2026): llms.txt, WebMCP, accessibility-tree integrity, and layout stability. |
| score.test_citation | Simulate "would an AI engine cite this for this query?" via MCP sampling, with deterministic heuristic fallback. |
| llms_txt.generate | Generate llms.txt and optionally llms-full.txt from a domain's sitemap. |
| llms_txt.validate | Lint an existing llms.txt for spec compliance and broken links. |
| rewrite.aeo | Rewrite content for Answer Engine Optimization (BLUF structure, FAQ format, schema additions). |
| rewrite.geo | Rewrite content for Generative Engine Optimization (entity definitions, comparison tables, synthesis-ready structure). |
| extract.entities | Extract named entities, sameAs links, and citation-density score from a page's content and structured data. |
| diff.pages | Compare two URLs for AI citation-worthiness: side-by-side dimension scores, gap analysis, and prioritized fix recommendations for url_a. |
| report.save | Render an audit.page / audit.site result as a Markdown report and write it to disk under MCP_WORKSPACE_ROOT. |
> v0.4.0 renamed tools from flat snake_case to dot-notation (audit.page, check.robots, …) for a navigable hierarchy. Update any saved invocations.
Environment variables: see ENV.md.
</details>
---
Contributing
Bug reports, feature ideas, and PRs welcome. See CONTRIBUTING.md.
Security
To report a vulnerability, see SECURITY.md.
License
MIT - see LICENSE.
Built by automatelab.tech
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
