IDP Build Classifier

IDP Build Classifier

Type: idp-build-classifier  ·  Package: IDP Activities v1.18.0  ·  Output: object

Builds the schema that identifies which kind of document you are looking at, from the list of taxonomies you know. Run it through AI Extract before extracting, and let the playbook decide whether to carry on.

The normal flow no longer uses it

IDP Classify now classifies each page (its type and whether it starts a document) internally, so it doesn’t need this activity. IDP Build Classifier remains as a low-level building block for anyone assembling classification by hand.

Why this is needed

Because IDP Ground does not cover this case, and it is worth understanding why.

Grounding verifies “this text is written in the document”. It does not verify “this document is the kind I think it is”. Feed an invoice to an equipment-record taxonomy:

• If you are lucky, the model returns null for everything and the whole document goes to review. Expensive (a person looks at it) but nothing wrong is saved.
• If you are not, the invoice carries a number that looks like a serial number. The model puts it in. And grounding confirms it, because that text is in the document. High confidence, auto-accepted, a wrong value saved with nobody looking.

That second case is what justifies classifying first.

Required parameters

Parameter	Editor	Description
taxonomies	list	The taxonomies to choose between: paths to .json files, or the objects. A single one is fine too.

Output

Returns an object holding the JSON Schema, ready for AI Extract. The model’s answer carries two fields:

Field	What it is
documentType	One of your taxonomies’ documentType values, or "unknown".
reason	What in the document made it decide that.

The enum builds itself

The list of types comes from the taxonomies themselves, so it cannot drift: add a new type to the project and the classifier knows about it without you touching anything. Each taxonomy’s description is passed to the model as context for telling them apart — one more reason to write it well.

unknown is not decoration

Without an honest way out, a model given a closed list picks the least bad option. That is why unknown is always in the enum, and why it is told explicitly not to pick the closest match. A document you don’t recognise is a correct answer; a misclassified document is not.

It asks for a reason, not a confidence

Consistent with the rest of the package: the confidence a model assigns itself is not calibrated, and here there is nothing to locate against the document to measure it for real — it would be a number that invites trust with nothing behind it. unknown is its honest way of saying it doesn’t know.

reason does earn its place: classification comes out better when it has to justify itself, and when a batch is misclassified, that is what tells you why without opening the documents by hand.

Example

IDP Build Classifier   taxonomies = = [asset("taxonomies/device-record.json"), asset("taxonomies/invoice.json")]   → output: classifier

IDP Load Document      path = = docPath   → output: doc
AI Extract             credential = = credential("anthropic-key")
                       prompt     = = doc["text"]
                       schema     = = classifier
                       → output: kind
If   condition = = kind["documentType"] == "hoja-de-vida-equipo-biomedico"
  ...extract with the device-record taxonomy
Else
  Log   message = = "Discarded: " + kind["documentType"] + " — " + kind["reason"]

Classifying is cheap: the document goes in once and the answer is three fields, so a small model is enough. What really saves money is what it prevents — not paying to extract a document that never belonged.

Related activities

• IDP Build Schema — the next step, once you know what it is.
• IDP Ground — verifies the values, not the kind of document.