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

> ## Agent Instructions
> Assistants connect to Parse over MCP at [https://agent.parse.gl/mcp](https://agent.parse.gl/mcp) (Streamable HTTP). With no sign-in it answers from Parse's public view (the numbers parse.gl's public pages show, up to 5 rows a list), starting with `check_brand`. Signed in with Parse, or sent a workspace key (`parse_mcp_…`), it works in the person's workspace, starting with `get_brief`. Scripts call the same tools over REST at `https://agent.parse.gl/v1/tools/<tool>`.
>
> ```bash
> npx parse-gl init
> ```
>
> To install just the skills: `npx skills add Parsegl/skills`.
> Every tool is also a POST to https://agent.parse.gl/v1/tools/<tool>; its OpenAPI description is https://agent.parse.gl/openapi.json.

# Apply a rubric

> classify_items: a workspace tool on Parse for agents (agent.parse.gl). Arguments, price, and a call over REST and MCP.

Classify or score answers or pages using your own custom question and labels (e.g., pricing perception, sentiment, feature accuracy). Paid: \$0.01/unit judged, runs within monthly budget; quote: true prices without buying. Select by ids or filter (up to 5,000 answers, excluding shared answers); answers >90d cost \$0.001 each once. Pass up to 30 labeled spotChecks to measure agreement. Creates a private cf\_ facet; check progress via read\_item on the cf\_ id.

## Who may call it, and what it costs

| Name | Access | Effect |
| - | - | - |
| `classify_items` | A workspace key, or a sign-in that allows changes. | Spends credits, within the budget |

**Price.** \$0.01 a unit judged. Runs when called, within the budget; `quote: true` prices it only and starts nothing. Answers that `target.filter` selects from before the last 90 days are past answers, \$0.001 each the first time: never a sample, the run buys every one the workspace does not own before it judges, or leaves the past out, and a quote shows their price on its own line. Every reply says what the call cost in `meta.costCredits`. The prices are on [Spending, tracking and stopping](/docs/credits.md).

## Arguments

**target** `object` *required*

**target.answers** `list of string`

ans\_ ids up to 5000

**target.pages** `list of string`

pg\_ ids of stored pages up to 500

**target.filter** `object`

the answers search\_answers finds for it in the window, at most 5,000; answers other workspaces share are left out

**target.window** `object`

default the last 28 days; "last" or from/to

**target.level** `one of company, product`

how brands count: company (default; a company and its products are one brand) or product (each brand on its own, so a product's numbers leave out its siblings)

**rubric** `object` *required*

**rubric.question** `string` *required*

one question every unit is judged on

**rubric.values** `list of string` *required*

the answers it may have up to 10

**rubric.examples** `list of object`

units with their right value, shown to the judge up to 10

**spotChecks** `list of object`

your labels; Parse reports how often the judge agrees up to 30

**name** `string` *required*

**quote** `boolean`

true: the price and whether it fits, buying nothing; without it the call runs when it fits

**idempotencyKey** `string`

the same key with the same arguments returns the same job and charges nothing more; other arguments are refused. Left out, an identical call within the UTC hour is the same call; pass a key to buy it again

Every argument the tool takes, as `GET /v1/tools` serves it, every shared object written out; `https://agent.parse.gl/openapi.json` serves the same schema with the filter and the window named once under `components` and pointed to by `$ref`. MCP `tools/list` leaves out the arguments few calls send, and says the filter and the window once, under `search_answers`; `resolve_ids {"kinds": ["argument"]}` lists what it left out, and a call with any of them runs:

```json theme={null}
{
  "type": "object",
  "properties": {
    "target": {
      "type": "object",
      "properties": {
        "answers": {
          "description": "ans_ ids",
          "maxItems": 5000,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          }
        },
        "pages": {
          "description": "pg_ ids of stored pages",
          "maxItems": 500,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          }
        },
        "filter": {
          "description": "the answers search_answers finds for it in the window, at most 5,000; answers other workspaces share are left out",
          "type": "object",
          "properties": {
            "brand": {
              "description": "brd_ ids; with brandRule, which answers count",
              "maxItems": 20,
              "type": "array",
              "items": {
                "type": "string",
                "minLength": 3,
                "maxLength": 220
              }
            },
            "brandRule": {
              "description": "default named; not_recommended keeps judged answers recommending none of the filter brands; warned filters to answers flagged with facet mention.advised_against",
              "type": "string",
              "enum": [
                "named",
                "recommended",
                "first",
                "not_named",
                "not_recommended",
                "warned"
              ]
            },
            "match": {
              "description": "with several brands; default any",
              "type": "string",
              "enum": [
                "any",
                "all"
              ]
            },
            "topic": {
              "maxItems": 50,
              "type": "array",
              "items": {
                "type": "string",
                "minLength": 3,
                "maxLength": 220
              }
            },
            "market": {
              "description": "Industry or category markets. For countries use country, and for cities use place.",
              "maxItems": 50,
              "type": "array",
              "items": {
                "type": "string",
                "minLength": 3,
                "maxLength": 220
              }
            },
            "question": {
              "maxItems": 100,
              "type": "array",
              "items": {
                "type": "string",
                "minLength": 3,
                "maxLength": 220
              }
            },
            "engine": {
              "description": "surface ids (resolve_ids with kinds: [\"surface\"] lists them); without engine or surfaceClass, the counted engines",
              "maxItems": 10,
              "type": "array",
              "items": {
                "type": "string",
                "maxLength": 40
              }
            },
            "surfaceClass": {
              "description": "classes of engines to cover; default counted",
              "maxItems": 5,
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "counted",
                  "wider",
                  "memory",
                  "search",
                  "imported"
                ]
              }
            },
            "place": {
              "description": "plc_ ids (resolve_ids finds them): the place a question is about, with the places under each (a region holds its cities). \"all\": every place, in place of a local subject's area. A country code here reads as filter.country for one release",
              "anyOf": [
                {
                  "type": "string",
                  "const": "all"
                },
                {
                  "maxItems": 20,
                  "type": "array",
                  "items": {
                    "type": "string",
                    "maxLength": 80
                  }
                }
              ]
            },
            "country": {
              "description": "ISO country codes the question was asked from; an answer asked with no place set counts as US",
              "maxItems": 20,
              "type": "array",
              "items": {
                "type": "string",
                "maxLength": 2
              }
            },
            "site": {
              "description": "domains or site: ids of cited sites",
              "maxItems": 50,
              "type": "array",
              "items": {
                "type": "string",
                "maxLength": 200
              }
            },
            "page": {
              "description": "pg_ ids of cited pages",
              "maxItems": 50,
              "type": "array",
              "items": {
                "type": "string",
                "minLength": 3,
                "maxLength": 220
              }
            },
            "text": {
              "description": "Full-text search over answer text: keywords, \"exact phrases\", AND/OR/NOT, NEAR/n, prefix*. A call reads at most the first 100,000 matches (20,000 in search_answers) before the brand filter and the rest apply: a brand filter does not narrow it, so a common word over a long window can miss a brand's answers; narrow by window, topic, market or engine",
              "type": "string",
              "maxLength": 500
            },
            "facet": {
              "description": "a facet with \"filter\" in its usableIn list",
              "type": "object",
              "propertyNames": {
                "type": "string",
                "maxLength": 80
              },
              "additionalProperties": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "maxItems": 50,
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  {
                    "type": "object",
                    "properties": {
                      "gte": {
                        "type": "number"
                      },
                      "lte": {
                        "type": "number"
                      }
                    },
                    "additionalProperties": false
                  }
                ]
              }
            },
            "scope": {
              "description": "default all: public plus this workspace's own; own: only the answers this workspace bought; tracked: its own answers and those about the questions, topics and brands it watches with the track tool (not the brands it added in the app); public: public answers only; index: the answers parse.gl's public pages count, which a logged-out call always reads",
              "type": "string",
              "enum": [
                "tracked",
                "public",
                "own",
                "all",
                "index"
              ]
            }
          },
          "additionalProperties": false
        },
        "window": {
          "type": "object",
          "properties": {
            "last": {
              "type": "string",
              "enum": [
                "7d",
                "28d",
                "90d",
                "365d",
                "all"
              ]
            },
            "from": {
              "description": "inclusive",
              "type": "string",
              "format": "date"
            },
            "to": {
              "description": "inclusive",
              "type": "string",
              "format": "date"
            }
          },
          "additionalProperties": false,
          "description": "default the last 28 days; \"last\" or from/to"
        },
        "level": {
          "description": "how brands count: company (default; a company and its products are one brand) or product (each brand on its own, so a product's numbers leave out its siblings)",
          "type": "string",
          "enum": [
            "company",
            "product"
          ]
        }
      },
      "additionalProperties": false
    },
    "rubric": {
      "type": "object",
      "properties": {
        "question": {
          "type": "string",
          "minLength": 10,
          "maxLength": 500,
          "description": "one question every unit is judged on"
        },
        "values": {
          "minItems": 2,
          "maxItems": 10,
          "type": "array",
          "items": {
            "type": "string",
            "minLength": 1,
            "maxLength": 60
          },
          "description": "the answers it may have"
        },
        "examples": {
          "description": "units with their right value, shown to the judge",
          "maxItems": 10,
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "minLength": 3,
                "maxLength": 220
              },
              "value": {
                "type": "string",
                "minLength": 1,
                "maxLength": 60
              }
            },
            "required": [
              "id",
              "value"
            ],
            "additionalProperties": false
          }
        }
      },
      "required": [
        "question",
        "values"
      ],
      "additionalProperties": false
    },
    "spotChecks": {
      "description": "your labels; Parse reports how often the judge agrees",
      "maxItems": 30,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "minLength": 3,
            "maxLength": 220
          },
          "value": {
            "type": "string",
            "minLength": 1,
            "maxLength": 60
          }
        },
        "required": [
          "id",
          "value"
        ],
        "additionalProperties": false
      }
    },
    "name": {
      "type": "string",
      "minLength": 1,
      "maxLength": 80
    },
    "quote": {
      "description": "true: the price and whether it fits, buying nothing; without it the call runs when it fits",
      "type": "boolean"
    },
    "idempotencyKey": {
      "description": "the same key with the same arguments returns the same job and charges nothing more; other arguments are refused. Left out, an identical call within the UTC hour is the same call; pass a key to buy it again",
      "type": "string",
      "maxLength": 100
    }
  },
  "required": [
    "target",
    "rubric",
    "name"
  ],
  "additionalProperties": false
}
```

## Example call

Price a judgment of a set of answers on your own question, and buy nothing. Over REST:

```bash theme={null}
export PARSE_API_KEY="<your-key>"

curl -s -X POST https://agent.parse.gl/v1/tools/classify_items \
  -H 'content-type: application/json' \
  -H "Authorization: Bearer $PARSE_API_KEY" \
  -d '{"target":{"filter":{"brand":["brd_21e2e46d-5498-46bc-bd54-791c1acd74e7"],"market":["mkt_6956b477-23eb-43da-99ad-c3e612482b08"]}},"rubric":{"question":"Does the answer recommend the brand for small teams?","values":["yes","no"]},"name":"Recommended for small teams","quote":true}'
```

Over MCP, the assistant calls the tool by name with the same arguments:

```json theme={null}
{
  "method": "tools/call",
  "params": {
    "name": "classify_items",
    "arguments": {
      "target": {
        "filter": {
          "brand": [
            "brd_21e2e46d-5498-46bc-bd54-791c1acd74e7"
          ],
          "market": [
            "mkt_6956b477-23eb-43da-99ad-c3e612482b08"
          ]
        }
      },
      "rubric": {
        "question": "Does the answer recommend the brand for small teams?",
        "values": [
          "yes",
          "no"
        ]
      },
      "name": "Recommended for small teams",
      "quote": true
    }
  }
}
```

The reply has `data`, `context`, `next`, `page` and `meta`; follow `next` for the calls that come after. A refused call returns `{ code, message, fix }`: see the [error table](/docs/mcp-reference.md#errors).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.