SEO Performance MCP
The SEO Performance MCP is a read-only, data-driven content audit server that unifies SEO and analytics signals from multiple sources (Google Search Console, Matomo/GA4, Microsoft Clarity, AI citation tracking) and runs a deterministic rule engine to produce actionable verdicts for every content URL.
What you can do:
Discover content inventory — enumerate posts from XML sitemaps, Ghost CMS, or custom JSON lists, with metadata (title, publish date, age, tags); filter by age or publish date.
Pull unified per-URL snapshots — fetch 30/60/90-day rollups combining GSC (clicks, impressions, CTR, position, top queries), Matomo/GA4 (visits, dwell time, bounce rate, pageviews), Microsoft Clarity (scroll depth, rage clicks), and AI citation counts — all in one call.
Analyze traffic decay/growth trends — bucket weekly GSC data to get a
decay,plateau, orgrowthtrend label with a decay percentage.Get per-post content verdicts — run the rule engine on a single URL to receive a verdict (
refresh,expand,merge,kill,double_down, orhold) with reason codes, supporting evidence, and a 0–1 confidence score. Rules and thresholds are customizable.Generate markdown refresh briefs — produce ready-to-hand-off briefs for editors or AI agents, including verdict, raw numbers, top queries, and suggested actions.
Run full cohort audits — score and rank your entire post library by verdict priority and confidence to answer "which three posts should I refresh this week?"
Track AI citation losses — identify which LLMs previously cited a URL but no longer do, including last-seen date and the replacing URL.
Find quick-win title rewrite opportunities — surface (page, query) pairs at positions 5–15 with impressions above a threshold but CTR below the position-expected curve.
It integrates seamlessly with AI clients (Claude, Cursor), can run as a GitHub Action, or be used via a one-shot CLI. All operations are read-only — no content is mutated.
Supports post discovery via XML sitemap for Astro sites.
Supports post discovery via XML sitemap for Framer sites.
Optional integration for richer metadata via Ghost Admin API.
Allows running tools as a GitHub Action on a cron schedule, outputting results to issues or PRs.
Provides clicks, impressions, CTR, position, and top queries data for each URL.
Supports post discovery via XML sitemap for Hugo sites.
Provides visits, dwell time, and bounce rate analytics data.
Supports post discovery via XML sitemap for Next.js sites.
Supports post discovery via XML sitemap for Notion-as-a-site.
Supports post discovery via XML sitemap for Squarespace sites.
Supports post discovery via XML sitemap for Substack mirror sites.
Supports post discovery via XML sitemap for Webflow sites.
Supports post discovery via XML sitemap for Wix sites.
Supports post discovery via XML sitemap for WordPress sites.
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-mcpIn 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:
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.Ghost Admin API - if both
GHOST_ADMIN_API_URLandGHOST_ADMIN_API_KEYare set, Ghost is used as a richer metadata source. Optional.HTML extraction - per-URL
og:title,article:published_time, and JSON-LDdatePublishedare read live from the URL.XML sitemap - set
POSTS_SITEMAP_URLto 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 with |
| Per-URL unified rollup for a 30/60/90-day window: GSC + Matomo + GA4 + Clarity + citations + meta. |
| Weekly GSC clicks/impressions/position buckets + a |
| Verdict ( |
| Markdown brief for a human or downstream LLM editor: numbers, top queries, suggested actions. |
| Cohort verdict table sorted by priority + confidence. "Which three posts should I refresh this week?" |
| LLM citations that dropped off for a given URL. Needs |
|
|
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 |
| Tool output as a multi-line string (markdown or JSON, per |
| Path of the file the tool output was written to. Hand to |
| For |
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 markdownSame 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. Composesgsc_quick_wins+cohort_report+posts_cite_lossinto 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.mdcin 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 |
|
|
|
|
|
|
Verdict engine
Deterministic, rule-based, traceable. Reason codes:
ctr_below_position_expectedposition_driftdecay_30d_over_30pct/decay_60d_over_50pctstagnant_no_clicksthin_content_low_dwellrising_impressions_low_ctr/rising_clicks_continue_investmentcitation_loss/citation_growthduplicate_or_cannibalizinghigh_bounce_low_scrollfresh_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 # vitestLicense
MIT
Available Tools
8 toolscohort.reportCohort report across postsARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| urls | No | Explicit list of post URLs to include. Overrides sitemap discovery. | |
| sitemap_url | No | Sitemap URL to enumerate the cohort. Falls back to POSTS_SITEMAP_URL env var. | |
| window | No | ||
| min_age_days | No | ||
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| rows | Yes |
TDQS
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.
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.
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.
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.
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.
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)BRead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| min_position | No | ||
| max_position | No | ||
| min_impressions | No | ||
| window | No | ||
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| wins | Yes |
TDQS
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.
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.
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.
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.
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.
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 URLARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Canonical URL of the post. |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| active | Yes | |
| losses | Yes |
TDQS
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.
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.
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.
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.
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.
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 curveARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Canonical URL of the post. | |
| weeks | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| buckets | Yes | |
| trend | Yes | |
| decay_pct | Yes |
TDQS
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.
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.
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.
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.
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.
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 platformARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| sitemap_url | No | URL of an XML sitemap to enumerate posts. Overrides POSTS_SITEMAP_URL env var. Required if neither POSTS_SITEMAP_URL nor POSTS_LIST is set. | |
| urls | No | Explicit list of post URLs to return directly, bypassing sitemap discovery. | |
| since | No | ISO date - only return posts published after this date. | |
| min_age_days | No | Skip posts younger than this many days. | |
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| posts | Yes |
TDQS
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.
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.
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.
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.
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.
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 postARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Canonical URL of the post. | |
| window | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| markdown | Yes |
TDQS
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.
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.
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.
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.
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.
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 snapshotARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Canonical URL of the post to snapshot. | |
| window | No | ||
| persist | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| meta | Yes | |
| window_days | Yes | |
| gsc | Yes | |
| matomo | No | |
| ga4 | No | |
| clarity | No | |
| citations | No | |
| cannibalization | No |
TDQS
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.
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.
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.
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.
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.
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)ARead-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.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Canonical URL of the post. | |
| window | No | ||
| persist | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| verdict | Yes | |
| reasons | Yes | |
| confidence | Yes | |
| evidence | Yes | |
| reason_strings | Yes |
TDQS
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.
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.
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.
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.
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.
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.
8 tool updates
v0.1.1- First observed
cohort.report - First observed
gsc.quick_wins - First observed
posts.cite_loss - First observed
posts.decay_curve - First observed
posts.list - First observed
posts.refresh_brief - First observed
posts.snapshot - First observed
posts.verdict
TDQS
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.
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.
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.
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
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
- RampifyOAuthdev.rampify
SEO MCP server: crawl your site, find AI-visibility gaps, and ship the fix from your coding agent.
- CalmSEOOAuthcom.calmseo
SEO MCP server for keyword research, SERP analysis, audits, and Search Console workflows.
Turn Search Console data into SEO actions, content, publishing, indexing, and AI insights.
Free technical-SEO audit MCP: crawl a site, run checks, return an LLM-ready shareable report.
Related MCP Servers
- AlicenseBqualityBmaintenanceProfessional 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.40196MIT
- AlicenseNot gradedqualityCmaintenanceOpen-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.1MIT
- AlicenseNot gradedqualityAmaintenanceAn open-source, local-first MCP server for automated Schema.org JSON-LD generation, GA4 metric validation, /llm.txt auditing, and content stickiness analytics.MIT
- AlicenseNot gradedqualityBmaintenanceAn 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
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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