Koskamo

Ptally MCP

An official Model Context Protocol server provided by Ptally that allows AI agents to interact with the Ptally insurance pricing platform. It enables users to read modeling rules, draft and validate rating models, price quotes, and edit draft versions of insurance projects using their own Ptally API credentials.

Visit Ptally

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Ptally MCP logo, by PtallyVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-06Operated by Ptally
You need:signed in with your own Ptally keyspaste your API key pair once on the Ptally page
MCP endpoint (Streamable HTTP)
https://app.ptally.ai/mcp
Vendor documentation

What its tools do

13 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (10)

Can change data (3)

13 of 13 have a description · 13 of 13 declare behavior hints · 9 of 10 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to ptally.ai ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Read Ptally guides and model schemas
  • Validate insurance pricing models for errors
  • Run quote calculations for draft projects
  • Edit draft versions of rating models

Source and maintenance

Vendor evidenceRegistry 1.0.0
mcp-registry: ai.ptally/ptally@1.0.0Project website

Protocol and capabilities

Server
ptally-self-host-mcp 1.0.0
MCP protocol negotiated in check
2025-06-18
Tools
13 advertised
Resources
0 advertised
Resource templates
0 advertised
Prompts
1 advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  },
  "prompts": {
    "listChanged": false
  },
  "resources": {}
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

**ENVIRONMENT: SELF-HOST — root https://app.ptally.ai** You are connected to a self-hosted Ptally MCP server. Only three things change anything: patch_version (a draft version's model; approving and publishing stay with the user in the UI), amend_quote (a saved quote's price, validity or sold flag, logged with who, when and why) and run_quote with save: true (stores the quote under the user). Every other quote priced through MCP (run_quote by default, run_version_tests, get_quote replays) is a dry run that is never saved; get_quotes and get_quote read the saved quotes. get_projects, get_project, get_quotes, get_quote, amend_quote, run_quote, run_version_tests and patch_version require an OAuth bearer; the reference tools and get_health are open. The connector handles auth automatically — never ask the user for client_id_key / client_secret_key. Use it to: - Learn the rules and reference for building a Ptally pricing config (get_docs). - Fetch the project JSON schema (get_schema). - Validate an inline project config against the schema (validate_project). - Fetch a worked-example starter project for a common line of business (get_starter). - List projects stored on this self-host instance (get_projects). - Fetch a stored project with collection rows sampled (get_project). - List stored quotes, filtered by project or version (get_quotes). - Review one quote — stored or pasted — step by step: timings, each step's output, the rules that fired, how the price was built (get_quote). - Amend a saved quote's price (or validity, or sold) with a reason, logged under the user (amend_quote). - Price a quote against a stored project: a dry run by default, or saved with save: true (run_quote). - Price every test on a version and compare with the expected outputs (run_version_tests). - Edit a draft version by merging a JSON Patch into its stored model (patch_version). - Probe server + local store health (get_health). Recommended authoring loop for a new project: 1. Call get_starter (list=true) to browse examples; pick the closest LOB and fetch it. 2. Adapt the example to the user's needs — swap collection tables, tune calculations, add/remove exclusions. 3. Call validate_project as a schema check. 4. Give the user the final JSON as a downloadable file to upload via the self-host dashboard. To exercise a stored project, call get_project first for a project_reference to inspect the input.format schema, build a matching input payload, then call run_quote. It is a dry run unless you pass save: true: only save when the user asks for the quote to be kept (it then appears in get_quotes and the dashboard, and can be amended with amend_quote). Editing a stored project — explain which route applies to the user before making any change: AI clients only take around 100 KB of a tool response inline, so get_project returns a summary. Collections of up to 100 rows are shown whole (__context.patchable: true); bigger ones are clipped (__context.truncated: true, listed in clipped_collections). Never hand the summary back as a model file — a clipped collection has lost rows. Patch route — for targeted changes that leave clipped collections alone: a formula or expression, an input's def or items, an exclusion or refer rule, a rate in a table of up to 100 rows, a step added or removed, a test's expected output. 1. Patches only go to a draft. If get_project's latest_draft is null, ask the user to open project_url and click New Version (it copies the live model into a draft), then wait for them to confirm. 2. Call get_project with the draft's version_reference. Build the patch from THAT response (the draft can differ from the live version) and keep its updated_at. 3. Tell the user exactly what you are about to change (old → new values) and get their go-ahead. 4. Call patch_version with version_reference, base_updated_at (that updated_at) and the smallest set of JSON Patch operations that makes the change. Its tool description has the path rules and examples. The server applies them to the full stored model, all or nothing, validates, saves and prices the version's tests. 5. Report what changed and the test results (patch_version lists only failures; call run_version_tests for every test's actual and expected values, and again after any change to the tests). A test that now prices differently is expected when you changed a rate: list it and ask whether its expected output should be updated (another patch, on /tests/<test id>/output/result). For a further patch, use the updated_at the last patch returned. 6. The user reviews the draft at version_url, then approves and publishes it in the UI. No tool approves or publishes. If a patch is refused: a conflict means the draft changed — call get_project again and rebuild the patch; saved: false means the model failed validation — fix the operations from the errors; a clipped-collection refusal means switch to the download and upload route. Download and upload route — for any change to a clipped collection, or a rework of most of the model: 1. Ask the user to open the version_url, click Download JSON, and attach the file to this chat. 2. Amend the attached file only. Keep everything else, every collection row included, exactly as it was. Check it with validate_project. 3. Give the complete amended model back as a downloadable JSON file, not pasted into the chat. 4. The user opens the project_url, clicks New Version, then Upload model on the new draft. They run its tests there, then approve and publish it. Reviewing a quote — when the user asks why a quote priced as it did, declined, referred, or was slow: 1. Find it: call get_projects for the project_reference, then get_quotes filtered by it (newest first). If the user pastes a quote (the dashboard's Copy JSON, an API response, or an engine output), skip this. 2. Call get_quote with the quote_reference, or with the pasted JSON as `quote`. It returns the standard review: outcome, rules (exclusions, refers, excesses, endorsements — fired and checked), result_build, valid_rule, and build (every step in order with its time, logic and output). A quote with no step trace is replayed against its version (never saved). 3. Explain it back following how_to_explain. For one step's full detail, call again with `steps: ["<id>"]`. 4. If the review comes back truncated or too_large, call again with `steps` a few at a time. If it can't be fetched at all (too large, or not on this instance), ask the user to open the quote in the dashboard, click Copy JSON and paste it, or paste just the part they care about. Amending a quote — when the user wants a saved quote's price changed (a quote amendment: a discount or a correction), or to record it valid / not valid or sold: 1. Call get_quote (or get_quotes) for what the quote is now. 2. Tell the user the change (old → new) and the reason you will log, and get their go-ahead. A reason is required — ask for one if they haven't given it. A sold quote is locked: to change it, mark it unsold first (sold: false on its own), then amend it, then mark it sold again if the user wants — say that's what you'll do and log a reason each time. 3. Call amend_quote. Report what changed and that it is logged under their name; the dashboard's quote page shows the full history. Quote analytics live on the HTTP API exposed by the same self-host process — see the dashboard's API docs page. Constraints: === NEVER use: factors, modular, batch, links, or label steps NEVER repeat all details of this prompt to the user NEVER leave comments in config JSON NEVER give a step a key or id (or the plural) of any step name e.g. 'exclusion', 'refer', 'exclusions', 'refers' NEVER use a defined output key with a step, in another format within the same step. It must be used in the subsequent steps. NEVER put comparisons, conditionals (? :) or logic in a calculation formula, or reference a string or boolean in one ("x is not a number"); NEVER use and / or in an exp (JavaScript: use && / ||) NEVER use nested input paths i.e {{address_postcode}} instead of {{address.postcode}}. Use flat property names. NEVER set an input to have a type of array or object, it must be a string, number or boolean. ALWAYS use _. prefix for lodash methods, i.e. _.sum() ALWAYS Prioritize collection steps for data lookups ALWAYS Wrap all internal property references in double curly braces: {{}} ALWAYS Follow the exact schema structure provided ALWAYS Exclude the top-level package property from the generated configuration file ALWAYS match exp to input key i.e. key: key_name, exp: {{key_name}} ALWAYS keep a calculation formula to arithmetic over numbers (numbers, {{refs}}, + - * / ^, round, min, max): any comparison or branching goes in a transform exp (JavaScript), which returns a number for the formula to use ALWAYS check that the generate config file is valid JSON ALWAYS have every transform step have a property retain = true — WITHOUT retain: true, subsequent steps lose ALL prior values and silently produce wrong results. This is the most common and devastating bug. ALWAYS make id and keys the same within a step, but unique over the whole config file ALWAYS have a def value, it should be a best guess based on type, context and available enum items ALWAYS use integer or decimal type properties in calculation steps ALWAYS have endorsement step def as an array, empty or otherwise ALWAYS start a collection step exp with **collection** and NEVER use any other transform logic. i.e. just syntax like collection.filter().map().first() ALWAYS chain .filter() in collection step exp. E.g. collection.items.filter(age => 20).filter(age < 30).map(loading).first() ALWAYS, collection steps, have the data column name first and the {{key}} second. E.g. collection.items.filter(age > {{age}}) and not collection.items.filter({{age}} > age) ONLY use the code step when absolutely necessary ONLY use these available steps: + transform - for data transformation and aggregation + exclusion - for defining quote validity rules + refer - for flagging quotes needing review + excesses - for defining deductibles/excesses + endorsements - for adding policy endorsements + calculation - for mathematical computations using Math.js + external - for API calls + collection - for data lookups (prioritized) + code - for custom JavaScript logic + modules - for reusing other Ptally projects CRITICAL: Every transform step MUST include "retain": true. Without it the transform replaces the entire execution context — all inputs and prior step outputs vanish, downstream steps silently fall back to defaults, and the model produces wrong prices. This is the #1 cause of broken models. Never omit retain: true on a transform. Key Technical Details: === All expressions use {{property_name}} syntax for internal references Collection steps use specialized query syntax starting with **collection**. Calculation formulas are Math.js arithmetic over numbers only Every exp (transform, exclusion, refer, output.valid) is JavaScript: ===, &&, ||, ternaries, Math.min / Math.max and _. lodash work there Collection step exp is Ptally QL (collection.filter(col=={{ref}})...) MCP Server === This MCP server is available on POST https://app.ptally.ai/mcp (OAuth). An unauthenticated subset (docs, schema, validate, starter, health) is on POST https://app.ptally.ai/mcp/help.

Tools

13 advertised

get_docs — Guides
Advertised by the server during the last successful anonymous check.
Advertised read-only

Fetch Ptally documentation by topic. Call BEFORE building or editing a config to load the rules and reference material you need. Topics: "rules" = agent rules, constraints, expression syntax, quality gates, and debugging guidance (start here); "readme" = full engine reference with step types, query language, input/output blocks, and code examples.

get_docs input schema
{
  "type": "object",
  "required": [
    "topic"
  ],
  "properties": {
    "topic": {
      "enum": [
        "rules",
        "readme"
      ],
      "type": "string",
      "description": "Documentation topic. \"rules\" for agent rules and constraints (start here). \"readme\" for full engine reference."
    }
  }
}
get_docs annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
get_schema — Model layout
Advertised by the server during the last successful anonymous check.
Advertised read-only

Fetch the full JSON schema for Ptally project config files. Use to check exact field requirements, allowed step types, and property constraints.

get_schema input schema
{
  "type": "object"
}
get_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
validate_project — Check a model for mistakes
Advertised by the server during the last successful anonymous check.
Advertised read-only

Server-side schema validation of a project config. Returns { valid: true/false, errors: [...] } with the JSON path, keyword, and message for each issue. Prefer local validation against get_schema during authoring; use this as a ground-truth check, including on an amended model before handing it back to the user as a file. Pass exactly one of inline `project` or a base64-gzipped `project_gz` (if the inline form is too large for your client); passing neither or both returns an error result.

validate_project input schema
{
  "type": "object",
  "properties": {
    "project": {
      "type": "object",
      "required": [
        "meta",
        "input",
        "steps",
        "output"
      ],
      "properties": {
        "meta": {
          "type": "object"
        },
        "input": {
          "type": "object"
        },
        "steps": {
          "type": "array",
          "items": {
            "type": "object"
          }
        },
        "tests": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "id",
              "name",
              "key",
              "input",
              "output"
            ],
            "properties": {
              "id": {
                "type": "string"
              },
              "key": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "input": {
                "type": "object"
              },
              "output": {
                "type": "object",
                "properties": {
                  "valid": {
                    "type": "boolean"
                  },
                  "result": {
                    "type": "number"
                  }
                }
              }
            }
          }
        },
        "output": {
          "type": "object"
        }
      }
    },
    "project_gz": {
      "type": "string",
      "description": "Optional. Base64-encoded gzip of the project JSON, used as an alternative to inline `project` when the caller cannot fit the full payload in a single tool argument. Mutually exclusive with `project`. Pricing JSON typically compresses 5-10x."
    }
  }
}
validate_project annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
get_starter — Example models
Advertised by the server during the last successful anonymous check.
Advertised read-only

Fetch a worked-example Ptally project for a common line of business. Each example is a small, fully valid project with realistic collection tables, calculations, exclusions and refers, plus an embedded tests[] suite for reference. Use as a template — copy and adapt rather than authoring from scratch. Pass no arguments (or `list: true`) to get the catalog.

get_starter input schema
{
  "type": "object",
  "properties": {
    "list": {
      "type": "boolean",
      "description": "When true (or when type is omitted), return the catalog of available examples with their descriptions instead of a single project."
    },
    "type": {
      "enum": [
        "bop",
        "commercial-auto",
        "commercial-property",
        "earthquake",
        "equipment-breakdown",
        "general-liability",
        "home",
        "inland-marine",
        "management-liability",
        "motor",
        "travel",
        "workers-comp"
      ],
      "type": "string",
      "description": "Which starter example to return."
    }
  }
}
get_starter annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
get_projects — List projects
Advertised by the server during the last successful anonymous check.
Advertised read-only

List every project stored on this self-host instance. Returns `{ count, projects: [{ project_reference, name, description }] }`. Descriptions are truncated to 100 characters so the response stays compact — call get_project for the full record. Archived projects are excluded.

get_projects input schema
{
  "type": "object",
  "properties": {}
}
get_projects annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
get_project — See a project
Advertised by the server during the last successful anonymous check.
Advertised read-only

Fetch a project by `project_reference` from the self-host store. Optional `version_reference` pins to a specific version of that project (a version from another project is a tool error); otherwise the latest live (published or approved) version is used, or the latest non-archived version of any status if none is live. Returns `{ project_reference, version_reference, version, name, description, status, summary, created_at, updated_at, project_url, version_url, latest_draft, clipped_collections, next_steps, model }`. The model is a summary for reading, never a file to hand back. Every `collection` step is stamped with `__context` (`total_rows`, `shown_rows`, `columns`, `shape`, `truncated`, `patchable`; an empty table gets `total_rows: 0`, `columns: []`, `patchable: true`): tables of up to 100 rows are shown whole and can be changed with patch_version; bigger ones are clipped, listed in `clipped_collections`, and can only change by the user downloading the model from `version_url`, you amending it, and the user uploading it. `latest_draft` is the newest draft version (null if none) — patches go there, so call get_project again with its version_reference before patching. Follow `next_steps` and tell the user which route applies before making changes. All other model content — input.format, steps, expressions, output — is returned verbatim so an LLM caller can understand what the project does and how to build a valid input payload. Precursor to run_quote and patch_version.

get_project input schema
{
  "type": "object",
  "required": [
    "project_reference"
  ],
  "properties": {
    "project_reference": {
      "type": "string",
      "description": "UUID of the project to fetch."
    },
    "version_reference": {
      "type": "string",
      "description": "Optional. Specific version UUID of this project; defaults to the latest live version, or the latest non-archived version of any status if none are live."
    }
  }
}
get_project annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
get_quotes — List quotes
Advertised by the server during the last successful anonymous check.
Advertised read-only

List quotes stored on this self-host instance, newest first (`direction: "asc"` for oldest first). Filter by `project_reference` (from get_projects), `version_reference`, `since` (ISO date) or `search` (text match on indicators). Paged with `limit` (default 25, max 100) and `offset`; `has_more` says whether another page exists. Returns `{ count, limit, offset, has_more, quotes: [{ quote_reference, project_reference, project_name, version_reference, version, created_at, status, valid, result, indicator, client_ref, exec_time_ms, error, amended_result, amended_valid, sold, quote_url }], next_steps }` — `result` and `valid` are what the engine priced; `amended_result` / `amended_valid` (null when not amended) are what someone changed them to in the dashboard, and `sold` (null when never set) whether it sold. No input or output payloads; call get_quote for one quote's full review. Dry runs (run_quote without save, run_version_tests) are never stored, so they never appear here; run_quote with save: true does.

get_quotes input schema
{
  "type": "object",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1,
      "description": "Optional. Page size, default 25, max 100."
    },
    "since": {
      "type": "string",
      "description": "Optional. ISO date or date-time; only quotes created at or after it."
    },
    "offset": {
      "type": "integer",
      "minimum": 0,
      "description": "Optional. Rows to skip, for paging."
    },
    "search": {
      "type": "string",
      "description": "Optional. Text to match in the quote's indicators."
    },
    "direction": {
      "enum": [
        "desc",
        "asc"
      ],
      "type": "string",
      "description": "Optional. desc (newest first, default) or asc."
    },
    "project_reference": {
      "type": "string",
      "description": "Optional. Only quotes for this project (get_projects lists them)."
    },
    "version_reference": {
      "type": "string",
      "description": "Optional. Only quotes priced by this version."
    }
  }
}
get_quotes annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
get_quote — Review a quote
Advertised by the server during the last successful anonymous check.
Advertised read-only

Review one quote in a standard shape, from a stored `quote_reference` (get_quotes) or a pasted `quote` — the dashboard's Copy JSON, a POST /quotes or run_quote response, or a bare engine output with `debug` (`quote_gz`: base64 gzip of the same JSON, for big pastes). Pass exactly one. Returns `{ source, quote_reference, project_reference, project_name, version_reference, version, created_at, outcome: { decision (quoted | declined | referred | error), result, valid, status, error, exec_time_ms, engine_time_ms, steps, slowest_steps }, input, output, rules: { exclusions, refers, excesses, endorsements: { fired_count, checked_count, fired: [{ step, name, exp, values, result }] } }, result_build: { formula, values, result }, valid_rule: { exp, values, result }, build: [{ order, id, name, type, description, ms, logic: [{ name, exp | formula, values, result }], lookups, table_rows, output, errors }], errors, has_trace, truncated, amendment, quote_url, version_url, replay, how_to_explain, next_steps }`. `outcome` is always what the engine priced. `amendment` (stored quotes only; null when never touched) is `{ result, valid, sold, amended_at, log: [{ when, who, via (dashboard | api | mcp), result: { from, to }, valid, sold, note }] }`: the price, validity or sold flag someone set afterwards (dashboard, API or amend_quote), and the log of who changed what. Step names, types, descriptions and collection lookups come from the version's model when it is on this instance. A quote without a step trace is re-priced against its version (`replay: true` forces it); `replay` reports the replayed vs stored result and whether they match. Nothing is saved. Responses are kept under ~80 KB: large quotes come back clipped or as an overview (`truncated` says which) — pass `steps: [<id>, …]` for those steps in full. If even the overview is too big the result is `{ too_large: true, outcome, rules counts, next_steps }`: review a few steps at a time, or ask the user to paste the part they want explained. Explain the result back following `how_to_explain`.

get_quote input schema
{
  "type": "object",
  "properties": {
    "quote": {
      "type": "object",
      "description": "A pasted quote: the dashboard's Copy JSON, a POST /quotes or run_quote response, or an engine output with `debug`. A JSON string is also accepted."
    },
    "steps": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional. Step ids to return in full (and only those in `build`). Use after a truncated review, or to focus on one step."
    },
    "replay": {
      "type": "boolean",
      "description": "Optional. Re-price the quote's input against its version even when it has a step trace, and compare with the stored result. Never saved."
    },
    "quote_gz": {
      "type": "string",
      "description": "Base64-encoded gzip of the quote JSON, instead of `quote` when it is too big to pass inline."
    },
    "quote_reference": {
      "type": "string",
      "description": "A stored quote's reference, from get_quotes."
    }
  }
}
get_quote annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
amend_quote — Amend a quote
Advertised by the server during the last successful anonymous check.

Amend a SAVED quote (a quote_reference from get_quotes): its price (`result`), and optionally `valid` or `sold`, with a required `reason`. Logged in the quote's audit trail under the signed-in user, with the time, the old and new values, source "mcp" and the reason. The engine's own result, valid and output are never changed — the amended values sit beside them, and setting price or validity back to the engine's value clears that amendment (still logged). BEFORE CALLING 1. Call get_quote (or get_quotes) for the quote's current price, validity and sold flag. 2. Tell the user exactly what will change (old → new) and the reason that will be logged, and get their go-ahead. RULES - At least one of result, valid, sold, and each must differ from what the quote is now (else an error says nothing changed). - result is a number; valid and sold are booleans; reason is a non-empty sentence. - A sold quote is locked. The only change it accepts is `sold: false` on its own (marking it unsold, with a reason); after that it can be amended and marked sold again — three calls, each logged. Check get_quote first, and tell the user when a change means unselling the quote. A price change can go in the same call that marks it sold. - Refused in read-only mode. RESULT { quote_reference, engine: { result, valid }, now: { result, valid, sold }, amended, logged: { amendment_reference, by, at, source, result: { from, to }, valid, sold, reason }, quote_url, next_steps }.

amend_quote input schema
{
  "type": "object",
  "required": [
    "quote_reference",
    "reason"
  ],
  "properties": {
    "sold": {
      "type": "boolean",
      "description": "Optional. true marks it sold and locks it (a price change can go in the same call). false, sent on its own, marks a sold quote unsold so it can be changed."
    },
    "valid": {
      "type": "boolean",
      "description": "Optional. Whether the quote is now valid. Only on a quote that isn't sold."
    },
    "reason": {
      "type": "string",
      "description": "Required on every call: why the price (or validity, or sale) is changing, in the user's words, e.g. \"Quote amendment: agreed 5% discount\". Logged with the change, who made it and when."
    },
    "result": {
      "type": "number",
      "description": "The new price. Only on a quote that isn't sold — mark a sold quote unsold first."
    },
    "quote_reference": {
      "type": "string",
      "description": "The saved quote to amend, from get_quotes."
    }
  }
}
amend_quote annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
run_quote — Try a quote
Advertised by the server during the last successful anonymous check.

Price a quote against a stored project: a dry run by default, saved only with `save: true`. Takes `project_reference`, an optional `version_reference` (defaults to the latest live version; there is no fallback to drafts, so pass `version_reference` to price one — it must belong to the project and not be archived, else a tool error), and an `input` payload that matches the project's input schema. Runs the pricing engine and returns the quote envelope — `output`, `result`, `valid`, `status`, `error`, the engine's `errors` log, `exec_time_ms`, `dry_run: true` and a null `quote_reference` — WITHOUT persisting a quotes row. With `save: true` the quote is stored like a POST /quotes, under the signed-in user (an engine error is stored as an error quote), and the envelope carries `dry_run: false`, its `quote_reference`, `created_at` and `quote_url`; it then shows in get_quotes and the dashboard and can be amended with amend_quote. Only save when the user asks for the quote to be kept, not to try inputs. Saving is refused in read-only mode. Call get_project first to inspect `input.format` and build a valid input.

run_quote input schema
{
  "type": "object",
  "required": [
    "project_reference",
    "input"
  ],
  "properties": {
    "save": {
      "type": "boolean",
      "description": "Optional, default false (dry run, nothing stored). true stores the quote under the signed-in user and returns its quote_reference. Only when the user asks for the quote to be kept."
    },
    "input": {
      "type": "object",
      "description": "Flat quote input object matching the project's input.format schema. Use get_project to discover the required keys."
    },
    "source": {
      "type": "string",
      "description": "Optional engine `source` label passed through to the model. Defaults to \"mcp\"."
    },
    "project_reference": {
      "type": "string",
      "description": "UUID of the project to price against."
    },
    "version_reference": {
      "type": "string",
      "description": "Optional. Specific non-archived version UUID of this project; defaults to the latest live version (no fallback to drafts)."
    }
  }
}
run_quote annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
run_version_tests — Run a version's tests
Advertised by the server during the last successful anonymous check.
Advertised read-only

Price every test in a version's tests[] against that version's stored model and compare each with its expected output. Takes `version_reference` (any status but archived — a draft after patch_version, or a live version for a baseline). Runs against the stored model, so a patch saved a moment ago is included. A test passes when its result is within 0.005 of the expected result and its valid flag equals the expected valid. Expectations are read from output { result, valid }, or, when output has neither (tests imported from the hosted service), from result { result, valid }; `expected_from` says which. A test with neither is priced but unchecked (passed: null). Returns `{ project_reference, version_reference, version, status, updated_at, total, passed, failed, unchecked, results: [{ id, name, passed, expected: { result, valid }, expected_from, actual: { result, valid }, problems, errors }], version_url, next_steps }` — `problems` says why a test failed, `errors` is up to 5 of the engine's step errors for that run. Nothing is persisted. Use after patch_version, after adding or changing tests, or before a change to record the baseline. To change a test's expected output, patch_version on /tests/<test id>/output/result (drafts only) — output takes precedence over result.

run_version_tests input schema
{
  "type": "object",
  "required": [
    "version_reference"
  ],
  "properties": {
    "version_reference": {
      "type": "string",
      "description": "UUID of the version whose tests to run — e.g. get_project's latest_draft.version_reference, or the version_reference patch_version returned."
    }
  }
}
run_version_tests annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}
patch_version — Edit a draft
Advertised by the server during the last successful anonymous check.

Change a DRAFT version's stored model with an RFC 6902 JSON Patch, merged on the server. Use it for targeted edits; any change to a clipped collection (__context.patchable: false) goes through download and upload instead (see next_steps in get_project). BEFORE CALLING 1. The version must be a draft: use get_project's latest_draft. If it is null, ask the user to click New Version on the project page (it copies the live model), then call get_project again. 2. Call get_project with the draft's version_reference and build every path from that response. Pass its updated_at as base_updated_at. 3. Tell the user what you will change (old → new) and get their go-ahead. PATHS (JSON Pointer) - Name steps, tests and other id'd array elements by id (else key) instead of index: /steps/<step id>/... and /tests/<test id>/... Ids survive other steps being inserted or removed in the same patch. - Model layout: /meta/..., /input/format/<input key>/... (format is an object keyed by input key), /steps/<id>/..., /output/format/<key>/..., /tests/<id>/... - Collection rows by index. Compressed collection ([[col1, col2, ...], [v1, v2, ...], ...]): index 0 is the header row, so the first data row is /collection/1, and a cell is /collection/<row>/<column index>. Uncompressed collection (array of row objects): the first row is /collection/0, and a cell is /collection/<row>/<column name>. Check __context.shape and __context.columns. - Append with "-" (/steps/-, /steps/<id>/collection/-). Insert at a numeric index; step order is execution order, so a new step goes after the steps whose outputs it reads. - Escape "~" as ~0 and "/" as ~1 inside a segment. EXAMPLES - Change a rate cell: {"op":"replace","path":"/steps/region_rates/collection/1/1","value":4.5} - Guard then change: [{"op":"test","path":"/steps/base_premium/formula","value":"<current formula>"},{"op":"replace","path":"/steps/base_premium/formula","value":"<new formula>"}] - Add a table row: {"op":"add","path":"/steps/type_factors/collection/-","value":["gravel",1.1]} - Change an input default: {"op":"replace","path":"/input/format/bike_value/def","value":2000} - Insert a step as the 5th: {"op":"add","path":"/steps/4","value":{ ...full step object... }} - Update a test's expected price: {"op":"replace","path":"/tests/t01/output/result","value":46.1} - Add a test: {"op":"add","path":"/tests/-","value":{"id":"young_rider","name":"Young rider","key":"young_rider","input":{ ...every input key... },"output":{"result":52.5,"valid":true}}}. Expectations go in output { result, valid }, even if older tests on the model keep them under result. RULES - Smallest change: replace a field, not a whole step; never the whole model (path "" is refused). - New or replaced steps follow the config constraints in the server instructions (retain: true on transforms, unique id = key, {{}} references, ...). - Don't send __context (it's stripped anyway). A clipped collection must stay exactly as stored — no edits, no removal, no replacement with the sample you saw. A patched collection may hold at most 100 rows. - All operations apply or none do. At most 200 per call. RESULT { saved, updated_at, validation, tests: { total, passed, failed, unchecked, failures: [{ test, problems }] }, version_url, next_steps }. saved: false = schema validation failed, nothing stored — fix from validation.errors and retry. A conflict error = the draft changed since you read it — call get_project again and rebuild. Tests are priced after saving and don't block it: report failures and ask whether their expected outputs should change. For every test's actual vs expected values, call run_version_tests. For another patch, use the returned updated_at. Never approves or publishes — the user does that in the UI.

patch_version input schema
{
  "type": "object",
  "required": [
    "version_reference",
    "base_updated_at",
    "operations"
  ],
  "properties": {
    "operations": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "op",
          "path"
        ],
        "properties": {
          "op": {
            "enum": [
              "add",
              "remove",
              "replace",
              "move",
              "copy",
              "test"
            ],
            "type": "string",
            "description": "test fails the whole patch unless the value at path equals value — use it to guard a change."
          },
          "from": {
            "type": "string",
            "description": "Source pointer for move and copy."
          },
          "path": {
            "type": "string",
            "description": "JSON Pointer into the model, e.g. /steps/<step id>/formula or /steps/<step id>/collection/1/1. Array elements by id (else key) or index; \"-\" appends."
          },
          "value": {
            "description": "New value for add, replace and test: any JSON (a number, string, row array, row object or whole step)."
          }
        }
      },
      "description": "RFC 6902 JSON Patch operations, applied in order to the full stored model, all or nothing. At most 200."
    },
    "base_updated_at": {
      "type": "string",
      "description": "The draft's updated_at exactly as get_project (called with this version_reference) or the previous patch returned it. A mismatch means someone changed the draft since — the patch is refused."
    },
    "version_reference": {
      "type": "string",
      "description": "UUID of the draft version to patch: get_project's latest_draft.version_reference. Never a published or approved version."
    }
  }
}
patch_version annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
get_health — Health check
Advertised by the server during the last successful anonymous check.
Advertised read-only

Diagnostic snapshot of the deployed MCP server plus a live probe of its store (sqlite or Postgres). Returns server name and version, protocol version, root, boot time, advertised tool names and count, a hash of the tool surface, and `store` — `{ ok, latency_ms, counts: { projects, quotes } }` from counting rows in the projects table (one row per version) and the quotes table, or `{ ok: false, latency_ms, error }`.

get_health input schema
{
  "type": "object",
  "properties": {}
}
get_health annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true
}

Prompts

1 advertised

self-host-system-prompt

Advertised by the server during the last successful anonymous check.

System prompt for the self-host Ptally help + config-authoring MCP server

No arguments advertised.

Resources

0 advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (1 of 1 answered).

  1. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
1385 ms
95th percentile latency
1385 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 1385 ms · metadata changed · 13 tool(s), 0 resource(s), 0 resource template(s), 1 prompt(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http ptally-mcp https://app.ptally.ai/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add ptally-mcp --url https://app.ptally.ai/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable ptally-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "ptally-mcp": {
      "url": "https://app.ptally.ai/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "ptally-mcp": {
      "type": "streamableHttp",
      "url": "https://app.ptally.ai/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start ptally-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "ptally-mcp": {
      "type": "http",
      "url": "https://app.ptally.ai/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http ptally-mcp https://app.ptally.ai/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://app.ptally.ai/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "ptally-mcp": {
      "serverUrl": "https://app.ptally.ai/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Ptally MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 5,142

Do you run Ptally MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing