Skip to main content
Glama
AutomateLab-tech

SEO Performance MCP

seo-performance-mcp

Know which blog posts to refresh, expand, merge, or kill - without guessing.

A MCP server that turns your scattered SEO and analytics data into one clear verdict per URL. Plug it into Claude, Cursor, or any MCP-aware client and ask: "Which three posts should I update this week?" - and get an answer backed by hard numbers.

What it does

seo-performance-mcp unifies post-publish signals from every channel you already pay for:

  • Google Search Console - clicks, impressions, CTR, position, top queries

  • Matomo or GA4 - visits, dwell time, bounce rate

  • Microsoft Clarity - scroll depth, rage clicks, dead clicks

  • AI citation tracking - which LLMs cite your URL today vs. last month

  • Sitemap / CMS - publish dates, tags, word counts (any platform via XML sitemap; optional Ghost integration for richer metadata)

It then runs a deterministic rule engine over those signals and emits a verdict per URL:

refresh / expand / merge / kill / double_down / hold

with reason codes, evidence, and a 0-1 confidence score. Reporting only - the server never mutates your posts.

Related MCP server: growth-mcp

Why it matters

Most content teams have analytics in five tabs and a gut feeling. That's how good posts rot quietly, mediocre posts get over-promoted, and the obvious "rewrite this one" is invisible until traffic has already cratered.

This MCP closes the loop:

  • One question, one URL in, one verdict out.

  • Same logic across the whole cohort, so the ranking is comparable.

  • All decisions traceable to numeric thresholds you can pin in src/verdict/rules.ts.

  • AI clients (Claude, Cursor, MCP hosts) can drive the entire content audit in plain English.

Who it's for

  • Content marketers running a blog of 50+ posts and tired of guessing what to refresh.

  • SEO consultants doing audits who want a portable, deterministic scoring layer instead of bespoke spreadsheets.

  • AI-first content teams wiring up rewrite agents - this MCP is the upstream signal layer.

  • Indie publishers on Ghost, WordPress, Hugo, Astro, Next, Webflow, or any CMS that exposes a sitemap.

What you get

After one cohort run you have:

  • A ranked table of every post with a verdict and confidence score.

  • A markdown brief per "refresh" URL: numbers + top queries + suggested actions an editor (or a writing agent) can act on immediately.

  • A list of "quick wins": queries sitting at positions 5-15 with below-expected CTR - the fastest title-rewrite wins on the property.

  • A historical AI-citation diff: which LLMs cited you and stopped.

Install

npx -y @automatelab/seo-performance-mcp

In a Claude, Claude Code, or Cursor MCP config:

{
  "mcpServers": {
    "seo-performance": {
      "command": "npx",
      "args": ["-y", "@automatelab/seo-performance-mcp"],
      "env": {
        "POSTS_SITEMAP_URL": "https://example.com/sitemap.xml",
        "GSC_SERVICE_ACCOUNT_JSON": "<base64-encoded service-account JSON>",
        "GSC_SITE_URL": "sc-domain:example.com",
        "MATOMO_URL": "https://example.com/analytics",
        "MATOMO_TOKEN": "...",
        "MATOMO_SITE_ID": "1",
        "GA4_PROPERTY_ID": "123456789",
        "GA4_SERVICE_ACCOUNT_JSON": "<base64-encoded service-account JSON>",
        "CLARITY_PROJECT_ID": "...",
        "CLARITY_API_TOKEN": "...",
        "CITATION_INTELLIGENCE_URL": "https://citation.example.com"
      }
    }
  }
}

Every env var is optional. Adapters that lack their env config skip their slice of the snapshot; the server still boots. The verdict engine works on whatever slices are present.

Platform integration

Point it at any site, no CMS plugin required. The post-discovery layer resolves in priority order:

  1. POSTS_LIST - JSON array of {url, title?, published_at?, tags?, word_count?}. Use this when you already have a content index and want exact control.

  2. Ghost Admin API - if both GHOST_ADMIN_API_URL and GHOST_ADMIN_API_KEY are set, Ghost is used as a richer metadata source. Optional.

  3. HTML extraction - per-URL og:title, article:published_time, and JSON-LD datePublished are read live from the URL.

  4. XML sitemap - set POSTS_SITEMAP_URL to your sitemap (or sitemap index) and the server enumerates posts from <loc> + <lastmod>.

Most users only need POSTS_SITEMAP_URL. WordPress, Hugo, Astro, Next.js, Webflow, Framer, Wix, Squarespace, Notion-as-a-site, Substack-mirror sites all expose a sitemap by default.

To add a brand-new platform: nothing to build - just point POSTS_SITEMAP_URL at it.

Tools exposed

Tool

What it returns

posts_list

Posts with {url, title, age_days, tags} from sitemap, Ghost, or your POSTS_LIST.

posts_snapshot

Per-URL unified rollup for a 30/60/90-day window: GSC + Matomo + GA4 + Clarity + citations + meta.

posts_decay_curve

Weekly GSC clicks/impressions/position buckets + a decay/plateau/growth trend label.

posts_verdict

Verdict (refresh/expand/merge/kill/double_down/hold) + reason codes + 0-1 confidence.

posts_refresh_brief

Markdown brief for a human or downstream LLM editor: numbers, top queries, suggested actions.

cohort_report

Cohort verdict table sorted by priority + confidence. "Which three posts should I refresh this week?"

posts_cite_loss

LLM citations that dropped off for a given URL. Needs CITATION_INTELLIGENCE_URL.

gsc_quick_wins

(page, query) pairs at positions 5-15 with low CTR - fastest title-rewrite wins.

Use as a GitHub Action

Run any of the tools on a cron from CI and post the output to a GitHub Issue, Discussion, or PR. The action is published on the GitHub Marketplace.

- uses: AutomateLab-tech/seo-performance-mcp@v1
  with:
    tool: cohort_report
    format: markdown
    input: '{"window": 90, "min_age_days": 90, "limit": 20}'
    gsc-service-account-json: ${{ secrets.GSC_SERVICE_ACCOUNT_JSON }}
    gsc-site-url: ${{ secrets.GSC_SITE_URL }}
    posts-sitemap-url: ${{ secrets.POSTS_SITEMAP_URL }}

Outputs:

Output

Description

result

Tool output as a multi-line string (markdown or JSON, per format).

result-file

Path of the file the tool output was written to. Hand to peter-evans/create-issue-from-file etc.

rows

For cohort_report with format: json only: number of rows returned.

A complete weekly-audit workflow that opens a GitHub Issue with the cohort report is in examples/weekly-cohort-report.yml.

Use as a one-shot CLI

The package also ships a seo-perf-cli bin so you can run a single tool without an MCP client:

npx -p @automatelab/seo-performance-mcp seo-perf-cli cohort_report \
  --input '{"window": 90, "limit": 20}' \
  --format markdown

Same env vars as the MCP server. --format markdown is supported for cohort_report and posts_refresh_brief; other tools fall back to fenced JSON.

Companion skills + Cursor rule

Three thin routing files ship in the repo so the LLM in your client knows when to reach for these tools:

  • skills/seo-performance/SKILL.md - tool-routing skill. Drop into ~/.claude/skills/seo-performance/ (or .claude/skills/ per project) to auto-load in Claude Code. Routes a single question to the right tool.

  • skills/weekly-audit/SKILL.md - one-shot weekly audit playbook. Composes gsc_quick_wins + cohort_report + posts_cite_loss into a deduped, cross-signal ranked digest with proposed edits per URL. Drop in alongside the routing skill.

  • cursor/rules/seo-performance.mdc - copy to .cursor/rules/seo-performance.mdc in any Cursor workspace.

All optional. The MCP server works without them; they just shorten the "which tool do I call" round-trip.

MCP prompts

The server exposes three prompts that bundle the playbook. Any MCP client (Claude Desktop, Claude Code, Cursor, Continue) can list and invoke them:

Prompt

What it runs

audit_cohort

cohort_report on posts >=90d, then posts_refresh_brief per refresh/expand/merge row. The weekly audit.

find_quick_wins

gsc_quick_wins (positions 5-15) + per-URL posts_snapshot, then proposes verbatim-query meta_title rewrites.

citation_loss_sweep

posts_cite_loss per URL, refresh_brief for any with losses, targeted H1/lead phrasing recommendations.

Verdict engine

Deterministic, rule-based, traceable. Reason codes:

  • ctr_below_position_expected

  • position_drift

  • decay_30d_over_30pct / decay_60d_over_50pct

  • stagnant_no_clicks

  • thin_content_low_dwell

  • rising_impressions_low_ctr / rising_clicks_continue_investment

  • citation_loss / citation_growth

  • duplicate_or_cannibalizing

  • high_bounce_low_scroll

  • fresh_post_too_young

The mapping (reasons → verdict) and every threshold lives in src/verdict/rules.ts. Edit it, pin it in tests, ship your own rule book.

Development

npm install
npm run dev        # tsx src/index.ts
npm run build      # tsc
npm test           # vitest

License

MIT

Available Tools

8 tools
cohort.reportCohort report across postsA
Read-only

Run the verdict engine across a cohort (filtered by tag and/or min-age) and return a ranked table sorted by verdict priority then confidence.

Practical use: 'which three posts should I refresh this week?' - the top three rows with verdict=refresh and highest confidence are the answer.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlsNoExplicit list of post URLs to include. Overrides sitemap discovery.
sitemap_urlNoSitemap URL to enumerate the cohort. Falls back to POSTS_SITEMAP_URL env var.
windowNo
min_age_daysNo
limitNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
rowsYes

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations (readOnlyHint=true) already indicate it's a read operation. The description adds that it runs the verdict engine, returns a sorted table, and can use sitemap_url or explicit urls. This provides useful behavioral context beyond annotations. No contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, directly stating the action and a practical use case. No redundant information, front-loaded with the core functionality. Efficient and clear.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that an output schema exists and annotations are present, the description provides a high-level overview and a use case. However, it lacks explanation of how cohort filtering works with the available parameters (e.g., the missing tag parameter). Overall, reasonably complete but a minor gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is low (40%). The description adds meaning by explaining min_age_days as a filter and mentioning 'tag' (though not in schema), but does not elaborate on window, limit, or the interaction between urls and sitemap_url. Partially compensates for low schema coverage but leaves gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool 'Run the verdict engine across a cohort... return a ranked table sorted by verdict priority then confidence'. The title 'Cohort report across posts' aligns, and the practical use case differentiates it from siblings like posts.verdict (single post) or posts.list (listing without verdicts).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives a concrete use case: 'which three posts should I refresh this week?' indicating when to use (cohort evaluation for refresh decisions). It mentions filtering by tag and min-age, but the schema lacks a tag parameter, slightly reducing clarity. No explicit exclusions or alternatives are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

gsc.quick_winsGSC quick wins (positions 5-15)B
Read-onlyIdempotent

Scan GSC for (page, query) pairs sitting in positions 5-15 with non-trivial impressions and a CTR below their position-expected curve. These are the fastest title-rewrite wins.

Returns top results sorted by impressions desc. Pure GSC pull - platform-agnostic.

ParametersJSON Schema
NameRequiredDescriptionDefault
min_positionNo
max_positionNo
min_impressionsNo
windowNo
limitNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
winsYes

TDQS

B3.3/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds that the tool is a read-only GSC pull (consistent with readOnlyHint and idempotentHint) and returns sorted results. It does not disclose behavioral details like rate limits, authentication needs, or data freshness. Since annotations already provide safety and idempotency, the description adds moderate value.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description consists of two short sentences that front-load the core purpose and end with sorting and source details. Every sentence adds distinct value without redundancy, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has 5 parameters with 0% schema coverage and an output schema, yet the description omits parameter details and does not mention the output format. While the purpose is clear, the lack of parameter semantics and output specification leaves the tool incomplete for effective usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for parameter meaning. However, it only vaguely references positions and impressions, without explaining any of the 5 parameters (min_position, max_position, min_impressions, window, limit). This leaves a significant gap for the agent to understand parameter semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: scanning GSC for (page, query) pairs in positions 5-15 with non-trivial impressions and low CTR relative to position expectation, returning top results sorted by impressions. It specifies the tool is for title-rewrite wins and is platform-agnostic, distinguishing it from sibling tools that may be platform-specific or focus on other metrics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is used for identifying quick title-rewrite opportunities, but it does not explicitly state when to use or not use it compared to alternatives. No guidance is given on prerequisites or exclusion criteria, leaving the agent to infer usage context from the purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

posts.cite_lossAI-citation losses per URLA
Read-onlyIdempotent

Return the list of LLMs that previously cited this URL but no longer do, with the prior query and last-seen date. Optionally includes the URL that replaced ours.

Requires a configured citation-intelligence MCP endpoint (CITATION_INTELLIGENCE_URL). Otherwise returns an empty list.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesCanonical URL of the post.

Output Schema

ParametersJSON Schema
NameRequiredDescription
urlYes
activeYes
lossesYes

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate read-only, idempotent, non-destructive, open-world. The description adds that the tool requires configuration and optionally includes replacement URL, without contradicting annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, both essential: first explains what the tool returns, second states a critical prerequisite. No redundant content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given a single parameter, output schema present, and low complexity, the description covers all necessary information: output details, optional replacement, and configuration requirement.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter 'url' is fully described in the schema (100% coverage) with format and meaning. The tool description does not add further parameter details, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states that the tool returns a list of LLMs that no longer cite a given URL, including prior query and last-seen date, and optionally the replacing URL. This is specific and distinguishes from siblings like 'posts.decay_curve'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description notes the prerequisite of a configured citation-intelligence MCP endpoint, and the behavior when not configured (returns empty list). It does not explicitly compare to alternatives but provides clear context for use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

posts.decay_curveWeekly GSC decay curveA
Read-onlyIdempotent

Bucket GSC clicks/impressions/avg-position into ~weekly windows for the last N weeks (default 12) and classify the trend: decay / plateau / growth.

Underpins the verdict engine's decay rules. Read-only GSC query.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesCanonical URL of the post.
weeksNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
urlYes
bucketsYes
trendYes
decay_pctYes

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. Description adds that it is a read-only GSC query and classifies trends, but does not reveal additional behavioral traits beyond annotations. No contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences front-loaded with main purpose. Every sentence adds value: first states the action, second provides context and read-only hint. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With existing output schema and annotations, description covers key aspects. Mentions trend classification which adds value. Could be more complete regarding return values, but output schema likely covers that.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers 50% of parameters with descriptions (only 'url' has description). Description adds context for 'weeks' (default 12) which is already in schema as default. No additional semantic meaning beyond schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses specific verbs ('bucket', 'classify') and clearly states the resource (GSC clicks/impressions/avg-position). It differentiates from siblings by mentioning it underpins the verdict engine's decay rules.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states it is a read-only GSC query and associates with the verdict engine's decay rules, indicating when to use. However, no explicit 'when not to use' or direct alternatives among siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

posts.listList posts from any platformA
Read-onlyIdempotent

Discover posts via an XML sitemap (POSTS_SITEMAP_URL or the sitemap_url arg), a JSON override list (POSTS_LIST), or - if configured - the Ghost Admin API. Pass an explicit urls[] to skip discovery entirely.

Returns metadata: url, title, published_at, age_days, tags. Filter by minimum age or published-after date.

When to use: discover which URLs are eligible for snapshot / verdict / cohort analysis. Works with any CMS that exposes a sitemap.

ParametersJSON Schema
NameRequiredDescriptionDefault
sitemap_urlNoURL of an XML sitemap to enumerate posts. Overrides POSTS_SITEMAP_URL env var. Required if neither POSTS_SITEMAP_URL nor POSTS_LIST is set.
urlsNoExplicit list of post URLs to return directly, bypassing sitemap discovery.
sinceNoISO date - only return posts published after this date.
min_age_daysNoSkip posts younger than this many days.
limitNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
postsYes

TDQS

A4.6/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral context: multiple discovery methods (sitemap, JSON list, Ghost API), bypassing discovery with urls, return fields, and filtering. No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured into two paragraphs: how it works and when to use. It is concise but could trim some redundancy, e.g., 'Discover posts via...' and 'Pass an explicit urls[]...' are clear but slightly wordy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (multiple discovery methods, 5 parameters, output schema present), the description covers discovery modes, filtering, and return metadata. It provides enough context for an agent to select and invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is high (80%). The description adds meaning by explaining the fallback environment variables for sitemap_url and the 'since' and 'min_age_days' filters. It goes beyond the schema by describing how urls bypass discovery, which is not in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Discover posts via an XML sitemap...' listing posts from any platform. It also distinguishes itself from sibling tools like snapshot, verdict, etc., by focusing on discovery and eligibility.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Includes a 'When to use' section that explains the tool's role in discovering URLs for downstream analysis. It provides clear context but lacks explicit instructions on when not to use it or alternatives besides the implied different purposes of siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

posts.refresh_briefRefresh brief (markdown) per postA
Read-only

Produce a markdown brief for a human (or downstream LLM) editor: verdict + reasons + raw numbers + top queries + suggested actions.

Use this as the hand-off artefact when verdict is refresh / expand / merge / double_down.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesCanonical URL of the post.
windowNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
markdownYes

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds behavioral context by detailing the brief's contents (verdict, reasons, raw numbers, etc.) and its purpose as a hand-off artefact. This goes beyond annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences that immediately convey the tool's purpose and usage. No wasted words, front-loaded with key information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Tool has an output schema, so return values need not be explained. Parameters are simple (url, optional window). Description covers usage context and output content, making it complete for a read-only brief generator.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50% (only 'url' described). The tool description does not elaborate on parameters beyond mentioning the output content. Since coverage is not high, description should compensate but doesn't, resulting in a baseline score of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the verb 'Produce' and the resource 'markdown brief' with specific contents. Distinguishes from siblings by tying usage to specific verdict outcomes (refresh/expand/merge/double_down) from the sibling tool posts.verdict.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'Use this as the hand-off artefact when verdict is refresh / expand / merge / double_down.' This provides clear when-to-use guidance and implies when not to use it, differentiating from alternative tools like posts.verdict.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

posts.snapshotUnified per-URL snapshotA
Read-only

Pull a 30/60/90-day snapshot across every configured signal source for one post: GSC clicks/impressions/CTR/position + top queries, Matomo visits + dwell, GA4 pageviews, Clarity scroll/rage clicks, AI-citation counts.

Each source is best-effort: if its env vars are missing the field is omitted. Returns whatever is available.

Read-only. No third-party writes. Optionally persists to the local DuckDB cache when persist=true.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesCanonical URL of the post to snapshot.
windowNo
persistNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
metaYes
window_daysYes
gscYes
matomoNo
ga4No
clarityNo
citationsNo
cannibalizationNo

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that sources are best-effort (omitted if env vars missing) and that persist optionally writes to a local DuckDB cache, which is a side-effect not captured by annotations. No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences: the first details purpose and sources, the second explains best-effort behavior, and the third summarizes read-only nature and cache option. Front-loaded with key information, no redundant words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (multiple sources, optional caching, best-effort), the description covers input parameters, behavior, side-effects, and outputs comprehensively. The output schema exists but is not shown; the description still lists expected metrics. No gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 33% (only 'url' described). The description adds meaning for 'window' (30/60/90-day) and 'persist' (opt-in DuckDB cache), and explains the URL role. It clarifies the overall context (snapshot across sources) beyond the schema, compensating for missing parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool pulls a 30/60/90-day snapshot for one post across multiple signal sources, listing specific metrics (GSC clicks, Matomo visits, etc.). It distinguishes from siblings like 'posts.list' or 'posts.decay_curve' by focusing on a comprehensive per-URL aggregation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for a unified snapshot of a single post's performance but does not explicitly state when to use vs. alternatives like 'gsc.quick_wins' or 'posts.verdict'. No when-not-to or exclusion criteria are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

posts.verdictVerdict per post (refresh / expand / merge / kill / double_down / hold)A
Read-only

Run the rule-based verdict engine on a single post: combine snapshot + decay curve and emit a verdict with reason codes and a 0-1 confidence score.

Reason codes are deterministic. The mapping reasons -> verdict lives in src/verdict/rules.ts and can be inspected.

Reporting only - does NOT mutate anything. To act on the verdict, hand the brief to a writer or to an AI rewrite tool.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesCanonical URL of the post.
windowNo
persistNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
urlYes
verdictYes
reasonsYes
confidenceYes
evidenceYes
reason_stringsYes

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, and the description confirms 'does NOT mutate anything', adding detail about deterministic reason codes and the composition from snapshot+decay curve. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each adding value: purpose, deterministic details, and usage scope. No fluff, front-loaded with the core action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given output schema exists (so return values are covered), the description fully covers tool purpose, behavioral constraints, and mapping location. It is complete for its complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is low (33%, only url has description). The description does not explain the 'window' or 'persist' parameters, relying on the schema enum/default. With low coverage, the description should compensate but does not.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it runs a rule-based verdict engine on a single post, combining snapshot and decay curve to emit a verdict with reason codes and confidence score. It distinguishes from sibling tools like posts.refresh_brief by focusing on verdict generation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states 'Reporting only - does NOT mutate anything' and directs agents to hand the brief to a writer or AI rewrite tool to act on the verdict. It also mentions the deterministic rules file for inspection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 8 tool updatesv0.1.1
    • First observedcohort.report
    • First observedgsc.quick_wins
    • First observedposts.cite_loss
    • First observedposts.decay_curve
    • First observedposts.list
    • First observedposts.refresh_brief
    • First observedposts.snapshot
    • First observedposts.verdict

TDQS

A4.1/5.0
Disambiguation5/5

Each tool targets a distinct operation: cohort aggregate analysis, GSC quick wins, citation loss, decay curve, post discovery, brief generation, snapshot, and single-post verdict. No two tools overlap in purpose, and descriptions clearly differentiate them.

Naming Consistency5/5

All tools follow a consistent dot-separated category.action pattern (e.g., posts.list, posts.snapshot, gsc.quick_wins) with lowercase and underscores. No deviations or mixed conventions.

Tool Count5/5

Eight tools is well-scoped for an SEO performance server. Each tool addresses a specific step in the analysis workflow without being excessive or insufficient.

Completeness4/5

The tool set covers the core workflow: discovery, data gathering, trend analysis, verdict, and reporting. Missing are direct action tools (e.g., rewrite or update posts), but this is by design—the brief serves as a hand-off. Minor gap in not having a cohort comparison tool.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • A
    license
    B
    quality
    B
    maintenance
    Professional Google Search Console MCP server providing 40+ SEO tools for performance analysis, content decay, CTR opportunities, and more, enabling real search data in clients like Cursor and Claude.
    40
    19
    6
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Open-source MCP server that audits websites for AI search readiness, providing deterministic scoring (0-100) and prioritized fix lists for metrics like JSON-LD, llms.txt, heading hierarchy, and AI crawler access.
    1
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    An MCP server that pulls PageSpeed Insights and Google Search Console data across multiple owned sites, enabling cross-site performance reports and synthesis via Claude.
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AutomateLab-tech/seo-performance-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server