## Step 4: Add Entity Extraction Schema Dataset

Define what entities to extract for each document type.

```python
# Create extraction schema dataset
schema_dataset = client.create_dataset(
    name="Document Extraction Schemas",
    description="Entity extraction rules per document type"
)

schema_version = client.create_dataset_version(
    dataset_id=schema_dataset.id,
    name="v1"
)

# Define extraction schemas per document type
schemas = [
    {
        "document_type": "invoice",
        "entities": [
            {"name": "invoice_number", "type": "string", "description": "Unique invoice identifier"},
            {"name": "invoice_date", "type": "date", "description": "Date of invoice"},
            {"name": "due_date", "type": "date", "description": "Payment due date"},
            {"name": "vendor_name", "type": "string", "description": "Company issuing the invoice"},
            {"name": "vendor_address", "type": "string", "description": "Vendor's address"},
            {"name": "customer_name", "type": "string", "description": "Bill-to company or person"},
            {"name": "customer_address", "type": "string", "description": "Customer's address"},
            {"name": "line_items", "type": "array", "description": "List of {description, quantity, unit_price, total}"},
            {"name": "subtotal", "type": "currency", "description": "Sum before tax"},
            {"name": "tax_amount", "type": "currency", "description": "Tax amount"},
            {"name": "tax_rate", "type": "percentage", "description": "Tax percentage"},
            {"name": "total_amount", "type": "currency", "description": "Final amount due"},
            {"name": "payment_terms", "type": "string", "description": "Payment conditions"},
            {"name": "bank_details", "type": "string", "description": "Payment account info"}
        ]
    },
    {
        "document_type": "contract",
        "entities": [
            {"name": "contract_title", "type": "string", "description": "Name/title of the contract"},
            {"name": "contract_date", "type": "date", "description": "Date contract was signed"},
            {"name": "effective_date", "type": "date", "description": "When contract takes effect"},
            {"name": "expiration_date", "type": "date", "description": "When contract expires"},
            {"name": "party_1", "type": "object", "description": "{name, role, address, representative}"},
            {"name": "party_2", "type": "object", "description": "{name, role, address, representative}"},
            {"name": "contract_value", "type": "currency", "description": "Total contract value"},
            {"name": "payment_schedule", "type": "string", "description": "Payment terms and schedule"},
            {"name": "key_terms", "type": "array", "description": "Important contractual obligations"},
            {"name": "termination_clause", "type": "string", "description": "Conditions for termination"},
            {"name": "governing_law", "type": "string", "description": "Jurisdiction/applicable law"},
            {"name": "signatures", "type": "array", "description": "List of {name, title, date}"}
        ]
    },
    {
        "document_type": "receipt",
        "entities": [
            {"name": "merchant_name", "type": "string", "description": "Store/business name"},
            {"name": "merchant_address", "type": "string", "description": "Store location"},
            {"name": "transaction_date", "type": "date", "description": "Date of purchase"},
            {"name": "transaction_time", "type": "time", "description": "Time of purchase"},
            {"name": "items", "type": "array", "description": "List of {name, quantity, price}"},
            {"name": "subtotal", "type": "currency", "description": "Sum before tax"},
            {"name": "tax", "type": "currency", "description": "Tax amount"},
            {"name": "total", "type": "currency", "description": "Final amount paid"},
            {"name": "payment_method", "type": "string", "description": "Cash, card, etc."},
            {"name": "card_last_four", "type": "string", "description": "Last 4 digits if card payment"}
        ]
    },
    {
        "document_type": "letter",
        "entities": [
            {"name": "sender_name", "type": "string", "description": "Person/org sending the letter"},
            {"name": "sender_address", "type": "string", "description": "Sender's address"},
            {"name": "recipient_name", "type": "string", "description": "Person/org receiving"},
            {"name": "recipient_address", "type": "string", "description": "Recipient's address"},
            {"name": "date", "type": "date", "description": "Date of the letter"},
            {"name": "subject", "type": "string", "description": "Subject line if present"},
            {"name": "main_topic", "type": "string", "description": "What the letter is about"},
            {"name": "action_requested", "type": "string", "description": "Any requested actions"},
            {"name": "deadline", "type": "date", "description": "Any mentioned deadlines"}
        ]
    },
    {
        "document_type": "medical",
        "entities": [
            {"name": "patient_name", "type": "string", "description": "Patient's full name"},
            {"name": "patient_dob", "type": "date", "description": "Date of birth"},
            {"name": "patient_id", "type": "string", "description": "Medical record number"},
            {"name": "provider_name", "type": "string", "description": "Doctor/provider name"},
            {"name": "facility_name", "type": "string", "description": "Hospital/clinic name"},
            {"name": "visit_date", "type": "date", "description": "Date of visit/service"},
            {"name": "diagnosis", "type": "array", "description": "List of diagnoses/conditions"},
            {"name": "procedures", "type": "array", "description": "Procedures performed"},
            {"name": "medications", "type": "array", "description": "List of {name, dosage, frequency}"},
            {"name": "follow_up", "type": "string", "description": "Follow-up instructions"}
        ]
    }
]

for schema in schemas:
    client.create_dataset_item(
        version_id=schema_version.id,
        data=schema
    )

## Step 7: Add Validation Node

Validate extracted entities and flag issues.

```python
# Validation node
validate_node = client.create_workflow_node(
    version_id=version.id,
    name="Validate Extraction",
    entity_type="model",
    entity_id=llm_model.id,
    config={
        "input_template": """
Validate the extracted data against the original document.

**Original Document Text:**
{{Extract Text (OCR)}}

**Extracted Data:**
{{Extract Entities}}

**Validation Checks:**
1. **Completeness**: Are all required fields extracted?
2. **Accuracy**: Do extracted values match the document?
3. **Format**: Are dates, currencies, numbers in correct format?
4. **Consistency**: Do calculated fields match (e.g., line items sum to subtotal)?
5. **Anomalies**: Any unusual values or potential errors?

**Return validation result as JSON:**
```json
{
  "is_valid": true|false,
  "completeness_score": 0.0-1.0,
  "accuracy_score": 0.0-1.0,
  "issues": [
    {
      "field": "field_name",
      "issue_type": "missing|incorrect|format_error|inconsistent",
      "description": "what's wrong",
      "suggested_fix": "correction if possible"
    }
  ],
  "corrected_entities": {
    // Only include fields that need correction
  },
  "requires_human_review": true|false,
  "review_reason": "why human review needed, if applicable"
}

## Step 8: Add Output Dataset

Store processed documents with extracted entities.

```python
# Create output dataset
output_dataset = client.create_dataset(
    name="Processed Documents",
    description="Documents with extracted entities"
)

output_version = client.create_dataset_version(
    dataset_id=output_dataset.id,
    name="v1"
)

# Output node
output_node = client.create_workflow_node(
    version_id=version.id,
    name="Store Results",
    entity_type="dataset",
    entity_id=output_dataset.id,
    config={
        "output_dataset_id": output_dataset.id,
        "output_version_id": output_version.id,
        "column_mapping": {
            "source_file": "{{input}}",
            "ocr_text": "{{Extract Text (OCR)}}",
            "document_type": "{{Classify Document}}",
            "extracted_entities": "{{Extract Entities}}",
            "validation_result": "{{Validate Extraction}}",
            "processed_at": "{{timestamp}}"
        }
    }
)

# Connect Validation → Output
client.create_workflow_edge(
    version_id=version.id,
    begin_node_id=validate_node.id,
    end_node_id=output_node.id,
    edge_type="data"
)

## Complete Workflow Code

```python
from seeme import Client

client = Client()

# --- Get your models ---
ocr_model = client.get_model("your-ocr-model-id")
llm_model = client.get_model("your-llm-model-id")

# --- Create workflow ---
workflow = client.create_workflow(
    name="Document Processing Pipeline",
    description="OCR → Classification → Entity Extraction → Validation → Storage"
)
version = client.create_workflow_version(workflow_id=workflow.id, name="v1")

# --- Node 1: OCR ---
ocr_node = client.create_workflow_node(
    version_id=version.id,
    name="Extract Text (OCR)",
    entity_type="model",
    entity_id=ocr_model.id,
    config={
        "input_template": "{{input}}",
        "timeout": 120,
        "config": {"languages": ["en"], "dpi": 300}
    }
)

# --- Node 2: Classification ---
classify_node = client.create_workflow_node(
    version_id=version.id,
    name="Classify Document",
    entity_type="model",
    entity_id=llm_model.id,
    config={
        "input_template": """Classify this document into one category: invoice, receipt, contract, letter, report, form, medical, financial, other.

Document text:
{{Extract Text (OCR)}}

Return JSON: {"document_type": "...", "confidence": 0.0-1.0}""",
        "config": {"temperature": 0.1, "max_tokens": 200}
    }
)

# --- Node 3: Extraction Schema (context) ---
schema_node = client.create_workflow_node(
    version_id=version.id,
    name="Extraction Schemas",
    entity_type="dataset",
    entity_id=schema_dataset.id,
    config={
        "context_config": {
            "dataset_version_id": schema_version.id,
            "context_name": "schemas"
        }
    }
)

# --- Node 4: Entity Extraction ---
extract_node = client.create_workflow_node(
    version_id=version.id,
    name="Extract Entities",
    entity_type="model",
    entity_id=llm_model.id,
    config={
        "input_template": """Extract entities from this {{Classify Document.document_type}} document.

Document text:
{{Extract Text (OCR)}}

Schema:
{{#each schemas}}{{#if (eq document_type ../Classify Document.document_type)}}{{entities}}{{/if}}{{/each}}

Return JSON with extracted entities.""",
        "config": {"temperature": 0.0, "max_tokens": 4000}
    }
)

# --- Node 5: Validation ---
validate_node = client.create_workflow_node(
    version_id=version.id,
    name="Validate Extraction",
    entity_type="model",
    entity_id=llm_model.id,
    config={
        "input_template": """Validate extraction accuracy.

Original: {{Extract Text (OCR)}}
Extracted: {{Extract Entities}}

Return JSON: {is_valid, issues[], corrected_entities, requires_human_review}""",
        "config": {"temperature": 0.1, "max_tokens": 2000}
    }
)

# --- Node 6: Output Dataset ---
output_node = client.create_workflow_node(
    version_id=version.id,
    name="Store Results",
    entity_type="dataset",
    entity_id=output_dataset.id,
    config={
        "output_dataset_id": output_dataset.id,
        "column_mapping": {
            "source_file": "{{input}}",
            "document_type": "{{Classify Document}}",
            "extracted_entities": "{{Extract Entities}}",
            "validation": "{{Validate Extraction}}"
        }
    }
)

# --- Connect nodes ---
edges = [
    (ocr_node.id, classify_node.id, "data"),
    (ocr_node.id, extract_node.id, "data"),
    (classify_node.id, extract_node.id, "data"),
    (schema_node.id, extract_node.id, "context"),
    (ocr_node.id, validate_node.id, "data"),
    (extract_node.id, validate_node.id, "data"),
    (validate_node.id, output_node.id, "data"),
]

for begin_id, end_id, edge_type in edges:
    client.create_workflow_edge(
        version_id=version.id,
        begin_node_id=begin_id,
        end_node_id=end_id,
        edge_type=edge_type
    )

print(f"Workflow ready: {workflow.id}")