Getting Started with aipartnerupflow¶

Welcome to aipartnerupflow! This guide will help you get started quickly, whether you're new to task orchestration or an experienced developer.

What is aipartnerupflow?¶

aipartnerupflow is a Python framework for orchestrating and executing tasks. Think of it as a conductor for your application's tasks - it manages when tasks run, how they depend on each other, and ensures everything executes in the right order.

Key Benefits¶

• Simple Task Management: Create, organize, and execute tasks with ease
• Dependency Handling: Tasks automatically wait for their dependencies to complete
• Flexible Execution: Support for custom tasks, LLM agents (CrewAI), and more
• Production Ready: Built-in storage, streaming, and API support
• Extensible: Easy to add custom task types and integrations

Quick Navigation¶

🚀 New to aipartnerupflow?¶

Start here if you're completely new:

1. Core Concepts - Learn the fundamental ideas (5 min read)
2. Quick Start Guide - Build your first task (10 min)
3. First Steps Tutorial - Complete beginner tutorial

📚 Already familiar?¶

Jump to what you need:

• Examples - Copy-paste ready examples
• Task Orchestration Guide - Deep dive into task management
• Custom Tasks Guide - Create your own task types
• API Reference - Complete API documentation

🎯 What do you want to do?¶

I want to...

• Execute simple tasks → Quick Start
• Build complex workflows → Task Orchestration Guide
• Create custom task types → Custom Tasks Guide
• Use LLM agents → CrewAI Examples
• Understand the architecture → Architecture Overview

Core Concepts at a Glance¶

┌─────────────────────────────────────────────────────────┐
│                    Your Application                      │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│              aipartnerupflow Framework                   │
│                                                          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │   Task 1     │  │   Task 2     │  │   Task 3     │ │
│  │  (Fetch)    │  │  (Process)   │  │  (Save)      │ │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘ │
│         │                 │                  │         │
│         └─────────────────┼──────────────────┘         │
│                           │                             │
│                    Dependencies                          │
│              (Task 2 waits for Task 1)                  │
│                                                          │
│              TaskManager orchestrates                   │
│              execution order automatically              │
└─────────────────────────────────────────────────────────┘

The Basics¶

• Task: A unit of work (e.g., "fetch data", "process file", "send email")
• Task Tree: A hierarchical structure organizing related tasks
• Dependencies: Relationships that control execution order
• Executor: The code that actually runs a task
• TaskManager: The orchestrator that manages task execution

Installation¶

Choose your installation based on what you need:

# Minimal: Core orchestration only
pip install aipartnerupflow

# With LLM support (CrewAI)
pip install aipartnerupflow[crewai]

# With API server
pip install aipartnerupflow[a2a]

# With CLI tools
pip install aipartnerupflow[cli]

# Everything
pip install aipartnerupflow[all]

See Installation Guide for details.

Your First 5 Minutes¶

Here's the fastest way to see aipartnerupflow in action:

from aipartnerupflow import TaskManager, TaskTreeNode, create_session
import asyncio

async def main():
    # 1. Create a database session
    db = create_session()

    # 2. Create a task manager
    task_manager = TaskManager(db)

    # 3. Create a simple task
    task = await task_manager.task_repository.create_task(
        name="system_info_executor",  # Built-in executor
        user_id="user123",
        inputs={"resource": "cpu"}
    )

    # 4. Build and execute
    task_tree = TaskTreeNode(task)
    await task_manager.distribute_task_tree(task_tree)

    # 5. Check the result
    result = await task_manager.task_repository.get_task_by_id(task.id)
    print(f"Task completed: {result.status}")
    print(f"Result: {result.result}")

asyncio.run(main())

That's it! You just executed your first task.

👉 Next: Read Core Concepts to understand what just happened, or jump to Quick Start for a more detailed walkthrough.

Learning Paths¶

Path 1: Quick Learner (30 minutes)¶

1. Core Concepts (5 min)
2. Quick Start (10 min)
3. Basic Examples (15 min)

Path 2: Comprehensive (2 hours)¶

1. Core Concepts
2. Quick Start
3. First Steps Tutorial
4. Task Trees Tutorial
5. Dependencies Tutorial

Path 3: Professional Developer (4+ hours)¶

1. Complete Path 2
2. Custom Tasks Guide
3. Best Practices
4. API Reference
5. Advanced Topics

Common Questions¶

Q: Do I need to know task orchestration?
A: No! Start with Core Concepts - we explain everything from scratch.

Q: Can I use this without LLM/AI?
A: Yes! The core framework has no AI dependencies. LLM support is optional via [crewai].

Q: Is this production-ready?
A: Yes! It includes storage, error handling, streaming, and API support out of the box.

Q: How is this different from Celery/Airflow?
A: aipartnerupflow focuses on simplicity and flexibility. It's designed for both simple workflows and complex AI agent orchestration.

Next Steps¶

• New to task orchestration? → Start with Core Concepts
• Ready to code? → Jump to Quick Start
• Want examples? → Check Examples
• Need help? → See FAQ

Ready to begin? → Start with Core Concepts →