Connect to Claude & AI Agents (MCP)

Nesika's Model Context Protocol (MCP) server lets Claude, ChatGPT, Cursor, and other AI agents query your pricing intelligence data as native tools — no custom code needed.

What is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI models like Claude call external tools and data sources. Nesika provides an MCP server that exposes pricing intelligence as tools that your AI client can invoke during a conversation — letting you ask natural-language questions about pricing data and get real, live answers.

Portfolio & pricing tools

List your tracked products, check your competitive price position, review competitor activity, and read pricing insight cards for your own portfolio.

Scans & report tools

Pull your latest scan results, track recent competitor price changes, and export a scan report as CSV or JSON. Every tool is customer-scoped and requires your API key.

Prerequisites

The Nesika MCP server is customer-only. You need a Nesika API key and an account with tracked products to use it. Every one of the 10 tools requires authentication -- there are no anonymous or public tools.

Generate an API Key

Go to Settings → API Keys to generate your key. Any workspace member can create their own API key. Copy the key immediately — it is only shown once.

Authentication Methods

Nesika supports three API key authentication methods. Use the one your client supports best, with the standard Bearer header as the preferred option.

Looking for the old Connect Claude.ai or Connect Cursor or VS Codesetup? This page now breaks those instructions into separate client-specific sections below.

Authorization: Bearer

Preferred for modern MCP clients. Send Authorization: Bearer nes_xxx.

X-API-Key

Legacy header for backward compatibility with older clients or saved integrations.

Query parameter

Use ?api_key=nes_xxx only when your client cannot send custom headers.

Use one auth method per connection

Do not send multiple authentication methods in the same connection. Pick one method and keep it consistent for that client profile.

Connect Cursor

Cursor supports remote MCP servers natively, so this is a zero-install setup.

Create the MCP config file

Save this config to .cursor/mcp.jsonin your project or to ~/.cursor/mcp.jsonfor a global setup.

{
  "mcpServers": {
    "nesika": {
      "url": "https://mcp.nesika.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_NESIKA_API_KEY"
      }
    }
  }
}

Reload Cursor

Restart Cursor or run MCP: Reload Servers from the command palette.

Use the Nesika tools

Open Cursor Chat, switch to Agent mode, and ask “Show me my tracked products using Nesika.”

Connect VS Code (GitHub Copilot)

VS Code also supports remote MCP servers natively. It uses a slightly different config shape than Cursor.

Create the VS Code MCP config file

Save this to .vscode/mcp.jsonor your user-level MCP config.

{
  "servers": {
    "nesika": {
      "type": "http",
      "url": "https://mcp.nesika.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${input:nesika_api_key}"
      }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "nesika_api_key",
      "description": "NesikaAI API Key (starts with nes_)",
      "password": true
    }
  ]
}

Note the VS Code schema

VS Code uses servers instead of mcpServers, and the prompt input keeps your key out of the file contents.

Open Copilot Chat in Agent mode

Use VS Code 1.101+ with the GitHub Copilot extension, then open Copilot Chat and switch to Agent mode.

Connect Claude Code

Claude Code can add the Nesika MCP server with a single CLI command.

Run the add command

claude mcp add --transport http nesika https://mcp.nesika.ai/mcp \
  --header "Authorization:Bearer YOUR_NESIKA_API_KEY"

Choose the scope you want

Add --scope user for a global config or --scope project for the current workspace only.

Verify the connection

Start a new Claude Code session and ask it to list your tracked products with the Nesika tools.

Connect Claude Desktop

Claude Desktop supports two setup paths: a zero-install custom connector URL or a config-file-based remote bridge.

Option A: Custom Connector URL (preferred)

Open Claude Desktop, go to Settings → Connectors → Add custom connector, and paste this URL:

https://mcp.nesika.ai/mcp?api_key=YOUR_NESIKA_API_KEY

This is the fastest setup and does not require Node.js because the API key is passed as a query parameter.

Option B: Config file (requires Node.js)

Add the following to claude_desktop_config.json.macOS: ~/Library/Application Support/Claude/claude_desktop_config.jsonWindows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "nesika": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote@latest",
        "https://mcp.nesika.ai/mcp",
        "--header", "Authorization:Bearer YOUR_NESIKA_API_KEY"
      ]
    }
  }
}

Restart Claude Desktop and test

Fully quit and reopen Claude Desktop, then try “Export my latest scan report as a CSV using the Nesika tools.”

Windows mcp-remote path bug

Some Windows installs fail when npx resolves through a path under Program Files. If that happens, install mcp-remote globally, point command to the full mcp-remote.cmd path, and remove -y plus mcp-remote@latest from args.

Connect Windsurf

Windsurf supports remote MCP servers with a JSON config file.

Update the Windsurf MCP config

Save this config to ~/.codeium/windsurf/mcp_config.json.

{
  "mcpServers": {
    "nesika": {
      "serverUrl": "https://mcp.nesika.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_NESIKA_API_KEY"
      }
    }
  }
}

Use the Windsurf-specific field names

Windsurf expects serverUrl instead of url.

Reload the window

Reload Windsurf after saving so the Nesika tools are discovered.

Connect ChatGPT

ChatGPT supports remote MCP-style connectors in Developer Mode using the server URL directly.

Enable Developer Mode

In ChatGPT, go to Settings → Apps & Connectors → Advanced settings and enable Developer Mode.

Create the connector

Add a new app named NesikaAI Pricing Intelligence and paste this URL:

https://mcp.nesika.ai/mcp?api_key=YOUR_NESIKA_API_KEY

Use the connector in chat

Start a chat, click the + menu, and select the Nesika connector before sending your prompt.

Claude API (Programmatic)

Use Anthropic's MCP server support when you want to call the Nesika tools directly from code.

import anthropic

client = anthropic.Anthropic()
response = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Show me my tracked products"}],
    mcp_servers=[{
        "type": "url",
        "url": "https://mcp.nesika.ai/mcp",
        "name": "nesika",
        "authorization_token": "YOUR_NESIKA_API_KEY",
    }],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "nesika"}],
    betas=["mcp-client-2025-11-20"],
)

OpenAI API (Programmatic)

OpenAI Responses API can connect to the same Nesika MCP endpoint with an authorization token.

from openai import OpenAI

client = OpenAI()
response = client.responses.create(
    model="gpt-4.1",
    input="Show me my tracked products",
    tools=[{
        "type": "mcp",
        "server_label": "nesika",
        "server_url": "https://mcp.nesika.ai/mcp",
        "authorization": "YOUR_NESIKA_API_KEY",
        "require_approval": "never",
    }],
)

Available MCP Tools

The Nesika MCP server is customer-only and exposes 10 tools, all scoped to your own portfolio. There are no anonymous or public tools -- every tool requires a valid API key and a Nesika account with tracked products.

Tool	Description
`my_products`	List your tracked products (name, SKU, brand, category, scan status, competitor count, current price).
`my_price_position`	Your competitive price position for one product or your whole portfolio (percentile, gap to cheapest/most expensive, market average).
`my_scan_results`	Your latest scan results (scan id, status, type, job counts, product count, timestamps).
`my_price_changes`	Recent competitor price changes for your tracked products (previous/current price, % change, direction).
`my_competitor_overview`	Overview of competitor activity (tracked product count, products being undercut, top competitors).
`my_insights_summary`	Paginated pricing insight cards (severity, type, status, product, what changed, why it matters, recommendation).
`export_scan_report`	Export your scan report as CSV (default) or JSON, using the same columns as the scan-completed email report (SKU, product details, your price, pricing position, and per-competitor regular/promo/delta/URL). Params: scanId (default "latest"), format ("csv" or "json"), optional category.
`my_price_history`	Competitor price history over time for one of your tracked products (a time-series of competitor prices so you can see trends and plot changes). Params: productId/SKU, optional date range.
`my_scan_status`	Data-freshness check for your portfolio (the date of your latest scan, how complete it was, and how old the data is) so you know whether your pricing intelligence is up to date.
`my_insight`	Rich, filterable pricing insight cards plus single-card lookup with full recommendation detail, complementing my_insights_summary. Filter by severity, type, status, or product, or fetch one insight by id. Params: optional filters, optional insightId.

API key required for every tool

Each of the 10 tools requires a valid API key linked to a customer account. Results are limited to your own tracked products, scans, and competitor data, so your account needs tracked products and recent scan history to return data.

Example Prompts

Once connected, try these prompts in your AI client to see each tool in action. Every prompt runs against your own portfolio and requires a valid API key.

my_products

“Show me all the products I'm tracking.”
“List my tracked products in the Electronics category.”
“Which of my tracked products are paused?”

my_price_position

“How does my pricing compare to the market overall?”
“What's my price position for SKU-12345?”
“Am I priced above or below my competitors across my portfolio?”

my_scan_results

“Show me my most recent scan results.”
“Did my last scan complete successfully?”
“List my failed scans.”

my_price_changes

“What price changes happened in the last 7 days?”
“Show me competitor price drops over the past month.”
“Which competitors raised prices recently?”

my_competitor_overview

“Give me an overview of my competitors.”
“Who are my top competitors and how many products do we overlap on?”
“How many of my products are being undercut?”

my_insights_summary

“Summarize my latest pricing insights.”
“Show me only high-severity pricing insights.”
“What pricing actions do you recommend right now?”

export_scan_report

“Export my latest scan report as a CSV.”
“Download the report for scan <scan-id>.”
“Give me a CSV of my Electronics scan results.”
“Export my scan report as JSON.”

my_price_history

“Plot competitor prices for SKU-123 this quarter.”
“Show me the price history for SKU-12345 over the last 90 days.”
“How have my competitors' prices for SKU-123 trended over time?”

my_scan_status

“Is my data fresh?”
“When did my last scan run and how complete was it?”
“How old is my latest pricing data?”

my_insight

“Show the full recommendation for my top critical insight.”
“List all my open high-severity insights in the Electronics category.”
“Give me the full details for insight <insight-id>.”

Troubleshooting

Connection refused or timeout

Verify the URL is exactly https://mcp.nesika.ai/mcp.
Check your internet connection and any outbound proxy rules.

401 Unauthorized

Confirm your API key starts with nes_.
Generate a fresh key from Settings → API Keys if needed.
Make sure the selected auth method matches your client config.

Claude Desktop: Some MCP servers could not be loaded

If you are using mcp-remote, make sure Node.js is installed.
On Windows, use the full path to mcp-remote.cmd if the default command fails.

Windsurf: tools not appearing

Use serverUrl, not url.
Reload the window after saving the config file.

VS Code: no tools in Copilot Chat

Use VS Code 1.101+ with the GitHub Copilot extension installed.
Switch Copilot Chat to Agent mode.
Check the MCP output panel for config or connection errors.

ChatGPT: search action not found

Enable Developer Mode under Settings → Apps & Connectors → Advanced settings.
Reconnect the app after turning Developer Mode on.

Tools return empty results

The tools only return data when your Nesika account has tracked products and scan history.
Run a scan from your dashboard first, then retry. For export_scan_report, use a valid scanId or leave it as latest.

Need help?

Contact our team at support@nesika.ai or visit the Agents Developer Portal for more resources.

← Previous: API Keys Next: Exporting Data →