Skip to main content
Glama
Unilytics MCP Server

Unilytics MCP Server

Official

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
UNILYTICS_API_KEYYesYour Unilytics API key. Get it from https://app.unilytics.ai/settings/api-keys

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Unilytics holds the user's saved skills (their own step-by-step playbooks for SEO, content, AEO/GEO and client work) and the research tools those skills use.

Skills: find_skill(task, project_id) ranks the user's skills against a task such as keyword research, a site audit, a content brief, a competitor comparison page or adding brand guidelines to a client's brand kit, and returns the best matches with skill ids. get_skill(skill_id) returns a skill's playbook text and its list of files. list_skills lists every skill. Built-in and Unilytics skills are read-only; the user's own copies are editable.

Projects are the user's clients (list_projects). project_id limits skills, files, settings and the Knowledge Base to that client. get_project_context returns the client's published Brand Kit (brand voice, audience, writing rules) and published Context records (company, offerings, audience, competitors, strategy), with their sources. propose_context_record saves a draft Context record with its sources, and propose_brand_kit saves Brand Kit values as the Brand Kit's draft with their sources; each reaches get_project_context only after the consultant publishes it in the Unilytics app. list_context_gaps lists the questions a client's Context can't answer yet; answer_context_gap saves an answer as a draft Context record, and dismiss_context_gap closes a gap the consultant doesn't want to answer.

Skill proposals are changes Unilytics' skill agents suggest to the user's skills: list_skill_proposals, get_skill_proposal and get_skill_proposal_diff read them, and dismiss_skill_proposal closes one. Approval is a click in the Agent Inbox in the Unilytics app; approve_skill_proposal returns that link and changes nothing.

Files: kb_write_text stores text as a Knowledge Base document, including text a code sandbox extracted from a PDF or PPTX (the text only, without images or layout). An original file takes two steps: an upload, then kb_add_file (Knowledge Base) or register_project_file (project files). The upload is direct (kb_create_direct_upload, upload_file_to_project) where the code sandbox can reach Amazon S3, as in Claude Code; create_upload_link gives the user a one-time page in their own browser for chats whose sandbox can't, as in claude.ai and Claude Desktop.

Limits: first-party Google Search Console and GA4 data is not available from this server. Competitor monitors (watch_competitor) run on a schedule and each run is billed.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}
experimental
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
list_skillsA

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.
find_skillA

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.
get_skillA

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.
author_skillA

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.

read_skill_fileA

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.
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.
update_skillA

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.
delete_skillA

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/...).
get_skill_memoryA

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.
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).
compact_skill_memoryA

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.
keyword_researchA

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]
page_speed_auditB

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]
serp_resultsA

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]
on_page_auditA

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]
content_scrapeC

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]
web_research_toolA

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]
google_trendsB

Compare keyword interest over time using Google Trends data.

Args:
    keywords: List of keywords to compare (e.g. ["chatgpt", "gemini", "claude"])
    time_range: Time period — "past_7_days", "past_30_days", "past_90_days", "past_12_months", "past_5_years"

[Provider: DataForSEO]
brand_visibilityA

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)]
list_projectsA

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.
list_connectionsA

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).
get_credit_balanceA

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.
google_ads_transparencyA

See what Google Ads a competitor is running via the Ads Transparency Center.

Returns one page of ad creatives: format (text, image, video), target domain, first/last shown dates, days
shown, and a link to each ad in the Google Ads Transparency Center. `next_page_token` is set when more
creatives exist; pass it back as `page_token` (with the same advertiser_name and region) for the next page.

Args:
    advertiser_name: Brand domain to search (e.g. "nike.com", "apple.com"). Use domain, not just brand name.
    region: Region code (default: "2840" = US). Common: "2356" India, "2826" UK, "2124" Canada, "2036" Australia.
    limit: Max ad creatives per page (default: 30, max: 40)
    page_token: next_page_token from a previous call, for the next page

[Provider: SerpAPI]
audience_segmentsA

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
audience_recommendationsA

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"
demographic_optionsA

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.

js_scrapeA

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]
batch_scrapeA

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]
site_crawlA

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]
site_mapA

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]
page_screenshotA

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]
link_extractA

Extract and classify all links from a webpage.

Returns internal vs external links with anchor text, nofollow attributes,
and link counts. Use for link audits, outbound link analysis, internal
linking reviews, finding link building opportunities on competitor pages,
or checking nofollow distribution.

Args:
    url: Full URL to extract links from (e.g. "https://example.com/page")
    js_rendering: Wait for JavaScript rendering before extracting (default: False)

[Provider: Firecrawl]
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.
add_tracked_keywordsA

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.
add_tracked_promptsA

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).
get_project_configA

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.
set_project_configA

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.
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").
list_foldersB

List the folders (Contexts) in a project.

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

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).
add_skill_to_folderA

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.
aeo_cluster_by_urlsA

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").
aeo_cluster_promptsA

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]
aeo_audit_promptsB

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]
aeo_filter_promptsA

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}.

aeo_serp_urlsA

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]
aeo_site_pagesA

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: …"}.
aeo_generate_promptsC

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

[Provider: OpenAI]
aeo_prompt_volumeB

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

[Provider: DataForSEO]
kb_listA

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

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.
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.

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.

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.

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.

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).

kb_searchA

Search a project's Knowledge Base for passages or whole files related to a query. Use when the user asks what a client's files say about something, or a task needs a client's own files (such as their approved pricing or a template). The query is natural language, in the documents' language.

Filters, combined with AND: collection_id limits the search to one KB; folder to the files in a folder
and every folder below it; skill_id limits results to the files linked to that skill (a skill id from
find_skill or list_skills); tags to files carrying any of those tags (case doesn't matter; at most
20); metadata_filter to documents with those metadata values. folder is a folder's path, a result's
`path` without the file name ("/Templates", "/Templates/Pricing"; case doesn't matter), which matches
that folder in every KB of the project that has one (in one KB with collection_id), or a folder id
(a document's `parent_id` in kb_get_document), which is exactly one folder; a leading "/" makes it a
path. A folder that matches nothing is error "not_found" with reason
FOLDER_NOT_FOUND and `folder` set to it; a skill that doesn't exist or can't be used in this project
is reason SKILL_NOT_FOUND with `skill_id`. A filter that matches more than 2,000 files is refused
(reason FILTER_TOO_BROAD).

granularity "snippet" (the default) returns passages of up to 400 characters: max_results 1 to 20,
default 10. granularity "file" returns one result per file with the file's text in `content`, from
its start: max_results 1 to 10, default 5. `total_chars` is the file's full length and
`content_truncated` is true when `content` isn't the whole file; `content_next_cursor`, when set, is
the `cursor` from which kb_get_document returns the rest of that file. All files' text shares one
result-size budget, best match first, so a lower-ranked file can come with `content` null.

Each result names its file: `document_id`, `name`, `path` (its place in the KB's folders, e.g.
"/Templates/Pricing deck.pdf"), `collection` (the KB's name), `tags`, and `source_url` for a web page.
A long name or passage ends in "…"; a value too large to return (metadata, path, source_url) is null
and the result's `omitted_fields` names it with its size. `results_total` is how many results the
search returned (at most max_results, best first; more files may match); `results` holds the first
`count` of them that fit in one result. `filters` echoes the folder (a path written as "/A/B", or
the folder id), skill_id and tags as applied (normalised; null or [] when not set) and `files`, how
many files they allowed. `exhaustive` is true when every passage the filters allow was compared.

Returns only passages that came close to the query, nearest first, each with its source, `score`
(higher is closer) and `match`: "meaning" when the score reached the result's `min_score`, "words"
when the score is lower but the passage holds every word of the query (how exact names and codes are
found). An empty `results` means nothing in the searched files came close to the query.
Limit: the word rule looks only at the passages nearest in meaning, so a name or code can come back
empty when its passage is far in meaning from the rest of the query, or when the query mixes it with
words the passage doesn't hold. A code matches when written as in the document ("SKU-4417" finds
"SKU-4417", "SKU 4417" may not).
kb_get_statusA

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.

kb_update_document_metadataA

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.

kb_delete_documentA

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

kb_get_documentA

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.
kb_update_documentA

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.

kb_deleteA

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

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]
get_competitor_changesA

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]
list_competitor_monitorsA

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]
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]
stop_watching_competitorA

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]
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.
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.

list_project_filesA

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.

get_project_fileB

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.

delete_project_fileB

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

get_project_contextA

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]
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]
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]
list_context_gapsA

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]
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]
dismiss_context_gapA

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]
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]
get_ai_citation_checkA

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.
list_skill_proposalsA

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.
get_skill_proposalA

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.
get_skill_proposal_diffA

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.
dismiss_skill_proposalA

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).
approve_skill_proposalA

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_…).
create_upload_linkA

Create a one-time link where the user uploads a file from their own browser into a project, for a file in a chat whose code sandbox can't reach outside hosts (claude.ai and Claude Desktop chats). destination is "knowledge_base" (the file becomes a searchable document) or "project_files" (the original is kept byte for byte for download). filename is the file's name with its extension; the link accepts only a file with that extension.

Returns {upload_link, expires_at, filename, destination, max_bytes, note} plus `signed_id` (knowledge_base: what
kb_add_file takes) or `s3_key` (project_files: what register_project_file takes). The page needs no sign-in,
works for one browser and one file, and expires about 14 minutes after the link is made. The file is in the
project only once the step-2 tool has run after the upload.
Knowledge Base: PDF, DOCX, PPTX, XLSX, XLS, CSV, TXT, MD, HTML, HTM. Project files: PPTX, PPT, XLSX, XLS, DOCX,
DOC, PDF, CSV, MD, TXT, JSON, PNG, JPG, JPEG, GIF, SVG, WEBP. Up to 256 MB.

Prompts

Interactive templates invoked by user choice

NameDescription
get-startedA starting point for a newly connected account: your client projects, three skills that start from a client's website, and an offer to run the first one.

Resources

Contextual data attached and managed by the client

NameDescription

No resources

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