> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kime.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# KIME MCP use cases

The KIME MCP server exposes the same data and actions as the KIME platform as a set of tools (prefixed `kime_*`) that an MCP-compatible AI assistant — Claude, an MCP-enabled ChatGPT connector, Cursor, or a custom agent you've built — can call on your behalf. Instead of logging into a dashboard, you ask in plain language, and your assistant reads your workspace, explains what it finds, and, where you ask it to, takes action for you (creating tasks, adding prompts, commenting, updating statuses).

Scopes: `read:kime` (analytics), `write:prompts` (create prompts), `write:tasks` (Actions Center). Every call is scoped to a `workspace_id`, which your assistant resolves once via `kime_list_workspaces` / `kime_list_brands` and reuses for the rest of the conversation.

<Note>
  This guide describes what each category of tool enables and the shape of data it returns. Response fields shown in examples are illustrative — your own numbers, brands, and content will reflect your workspace.
</Note>

## Why MCP instead of the dashboard

The dashboard is built for looking things up. MCP is built for asking questions and getting things done without switching tools. The same underlying data is available either way — MCP just puts a conversational layer, and the ability to take action, in front of it. That matters most when:

* The person who needs the answer isn't the person who lives in the KIME dashboard day-to-day (an executive, a client, a teammate on another team).
* The question requires connecting several pieces of data together ("why" questions, not just "what" questions).
* You want the assistant to actually do something with the answer — file a task, draft a follow-up, pull a document — not just report a number.
* You're already working inside another tool (an IDE, a chat app, an internal agent) and don't want to leave it.

## Conversational brand visibility and competitive benchmarking

**Tools:** `kime_list_brands`, `kime_get_visibility`, `kime_get_share_of_voice`, `kime_get_performance`

**You ask:** *"How's our AI visibility trending, and how do we compare to \[Competitor]?"* or *"Give me a one-line performance summary I can put in a status update."*

Your assistant resolves your brand and the named competitor's IDs via `kime_list_brands`, then blends `kime_get_visibility` (a time series of how often each brand shows up in AI answers), `kime_get_share_of_voice` (your share of total brand mentions across the same query set), and `kime_get_performance` (a single composite score combining visibility, position, and sentiment) into a plain-language answer instead of a wall of numbers.

Because these tools accept category, tag, and location filters, you can go narrower in the same conversation: *"Now just for the enterprise segment"* or *"Break that down by market"* — your assistant re-runs the same calls with the added scope rather than you needing to know which parameter does what.

**Illustrative response shape** (`kime_get_performance`):

```json theme={null}
{
  "performance_score": 0,
  "visibility_score": 0,
  "position_score": 0,
  "sentiment_score": 0
}
```

This makes a recurring status update ("how are we doing") a single conversational request instead of a dashboard visit, and it scales to "how is every competitor we track doing" just as easily, since `kime_list_brands` returns the full competitor set in one call.

## AI perception diagnostics — not just a score, but why

**Tools:** `kime_get_sentiment`, `kime_get_sentiment_breakdown`, `kime_get_brand_insights`, `kime_get_topic_keywords`

**You ask:** *"Why did our sentiment score move this period?"* or *"What's driving negative sentiment right now?"*

This is where MCP earns its keep over a static dashboard number. Your assistant chains several calls: `kime_get_sentiment` to spot the trend, `kime_get_sentiment_breakdown` filtered to negative excerpts to find the actual sentences behind the drop (each excerpt is scored on a 0–100 scale with a multi-factor breakdown — lexical tone, stance, comparative framing, supporting evidence, freshness, risk language, hedging/uncertainty, and salience — plus the exact source URL it was drawn from), and `kime_get_topic_keywords` to see which recurring words or phrases are associated with positive versus negative mentions.

Instead of a number that just says "sentiment: moderate," you get something like: *"Two themes are pulling your score down — a handful of sites frame your pricing as steep relative to alternatives, and one recurring comparison page positions a competitor as more established. Here are the specific pages doing that, if you want to follow up."*

`kime_get_brand_insights` additionally returns an AI-generated narrative summary — genuinely usable as-is in an executive brief without further editing, and it works for any tracked competitor's `brand_id` too, so "what does AI think of \[Competitor]" is the same request pattern.

## Citation and source research on demand

**Tools:** `kime_list_source_domains`, `kime_get_citation_analysis`

**You ask:** *"Which sites are AI models citing when our category comes up?"* or *"Are we being cited more or less than \[Competitor] lately?"*

`kime_list_source_domains` returns an aggregate view of every domain feeding AI answers in your tracked prompts, classified by type — your own site, a named competitor, user-generated content (forums, review sites), corporate/vendor sites, commercial or affiliate content, and social platforms — with how often each is used and how it tends to sentiment-score. `kime_get_citation_analysis` drills into individual URLs, showing citation counts and a sentiment-band distribution per page.

A PR or content lead can ask the question conversationally and get back a ranked outreach target list — the sites most worth pitching for a mention or correction — grounded in actual citation frequency rather than guesswork, and can immediately follow up with *"which of those are currently sentiment-negative toward us?"* to prioritize damage control over pure opportunity.

## Instant technical GEO audits

**Tool:** `kime_get_ai_website_health`

**You ask:** *"Can AI crawlers actually read our site right now?"* or *"Did that robots.txt change we just shipped break anything?"*

This runs a real crawl of your site and scores it category by category, with individual pass/fail checks per major AI crawler (OpenAI's search bots, Anthropic's, Perplexity's, and others) against your live `robots.txt` and page structure — distinct from a classic SEO crawler, which doesn't check any of this.

A developer can ask this immediately after a deploy, in the same conversation where the deploy just happened, instead of switching to a separate audit tool and remembering to run it.

## Conversational Actions Center triage

**Tools:** `kime_list_tasks`, `kime_get_task`, `kime_bulk_get_tasks`, `kime_create_task`, `kime_update_task`, `kime_add_task_comment`, `kime_list_task_comments`

**You ask:** *"What should we work on this week?"* then keep going conversationally.

KIME's Actions Center turns gap analysis into a prioritized backlog automatically — content gaps, comparison-page updates, "get mentioned here" outreach opportunities, and validation/trust-signal suggestions, each with a full brief (why it matters, which of your tracked prompts it would help win, and either a content brief or outreach contact details). Your assistant can filter and explain this list in plain language instead of you reading a raw table, then act on it in the same conversation:

* *"Create a task to fix that gap"* → `kime_create_task`
* *"Mark it in progress and note who's working on it"* → `kime_update_task` plus `kime_add_task_comment`
* *"Show me everything high-priority and still unassigned"* → filtered `kime_list_tasks`
* *"Pull up the three tasks I flagged yesterday"* → `kime_bulk_get_tasks`

The whole backlog gets managed by talking to an assistant, with the audit trail (status changes, comments) living in one place your team can review later — including from a different tool entirely, since it's the same underlying data your dashboard shows.

## Reviewing AI-generated content inline in chat

**Tools:** `kime_list_content_tasks`, `kime_get_content_task_output`

**You ask:** *"Is that article ready? Show me the draft."*

Certain Actions Center tasks can spin up a linked content-generation job that produces a publish-ready draft, not just an outline — complete with SEO metadata (title, slug, meta description, primary and secondary keywords), Open Graph and social card data, a ready-to-use structured-data (schema.org) block including a populated FAQ section where relevant, and the full article body. Your assistant can pull this and paste the relevant sections directly into your conversation for review, so a content reviewer can approve, request edits, or flag issues without opening a separate app.

Because the export supports multiple formats (structured JSON, Markdown, HTML, and WordPress's WXR import format), once you approve it in chat, the same or a follow-up automation can hand it straight to publishing.

## Setting up tracking by describing intent

**Tools:** `kime_bulk_create_prompts`, `kime_get_prompt_run_status`, `kime_list_prompts`, `kime_get_prompt`

**You ask:** *"We're launching in a new market — set up tracking for our branded and comparison queries there."*

Your assistant translates a plain-language request into a structured batch of prompts (each tagged with the right location and category), submits them in one `kime_bulk_create_prompts` call, and polls `kime_get_prompt_run_status` until results are in — letting you know when it's done rather than you needing to check back manually.

<Warning>
  This is a real write action, not a preview: each prompt submitted this way kicks off live model runs across every AI engine enabled in your workspace. A well-built assistant should read the proposed list back to you and get confirmation before submitting, especially for large batches.
</Warning>

`kime_get_prompt` (for a single prompt) additionally returns detailed industry-ranking data that the summary list view omits for performance — useful when you want to ask "who currently dominates this exact query" about one specific prompt in depth.

## Competitive ads intelligence, conversationally

**Tools:** `kime_get_ads_share`, `kime_get_ads_share_by_category`, `kime_get_ads_share_by_location`, `kime_list_ads_advertisers`, `kime_get_ads_advertiser`, `kime_list_ads_creatives`, `kime_get_ads_creative`

**You ask:** *"Is anyone running paid ads in our category's AI answers, and who?"*

Sponsored ads are starting to appear inside some AI assistant answers, tracked separately from organic brand mentions. Your assistant can pull the overall trend, break it down by prompt category or market to see where paid competition is concentrated, and look up specific advertisers and their creative (ad copy, imagery, and how often each appears) — turning "is this becoming a paid channel we need to think about" into a quick conversational check instead of a separate research project.

## Using it inside your coding tools, not just chat

Because this is MCP, it works anywhere an MCP client does — an IDE-integrated agent, a custom internal tool, or any assistant you've wired it into — not only a standalone chat window. A developer working on the marketing site can ask the same assistant, without leaving their editor, *"which pages are we missing that competitors have?"* and get an actioned list, or have the assistant open the relevant Actions Center task while already looking at the page in question. If you also connect other MCP servers (your CMS, your PM tool, your analytics stack), the same assistant can reason across all of them in one conversation — for example, cross-referencing a KIME content gap against what's already in your CMS's draft queue before creating a duplicate task.

## Notes for building on the MCP tools

* **Tool naming:** everything is prefixed `kime_*`, grouped into discovery (`list_workspaces`, `list_brands`, `list_categories`, `list_tags`), analytics/read (`get_*`), prompt management (`*_prompts`), Actions Center (`*_task*` under the tasks umbrella), and content (`list_content_tasks`, `get_content_task_output`).
* **Large responses:** a few tools (`kime_get_ai_website_health`, `kime_get_citation_analysis`, `kime_list_ads_advertisers`) can return very large payloads on an active, heavily-tracked workspace — a well-built agent should summarize findings rather than paste raw JSON back to you, and should narrow date ranges or filters where possible.
* **Pagination:** list tools return `items`, `totalCount`, `limit`, and `offset` — an agent that needs everything should page by incrementing `offset` by `limit` until it reaches `totalCount`, rather than assuming the first page is complete.
* **Scoping filters:** most analytics tools accept a category, tags, location, and an AI-engine filter, so a narrower question ("just this category, just on one engine") doesn't require a different tool — just a different set of arguments on the same call.
* **Read versus write:** be deliberate about which scopes you grant. `read:kime` alone is enough for every "ask a question" use case above; `write:prompts` and `write:tasks` should only be granted to an assistant you trust to take action on your behalf, since both make real, persisted changes.

## Tool index

| Tool                             | Scope         |
| -------------------------------- | ------------- |
| `kime_list_workspaces`           | read          |
| `kime_list_brands`               | read          |
| `kime_list_categories`           | read          |
| `kime_list_tags`                 | read          |
| `kime_list_prompts`              | read          |
| `kime_get_prompt`                | read          |
| `kime_bulk_create_prompts`       | write:prompts |
| `kime_get_prompt_run_status`     | read          |
| `kime_get_visibility`            | read          |
| `kime_get_share_of_voice`        | read          |
| `kime_get_performance`           | read          |
| `kime_get_sentiment`             | read          |
| `kime_get_sentiment_breakdown`   | read          |
| `kime_get_brand_insights`        | read          |
| `kime_get_topic_keywords`        | read          |
| `kime_get_citation_analysis`     | read          |
| `kime_list_source_domains`       | read          |
| `kime_get_ai_website_health`     | read          |
| `kime_get_ads_share`             | read          |
| `kime_get_ads_share_by_category` | read          |
| `kime_get_ads_share_by_location` | read          |
| `kime_list_ads_advertisers`      | read          |
| `kime_get_ads_advertiser`        | read          |
| `kime_list_ads_creatives`        | read          |
| `kime_get_ads_creative`          | read          |
| `kime_list_tasks`                | write:tasks   |
| `kime_get_task`                  | write:tasks   |
| `kime_bulk_get_tasks`            | write:tasks   |
| `kime_create_task`               | write:tasks   |
| `kime_update_task`               | write:tasks   |
| `kime_add_task_comment`          | write:tasks   |
| `kime_list_task_comments`        | write:tasks   |
| `kime_list_content_tasks`        | read          |
| `kime_get_content_task_output`   | read          |

## When to reach for the API instead

MCP is the right layer when a person is in the loop, asking questions in natural language, or reviewing/approving before something happens. When you want something to run unattended — on a schedule, inside a pipeline, embedded in your own product — call the KIME API directly instead. See **KIME API — Use Cases** for that side of the picture; both surfaces expose the same underlying data and actions.