# Introduction

> Extract data from documents in UiPath Maestro™ Flow, using IXP models that you build, evaluate, and run in the Extract node.

The **Extract** node brings document processing onto the UiPath Maestro™ Flow canvas as a step in your flow. It pulls structured fields out of a document using an IXP extraction model, and returns the result for downstream nodes to act on. Because the flow calls the node at a fixed point with the inputs you configure, extraction behaves deterministically.

This guide covers the full lifecycle of the model behind the **Extract** node:

* [Building the model](overview-build.md): uploading sample documents, defining the taxonomy, configuring the model, and validating predictions.
* [Evaluating model performance](overview-validation.md) before you deploy the model to production.
* [Deploying and managing models](overview-deployment.md).
* Consuming models [via Flow](consuming-models-via-flow.md), [via automations](consuming-models-via-automations.md), or [via the Document Understanding API](consuming-models-via-du-api.md).

:::warning
The **Validate extraction** node works only with **Extract** nodes created in the same flow, with the **Extract document** option. It does not yet work with **Extract** nodes bound to a published model or to a model from another flow. For details, check [Consuming models via Flow](consuming-models-via-flow.md).
:::

:::warning
Only the user who generated the predictions that a trace belongs to can view that trace. For details, check [Maintenance and monitoring](faq-maintenance-and-monitoring.md).
:::

## Data extraction challenges

Depending on the stage you are at, some of the common challenges when extracting data from documents are:

### During solution design

* Difficult to build a document processing solution from scratch that integrates well with the rest of the automation in an organization.
* Difficult to create a structured extraction schema. Custom solutions usually have no user interface to build and visualize the taxonomy.

### During model building and testing
* Access required to different LLMs to test on various document types, which are use cases.
* Difficult to quickly iterate on a user prompt and view prediction results.
* Access required to more parameters to optimize prediction results.

### During evaluation
* Difficult to validate predictions and provide ground truth.
* Time-consuming to assess model and field-level metrics.
* Required to compare the impact of adjusting model parameters, for example, model, user prompts, chunk size, zero-shot, or few-shot.
* Required to build a visualization of performance metrics, for example, precision, recall, F1 score.

### During production deployment

* No easy way to modify and maintain data schema for a use case.
* Little model governance, for example, the ability to revert to a previous version, or to select a particular version for production.

## Document processing in Flow

The **Extract** node in Flow helps you solve the challenges outlined in the previous section, and integrates document processing with the rest of your flow.

Use the **Extract** node for document processing in general, from simple, documents to advanced scenarios where data is not consistently formatted, for example, when:

* Documents contain paragraphs of free-form text or complex elements, such as:
  + Complex tables
  + Graphics
  + Charts
  + Checkboxes
  + Call-out boxes
  + Signatures
  + Handwriting, and so on.
* You need to extract inferred values, which are information that is not stated directly but must be derived from context.
* There is high variation in layout or structure between documents or within fields to be extracted.
* You are dealing with stacks of multiple document types combined as one file and need to extract data without splitting them up first.

## Benefits

These are some of the benefits of using the **Extract** node in Flow:

* The **Extract** node runs alongside agents, automations, and human tasks in the same flow.
* You can build a model directly in the node or reuse one deployed from IXP.
* Complex data, such as tables and long documents, is better supported.
* You control prompts, LLMs, and model settings.
* Evaluation runs are versioned.
* Models and taxonomies deploy together with the solution, from development to production, without being re-created by hand.
* Every extraction run is recorded in the flow trace, for end-to-end debugging and monitoring.
* Every LLM request passes through the [AI Trust Layer](auditing-llm-interactions.md) and is audited.
* Solution packages are versioned, so you can upgrade or roll back, and fields keep a change history.
* Models built in Flow can be consumed from public APIs and activities, without changing your automations.