optifeed-radar

# Optifeed Radar

[![npm version](https://img.shields.io/npm/v/optifeed-radar.svg)](https://www.npmjs.com/package/optifeed-radar)
[![CI](https://github.com/optifeed/optifeed-radar/actions/workflows/ci.yml/badge.svg)](https://github.com/optifeed/optifeed-radar/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![Node](https://img.shields.io/node/v/optifeed-radar.svg)](https://nodejs.org)
[![Glama MCP server](https://glama.ai/mcp/servers/optifeed/optifeed-radar/badge)](https://glama.ai/mcp/servers/optifeed/optifeed-radar)

**Open-source AI visibility checker. Now on npm - run it with `npx optifeed-radar`.**

Is your brand recommended when buyers ask AI? Optifeed Radar checks whether
ChatGPT, Perplexity, Gemini and Claude actually recommend you, and tells you
where you stand against competitors. It runs locally, uses your own API keys,
and has no Optifeed-hosted backend.

It is built for two kinds of AI agents at once: it measures how **AI agents**
see and recommend you, and it can be **run by your own AI agents** (CLI, JSON,
and an MCP server). People also call this AI visibility, generative engine
optimization (GEO), answer engine optimization (AEO), or AI-SEO.

<p align="center">
  <img src="https://raw.githubusercontent.com/optifeed/optifeed-radar/main/docs/assets/optifeed-radar-overview.png" alt="Optifeed Radar AI visibility dashboard and report" width="900">
</p>

## 60-second setup

No install needed - `npx` fetches and runs it. The zero-key `audit` runs end
to end with no API keys and no AI calls:

```bash
npx optifeed-radar audit yourbrand.com
```

It checks AI-crawler access (robots.txt), llms.txt, schema.org structured
data, meta basics, and your sitemap, then prints a 0-100 AI-readiness score.

The `check` pipeline runs once you set at least one engine API key. Put it in a
`.env` file in the directory you run from, or export it:

```bash
echo "OPENAI_API_KEY=sk-..." > .env      # any one engine key gets you started
npx optifeed-radar check yourbrand.com
```

The CLI loads `.env` from the directory you run it in, so there is no shell
setup step. Exporting the keys works too (`export OPENAI_API_KEY=...`), and an
exported key always wins over the same key in `.env`. `config` shows which
keys were found and which file they came from, never the values.

It discovers your brand, generates a buyer-prompt pack, asks the engines, and
scores recommendation, position, and share of voice into one AI Visibility
Score. The score reads only the unbranded buyer questions (did the AI surface
you unprompted); questions that name your brand are reported separately as
reputation. All four engines are verified live against their production APIs
(2026-07-20).

Working from a clone instead? Run `npx tsx src/cli/index.ts <command>` so flags
reach the CLI unchanged, or use the `npm run dev` script with `--` before the
arguments (`npm run dev -- check yourbrand.com --report out.html`).

### See it in action

Run a full visibility check from the terminal, from brand discovery and buyer
prompt generation through live engine queries and scoring.

<p align="center">
  <a href="https://github.com/optifeed/optifeed-radar/blob/main/docs/assets/optifeed-radar-cli.mp4">
    <img src="https://raw.githubusercontent.com/optifeed/optifeed-radar/main/docs/assets/optifeed-radar-cli-preview.png" alt="Watch the Optifeed Radar CLI demo" width="760">
  </a>
</p>

<p align="center"><a href="https://github.com/optifeed/optifeed-radar/blob/main/docs/assets/optifeed-radar-cli.mp4"><strong>Watch the 15-second CLI demo</strong></a></p>

## What it does

Optifeed Radar asks real AI engines real buyer questions and measures whether
your brand gets recommended - not whether you rank in a search index, but
whether the answer an AI gives a buyer names you. Grounded engines (which cite
web sources) are reported separately from parametric ones (which answer from
model weights alone), because they behave differently. An engine counts as
grounded only for the answers where it actually searched: asking for grounded
mode is a request a model can decline, so the report says when an engine
searched on only some of its answers. [METHODOLOGY.md](METHODOLOGY.md) has the
formula.

The questions match what you sell. If you make your own products, buyers are
asked what to buy and you are measured against rival makers. If you are a shop
selling other companies' products, buyers are asked where to buy and you are
measured against rival shops - product questions get answered with
manufacturers, so scoring a shop on them reports a zero that says nothing about
the shop. The tool works this out from your site and stores it as
`businessType` in `profile.json`; edit it if it guessed wrong.

One level down, `shopping` does the same thing for individual products you
name (beta). Each product gets its own 0-100 visibility score, and the report
is ordered by what the engines did: any product they answered about but never
recommended leads, since that is the finding worth reading, then the rest by
visibility, and last anything the run could not measure at all. The order you
list your products in carries no ranking meaning; it only breaks ties between
identical scores. Each product is checked twice over - category
buying questions that never name it, and questions that do - and when a
product is absent the report leads with the rival products the engines named
instead, which is the more useful half of a zero. Because every product is
asked its own questions, the scores say how decisively each one wins its own
shelf, not that one product beats another. You name the products; nothing is
imported or crawled.

## Use it from your AI agents (MCP)

The `optifeed-mcp` server exposes the same capability to AI agents. It runs
over stdio, and `npx` fetches it on demand - no clone or build needed.

<p align="center">
  <img src="https://raw.githubusercontent.com/optifeed/optifeed-radar/main/docs/assets/optifeed-radar-claude-desktop.png" alt="Optifeed Radar running through Claude Desktop via MCP" width="760">
</p>

Claude Desktop (`claude_desktop_config.json`). The fastest way to open it is
Settings -> Developer -> Edit Config, which creates the file if it does not
exist yet. On disk it lives at:

- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "optifeed-radar": {
      "command": "npx",
      "args": ["-y", "--package=optifeed-radar", "optifeed-mcp"],
      "env": {
        "OPENAI_API_KEY": "sk-..."
      }
    }
  }
}
```

Claude Desktop reads that file at startup, so quit and reopen it after editing.

Claude Code (`.mcp.json` in your project):

```json
{
  "mcpServers": {
    "optifeed-radar": {
      "command": "npx",
      "args": ["-y", "--package=optifeed-radar", "optifeed-mcp"]
    }
  }
}
```

Cursor (`.cursor/mcp.json`) and Windsurf (`mcp_config.json`) use the same
shape:

```json
{
  "mcpServers": {
    "optifeed-radar": {
      "command": "npx",
      "args": ["-y", "--package=optifeed-radar", "optifeed-mcp"]
    }
  }
}
```

Working from a clone instead? Build first (`npm install && npm run build`),
then run the server with `node` pointed at the built entrypoint - replace
`/path/to/optifeed-radar` with your clone path:

```json
{
  "mcpServers": {
    "optifeed-radar": {
      "command": "node",
      "args": ["/path/to/optifeed-radar/dist/mcp/index.js"]
    }
  }
}
```

### Example prompts

Once it is connected, ask your AI agent in plain language. These map onto the
five tools and the arguments they accept:

- "Run a free AI-readiness audit on yourbrand.com." -> `audit_store`, no keys,
  no cost.
- "What buyer questions should yourbrand.com be visible for?" ->
  `generate_buyer_queries`, so you can review the pack before paying for a run.
- "Check yourbrand.com's AI visibility, quick mode, cap it at 20 cents." ->
  `check_visibility` with `quick` and `max_cost`.
- "Check yourbrand.com on OpenAI and Perplexity only." -> `check_visibility`
  with `engines`.
- "Check whether AI recommends my products: Aria 2, Presto X, Brew Mini, in
  that order, for yourbrand.com." -> `shopping_check`. Input order is not a
  ranking; it only breaks ties between products with identical scores.
- "Check the Aria 2, a quiet home espresso machine, and the Presto X, a fast
  dual-boiler, on yourbrand.com. Cap it at one dollar." -> `shopping_check`
  with a descriptor per product and `max_cost`. Saying what each product IS is
  what rescues an opaque model name: without it the questions are guessed from
  the store category.
- "What changed since the last visibility run on yourbrand.com?" ->
  `get_snapshot_diff`, free, and it needs two saved runs before it can compare.

Start with the audit prompt: it needs no keys, so it confirms the server is
wired up before anything spends API credit. `check_visibility` runs
non-interactively (no confirmation prompt over MCP), so the `max_cost` cap is
what bounds a run your AI agent starts - it defaults to $0.50.
`shopping_check` is bigger, so its default cap scales with the list, at $0.20
per product you name.

## Tools and cost

| Surface | Name                     | What it does                                                    | Cost                           |
| ------- | ------------------------ | --------------------------------------------------------------- | ------------------------------ |
| CLI     | `audit`                  | Zero-key AI-readiness check (robots, llms.txt, schema, sitemap) | Free, no AI calls              |
| CLI     | `check`                  | Full pipeline: buyer prompts, engines, AI Visibility Score      | BYO keys                       |
| CLI     | `shopping`               | Products you name: your ranking vs AI's, and the rival shelf    | BYO keys                       |
| CLI     | `diff`                   | What changed between your last two runs