Skip to main content
Glama
Unilytics MCP Server

Unilytics MCP Server

Official

Unilytics MCP

Connects Claude Desktop and other MCP clients to your Unilytics account: your saved skills, your clients' context and Knowledge Base, and the SEO, content and AEO research tools.

You don't need to install Node, edit a config file or keep your key in a text file.

  1. Create an API key in the Unilytics app: Settings → API Keys.

  2. Download unilytics.mcpb and double-click it. Claude Desktop opens the install screen.

  3. Click Install, paste your API key when Claude asks for it, and make sure the extension is switched on.

  4. In the chat box, click the settings icon → Tool access → Load tools when needed. Unilytics has many tools, and with "Tools already loaded" Claude leaves them out of the chat.

  5. Start a new chat and ask: "List my projects on Unilytics."

Full guide: Install the Unilytics extension for Claude Desktop.

Prefer not to use a key? Claude can also connect with one link and your Google account: see Connect Claude to Unilytics.

Related MCP server: gsc-mcp-rs

Other MCP clients (npm)

For Claude Code and other stdio clients. Needs Node 18 or newer.

claude mcp add unilytics --scope user --env UNILYTICS_API_KEY=ulk_live_your_key -- npx -y @unilytics/mcp-server

Any client with an mcpServers config:

{
  "mcpServers": {
    "unilytics": {
      "command": "npx",
      "args": ["-y", "@unilytics/mcp-server"],
      "env": { "UNILYTICS_API_KEY": "ulk_live_your_key" }
    }
  }
}

On Windows, use "command": "cmd" and "args": ["/c", "npx", "-y", "@unilytics/mcp-server"].

Pass the key with UNILYTICS_API_KEY (recommended) or --api-key=ulk_live_xxx.

Tools

The tools are served by Unilytics, so new and changed tools reach you without updating anything here. Your AI lists every tool when it connects. Some use credits from your account. These are the groups, with a few tools from each:

Group

What it's for

For example

Skills

Find, read and write your saved playbooks

find_skill, list_skills, get_skill, create_skill, update_skill

Client context

Each client's Brand Kit, Context records and settings

list_projects, get_project_context, propose_context_record, propose_brand_kit, list_context_gaps

Knowledge Base and files

Store and search each client's documents, pages and files

kb_search, kb_write_text, kb_add_urls, upload_file_to_project, create_upload_link

SEO research

Keywords, search results, on-page checks and page speed

keyword_research, serp_results, on_page_audit, page_speed_audit, google_trends

AEO and AI search

Prompts to track, and how AI answers mention and cite a brand

aeo_generate_prompts, aeo_prompt_volume, brand_visibility, ai_citation_check

Web pages

Read, crawl and screenshot websites

content_scrape, js_scrape, site_crawl, site_map, page_screenshot

Competitors and ads

Watch competitor pages for changes and see the ads they run; browse ad audiences for your own campaigns

watch_competitor, get_competitor_changes, google_ads_transparency, audience_segments

Account

Your credit balance, and which accounts are linked to a project in the app (it doesn't read their data)

get_credit_balance, list_connections

Competitor watches (watch_competitor) run on a schedule, and each run uses credits.

What isn't included

  • Google Search Console and GA4 data. Unilytics doesn't serve your first-party analytics. Connect your AI to them with your own connector (for example a Search Console or GA4 MCP server), and the skills use it.

  • Backlinks, ranking keywords, top pages and traffic history. Use your own Semrush or Ahrefs connection.

How it works

A thin stdio-to-HTTP bridge. Your MCP client talks to it over stdin/stdout, and it forwards each message to https://mcp.unilytics.ai/mcp with your key. Everything runs server-side; the bridge stores nothing.

If a request fails, your AI gets an error saying what to do. A failed tool call is never retried automatically, because the first attempt may have finished and used credits.

Versions and updates

The version in package.json is the only version number: the manifest is stamped from it at build time, and src/version.ts is pinned to it by a test.

  • Releasing. Merging a new version to main publishes unilytics.mcpb as GitHub release v<version> (.github/workflows/release.yml), after the tests pass on the packed file on Linux, macOS and Windows. Published releases are immutable (a repository setting). If a run fails, re-run it from the Actions tab (Release → Run workflow). npm is a separate, manual npm publish from the same commit.

  • Download URLs. releases/latest/download/unilytics.mcpb always serves the newest release. Every version keeps its own URL (releases/download/v1.1.0/unilytics.mcpb) for rollback.

  • Verify a download. gh attestation verify unilytics.mcpb --repo TeamUnilytics/unilytics-mcp

  • No auto-update. Claude Desktop doesn't update extensions installed from a file. New and changed tools arrive from the server with no reinstall. A bridge release is for a bug or security fix in the bridge itself, and users get it by double-clicking the new file, which replaces the old version.

  • Keep old bridges working. Installed copies stay in use indefinitely, so the server must keep speaking MCP over Streamable HTTP at https://mcp.unilytics.ai/mcp, answering each POST with a JSON response, not an SSE stream, and tool changes reach them as ordinary tools/list changes. The bridge can only report a failed reply when the POST itself fails. If a stream dropped, a request would wait until the client's own timeout. npm run test:live checks this against the live endpoint. The User-Agent (unilytics-mcp-bridge/<version>) shows which versions are still in use. Before retiring a version or shipping a security fix, tell users through the app and the changelog.

  • Never rename. name and author.name in mcpb/manifest.json form the extension's id. Changing either makes Claude Desktop treat an update as a different extension, with a second copy and a lost key. The default URL can't change either: the bridge refuses cross-origin redirects, because the key travels with every request.

Development

npm ci
npm test                # bridge tests
npm run build:mcpb      # dist-mcpb/unilytics.mcpb
npm run test:mcpb       # unpacks it outside the repo and runs the same tests on it
npm run test:live       # the live endpoint still answers with JSON (no key needed, uses a made-up one)
npm run test:docs       # every tool this README and the manifest name is still served (also weekly in CI)

Only the packages allowed in scripts/build-mcpb.mjs may enter the bundle. The build stops if a dependency update brings in another one.

Available Tools

87 tools
add_skill_to_folderA
Idempotent

Attach a skill to a folder by reference (the skill's files stay in the skill store).

Records that the folder contains the skill; the skill's files aren't copied. A repeat with the
same skill changes nothing. Attaching takes the owner, an admin or an editor role on the
folder's project; a viewer's call changes nothing.

Args:
    folder_id: The folder ID (from list_folders or create_folder).
    skill_id: The skill ID to attach.

Inputs: skill_id (required), folder_id (required).

add_tracked_keywordsA
Idempotent

Add tracked keywords, competitors, and/or target locations to a project.

Appends to the project's existing lists (no duplicates, ignoring letter case; nothing removed),
with the same checks as the project's Settings in the Unilytics app: at most 500 keywords, 200
competitors and 200 locations per project, each item up to 200 characters (a competitor 2,048).
A refusal names the list and the limit, and nothing is saved. At least one of keywords,
competitors or locations is required. Changing a project takes the owner, an admin or an editor
role on it; a viewer's call changes nothing.

The result has `changed` (false when every item was already tracked), the number of items now
in each list (`keywords_tracked`, `competitors_tracked`, `locations_tracked`) and
`settings_rev`, the version of the project's settings after the change.

Args:
    project_id: The project UUID (from list_projects or create_project).
    keywords: Keywords to add — a list, a JSON list as text, or a comma-separated string.
    competitors: Competitor domains to add — a list, a JSON list as text, or a comma-separated string.
    locations: Target locations to add — a list, a JSON list as text, or a comma-separated string.

Inputs: project_id (required), keywords, locations, competitors.

add_tracked_promptsA
Idempotent

Add AEO prompts to track for a project (questions sent to AI answer engines).

EXPECTED SHAPE — each prompt is an object with at minimum a `text` field:
    {"text": "best managed file transfer tools", "topic": "MFT",
     "tags": ["mft"], "prompt_type": "category"}
Only `text` is required. Optional: topic, tags (list or comma-string),
prompt_type ("brand"|"category", default "category"), regions, language,
personas, platforms, analysis_types.

A sheet or CSV maps onto this shape column by column (e.g. "Prompt" -> text, "Topic" -> topic,
"Tags" -> tags). Invalid rows come back as a structured error naming each problem. Prompts
already tracked (ignoring letter case) are skipped. Adding prompts takes the owner, an admin or
an editor role on the project; a viewer's call changes nothing.

The same limits apply as in the Unilytics app: the customer's tracked-prompt allowance (set by
Unilytics for the account that owns the project, counting active prompts across all its
projects; paused prompts don't count) and a per-project ceiling on active prompts. A call over
a limit adds nothing, and its error message says which limit. The result has `imported`,
`skipped_duplicates` and `total` (the project's active prompts after the add); the paying
customer's own accounts also get `cap`, `tracked` and `allowance` (the limit that applied, the
customer's active prompts across its projects, and its allowance).

Args:
    project_id: The project UUID (from list_projects or create_project).
    prompts: List of prompt objects (see shape above).

Inputs: prompts (required), project_id (required).

aeo_audit_promptsB
Read-only

Audit a tracked-prompt set — per-prompt intent, realistic metric, play, and a keep/cut/ rewrite recommendation. prompts = [{id, text, intent?, mention_rate?, citation_rate?}], at most 80 per call, each text up to 300 characters. With use_llm (the default) the prompts are sent to OpenAI for classification.

[Provider: OpenAI]

Inputs: prompts (required), use_llm.

aeo_cluster_by_urlsA
Read-only

Cluster prompts by shared Google SERP URLs, then assign each cluster a page.

Greedy centroid assignment on an ABSOLUTE shared-URL count (no transitive chaining). A join on
exactly one shared URL is allowed only if that URL is specific (low corpus document frequency),
is not a generic hub host, and the prompt is not a brand comparison — and such joins are NEVER
auto-accepted (they come back with needs_review=true). Query-drift SERPs are quarantined.
Page assignment is rank-weighted: a rank-1 brand hit outweighs a rank-10 one.

items = [{id, text, impressions?, serp: [{url, rank, near_miss}], serp_urls?: [...] (legacy),
          citation_urls?: [...] (a SEPARATE signal — never joins clusters), spell?, mapped_pages?}]
config = per-project {brand:{domain, owned_domains[]}, competitors[], cluster:{T, one_shared_max_df, hub_hosts,...},
         signals:{a_min_hits, a_high_confidence_max_rank}} — nothing client-specific is hardcoded.
         brand.owned_domains = the brand's other domains (e.g. "example.com" for a site on blog.example.com).

At most 80 items per call, each text up to 300 characters.

Returns {clusters (with prompt_ids), assignments (prompt_id → cluster_id, mapped page, signal, confidence),
n_items, n_clusters, needs_review, n_quarantined, caveat}. A mapped brand page is a path ("/pricing") on the
brand.domain host, or a full URL on any other host of brand.domain or brand.owned_domains
("https://docs.example.com/setup").

Inputs: items (required), config, page_inventory.

aeo_cluster_promptsA
Read-only

Group prompts into topic clusters by text embedding similarity. items = [{id, text, intent?, volume?}], at most 140 per call, each text up to 300 characters. Returns {clusters (members: id, text), n_items, n_clusters}. The prompts are sent to OpenAI for embeddings.

[Provider: OpenAI]

Inputs: items (required), brand, distance_threshold.

aeo_filter_promptsA
Read-only

Clean an imported keyword/prompt list — remove junk (operators, year-stamps, foreign, geo, brand-variants, other-brands, dupes). items = [{text}] or [str], at most 175 per call, each up to 300 characters. Returns {kept, removed, summary}.

Inputs: items (required), brand, geo_target, competitor_domains.

aeo_generate_promptsC
Read-only

Propose additional natural-language AEO prompts for a topic, intent-balanced + deduped. The topic and existing prompts are sent to OpenAI.

[Provider: OpenAI]

Inputs: topic (required), brand, target_count, primary_intent, +1 more.

aeo_prompt_volumeB
Read-only

AI search-volume estimate for a prompt (expensive multi-API pipeline). Returns {volume, bucket}.

[Provider: DataForSEO]

Inputs: prompt (required), topic.

aeo_serp_urlsA
Read-only

Top Google organic results for a keyword/prompt, WITH RANK (Google US).

Returns {status: "complete", results: [{url, rank, near_miss}], urls: [top-N urls], spell, fetched_at}.
Fetches the top-20; top_n is 1 to 20 (default 10). `near_miss` marks ranks beyond top_n (a real ranking, but
weak evidence — use it to find refresh candidates, not to claim the page ranks). `spell` carries Google's
did_you_mean / showing_results_for so callers can detect query drift. `unresolved_dropped` (when present)
counts results left out because Google gave only a redirect link that couldn't be resolved to the page;
`partial: true` means some of the SERP's pages couldn't be retrieved.

Fetching a SERP takes about 1 to 3 minutes (Google's result links are resolved to each page's own URL), so a
call either returns it or answers `status: "pending"`. A later call with the same keyword returns the same SERP
once it is ready, waiting up to about 45 seconds for it, and within 6 hours of its fetch (`fetched_at`)
returns it again without fetching it anew.

[Provider: DataForSEO]

Inputs: keyword (required), top_n.

aeo_site_pagesA
Read-only

Discover a site's sitemaps via robots.txt. Returns {site, sitemaps:[{url,url_count,is_index,error?}]}.

Public websites only (http/https, ports 80/443): a site that is or redirects to a private, loopback or
link-local address returns {error: "refused: …"}.

Inputs: site (required).

ai_citation_checkA

Start a check of which sources AI answer engines cite for up to 5 prompts, and how often they cite a brand's own domain.

Asks each prompt `runs` times on each engine: chatgpt and gemini (their consumer apps), google_ai_mode,
google_ai_overview, claude (Claude Sonnet 5.5 with web search) and perplexity. Returns a job_id at once;
Claude and Perplexity answer during this call, Google AI Mode usually within a minute, ChatGPT and Gemini within
about 5 minutes. get_ai_citation_check(job_id) returns the results: per engine and per prompt, citation rate
(answers citing the brand's domain ÷ answers citing any source), citation share (the brand's citations ÷ all
citations), mention rate and share of voice when names are given, every cited URL and domain with its source
category (owned, competitor, social, institution, pr_wire, earned), and the category mix per segment. The
engines' answer text is not returned.

Billing: the measured vendor cost of this call (about 65 credits per prompt per run with all six engines;
claude is most of it). A check that starts nothing is not charged. The same check repeated within 15 minutes
is refused (CHECK_EXISTS, not charged) with the first check's job_id. At most 3 checks run at once per user;
Claude and Perplexity together answer at most 20 times per check.

Use when the user asks which sources ChatGPT, Gemini, Google AI Mode/Overviews, Claude or Perplexity cite for
a query, a domain's citation rate or citation share in AI answers, or a citation-mix analysis.

Args:
    prompts: 1–5 questions a customer might ask an AI assistant, each up to 700 characters.
    project_id: Optional Unilytics project (from list_projects); its domain is the brand's domain and its
        competitor URLs count as competitors, unless given below.
    brand_domain: The brand's own domain (e.g. "hubspot.com"); required without a project_id that has one.
    competitor_domains: Up to 20 competitor domains, added to the project's.
    brand: Optional brand name, for mention rate.
    competitor_names: Up to 20 competitor names, for share of voice.
    segments: Optional label per prompt (same order), for the citation mix per segment.
    engines: Subset of chatgpt, gemini, google_ai_mode, google_ai_overview, claude, perplexity (default all).
    runs: Times each prompt is asked per engine, 1–3 (default 1); answers vary run to run.
    country: Searcher location: US, GB, CA, AU, IN, DE, FR, ES, IT, NL, BR, MX, SG, AE, IE, NZ or ZA.
    language_code: en, de, fr, es, it, nl or pt (the scraped engines' interface language).

[Provider: DataForSEO (ChatGPT, Gemini, Google AI Mode, Google AI Overviews), Anthropic (Claude), Perplexity]

Inputs: prompts (required), runs, brand, country, +7 more.

answer_context_gapA

Save the answer to one of a client project's Context gaps as a draft of the Context record the gap is about (for example Audience › Ideal customer profile), with the sources it comes from. The gap then reads answered. The draft waits on the project's Context page, where the consultant publishes or discards it; publishing resolves the gap. The published Context stays unchanged until then. This tool doesn't publish, discard or delete.

Use when the user answers a gap's question, for example while going through list_context_gaps with them.

`body` is the record's whole text, written from the answer. Every answer cites at least one source: the user's own
words (`user_statements`, recorded as quotes reported by the AI, not verified) and/or Knowledge Base documents
(`kb_sources`, each with the content_hash kb_get_document returned, which is refused once the document has
changed). A record that already has a draft waiting for review takes no new draft, except one that replaces this
connection's own earlier draft.

Args:
    project_id: The project (from list_projects()).
    gap_id: The gap's gap_id from list_context_gaps.
    body: The record's full text, in Markdown.
    published_revision_number: The gap's published_revision_number from list_context_gaps (null for a `missing`
        gap). A record published again since is refused.
    title: Optional record title. Default: the current title, or the context type's name for a new record.
    kb_sources: Knowledge Base documents the answer comes from: [{document_id, content_hash}].
    user_statements: The user's own words the answer comes from, quoted exactly.
    replace_draft_number: The draft_number an earlier call returned (or the gap's answer.draft_number), to replace
        that draft with this one.
    proposal_id: Optional UUID for this answer. A repeat with the same proposal_id and arguments returns the saved
        draft instead of saving another; an OUTCOME_UNKNOWN error names the one it used.

[Provider: Unilytics]

Inputs: body (required), gap_id (required), project_id (required), published_revision_number (required), +5 more.

append_skill_memoryA

Add one entry (a learning, workaround or preference) to a skill's memory.

Use to record what a run of the skill taught: something that failed, a faster order, or a
preference the user stated. Works on built-in and Unilytics skills too: the entry goes to the
user's own memory of that skill and the skill text is unchanged. Returns memory_full once the
memory reaches its limit (4,000 entries or 256 KB of text); compact_skill_memory then condenses
it, one page of entries at a time.

Args:
    skill_id: The skill the learning belongs to.
        A bare name (the last part of an id, e.g. "keyword_research" or a skill's own name) is
        accepted when exactly one skill the user can use has it; the result then carries `resolved`
        with its full id. A name several skills share is not_found with their full ids in
        `did_you_mean`, and so is a project skill's name: its memory is shared with the project's
        members and is written only by its full id.
    text: The learning/workaround/preference to remember (one concise entry).

Inputs: text (required), skill_id (required).

approve_skill_proposalA
Read-only

Return the Agent Inbox link where the user approves an open skill proposal. Approval is a click in the Unilytics app, by design: this tool never approves, applies or changes a proposal.

Use when the user asks to approve, accept or apply a proposal. Read-only.

Args:
    proposal_id: From list_skill_proposals (prp_…).

Inputs: proposal_id (required).

audience_recommendationsA
Read-only

Suggest audience signals for a Google Ads campaign from Google Ads' fixed audience catalog.

Matches the first few keywords against the catalog's in-market and affinity segment names (a text
match, not a model) and adds demographic and bid-modifier suggestions for the campaign type.

Args:
    keywords: Target keywords for the campaign (e.g. ["hotels in goa", "beach resorts"])
    campaign_type: "standard" or "pmax" (Performance Max). Default: "standard"
    industry: Business industry (e.g. "travel", "ecommerce", "saas"). Default: "general"

Inputs: keywords (required), industry, campaign_type.

audience_segmentsA
Read-only

Browse Google Ads audience segments for campaign targeting.

Returns available audience segments filtered by type and optional search query.

Args:
    segment_type: Segment type — "IN_MARKET", "AFFINITY", or "LIFE_EVENTS"
    query: Optional filter (e.g. "fitness", "travel") to narrow results

Inputs: query, segment_type.

author_skillA
Read-only

Return Unilytics' guide to writing a skill, plus a starter SKILL.md template.

The guide covers progressive disclosure, gotchas, sub-agents, measured gates, trigger descriptions, the self-learning loop and how to import an existing document word for word. Use when the user asks to create, port or restructure a skill.

Inputs: no named parameters.

batch_scrapeA
Read-only

Scrape multiple URLs in a single call (up to 10 URLs).

Firecrawl processes all URLs in parallel — much faster than scraping one
by one. Use for competitor analysis, content gap analysis, SERP page
comparisons, link prospecting, or any task requiring data from multiple pages.

Returns one entry in `pages` per requested URL, in the order you sent them. Each has
`url` (as requested), `final_url` (only if it redirected), `status_code`, and `error`
when the page failed (4xx/5xx, DNS failure, timeout, blocked); a failed URL is never
dropped. Successful pages also carry title, description, h1–h3 headings and markdown
`content`. Content is capped at 15,000 characters per page, and lower when many long pages
share one reply (`content_cap_chars` is the cap used): `truncated` says whether a page was
cut, `original_chars` is its full length and `word_count` counts the whole page; content_scrape
returns one page in full.
URLs beyond the first 10 are not scraped and come back in `urls_not_scraped`; a URL sent
twice is scraped once and listed in `duplicate_urls_ignored`. Every URL must start with
http:// or https:// (one that doesn't gets an `error` page; the others still run).

Args:
    urls: List of URLs to scrape (max 10)
    js_rendering: Wait for JavaScript rendering on each page (default: False)

[Provider: Firecrawl]

Inputs: urls (required), js_rendering.

brand_visibilityA
Read-only

Measure how ChatGPT (OpenAI), Claude (Anthropic) and Perplexity represent a brand when asked one prompt.

Each engine answers the prompt, and Unilytics analyzes each answer. Returns, per engine: status, model,
whether the brand is mentioned, its position among the brands named (1 = named first), sentiment toward the
brand (positive / neutral / negative), which of the given competitors the answer names and their positions,
and the URLs and domains the engine cited (Perplexity is the only engine that returns citations). Also returns
a summary (engines analyzed, engines mentioning the brand, engines failed). The answer text itself is not
returned, and competitors that weren't given aren't listed. An engine that fails is reported with a status code
(engine_failed, analysis_failed, timed_out), never as "not mentioned"; when no engine can be analyzed the call
is an error and is not charged.

Use when the user asks whether AI assistants mention or recommend a brand, where it ranks against competitors
in AI answers, how AI describes it, or which sources Perplexity cites for a query. One prompt per call. The
credits charged depend on the engines analyzed: 8 when all three are, 5 for two, 3 for one.

Args:
    prompt: The question a customer might ask an AI assistant (e.g. "What is the best CRM for startups?"),
        up to 2,000 characters.
    brand: The brand to look for in the answers (e.g. "HubSpot"), up to 100 characters.
    competitors: Optional competitor brand names to track in the same answers (up to 20); only these are
        reported in competitors_named.

[Provider: OpenAI, Anthropic, Perplexity (answers); OpenAI (analysis)]

Inputs: brand (required), prompt (required), competitors.

check_competitor_nowA

Run an immediate check of one of the user's monitored competitors, outside its schedule.

Use when the user wants a fresh check, e.g. right after creating a monitor or
when a competitor may have just shipped something. Each run is billed; its
results reach get_competitor_changes shortly after. A stopped monitor can't run.

Args:
    monitor_id: ID returned by watch_competitor() or list_competitor_monitors().

[Provider: Parallel AI]

Inputs: monitor_id (required).

compact_skill_memoryA
Destructive

Replace a page of a skill's memory entries with one summary entry (for a memory that is full).

Replaces exactly the entries a get_skill_memory read showed (its `page`) with `summary`, which is
added as the newest entry; every other entry is kept. A full memory is condensed page by page:
an oldest_first read, then this tool on its page, until there is room. An entry no read showed
is never replaced: page_changed when the page's entries changed since the read, range_required
without a page or up_to (or when up_to covers more than one read), and stale_read when up_to
comes from a read older than a later compaction. Irreversible for the replaced entries.

Args:
    skill_id: The skill whose memory to compact.
        A bare name (the last part of an id, e.g. "keyword_research" or a skill's own name) is
        accepted when exactly one skill the user can use has it; the result then carries `resolved`
        with its full id. A name several skills share is not_found with their full ids in
        `did_you_mean`, and so is a project skill's name: its memory is shared with the project's
        members and is written only by its full id.
    summary: The distilled summary of durable lessons to keep.
    up_to: The older form: the `as_of` of a newest-first read; replaces every entry up to it.
    page: The `page` value of the get_skill_memory read whose entries the summary covers.

Inputs: summary (required), skill_id (required), page, up_to.

content_scrapeC
Read-only

Scrape a web page and extract its content, headings, and structure.

Args:
    url: Full URL to scrape (e.g. "https://example.com/blog/post")
    include_metadata: Include meta tags and OpenGraph data (default: False)

[Provider: Firecrawl]

Inputs: url (required), include_metadata.

create_folderA

Create a folder (Context) inside a project to organize skills + files.

A folder groups a related set of skills (e.g. a "Content Refresh" folder),
its knowledge-base files, and its memory: the project's working context. Creating one
takes the owner, an admin or an editor role on the project; a viewer's call changes nothing.

Args:
    project_id: The project UUID (from list_projects or create_project).
    name: The folder name (e.g. "Content Refresh").

Inputs: name (required), project_id (required).

create_projectA

Create a new Unilytics project for the authenticated user.

Use when the user asks to set up a new client or project. Returns the new project_id, which the
other project tools take.

The project is created exactly as in the Unilytics app, with the same checks: the plan's project
limit (at the limit the result is `project_limit_reached` with the plan's numbers, and nothing is
created), and the same field rules (at most 500 keywords and 200 competitors, each up to 200
characters, a competitor 2,048; the website a public domain). With a website, Unilytics queues an
import of the site's pages from its sitemap into the project's Knowledge Base (`sitemap_import_queued`).

The result carries `request_id`. A call with the request_id of an earlier one and the same arguments
returns the project that call created (`replayed: true`) instead of creating another, for 24 hours.

Args:
    name: The project / brand / business name (required).
    domain: The project's website URL (optional, e.g. "example.com").
    keywords: Keywords to track — a list, a JSON list as text, or a comma-separated string.
    competitors: Competitor domains — a list, a JSON list as text, or a comma-separated string.
    industry: The project's industry (optional).
    request_id: Optional UUID for this create, e.g. from an outcome_unknown error; left out, a new one is used.

Inputs: name (required), domain, industry, keywords, +2 more.

create_skillA

Save a new editable skill (a SKILL.md playbook) for the user or one of their projects.

Use when the user asks to create a skill, save a method as a skill, customize a built-in or
Unilytics skill, or share one of their own personal skills with a client team by copying it into
that client's project (extends="<skill_id>" seeds the copy with that skill's files). Reference and
data files are added afterwards with update_skill. Refuses a name the owner already uses, and a
skill_markdown whose frontmatter (name and description between --- lines) is missing or broken
(invalid YAML, a repeated key, not key: value lines, a requires: block that isn't schema 1), or
whose description is over 1,024 characters (skill_md_invalid). The result's `lint`
lists authoring findings on the saved skill (lint-v1 rule ids, each with a message and a fix);
findings don't stop the save.

File layout (a skill is SKILL.md plus supporting files):
  - SKILL.md        the workflow and its definition of done; short, linking to the files below.
  - reference/*.md  documents read when a step needs them (style guides, pipelines).
  - data/*          assets the skill carries, including runnable scripts such as a
                    data/verify_row.py checker; get_skill lists them as data_files.

Args:
    name: Skill name: the title people see (unless SKILL.md sets metadata.title); its slug is the
        last part of the skill id. Required.
    skill_markdown: The SKILL.md contents (frontmatter + workflow). Required
        unless `extends` is given (then it's seeded from the built-in, but you
        may override).
    description: Short description (else taken from frontmatter).
    category: Category label (e.g. "seo", "content").
    scope: "user" (private to you) or "project" (shared with collaborators).
    project_id: Required when scope="project".
    extends: The skill to copy as the starting point: a built-in id, a Unilytics skill id, or the id
        of one of the user's own personal skills (user/…). A Unilytics skill's approved version and a
        personal skill's current version are copied with all their files; a built-in (by its exact id,
        with skill_markdown left empty) is copied with its reference and data files. A personal skill
        copied with scope="project" is shared with that project's team, and the result's `copied_from`
        names the version copied. Project skills aren't copied, and a project copy whose files name
        skills outside that project (personal or another project's) is refused.
    visibility: "private" | "project" | "public".
    verbatim_source: When porting an existing document, its original text. The store runs a
        coverage-based fidelity check and returns a report: FAIL means content was condensed or
        dropped; splitting and intentional edits pass. author_skill returns the full authoring guide.

Inputs: name (required), skill_markdown (required), scope, extends, +5 more.

delete_project_fileB
DestructiveIdempotent

Delete a stored project file (removes both the S3 object and its record).

Inputs: file_id (required), project_id (required).

delete_skillA
DestructiveIdempotent

Archive one of the user's editable skills (soft delete). Built-in and Unilytics skills can't be deleted.

The user archives their own skills; a project skill is archived by the project's owner or an admin (an
editor can change it but not archive it).

Args:
    skill_id: The editable skill id (user/... or project/...).

Inputs: skill_id (required).

demographic_optionsA
Read-only

Get all available Google Ads demographic targeting options.

Returns age ranges, genders, parental status, and household income tiers with their Google Ads API enum values. Useful for building campaign targeting criteria.

Inputs: no named parameters.

dismiss_context_gapA
DestructiveIdempotent

Dismiss one of a client project's Context gaps that the consultant doesn't want to answer, with an optional reason. The gap leaves the open gaps and is listed under status "dismissed"; it can be restored on the project's Context page. A draft already saved for it stays on the Context page.

Use when the user says a gap doesn't apply to this client or isn't worth answering.

`rev` and `published_revision_number` are the gap's values as list_context_gaps returned them (or gap_rev from
answer_context_gap). A gap that changed since (someone answered, dismissed or restored it, or its record was
published again) is refused, and nothing is changed.

Args:
    project_id: The project (from list_projects()).
    gap_id: The gap's gap_id from list_context_gaps.
    rev: The gap's rev from list_context_gaps.
    published_revision_number: The gap's published_revision_number from list_context_gaps (null for a `missing`
        gap).
    reason: Optional reason, up to 1,000 characters (shown with the dismissed gap).

[Provider: Unilytics]

Inputs: rev (required), gap_id (required), project_id (required), published_revision_number (required), +1 more.

dismiss_skill_proposalA
DestructiveIdempotent

Dismiss an open skill proposal with a reason. The proposal closes, and the agents hold back the same proposal for everyone who can edit its skills: wrong for 90 days, not_now for 30 days, never_for_this_skill until the suppression is cleared in the Agent Inbox, duplicate not at all. A dismissed proposal can't be reopened.

Use when the user asks to dismiss, reject or skip a proposal. The same call repeated returns the same result.

Args:
    proposal_id: From list_skill_proposals (prp_…).
    expected_revision: The proposal's revision as last read (list_skill_proposals or get_skill_proposal). A newer
        revision is refused with current_revision.
    reason: wrong, not_now, never_for_this_skill or duplicate.
    note: Optional reason in the user's words (up to 500 characters).

Inputs: reason (required), proposal_id (required), expected_revision (required), note.

find_skillA
Read-only

Search the user's saved skills (their own playbooks for SEO, content, AEO/GEO and client work) for a task.

Use when the user asks for a task their saved skills may cover, including work for one of their
clients: keyword research, a site audit, a content brief, an AEO or AI-visibility audit, blog
topics, a competitor comparison page, adding brand guidelines to a client's brand kit. Ranks the built-in skills, the skills provided by Unilytics, the user's own
skills and their project skills by name and description, and returns up to 3 matches, each with
its skill_id and the reason it matched. An empty `matches` means no saved skill fits the task.
No project_id is needed: without one, the skills of every project the user can access are searched.

Args:
    task: What the user wants done, in their own words (e.g. "keyword research for acme.com").
    project_id: Optional. Limits project skills to this one project.

Inputs: task (required), project_id.

get_ai_citation_checkA
Read-only

Read one of the user's AI citation checks: status, progress and every metric so far.

status is running (some engines still answering), complete, expired (runs unfinished after 24 hours), or failed
(the check didn't start; it has no results and wasn't charged). Metrics come per engine, per prompt and across
engines (each engine weighted equally), each with its numerator and denominator; a null value means nothing to
measure yet (a zero denominator), not 0%. Also returns the top cited domains (up to 30) and URLs (up to 25) with
their source category, the category mix per segment, failures by engine and the metric definitions. Free.

Args:
    job_id: From ai_citation_check.

Inputs: job_id (required).

get_competitor_changesA
Read-only

Read changes detected on one of the user's monitored competitor sites, newest first.

Each change has a stable `event_id`, so repeated polls can be told apart from
new changes. An empty result means no changes detected yet; the first scheduled
run may still be in progress, and check_competitor_now starts a run immediately.
Works on stopped monitors too (their past changes).

Args:
    monitor_id: ID returned by watch_competitor() or list_competitor_monitors().
    limit: Max changes per page (1-12; a larger value returns 12). Default 12. A long change
        summary is shortened to 4,000 characters and marked change_truncated.
    cursor: Pagination cursor from a previous call's `next_cursor`.

[Provider: Parallel AI]

Inputs: monitor_id (required), limit, cursor.

get_credit_balanceA
Read-only

Return the user's Unilytics credit balance and recent usage.

Use when the user asks about credits or before a run they want costed. Data tools are charged
their real API cost, never more than the tool's maximum, which must be available when the call
starts; a call that can't be covered returns out_of_credits with credits_needed. Skill and
project lookups are free.

Inputs: no named parameters.

get_project_configA
Read-only

Return a project's stored client settings: brand domain, competitors, industry, tracked keywords, locations.

Use when a skill or task needs client-specific values: these are the settings the user already
saved for the project. Fields with no value yet are listed under `missing`; set_project_config
stores skill-specific values.

Returns brand/competitor/industry config plus `custom` (skill-specific config
saved by set_project_config, namespaced per skill). The first 50 namespaces by name are listed
(`custom_total` counts them all when there are more). When the custom config is large, some
namespaces are listed as {"omitted": true, "chars": n} and `custom_omitted` names them; pass
`namespace` to read one of them (a very large one comes as JSON text in pages: `namespace_json`
with `next_cursor`, passed back as `cursor`). Keyword, competitor and location lists return their
first entries (up to 300, fewer when they are long) with a `*_total` count. Long text fields end
in "…"; a value too large to return (domain, aeo) is null and named with its size in
`omitted_fields`. A list stored in an older, unreadable shape is empty and named in
`unreadable_fields`.

`settings_rev` is the version of the project's settings as returned here (every field but
`custom` and the `aeo` keys outside the project's Settings); it changes whenever one of them
changes, in the app or through add_tracked_keywords.

Args:
    project_id: The project to load config for (from list_projects()).
    namespace: Optional: return only this namespace of the custom config.
    cursor: next_cursor from a previous call, for the next page of a large namespace.

Inputs: project_id (required), cursor, namespace.

get_project_contextA
Read-only

Return a client project's published Brand Kit (brand voice, audience, point of view, CTA, writing rules), its published Context records (company, offerings, audience, competitors, strategy, execution, engagement, each with its sources) and its project settings.

Use when writing or reviewing content for a client project: posts, pages, emails, briefs, outlines,
audits with recommendations. It is what the consultant has already written down for this client.

With `content_type` (a name such as "Blog post", or its id) the result also carries that type's rules
and CTA; without it, the global rules and `available_content_types`. `brand_kit.missing` lists fields
not written yet, `context_records.missing` the Context records not published yet, and `guidance` explains
how the parts relate. Long record bodies are shortened to keep the response bounded (`body_status`).

Args:
    project_id: The project to load (from list_projects()).
    content_type: Optional content type name or id (`cty_…`) from available_content_types.
    include_samples: Also return the writing samples' full text (larger). Default: titles, urls and outlines only.
    context_groups: Optional Context groups to include (company, offerings, audience, competitors, strategy,
        execution, engagement). Default: all.

[Provider: Unilytics]

Inputs: project_id (required), content_type, context_groups, include_samples.

get_project_fileB
Read-only

Get a time-limited download URL for a stored project file. Returns {download_url, name, content_type}. The URL serves the exact original bytes (e.g. the real .pptx with its design), so the stored file itself can be edited rather than rebuilt.

Inputs: file_id (required), project_id (required).

get_skillA
Read-only

Return one of the user's saved skills: its playbook text, files and how many memory entries it has.

A skill is a step-by-step playbook written by the user, their team (project skills) or Unilytics
(built-in and Unilytics skills). Returns `workflow` (the SKILL.md body), the lists of its
reference_files and data_files, `memory_entries` (learnings saved from earlier runs) and `notes`
(facts such as whether the skill is read-only). A user or project skill also has `owner_display`,
the name of the person who created it ("User" when their account has no name, "Deleted account"
when it was deleted, empty when no person is recorded); `your_role`
(owner, admin or editor can change it; a project viewer can use it, and then `read_only` is true);
and, when the version served
recorded them, `last_edited_by_display` (who saved that version) and `updated_at` (when). A copy of
one of the user's own personal skills has `copied_from` (that skill's id and the version copied),
shown only to that user.

A long workflow comes in pages of up to 40,000 characters as sent (JSON-escaped, so quotes and
line breaks count twice): `workflow_truncated` is true and
`workflow_next_cursor` is set while more steps follow; pass it back as `cursor` for the next page.
An archived skill of the user's answers `archived: true` and `superseded_by`: the skill it was merged into or
replaced by (null when there is none); a merged skill lists `merged_from`.
A very long file list returns its first paths with `<list>_total` (every file stays readable by
path), a long name or description ends in "…", and a field too large to return is null and named
with its size in `omitted_fields`.

Args:
    skill_id: The skill id (e.g. "seo/keyword_research", "unilytics/<name>", "user/<uuid>/<name>"),
        as returned by find_skill or list_skills.
        A bare name (the last part of an id, e.g. "keyword_research" or a skill's own name) is
        accepted when exactly one skill the user can use has it; the result then carries `resolved`
        with its full id. A name several skills share is not_found with their full ids in
        `did_you_mean`.
    cursor: workflow_next_cursor from a previous call, for the next page of the workflow.

Inputs: skill_id (required), cursor.

get_skill_memoryA
Read-only

Return a skill's memory: the learnings, workarounds and preferences saved from earlier runs.

One page up to a size cap, newest first (`truncated` says some entries were left out). `page`
names exactly the entries shown (from_seq to to_seq): compact_skill_memory with that page
replaces those entries and no others. With oldest_first the page starts at the oldest entry, and
`next_after` is the `after` value of the next page (null on the last). `as_of` (newest-first
reads) is the older up_to form. Built-in and Unilytics skills keep one memory per user.

Args:
    skill_id: The skill id (built-in like "seo/keyword_research", or user/project).
        A bare name (the last part of an id, e.g. "keyword_research" or a skill's own name) is
        accepted when exactly one skill the user can use has it; the result then carries `resolved`
        with its full id. A name several skills share is not_found with their full ids in
        `did_you_mean`.
    oldest_first: Page from the oldest entry instead of the newest (the order compaction uses).
    after: With oldest_first, the `next_after` of the previous page; the page starts after it.

Inputs: skill_id (required), after, oldest_first.

get_skill_proposalA
Read-only

Return one skill proposal: its summary, every target skill (with the version it was written against and the current one), the agent's brief (what it found, what it suggests, why it helps), its rationale and evidence, its sources, its revision history, its dismissal if any, the files it changes (skill, path, added/modified/deleted, sizes), the agent's notes on the lines it changes (annotations: skill, file, side and line range of that file's diff, why, and evidence marked verified when Unilytics checked it), its effects (each skill it writes, creates or archives, with where an archived skill redirects and what a merged skill was merged from), the finding of a skill.flag, and the Agent Inbox link.

Use when the user asks what a proposal says or why an agent proposed it. One file's diff comes from
get_skill_proposal_diff (the annotations' line numbers are that diff's). Long file, annotation and source lists
come in pages: with cursor, the result holds only the next ones. Read-only.

Args:
    proposal_id: From list_skill_proposals (prp_…).
    cursor: next_cursor from a previous call, for the next page of files, annotations and sources.

Inputs: proposal_id (required), cursor.

get_skill_proposal_diffA
Read-only

Return the unified diff of one file a skill proposal changes (a new skill's files diff against nothing).

against="base" (default) compares with the skill version the agent read. When the proposal is stale (the skill
changed since), against="current" compares the proposal applied to the skill's current version, and
applies_to_current says whether it still applies. A long diff comes in pages of up to 40,000
characters as sent (JSON-escaped), with next_cursor. Use when the user wants to see exactly what a proposal changes in a file. Read-only.

Args:
    proposal_id: From list_skill_proposals (prp_…).
    target_id: A skill_id from the proposal's files (get_skill_proposal).
    path: That file's path, exactly as get_skill_proposal lists it.
    against: base (default) or current.
    cursor: next_cursor from the previous page of this diff.

Inputs: path (required), target_id (required), proposal_id (required), cursor, +1 more.

js_scrapeA
Read-only

Scrape a JavaScript-rendered page (SPAs, React, Vue, Angular apps).

Unlike the standard scrape, this waits for JavaScript to fully execute
before extracting content. Use this for single-page applications, dynamic
content, or any page where content loads via JS.

Returns full SEO audit signals from the rendered HTML: title, meta tags,
headings, Open Graph, structured data, canonical, images, and issues.

Args:
    url: Full URL to scrape (e.g. "https://app.example.com")
    wait_for: Milliseconds to wait for JS to render (default: 5000, max: 15000)

[Provider: Firecrawl]

Inputs: url (required), wait_for.

kb_add_fileA

Step 2 of a two-step file upload: create the KB document from a file already PUT to the upload_url from kb_create_direct_upload (signed_id). The file's full text is extracted, chunked and embedded in the background. Returns {document_id, status}; kb_get_status reports progress. A file that can't be read, or holds more text than one document can (about 5 million characters), ends as status 'failed' with error saying why; it keeps its document_id, and kb_retry_document re-runs it in place.

Inputs: name (required), signed_id (required), project_id (required), collection_id (required), +2 more.

kb_add_urlsA

Add one or more webpage URLs to a KB — each is scraped + ingested as its own document. Returns a job id; ingestion runs in the background and kb_get_status reports each document's progress. The same metadata hash is applied to every document.

Inputs: urls (required), project_id (required), collection_id (required), metadata.

kb_create_direct_uploadA

Step 1 of a two-step file upload: get a presigned URL to upload a file into a KB. Returns {signed_id, upload_url, content_type}. The file bytes go to upload_url as an HTTP PUT with the returned content_type as the Content-Type header; kb_add_file(signed_id) then creates the document. Needs outbound network access to the storage URL; in a chat whose code sandbox has none (claude.ai, Claude Desktop), create_upload_link gives the user a browser page for the same upload. Allowed: PDF, DOCX, PPTX, XLSX, XLS, CSV, TXT, MD, HTML, HTM (max 256 MB). Other types are refused.

Inputs: filename (required), project_id (required), byte_size, content_type.

kb_deleteA
DestructiveIdempotent

Permanently delete a Knowledge Base and all its documents. Irreversible. A Knowledge Base that is already gone returns error "not_found".

Inputs: project_id (required), collection_id (required).

kb_delete_documentA
DestructiveIdempotent

Permanently delete one document from a KB, including its indexed chunks. Irreversible. A document that is already gone returns error "not_found".

Inputs: project_id (required), document_id (required).

kb_get_documentA
Read-only

Read a KB document's stored content and metadata (not just search chunks). Use when the user wants a known document, or a previously written one, read end to end.

Content comes in pages of up to 40,000 characters as sent (JSON-escaped, so quotes and line breaks
count twice): `truncated` is true and `next_cursor` is set
while more follows; pass it back as `cursor` for the next page. A whole-file kb_search result's
`content_next_cursor` is such a cursor too. `total_chars` is the full length.
For a file, `document.content_hash` fingerprints the full stored text: it is the same on every page
while the document is unchanged, and propose_context_record cites the document with it.
`document.text_fingerprint` fingerprints the same text with spacing, quote marks and case
normalised, the way the context_write_qa skill compares a copy of it. A long
name or error ends in "…"; a value too large to return (metadata, path, source_url) is null and
`document.omitted_fields` names it with its size.

Inputs: project_id (required), document_id (required), cursor.

kb_get_statusA
Read-only

Get a KB's indexing status: total/ready/pending/failed counts and per-document status. Writes are ingested in the background, and kb_search returns only 'ready' documents. A 'failed' document's error says why it failed. The counts cover the whole KB; documents is one page, and next_cursor (when set) is passed back as cursor for the next page.

Inputs: project_id (required), collection_id (required), cursor.

kb_listA
Read-only

List a project's Knowledge Bases (collections) with file counts + sizes.

Inputs: project_id (required).

kb_manageA

Create a Knowledge Base (collection) in a project and return its collection_id.

Knowledge Bases aren't created implicitly: the write tools take the collection_id of an
existing one.

Inputs: name (required), project_id (required).

kb_retry_documentA

Re-run ingestion of a failed document in place, keeping its document_id: an uploaded file is read again, pasted text re-embedded, a web page re-fetched. Returns {document_id, status}; kb_get_status reports the outcome. A failure on Unilytics' side usually succeeds on a retry; a file that failed because of its content (unreadable, too long) fails the same way again, since the retry reads the same file (a fixed file is a new upload: kb_create_direct_upload + kb_add_file). Only a failed document can be retried, at most 10 times: a refusal is error 'invalid_request' with its document_id, document_status and a reason of BUSY (still processing), NOT_FAILED, RETRY_LIMIT or CONFLICT (changed during the retry).

Inputs: project_id (required), document_id (required).

kb_update_documentA
Destructive

Refresh a document's content in place, keeping the SAME document_id (so references stay valid). Pass a url to re-fetch a URL doc, or content for a text doc. Status goes ready→pending→ready. A resync rebuilds the index; metadata set earlier with kb_update_document_metadata isn't carried over.

Inputs: project_id (required), document_id (required), url, name, +1 more.

kb_update_document_metadataA
DestructiveIdempotent

Replace a document's metadata (single-level key/value hash) in full — no merge, no re-embed. To remove a key, pass the full new hash without it. Filterable via kb_search.

Inputs: metadata (required), project_id (required), document_id (required).

kb_write_textA

Write an inline text/markdown document into a KB (research summary, agent output, notes). Returns {document_id, status}. Ingestion embeds the content in the background; kb_get_status reports when it is 'ready', and kb_search returns only ready documents. metadata is a single-level key/value hash, filterable in kb_search. Text from a file fits here too (MD, CSV, TXT, or text a code sandbox extracted from a PDF or PPTX): the text only, without images or layout; the original file goes in with create_upload_link or kb_create_direct_upload.

Inputs: name (required), content (required), project_id (required), collection_id (required), +1 more.

keyword_researchA
Read-only

Research a keyword: monthly search volume, CPC, ad competition and a 12-month volume trend.

Volumes come from Google Keyword Planner data. `competition` (0-1) is advertiser
competition for the keyword in Google Ads, not SEO ranking difficulty.

Args:
    keyword: Keyword to research (e.g. "best crm software")
    country: Two-letter country code (default: "us")

[Provider: Keywords Everywhere]

Inputs: keyword (required), country.

list_competitor_monitorsA
Read-only

List the competitor sites this user is currently monitoring for changes.

Returns each of the user's active monitors with its monitor_id, domain, project_id,
schedule, status and credits per scheduled run, newest first, plus the most active
monitors one user can have. Use when the user asks what is being watched.

Args:
    project_id: Optional — only monitors labelled with this Unilytics project
                (one the user can access; from list_projects).
    limit: Max monitors to return (1-100). Default 20.

[Provider: Parallel AI]

Inputs: limit, project_id.

list_connectionsA
Read-only

List the data-source accounts linked to a project in the Unilytics app (e.g. Search Console, GA4).

Returns each linked source's type and its linked accounts or workspace (ids, and names or emails
where the app saved them), so a step can tell whether the client's Search Console or GA4 is
linked. This server doesn't return those sources' data.

Args:
    project_id: The project's id (from list_projects).

Inputs: project_id (required).

list_context_gapsA
Read-only

List a client project's Context gaps: the questions its Context can't answer yet, written to be asked to the consultant ("Who is the client's ideal customer: company size, industry, …?"), highest priority first.

Use when the user wants to find or fill what is missing from a client's Context, or asks what Unilytics doesn't
know about a client yet.

A `missing` gap is a Context record that was never published; a `review` gap is a published record that cites a
Knowledge Base document that no longer exists (`deleted_document_id`). Each gap carries the
`published_revision_number` and `rev` that answer_context_gap and dismiss_context_gap take. `answer` is this
connection's own draft for the gap; an `answered` gap with `answer: null` was answered by a person or another
connection. `counts` covers the whole project. A gap is resolved, and leaves the list, once its record is
published.

Args:
    project_id: The project (from list_projects()).
    status: "open" (default), "answered", "dismissed" or "all".
    cursor: next_cursor from the previous page.

[Provider: Unilytics]

Inputs: project_id (required), cursor, status.

list_folderA
Read-only

List a folder's contents — its skills (by reference) first, then its files.

Args:
    folder_id: The folder ID (from list_folders or create_folder).

Inputs: folder_id (required).

list_foldersB
Read-only

List the folders (Contexts) in a project.

Args:
    project_id: The project UUID (from list_projects).

Inputs: project_id (required).

list_project_filesA
Read-only

List a project's stored files/assets (template decks, sheets, docs, images) with their file_id, name, type, size and upload date. Use when a task needs the project's existing templates or deliverables (e.g. the client's audit-deck template). total counts every file; next_cursor (when set) is passed back as cursor for the next page.

Inputs: project_id (required), cursor.

list_projectsA
Read-only

List the user's Unilytics projects (their clients): the ones they own and the ones shared with them.

Returns each project's project_id, name, domain and the user's role. Other project tools take
the project_id. `total` counts every project; `next_cursor` (when set) is passed back as
`cursor` for the next page. An account with no project gets an empty list and a `note` saying so.

Inputs: cursor.

list_skill_proposalsA
Read-only

List the changes Unilytics' skill agents propose to the user's own skills and to the skills of projects the user can edit, newest first, 25 per page.

Use when the user asks what the agents have proposed, what is waiting for review, or about their Unilytics
proposals or Agent Inbox. Each entry has its proposal_id, kind (skill.edit = a change to the skill's files,
skill.flag = a finding with no change, skill.consolidate = merge similar skills into one, skill.retire = archive
skills, skill.trigger_conflict = new descriptions for skills that match the same tasks, skill.new_evals = new
eval cases, skill.new = a new skill), label, status, project_id (null = the user's own skills), title, the skills
it targets, revision, whether it is stale (a target skill changed since) and when it expires. Like the Agent
Inbox, it leaves out the agents' own maintenance items (new eval cases, requirement lists, rule fixes), so a
kind filter of skill.new_evals lists none, and a finding repeated across many of the user's skills. Read-only.

Args:
    status: open (default), dismissed, acknowledged, applied, reverted (applied, then undone), expired, or all.
    project_id: Only this project's proposals (from list_projects).
    kind: Only proposals of this kind.
    cursor: next_cursor from the previous page, with the same filters.

Inputs: kind, cursor, status, project_id.

list_skillsA
Read-only

List every skill the user can use: their saved step-by-step playbooks for SEO, content and AEO/GEO work.

Returns the built-in skills grouped by category (seo, content, geo), the skills provided by
Unilytics (read-only) and the user's own and project skills, each with its skill_id, name and
description (the first 200 characters; get_skill has the rest). Use when the user wants to browse
or choose from their skills; find_skill ranks them against one task. Each of the user's own and
project skills has `your_role`: owner, admin or editor can change it, viewer can use it; a project
skill whose role isn't owner is one shared with the user. `total_skills` counts all of them;
`next_cursor` (when set) is passed back as `cursor` for the next page.

Inputs: cursor.

on_page_auditA
Read-only

Audit a specific page's on-page SEO: title, meta, headings, content quality.

Args:
    url: Full URL to audit (e.g. "https://example.com/page")

[Provider: DataForSEO]

Inputs: url (required).

page_screenshotA
Read-only

Capture a screenshot of a webpage.

Takes a rendered screenshot after JavaScript execution. Use for visual
audits, above-the-fold analysis, competitor page comparison, UX review,
or documenting current page state.

Args:
    url: Full URL to screenshot (e.g. "https://example.com")
    full_page: Capture full scrollable page vs viewport only (default: False)

[Provider: Firecrawl]

Inputs: url (required), full_page.

page_speed_auditB
Read-only

Audit a page's loading performance: Core Web Vitals, performance score, opportunities.

Args:
    url: Full URL to audit (e.g. "https://example.com")
    strategy: "desktop" or "mobile" (default: "desktop")

[Provider: Google PageSpeed Insights]

Inputs: url (required), strategy.

propose_brand_kitA

Save Brand Kit values for a client project as the Brand Kit's draft, with the sources they come from: brand facts (about, ideal customer profile, point of view, author persona), tone of voice, the call to action, writing rules, content types, writing samples and custom variables. The draft waits on the project's Brand Kit page, where the consultant publishes or discards it; the published Brand Kit, and what get_project_context returns, stay unchanged until then. This tool doesn't publish, discard or delete.

Use when the user asks to add to or update a client's Brand Kit, for example from their brand guidelines.

The changes apply to the published Brand Kit: a field given replaces that field whole; in each list, `remove`
takes items out by id, then `set` adds new items (no id) or replaces an existing item whole (its id). A Brand Kit
that already has a draft waiting for review takes no new proposal, except one that adds to this connection's own
pending proposal (draft_proposal_id). Every proposal cites at least one source: Knowledge Base documents
(`kb_sources`, each with the content_hash kb_get_document returned, which is refused once the document has
changed) and/or the user's own words (`user_statements`, recorded as quotes reported by the AI, not verified).

Args:
    project_id: The project (from list_projects()).
    based_on_version: brand_kit.published_version as get_project_context returned it (0 when there is no
        published Brand Kit). A Brand Kit published again since is refused.
    fields: Fields to replace: about, ideal_customer_profile, point_of_view, author_persona, tone_of_voice (text),
        cta ({text, destination}) and header_case.
    writing_rules: {set, remove}. A rule is {id?, text, content_type_ids}; content_type_ids [] applies it to every
        content type. get_project_context lists the global rules, and a content type's own rules when called
        with that content_type, each with its id and content_type_ids.
    content_types: {set, remove}. A content type is {id?, name, description, cta}; cta is an object, "inherit"
        (the Brand Kit's CTA; the default for a new one) or "none". One named by id states its cta, as
        get_project_context's available_content_types shows it.
    writing_samples: {set, remove}. A sample is {id?, title, url, body, outline}; its current body comes from
        get_project_context with include_samples.
    custom_variables: {set, remove}. A variable is {id?, key, value}; brand_kit.custom_variable_ids gives each
        key's id.
    kb_sources: Knowledge Base documents the values come from: [{document_id, content_hash}].
    user_statements: The user's own words the values come from, quoted exactly.
    draft_proposal_id: The proposal_id (kbp_…) an earlier call returned, to add these changes to that pending
        proposal; a field named here replaces the value that proposal set.
    mutation_id: Optional UUID for this proposal. A repeat with the same mutation_id and arguments returns the
        saved proposal instead of saving another; an OUTCOME_UNKNOWN error names the one it used.

[Provider: Unilytics]

Inputs: project_id (required), based_on_version (required), fields, kb_sources, +7 more.

propose_context_recordA

Save a draft of one of a client project's Context records (for example the company's positioning, an ICP or the competitors), with the sources it comes from. The draft waits on the project's Context page, where the consultant publishes or discards it; the published Context, and what get_project_context returns, stay unchanged until then. This tool doesn't publish, discard or delete.

Use when the user asks to add something to a client's Context, or to update a Context record.

Every draft cites at least one source: Knowledge Base documents (`kb_sources`, each with the content_hash
kb_get_document returned, which is refused once the document has changed) and/or the user's own words
(`user_statements`, recorded as quotes reported by the AI, not verified). A record that already has a draft
waiting for review takes no new draft, except one that replaces this connection's own earlier draft.

Args:
    project_id: The project (from list_projects()).
    context_type: The record: a context type such as "positioning" or "icp", or its path such as
        "company/positioning.md", as get_project_context lists them.
    body: The record's full text, in Markdown. It replaces the record's text in the draft.
    based_on_revision: The published revision_number get_project_context returned for this record, or null when
        it listed the record under `missing` (never published). A record published again since is refused.
    title: Optional record title. Default: the current title, or the context type's name for a new record.
    kb_sources: Knowledge Base documents the text comes from: [{document_id, content_hash}].
    user_statements: The user's own words the text comes from, quoted exactly.
    replace_draft_number: The draft_number an earlier call returned, to replace that draft with this one.
    proposal_id: Optional UUID for this proposal. A repeat with the same proposal_id and arguments returns the
        saved draft instead of saving another; an OUTCOME_UNKNOWN error names the one it used.

[Provider: Unilytics]

Inputs: body (required), project_id (required), context_type (required), based_on_revision (required), +5 more.

read_skill_fileA
Read-only

Return one reference or data file of a skill (e.g. "reference/keyword-pipeline.md", "data/verify_row.py").

A skill keeps long documents and scripts in separate files so they're read only when a step
needs them; get_skill lists them as reference_files and data_files. A long file comes
in pages of up to 40,000 characters as sent (JSON-escaped, so quotes and line breaks count
twice): `truncated` is true and `next_cursor` is set while more follows;
pass it back as `cursor` for the next page. The pages joined in order are the file exactly, and
`sha256` is the hex SHA-256 of the whole file's UTF-8 bytes (the same on every page).

Args:
    skill_id: The skill id (a built-in such as "context/context_write_qa", or user/..., project/...
        or unilytics/...).
        A bare name (the last part of an id, e.g. "keyword_research" or a skill's own name) is
        accepted when exactly one skill the user can use has it; the result then carries `resolved`
        with its full id. A name several skills share is not_found with their full ids in
        `did_you_mean`.
    path: The file path within the skill (e.g. "reference/competitor-analysis.md").
        `file_path` is accepted as an alias (matches the file tools).
    cursor: next_cursor from a previous call, for the next page of the file.

Inputs: skill_id (required), path, cursor, file_path.

register_project_fileA

Step 2 of the upload: record a file already POSTed to the uploadUrl from upload_file_to_project (a 201), so the project lists it and it can be downloaded. Takes the s3_key from step 1 and a human-readable name (e.g. "Client X audit deck template"). Returns {file_id, name}; the file_id is stable and get_project_file takes it.

Inputs: name (required), s3_key (required), project_id (required), byte_size, +1 more.

serp_resultsA
Read-only

Get current Google search results for a keyword (up to the top 20 organic results).

Fetching a SERP takes about 1 to 3 minutes (Google's result links are resolved to each page's own URL), so a
call either returns it (`status: "complete"`) or answers `status: "pending"`. A later call with the same
keyword and location_code returns the same SERP once it is ready, waiting up to about 45 seconds for it, and
within 6 hours of its fetch (`fetched_at`) returns it again without fetching it anew. The SERP is charged once,
on the call that first returns it; the other calls are free.

Each result carries its page's own URL. `unresolved_dropped` (when present) counts organic results
left out because Google gave only a redirect link that couldn't be resolved to the page; `partial: true`
means some of the SERP's pages couldn't be retrieved.

Args:
    keyword: Search query (e.g. "best project management tools")
    location_code: Google Ads location code (default: 2840 = United States)

[Provider: DataForSEO]

Inputs: keyword (required), location_code.

set_project_configA
DestructiveIdempotent

Save skill-specific client config on a project (expert rosters, clusters, style rules).

Use for values a skill needs that aren't standard project fields: an expert-blog roster,
keyword clusters, a client's tone rules. Config is stored on the project (not in the skill), so
one skill serves many clients, and the values are shared with project collaborators. Standard
fields (keywords, competitors, locations) are stored by add_tracked_keywords instead. Saving
takes the owner, an admin or an editor role on the project; a viewer's call changes nothing.

Args:
    project_id: The project to save config for.
    namespace: A key identifying the owning skill (e.g. "expert-blog-sweep"): lowercase
        letters, digits, '-' and '_' (no '.'), at most 64 characters.
        Namespacing keeps skills from overwriting each other's config.
    values: A dict of config values to store under this namespace. Replaces
        the namespace's previous contents.

Inputs: values (required), namespace (required), project_id (required).

site_crawlA
Read-only

Crawl a website and return data for every discovered page (up to max_pages).

Recursively follows internal links from the starting URL. Use for site-wide
audits, content inventory, internal link analysis, finding orphan pages,
detecting missing meta tags across a site, or any task needing full-site data.

Returns per-page SEO signals: title, meta description, headings, issues.

Args:
    url: Starting URL (e.g. "https://example.com")
    max_pages: Maximum pages to crawl (default: 50, max: 100)

[Provider: Firecrawl]

Inputs: url (required), max_pages.

site_mapA
Read-only

Discover all URLs on a website without scraping their content.

Fast URL discovery that maps out a site's structure. Use for sitemap
audits (compare against sitemap.xml), finding unindexed pages, understanding
site architecture, or sizing a site ahead of a crawl.

Args:
    url: Website URL (e.g. "https://example.com")

[Provider: Firecrawl]

Inputs: url (required).

stop_watching_competitorA
DestructiveIdempotent

Stop monitoring a competitor site. Halts scheduled runs and their charges.

Only the user who created the monitor can stop it. Stopping is permanent; its past
changes stay readable with get_competitor_changes.

Args:
    monitor_id: ID returned by watch_competitor() or list_competitor_monitors().

[Provider: Parallel AI]

Inputs: monitor_id (required).

update_skillA
Destructive

Save changes to one of the user's editable skills as a new version (no publish step).

Use when the user asks to change a skill they own or share through a project (as its owner, an
admin or an editor; a project viewer can use a skill but not change it). Three ways to
change files, combinable in one version; file_edits sends only the changed text, so it suits
small changes.

  file_edits   — surgical find/replace on an EXISTING file. Maps path ->
    list of edits, e.g.
        {"reference/style-guide.md": [{"find": "—", "replace": "-", "count": 5}]}
    Each `find` must match exactly `count` times (default 1); a 0-match or a
    count mismatch is rejected and nothing is written. A longer, unique `find`
    targets one place; `count` replaces several occurrences.

  file_changes — create a new file or whole-file replace. Maps path ->
    full markdown, e.g. {"SKILL.md": "...", "reference/new.md": "..."}.
    Use for new files or large rewrites.

  delete_files — remove files, e.g. ["reference/old.md"]. SKILL.md can't be
    deleted (it is the contract).

File layout (get_skill lists files by these prefixes):
  - reference/*  documents (style guides, pipelines, specs).
  - data/*       assets the skill carries, including runnable scripts such as a
                 data/verify_row.py checker.

Built-in and Unilytics skills are read-only and an update to one is rejected;
create_skill(extends=<skill_id>) makes an editable copy.

Size: the whole SKILL.md loads on every run of the skill. In a well-kept skill a correction or a
new step is one line in SKILL.md at the step it changes, and its detail (examples, edge cases,
the why) sits in that phase's reference/ file, which keeps SKILL.md under 500 lines.

The result's `lint` lists authoring findings on the saved version, as lint-v1 rule ids with a
message and a fix: body.too_long (the body's line count and its largest sections),
references.unlinked, description.no_trigger, and the frontmatter or description problems an
Agent Skills export refuses. Findings don't stop the save. The save is refused (skill_md_invalid,
nothing written) when the change introduces a SKILL.md frontmatter break, or makes the description
longer than 1,024 characters or a description already over that longer; a problem already there
that the change leaves untouched is allowed.

Args:
    skill_id: The editable skill id (user/... or project/...).
    file_changes: {path: markdown} — create/replace whole files.
    file_edits: {path: [{find, replace, count?}]} — surgical edits to existing files.
    delete_files: [path, ...] — files to remove.
    change_summary: Short note on what changed (for version history).
    expected_version: The version the change was made on (get_skill returns it). Required for a
        project skill, which collaborators share, and optional for the user's own. The save fails with
        version_conflict (naming who saved the newer version and when) unless the skill is still at it.
    verbatim_source: When porting or restructuring existing content, its original text. The
        store returns a fidelity report on the resulting files: FAIL means content was condensed
        or dropped; splitting and intentional edits pass.

Inputs: skill_id (required), file_edits, delete_files, file_changes, +3 more.

upload_file_to_projectA

Step 1 of storing an original file (template deck, sheet, doc, image) in a project, kept byte for byte so it can be downloaded and edited later. For searchable text, the KB tools fit instead.

Returns {uploadUrl, uploadDetails, s3_key, upload_requires}. The upload completes with a
multipart/form-data POST of the file to `uploadUrl`: every property of `uploadDetails` as a form
field, then the file itself under the field `file` as the LAST field (S3 ignores fields after
`file`); a 201 response means success. register_project_file(s3_key) then records the file.

Example (curl):
  curl -X POST "<uploadUrl>" \
    -F key="<uploadDetails.key>" -F Policy="<uploadDetails.Policy>" \
    -F X-Amz-Algorithm="..." -F X-Amz-Credential="..." -F X-Amz-Date="..." \
    -F X-Amz-Signature="..." -F Content-Type="<uploadDetails.Content-Type>" \
    -F success_action_status="201" \
    -F file=@/path/to/your/file.pptx
  (every field present in uploadDetails, with -F file=@... last.)

Allowed: pptx/ppt/xlsx/xls/docx/doc/pdf/csv/md/txt/json/png/jpg/gif/svg/webp (max 256MB).

The POST needs outbound HTTPS access to Amazon S3. In an environment without it, the POST fails
before reaching S3 (e.g. "CONNECT tunnel failed", "Could not resolve host", HTTP 000 or a proxy
403), and a retry fails the same way; create_upload_link gives the user a browser page for the
same upload, or the file can be uploaded in the Unilytics app.

Inputs: filename (required), project_id (required), byte_size, content_type.

watch_competitorA

Start monitoring a competitor's website for material changes.

Detects meaningful changes — pricing/plan updates, new product or feature
launches, positioning and messaging shifts, funding or acquisition news —
rather than raw HTML diffs, so it does not fire on cosmetic edits.

Runs on a schedule. Changes are read back with get_competitor_changes(). The monitor
belongs to the user who creates it: only that user can list, read, run or stop it.
Billing: this call covers the first run; every later scheduled run is charged to the
user's credits (5 credits per lite run, 10 per base run), and a monitor stops when
the balance can't cover its runs. A user can have at most 10 active monitors, and
the same settings twice return the existing monitor_id instead of a second monitor.

Args:
    domain: Competitor domain, e.g. "semrush.com".
    frequency: Check interval as '<number><unit>', unit h/d/w. Default "1d".
               Use "1w" to keep costs low, "12h" for fast-moving competitors.
    focus: Optional list of specific things to watch, e.g. ["pricing changes"].
           Omit to watch the default commercial change set.
    processor: "lite" (cheap, fast) or "base" (more thorough, ~2x cost).
    project_id: Optional Unilytics project to label the monitor with (from list_projects;
                needs owner, admin or editor access to that project).

[Provider: Parallel AI]

Inputs: domain (required), focus, frequency, processor, +1 more.

web_research_toolA
Read-only

Research a topic using AI-powered web search. Returns synthesized findings.

Args:
    query: Research query (e.g. "latest SEO trends 2026")
    research_type: One of "general", "news", "brand_research", "competitor_audit"

[Provider: Perplexity]

Inputs: query (required), research_type.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 87 tools

    Disambiguation2/5

    Several tools have overlapping purposes: serp_results and aeo_serp_urls both return Google organic results for a keyword, content_scrape and js_scrape both scrape a page (differing only in JS rendering), and aeo_cluster_prompts and aeo_cluster_by_urls both cluster prompts by different methods. Descriptions are detailed and help, but the boundaries between these and other pairs (e.g., get_project_config vs get_project_context, list_folder vs list_folders) remain unclear enough that an agent could easily misselect.

    Naming Consistency3/5

    Names mix verb-first patterns (get_skill, list_projects, create_project, watch_competitor) with noun-first patterns (page_speed_audit, serp_results, content_scrape, brand_visibility, site_crawl) and prefixed families (kb_*, aeo_*). Everything is snake_case and grouped readably, but there is no single consistent verb_noun convention throughout.

    Tool Count1/5

    With 87 tools, the surface is far beyond the typical 3-15 range and even beyond the 50+ threshold for an extreme mismatch. While the platform genuinely spans many domains (SEO, AEO, KB, skills, projects, competitors, ads, AI visibility), the sheer number makes tool selection and orchestration burdensome for an agent.

    Completeness4/5

    The surface covers a lot: full skill lifecycle (create/read/update/archive/list/find/files/memory/proposals), KB lifecycle (create/list/write/upload/search/status/update/delete), competitor monitoring, SEO audits, Google Ads research, AI visibility checks, and context/brand-kit proposals. Notable gaps remain—no update/delete for projects, and no tool to list or remove tracked prompts (only add_tracked_prompts exists)—but most workflows can be completed or worked around.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      B
      maintenance
      SEO audit and Google Search Console MCP server with 23 tools. Search analytics, URL inspection, Indexing API, Core Web Vitals (CrUX), striking distance keywords, keyword cannibalization detection, branded query analysis, and automated site audits.
      43
      3
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for Google Search Console. 21 tools for search analytics, keyword opportunities, URL inspection, sitemaps, indexing, and property management.
      1
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      An MCP server that gives AI assistants 23 SEO tools for rank tracking, Google Analytics, site audits, keyword research, competitive analysis, and more, accessible through natural language.
      25
      12
      MIT
    • A
      license
      C
      quality
      B
      maintenance
      MCP server providing 32 tools for Google Search Console and Google Analytics 4, enabling search analytics, URL inspection, indexing, and cross-platform analysis via natural language.
      81
      89 PyPI
      25
      MIT