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

# Datamarkin Ecosystem

> Understanding how AgentUI, Mozo, and PixelFlow work together

## The Datamarkin Ecosystem

Datamarkin provides three powerful libraries that work seamlessly together to create a complete computer vision development platform. Each library serves a distinct purpose while integrating naturally with the others.

> [card] AgentUI
>
> **The Builder**
>
> Visual workflow creation and management

> [card] Mozo
>
> **The Engine**
>
> Model serving and execution

> [card] PixelFlow
>
> **The Foundation**
>
> Core CV primitives and visualization

## How They Work Together

The three libraries form a complete pipeline for computer vision development:

```mermaid theme={null}
graph LR
    A[AgentUI] -->|Workflows| B[Mozo]
    B -->|Results| C[PixelFlow]
    C -->|Annotated Output| D[Your Application]
    C -.->|Visualization Tools| A
```

### The Complete Workflow

**1. Build in AgentUI**

Create visual workflows by connecting tools with a drag-and-drop interface. Choose from 35+ built-in tools for detection, segmentation, tracking, annotation, and more. Export workflows as JSON for version control.

**2. Execute on Mozo**

Deploy your workflows on Mozo's model server. Access 35+ pre-configured models across 10 frameworks including Detectron2, YOLOv8, Florence-2, and more. Mozo handles memory management and lazy loading automatically.

**3. Visualize with PixelFlow**

Process results using PixelFlow's powerful annotation and analysis tools. Draw bounding boxes, add labels, track objects across frames, monitor zones, and export results.

## Library Comparison

| Feature | AgentUI | Mozo | PixelFlow |
| - | - | - | - |
| **Primary Purpose** | Visual workflow builder | Model server | CV primitives & visualization |
| **Key Feature** | Drag-and-drop interface | 35+ pre-configured models | 20+ annotators |
| **Deployment** | Web UI + Python API | HTTP server + Python SDK | Python library |
| **Dependencies** | PixelFlow, Mozo (optional) | PixelFlow (for output format) | NumPy, OpenCV |
| **Best For** | Rapid prototyping | Production deployments | Custom CV pipelines |
| **Model Support** | Via Mozo integration | Detectron2, YOLO, Florence-2, OCR | Framework agnostic |

## Integration Patterns

### Pattern 1: Full Stack (All Three Libraries)

Use all three libraries for a complete solution from design to deployment to visualization.

```python theme={null}
from agentui import Workflow
from mozo import ModelManager
from pixelflow import annotate

# Load workflow built in AgentUI
workflow = Workflow.load("my_workflow.json")

# Execute on Mozo's model server
results = workflow.run(image, use_mozo=True)

# Visualize with PixelFlow
annotated = annotate.box(image, results.detections)
annotate.label(annotated, results.detections)
```

### Pattern 2: AgentUI + PixelFlow (Local Execution)

Build workflows visually and run them locally without needing a model server.

```python theme={null}
from agentui import Workflow
from pixelflow import annotate

# Load and run workflow locally
workflow = Workflow.load("detection_workflow.json")
results = workflow.run(image)

# Annotate results
annotated = annotate.box(image, results.detections)
```

### Pattern 3: Mozo + PixelFlow (API-First)

Use Mozo as a model serving layer with PixelFlow for visualization.

```python theme={null}
from mozo import predict
from pixelflow import annotate, Detections

# Call Mozo's API
response = predict("detectron2", "mask_rcnn_R_50_FPN", image)

# Convert to PixelFlow format
detections = Detections.from_mozo(response)

# Visualize
annotated = annotate.mask(image, detections)
annotate.box(annotated, detections)
```

### Pattern 4: PixelFlow Standalone

Use PixelFlow independently for custom computer vision pipelines.

```python theme={null}
from pixelflow import annotate, Detections, Tracker, Zones

# Your custom detection logic
detections = your_model.predict(image)

# Use PixelFlow for tracking and analysis
tracker = Tracker()
tracked = tracker.update(detections)

# Monitor zones
zone = Zones.rectangle((100, 100), (500, 500))
in_zone = detections.filter_by_zone(zone)

# Annotate
annotated = annotate.box(image, tracked)
annotate.label(annotated, tracked)
```

## Data Flow

Understanding how data flows between the libraries:

> [accordion] AgentUI → Mozo
>
> **Format:** JSON workflow definition
>
> AgentUI exports workflows as JSON that specify which models to use, how to connect them, and what parameters to apply. Mozo can parse these workflows and execute them using its model registry.

> [accordion] Mozo → PixelFlow
>
> **Format:** Unified Detections object
>
> Mozo returns results in PixelFlow's `Detections` format, which provides a consistent interface regardless of the underlying model framework (Detectron2, YOLO, etc.).

> [accordion] PixelFlow → Application
>
> **Format:** NumPy arrays with metadata
>
> PixelFlow processes and annotates images as NumPy arrays. All metadata (bounding boxes, labels, masks) is preserved in the `Detections` object for downstream use.

## Architectural Benefits

### Loose Coupling

Each library can be used independently. You're not forced to use all three - choose what fits your needs.

### Shared Standards

All libraries use PixelFlow's `Detections` format as a common data structure, ensuring seamless interoperability.

### Incremental Adoption

Start with one library and add others as your needs grow:

* Begin with **PixelFlow** for basic CV needs
* Add **Mozo** when you need pre-configured models
* Include **AgentUI** for visual workflow management

## Real-World Use Cases

> [card] Surveillance System
>
> **Libraries:** All three
>
> * Build detection + tracking workflows in AgentUI
> * Deploy on Mozo for efficient model serving
> * Use PixelFlow for zone monitoring and alerts

> [card] Document Processing
>
> **Libraries:** Mozo + PixelFlow
>
> * Use Mozo's OCR models (PaddleOCR, EasyOCR)
> * Extract layout with PP-Structure
> * Visualize results with PixelFlow annotators

> [card] Quality Inspection
>
> **Libraries:** AgentUI + Mozo
>
> * Design inspection workflows in AgentUI
> * Run on Mozo with custom defect detection models
> * Export results for analysis

> [card] Custom CV Pipeline
>
> **Libraries:** PixelFlow standalone
>
> * Integrate with your existing ML models
> * Use PixelFlow's annotators and trackers
> * Build custom analysis workflows

## Getting Started

Choose your entry point based on your use case:

> [tab] I want to build workflows visually
>
> Start with **AgentUI**:
>
> ```bash theme={null}
> pip install agentui
> agentui serve
> ```
>
> Visit [http://localhost:8000](http://localhost:8000) to access the visual workflow builder.
>
> [View AgentUI Quickstart →](https://docs.datamarkin.com/agentui/quickstart.md)

> [tab] I need pre-configured models
>
> Start with **Mozo**:
>
> ```bash theme={null}
> pip install mozo
> mozo serve
> ```
>
> Access 35+ models via HTTP API at [http://localhost:8000](http://localhost:8000).
>
> [View Mozo Quickstart →](https://docs.datamarkin.com/mozo/quickstart.md)

> [tab] I'm building a custom pipeline
>
> Start with **PixelFlow**:
>
> ```bash theme={null}
> pip install pixelflow
> ```
>
> Use PixelFlow's annotators, trackers, and analysis tools in your Python code.
>
> [View PixelFlow Quickstart →](https://docs.datamarkin.com/pixelflow/quickstart.md)

## Next Steps

> [card] [Explore AgentUI](https://docs.datamarkin.com/agentui/index.md)
>
> Learn about visual workflow building

> [card] [Explore Mozo](https://docs.datamarkin.com/mozo/index.md)
>
> Discover available models

> [card] [Explore PixelFlow](https://docs.datamarkin.com/pixelflow/index.md)
>
> Master CV primitives and annotators

> [card] [GitHub](https://github.com/datamarkin)
>
> View source code and examples


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