Building Workflows

This guide walks you through creating a complete workflow from scratch.

What We’ll Build

A document processing pipeline that:

Extracts text from images (OCR)
Identifies named entities (NER)
Summarizes the content (LLM)
Stores results in a dataset

graph LR
    A[Image Input] --> B[OCR]
    B --> C[NER]
    C --> D[LLM Summary]
    D --> E[Output Dataset]

Step 1: Create the Workflow

Using the Python SDK

from seeme import Client

client = Client()

## Create the workflow
workflow = client.create_workflow(
    name="Document Processing Pipeline",
    description="Extract, analyze, and summarize documents"
)

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

# A version is created automatically, or create one explicitly
version = client.create_workflow_version(
    workflow_id=workflow.id,
    name="v1"
)

print(f"Version created: {version.id}")

Using the REST API

# Create the workflow
curl -X POST "https://api.seeme.ai/api/v1/workflows" \
  -H "Authorization: myusername:my-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Document Processing Pipeline",
    "description": "Extract, analyze, and summarize documents"
  }'

# Create a workflow version
curl -X POST "https://api.seeme.ai/api/v1/workflows/{workflow_id}/versions" \
  -H "Authorization: myusername:my-api-key" \
  -H "Content-Type: application/json" \
  -d '{"name": "v1"}'

Step 2: Add Model Nodes

Add OCR Node

From the node palette, drag Model onto the canvas
Click the node to configure:
- Name: “Extract Text (OCR)”
- Model: Select your OCR model
- Input Template: {{input}}
Position it as the first step

# Assume you have an OCR model
ocr_model = client.get_model("your-ocr-model-id")

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}}"
    },
    position={"x": 100, "y": 100}
)

Add NER Node

Drag another Model node onto the canvas
Configure:
- Name: “Extract Entities (NER)”
- Model: Select your NER model
- Input Template: {{ocr_node}} (references OCR output)
Position after OCR node

ner_model = client.get_model("your-ner-model-id")

ner_node = client.create_workflow_node(
    version_id=version.id,
    name="Extract Entities (NER)",
    entity_type="model",
    entity_id=ner_model.id,
    config={
        "input_template": "{{" + ocr_node.id + "}}"
    },
    position={"x": 300, "y": 100}
)

Add LLM Summary Node

Drag a third Model node

Configure:

Name: “Generate Summary”
Model: Select your LLM model

Input Template:

Summarize this document:

Text: {{ocr_node}}

Entities found: {{ner_node}}

Provide a 2-3 sentence summary.

llm_model = client.get_model("your-llm-model-id")

llm_node = client.create_workflow_node(
    version_id=version.id,
    name="Generate Summary",
    entity_type="model",
    entity_id=llm_model.id,
    config={
        "input_template": f"""
Summarize this document:

Text: {{{{{ocr_node.id}}}}}

Entities found: {{{{{ner_node.id}}}}}

Provide a 2-3 sentence summary.
"""
    },
    position={"x": 500, "y": 100}
)

Step 3: Add Output Dataset

Drag a Dataset node onto the canvas
Configure:
- Name: “Store Results”
- Dataset: Select or create an output dataset
- Output Configuration:
  - Map text → OCR output
  - Map entities → NER output
  - Map summary → LLM output

# Create or get output dataset
output_dataset = client.create_dataset(
    name="Document Analysis Results",
    content_type="text"
)

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_dataset.versions[0].id,
        "column_mapping": {
            "text": f"{{{{{ocr_node.id}}}}}",
            "entities": f"{{{{{ner_node.id}}}}}",
            "summary": f"{{{{{llm_node.id}}}}}"
        }
    },
    position={"x": 700, "y": 100}
)

Step 4: Connect Nodes with Edges

# Connect OCR → NER
client.create_workflow_edge(
    version_id=version.id,
    begin_node_id=ocr_node.id,
    end_node_id=ner_node.id,
    edge_type="data"
)

# Connect NER → LLM
client.create_workflow_edge(
    version_id=version.id,
    begin_node_id=ner_node.id,
    end_node_id=llm_node.id,
    edge_type="data"
)

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

Step 5: Test the Workflow

Single Execution

# Execute with a test file
execution = client.execute_workflow(
    workflow_id=workflow.id,
    version_id=version.id,
    input_mode="single",
    item="./test-document.png"
)

# Monitor progress
import time
while execution.status in ["pending", "running"]:
    time.sleep(2)
    execution = client.get_workflow_execution(
        workflow_id=workflow.id,
        execution_id=execution.id
    )
    print(f"Status: {execution.status}")
    if execution.progress:
        print(f"  Node: {execution.progress.current_node_id}")

# View results
print("\n=== Results ===")
print(execution.results)

# Execute workflow with a file
curl -X POST "https://api.seeme.ai/api/v1/workflows/{workflow_id}/execute" \
  -H "Authorization: myusername:my-api-key" \
  -F "file=@./test-document.png" \
  -F "version_id={version_id}" \
  -F "input_mode=single"

# Get execution status
curl -X GET "https://api.seeme.ai/api/v1/workflows/{workflow_id}/executions/{execution_id}" \
  -H "Authorization: myusername:my-api-key"

# Get execution results
curl -X GET "https://api.seeme.ai/api/v1/workflows/{workflow_id}/executions/{execution_id}/results" \
  -H "Authorization: myusername:my-api-key"

Step 6: Activate the Version

Once tested, activate the version for production use:

# Activate the tested version
client.activate_workflow_version(
    workflow_id=workflow.id,
    version_id=version.id
)

print(f"Version {version.name} is now active")

# Activate the workflow version
curl -X POST "https://api.seeme.ai/api/v1/workflows/{workflow_id}/versions/{version_id}/activate" \
  -H "Authorization: myusername:my-api-key"

# List workflow versions
curl -X GET "https://api.seeme.ai/api/v1/workflows/{workflow_id}/versions" \
  -H "Authorization: myusername:my-api-key"

Complete Code Example

Here’s the full workflow creation in one script:

from seeme import Client

client = Client()

# 1. Create workflow
workflow = client.create_workflow(
    name="Document Processing Pipeline",
    description="OCR → NER → Summary"
)
version = workflow.versions[0]

# 2. Add nodes
ocr_node = client.create_workflow_node(
    version_id=version.id,
    name="OCR",
    entity_type="model",
    entity_id="ocr-model-id",
    config={"input_template": "{{input}}"}
)

ner_node = client.create_workflow_node(
    version_id=version.id,
    name="NER",
    entity_type="model",
    entity_id="ner-model-id",
    config={"input_template": "{{" + ocr_node.id + "}}"}
)

llm_node = client.create_workflow_node(
    version_id=version.id,
    name="Summary",
    entity_type="model",
    entity_id="llm-model-id",
    config={
        "input_template": f"Summarize: {{{{{ocr_node.id}}}}}\nEntities: {{{{{ner_node.id}}}}}"
    }
)

output_node = client.create_workflow_node(
    version_id=version.id,
    name="Output",
    entity_type="dataset",
    entity_id="output-dataset-id",
    config={
        "output_dataset_id": "output-dataset-id",
        "column_mapping": {"summary": f"{{{{{llm_node.id}}}}}"}
    }
)

# 3. Connect nodes
for begin, end in [(ocr_node, ner_node), (ner_node, llm_node), (llm_node, output_node)]:
    client.create_workflow_edge(
        version_id=version.id,
        begin_node_id=begin.id,
        end_node_id=end.id,
        edge_type="data"
    )

# 4. Test
execution = client.execute_workflow(
    workflow_id=workflow.id,
    item="./test.png"
)

# 5. Activate when ready
client.activate_workflow_version(
    workflow_id=workflow.id,
    version_id=version.id
)

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

Best Practices

Name nodes descriptively - Makes debugging easier
Set appropriate timeouts - Account for slow models
Use on_failure wisely - “continue” for optional steps
Test with edge cases - Empty inputs, large files
Version frequently - Easy rollback if issues arise

Troubleshooting

Issue	Cause	Solution
Node not executing	Missing edge	Check edge connections
Wrong output	Template error	Verify node ID references
Timeout	Model too slow	Increase timeout setting
Empty results	Input format	Check model input requirements

Next Steps

Node Types Edge Types Examples

Workflow Concepts Node Types