Skip to main content
Glama

negotiate-mcp

PyPI

Model Context Protocol (MCP) server for the negotiate.v1 protocol. Once installed in Claude Desktop, Cowork, Claude Code, or any other MCP-aware client, your Claude gains five native tools for negotiating with any negotiate.v1-compliant store.

What you get

Tool

Purpose

discover_store(domain)

Probe a domain to check if it's negotiable. Returns the protocol descriptor.

list_products(domain)

Enumerate negotiable products at the store.

start_negotiation(domain, product_id)

Open a chat session with the merchant agent.

send_message(next_url, message)

Send one shopper turn.

read_history(history_url)

Read the running history of a session.

The agent uses these like a human would use a browser: discover the store, pick a product, start a chat, send turns until the deal closes.

mcp-name: io.github.sanjana-pier39/negotiate-mcp

Related MCP server: wafle MCP server

Install

The recommended path uses uv — no virtualenv plumbing, picks the right Python automatically.

# install uv if you don't have it (macOS):
brew install uv

# then point Claude Desktop / Cowork / Claude Code at it (see below).
# uvx will install the package the first time it's invoked.

If you'd rather use plain pip:

pip install negotiate-mcp

Wire it into Claude Desktop

  1. Open your Claude Desktop config:

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

    • Windows: %APPDATA%\Claude\claude_desktop_config.json

  2. Add this entry under mcpServers (creating the file if it doesn't exist):

    {
      "mcpServers": {
        "negotiate-agent": {
          "command": "uvx",
          "args": ["negotiate-mcp"]
        }
      }
    }

    See claude_desktop_config.example.json.

  3. Quit and re-open Claude Desktop. The five tools should appear in any new conversation.

If you installed with plain pip instead of uv, replace the command/args block with:

"command": "negotiate-mcp",
"args": []

Wire it into Cowork or Claude Code

Same negotiate-mcp command. Add it to the corresponding MCP config in those clients (consult their docs for exact paths). The tool surface is identical.

Try it

Once installed, in a fresh chat:

Negotiate for a Dyson HP07 at negotiate.pier39.ai. Try to get it under $500. Bonus points for the engraved gift box.

Claude will call discover_store("negotiate.pier39.ai"), find the HP07 in the product list, call start_negotiation, then drive the conversation through send_message until closed: true. No prompt acrobatics needed.

Test standalone (no Claude required)

# Run the server on stdio:
uvx negotiate-mcp

# Or, if you've used pip:
python -m negotiate_mcp

Most useful when paired with the mcp CLI to inspect tool definitions and exercise them by hand.

Adding more stores

The connector works against any negotiate.v1-compliant store, not just the Atlas reference (negotiate.pier39.ai). As stores adopt the protocol, just point your shopper agent at their domain — the same five tools work everywhere.

See PROTOCOL.md for the full spec.

Develop locally

git clone https://github.com/sanjana-pier39/negotiate-mcp
cd negotiate-mcp
pip install -e .
python -m negotiate_mcp     # runs on stdio

To publish a new version, see PUBLISH.md.

License

MIT.

Available Tools

6 tools
discover_storeA
Read-onlyIdempotent

Probe a domain to discover whether it speaks the negotiate.v1 protocol.

Fetches /negotiate.json (with /.well-known/negotiate.json fallback) and validates the schema. Returns the full protocol descriptor on success.

Args: domain: Site to probe. Accepts 'example.com', 'https://example.com', or with trailing slash.

Returns: The negotiate.v1 descriptor: store info, endpoints, products, limits.

Raises: RuntimeError if the domain doesn't speak negotiate.v1 or can't be reached.

Inputs: domain (required).

find_storesA
Read-onlyIdempotent

Find negotiate.v1-compliant stores matching a search query or category.

Use this when the shopper asks to negotiate for something but hasn't specified a particular store. Search by free-text product name, category, or both. Returns a ranked list of matching stores; pick one and pass its domain to start_negotiation.

Args: query: Free-text search across store name, tagline, categories, and product names. Empty string matches all stores. category: Filter by category tag (e.g., "appliances", "books", "fitness", "office", "fashion"). Empty string skips filter.

Returns: List of matching store dicts. Each entry has: - name: human-readable store name - domain: the domain to pass to discover_store / start_negotiation - tagline: short marketing line - categories: list of category tags - products_count: how many products are listed - sample_products: a few example product names

Empty list if nothing matches. Raises RuntimeError if the directory
is unreachable on first call.

Inputs: query, category. Returns: result

list_productsA
Read-onlyIdempotent

List products available for negotiation at a store.

Fetches the store's negotiate.json and returns a paginated, optionally filtered slice of the products array. Each product has id, name, kind, list_price, page_url, and start_chat_url.

Args: domain: Site to query. Same accepted forms as discover_store. query: Optional case-insensitive substring filter against product name and id. Empty string matches all. limit: Max products to return (default 50, max 100). Stores can have thousands of SKUs — keep this small to avoid hitting the MCP 1MB result-size cap. offset: Skip this many matches before returning (default 0). Use with limit to paginate through large catalogs.

Returns: { "total_in_store": int, # total products at this store "matched": int, # how many matched the query "returned": int, # how many returned in this page "offset": int, "limit": int, "products": [ ... ], # the page of results "more_available": bool, # True if matched > offset+returned "next_offset": int|None, # pass to next call, or None if done }

Inputs: domain (required), query, limit, offset.

read_historyA
Read-onlyIdempotent

Read the running history of a chat session.

Useful for resumption or for double-checking what's been said. The history_url comes from the read_history endpoint in the store's descriptor — typically /api/store/chat/<session_id>.

Args: history_url: Full URL to the history endpoint with session_id substituted.

Returns: Dict with session_id and history (list of {speaker, message}).

Inputs: history_url (required).

send_messageA

Send one shopper turn in an active negotiation.

Take the 'next' URL from the previous response (returned by start_negotiation or the previous send_message call), substitute your URL-encoded shopper message, and fetch.

Args: next_url: The 'next' URL from the previous response. Should contain a {url_encoded_message} placeholder. message: Your shopper turn, plain text. Will be URL-encoded.

Returns: Dict with the merchant's reply, a 'closed' flag, and the next URL for the following turn (or null if the negotiation is closed).

Inputs: next_url (required), message (required).

start_negotiationA

Open a new negotiation session for a specific product.

Looks up the start_chat URL template from the store's descriptor, substitutes the product_id, fetches the result. The merchant agent's opening greeting is in the response.

Args: domain: Site to negotiate at. product_id: Must be one of products[].id from list_products().

Returns: Dict with session_id, greeting (merchant's opener), and next URL for the next turn (with {url_encoded_message} placeholder).

Inputs: domain (required), product_id (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.6/5.0

    Scored across 6 tools

    Disambiguation5/5

    Every tool has a distinct purpose with no overlap. discover_store probes a specific domain, find_stores searches across stores, list_products enumerates products, and the three negotiation tools handle distinct phases of a chat session.

    Naming Consistency5/5

    All tool names follow the verb_noun pattern consistently: discover_store, find_stores, list_products, read_history, send_message, start_negotiation. The convention is uniform throughout.

    Tool Count5/5

    Six tools is ideal for a negotiation protocol: discovery, search, listing, session start, messaging, and history. The count is well-scoped and each tool is essential.

    Completeness4/5

    The tool surface covers the full negotiation workflow from store discovery to chatting. A minor gap is the lack of an explicit cancel/close negotiation tool, but the 'closed' flag in send_message responses provides a workaround.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      MCP server that lets Claude (or any MCP-compatible client) compare on-demand compute + storage pricing across AWS, Azure, and GCP in real time.
      39
      638 PyPI
      2
      MIT
    • F
      license
      A
      quality
      C
      maintenance
      An MCP server that exposes marketplace seller operations (Shopee first) as tools Claude can call, enabling automation of product, pricing, inventory, customer service, and other seller tasks.
      32
      -
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that wraps the Universal Commerce Protocol (UCP) Discovery and Catalog capabilities, letting you search and compare products across UCP merchants directly from Claude.
      4
      MIT