Flows

​

Overview

1. Simplified Workflow Creation: Easily chain together multiple Crews and tasks to create complex AI workflows.
2. State Management: Flows make it super easy to manage and share state between different tasks in your workflow.
3. Event-Driven Architecture: Built on an event-driven model, allowing for dynamic and responsive workflows.
4. Flexible Control Flow: Implement conditional logic, loops, and branching within your workflows.

​

Getting Started

from crewai.flow.flow import Flow, listen, start
from dotenv import load_dotenv
from litellm import completion


class ExampleFlow(Flow):
    model = "gpt-4o-mini"

    @start()
    def generate_city(self):
        print("Starting flow")
        # Each flow state automatically gets a unique ID
        print(f"Flow State ID: {self.state['id']}")

        response = completion(
            model=self.model,
            messages=[
                {
                    "role": "user",
                    "content": "Return the name of a random city in the world.",
                },
            ],
        )

        random_city = response["choices"][0]["message"]["content"]
        # Store the city in our state
        self.state["city"] = random_city
        print(f"Random City: {random_city}")

        return random_city

    @listen(generate_city)
    def generate_fun_fact(self, random_city):
        response = completion(
            model=self.model,
            messages=[
                {
                    "role": "user",
                    "content": f"Tell me a fun fact about {random_city}",
                },
            ],
        )

        fun_fact = response["choices"][0]["message"]["content"]
        # Store the fun fact in our state
        self.state["fun_fact"] = fun_fact
        return fun_fact



flow = ExampleFlow()
flow.plot()
result = flow.kickoff()

print(f"Generated fun fact: {result}")

In the above example, we have created a simple Flow that generates a random city using OpenAI and then generates a fun fact about that city. The Flow consists of two tasks: generate_city and generate_fun_fact. The generate_city task is the starting point of the Flow, and the generate_fun_fact task listens for the output of the generate_city task.

1. Generate a unique ID for the flow state
2. Generate a random city and store it in the state
3. Generate a fun fact about that city and store it in the state
4. Print the results to the console

​

@start()

​

@listen()

​

Usage

1. Listening to a Method by Name: You can pass the name of the method you want to listen to as a string. When that method completes, the listener method will be triggered.
   Code

   Copy

   Ask AI

   @listen("generate_city")
   def generate_fun_fact(self, random_city):
       # Implementation
   

2. Listening to a Method Directly: You can pass the method itself. When that method completes, the listener method will be triggered.
   Code

   Copy

   Ask AI

   @listen(generate_city)
   def generate_fun_fact(self, random_city):
       # Implementation
   

​

Flow Output

​

Retrieving the Final Output

from crewai.flow.flow import Flow, listen, start

class OutputExampleFlow(Flow):
    @start()
    def first_method(self):
        return "Output from first_method"

    @listen(first_method)
    def second_method(self, first_output):
        return f"Second method received: {first_output}"


flow = OutputExampleFlow()
flow.plot("my_flow_plot")
final_output = flow.kickoff()

print("---- Final Output ----")
print(final_output)

​

Accessing and Updating State

from crewai.flow.flow import Flow, listen, start
from pydantic import BaseModel

class ExampleState(BaseModel):
    counter: int = 0
    message: str = ""

class StateExampleFlow(Flow[ExampleState]):

    @start()
    def first_method(self):
        self.state.message = "Hello from first_method"
        self.state.counter += 1

    @listen(first_method)
    def second_method(self):
        self.state.message += " - updated by second_method"
        self.state.counter += 1
        return self.state.message

flow = StateExampleFlow()
flow.plot("my_flow_plot")
final_output = flow.kickoff()
print(f"Final Output: {final_output}")
print("Final State:")
print(flow.state)

​

Flow State Management

​

Unstructured State Management

from crewai.flow.flow import Flow, listen, start

class UnstructuredExampleFlow(Flow):

    @start()
    def first_method(self):
        # The state automatically includes an 'id' field
        print(f"State ID: {self.state['id']}")
        self.state['counter'] = 0
        self.state['message'] = "Hello from structured flow"

    @listen(first_method)
    def second_method(self):
        self.state['counter'] += 1
        self.state['message'] += " - updated"

    @listen(second_method)
    def third_method(self):
        self.state['counter'] += 1
        self.state['message'] += " - updated again"

        print(f"State after third_method: {self.state}")


flow = UnstructuredExampleFlow()
flow.plot("my_flow_plot")
flow.kickoff()

• Flexibility: You can dynamically add attributes to self.state without predefined constraints.
• Simplicity: Ideal for straightforward workflows where state structure is minimal or varies significantly.

​

Structured State Management

from crewai.flow.flow import Flow, listen, start
from pydantic import BaseModel


class ExampleState(BaseModel):
    # Note: 'id' field is automatically added to all states
    counter: int = 0
    message: str = ""


class StructuredExampleFlow(Flow[ExampleState]):

    @start()
    def first_method(self):
        # Access the auto-generated ID if needed
        print(f"State ID: {self.state.id}")
        self.state.message = "Hello from structured flow"

    @listen(first_method)
    def second_method(self):
        self.state.counter += 1
        self.state.message += " - updated"

    @listen(second_method)
    def third_method(self):
        self.state.counter += 1
        self.state.message += " - updated again"

        print(f"State after third_method: {self.state}")


flow = StructuredExampleFlow()
flow.kickoff()

• Defined Schema: ExampleState clearly outlines the state structure, enhancing code readability and maintainability.
• Type Safety: Leveraging Pydantic ensures that state attributes adhere to the specified types, reducing runtime errors.
• Auto-Completion: IDEs can provide better auto-completion and error checking based on the defined state model.

​

Choosing Between Unstructured and Structured State Management

• Use Unstructured State Management when:
  • The workflow’s state is simple or highly dynamic.
  • Flexibility is prioritized over strict state definitions.
  • Rapid prototyping is required without the overhead of defining schemas.
• Use Structured State Management when:
  • The workflow requires a well-defined and consistent state structure.
  • Type safety and validation are important for your application’s reliability.
  • You want to leverage IDE features like auto-completion and type checking for better developer experience.

​

Flow Persistence

​

Class-Level Persistence

@persist  # Using SQLiteFlowPersistence by default
class MyFlow(Flow[MyState]):
    @start()
    def initialize_flow(self):
        # This method will automatically have its state persisted
        self.state.counter = 1
        print("Initialized flow. State ID:", self.state.id)

    @listen(initialize_flow)
    def next_step(self):
        # The state (including self.state.id) is automatically reloaded
        self.state.counter += 1
        print("Flow state is persisted. Counter:", self.state.counter)

​

Method-Level Persistence

class AnotherFlow(Flow[dict]):
    @persist  # Persists only this method's state
    @start()
    def begin(self):
        if "runs" not in self.state:
            self.state["runs"] = 0
        self.state["runs"] += 1
        print("Method-level persisted runs:", self.state["runs"])

​

How It Works

1. Unique State Identification
   • Each flow state automatically receives a unique UUID
   • The ID is preserved across state updates and method calls
   • Supports both structured (Pydantic BaseModel) and unstructured (dictionary) states
2. Default SQLite Backend
   • SQLiteFlowPersistence is the default storage backend
   • States are automatically saved to a local SQLite database
   • Robust error handling ensures clear messages if database operations fail
3. Error Handling
   • Comprehensive error messages for database operations
   • Automatic state validation during save and load
   • Clear feedback when persistence operations encounter issues

​

Important Considerations

• State Types: Both structured (Pydantic BaseModel) and unstructured (dictionary) states are supported
• Automatic ID: The id field is automatically added if not present
• State Recovery: Failed or restarted flows can automatically reload their previous state
• Custom Implementation: You can provide your own FlowPersistence implementation for specialized storage needs

​

Technical Advantages

1. Precise Control Through Low-Level Access
   • Direct access to persistence operations for advanced use cases
   • Fine-grained control via method-level persistence decorators
   • Built-in state inspection and debugging capabilities
   • Full visibility into state changes and persistence operations
2. Enhanced Reliability
   • Automatic state recovery after system failures or restarts
   • Transaction-based state updates for data integrity
   • Comprehensive error handling with clear error messages
   • Robust validation during state save and load operations
3. Extensible Architecture
   • Customizable persistence backend through FlowPersistence interface
   • Support for specialized storage solutions beyond SQLite
   • Compatible with both structured (Pydantic) and unstructured (dict) states
   • Seamless integration with existing CrewAI flow patterns

​

Flow Control

​

Conditional Logic: or

from crewai.flow.flow import Flow, listen, or_, start

class OrExampleFlow(Flow):

    @start()
    def start_method(self):
        return "Hello from the start method"

    @listen(start_method)
    def second_method(self):
        return "Hello from the second method"

    @listen(or_(start_method, second_method))
    def logger(self, result):
        print(f"Logger: {result}")



flow = OrExampleFlow()
flow.plot("my_flow_plot")
flow.kickoff()

​

Conditional Logic: and

from crewai.flow.flow import Flow, and_, listen, start

class AndExampleFlow(Flow):

    @start()
    def start_method(self):
        self.state["greeting"] = "Hello from the start method"

    @listen(start_method)
    def second_method(self):
        self.state["joke"] = "What do computers eat? Microchips."

    @listen(and_(start_method, second_method))
    def logger(self):
        print("---- Logger ----")
        print(self.state)

flow = AndExampleFlow()
flow.plot()
flow.kickoff()

​

Router

import random
from crewai.flow.flow import Flow, listen, router, start
from pydantic import BaseModel

class ExampleState(BaseModel):
    success_flag: bool = False

class RouterFlow(Flow[ExampleState]):

    @start()
    def start_method(self):
        print("Starting the structured flow")
        random_boolean = random.choice([True, False])
        self.state.success_flag = random_boolean

    @router(start_method)
    def second_method(self):
        if self.state.success_flag:
            return "success"
        else:
            return "failed"

    @listen("success")
    def third_method(self):
        print("Third method running")

    @listen("failed")
    def fourth_method(self):
        print("Fourth method running")


flow = RouterFlow()
flow.plot("my_flow_plot")
flow.kickoff()

​

Adding Agents to Flows

import asyncio
from typing import Any, Dict, List

from crewai_tools import SerperDevTool
from pydantic import BaseModel, Field

from crewai.agent import Agent
from crewai.flow.flow import Flow, listen, start


# Define a structured output format
class MarketAnalysis(BaseModel):
    key_trends: List[str] = Field(description="List of identified market trends")
    market_size: str = Field(description="Estimated market size")
    competitors: List[str] = Field(description="Major competitors in the space")


# Define flow state
class MarketResearchState(BaseModel):
    product: str = ""
    analysis: MarketAnalysis | None = None


# Create a flow class
class MarketResearchFlow(Flow[MarketResearchState]):
    @start()
    def initialize_research(self) -> Dict[str, Any]:
        print(f"Starting market research for {self.state.product}")
        return {"product": self.state.product}

    @listen(initialize_research)
    async def analyze_market(self) -> Dict[str, Any]:
        # Create an Agent for market research
        analyst = Agent(
            role="Market Research Analyst",
            goal=f"Analyze the market for {self.state.product}",
            backstory="You are an experienced market analyst with expertise in "
            "identifying market trends and opportunities.",
            tools=[SerperDevTool()],
            verbose=True,
        )

        # Define the research query
        query = f"""
        Research the market for {self.state.product}. Include:
        1. Key market trends
        2. Market size
        3. Major competitors

        Format your response according to the specified structure.
        """

        # Execute the analysis with structured output format
        result = await analyst.kickoff_async(query, response_format=MarketAnalysis)
        if result.pydantic:
            print("result", result.pydantic)
        else:
            print("result", result)

        # Return the analysis to update the state
        return {"analysis": result.pydantic}

    @listen(analyze_market)
    def present_results(self, analysis) -> None:
        print("\nMarket Analysis Results")
        print("=====================")

        if isinstance(analysis, dict):
            # If we got a dict with 'analysis' key, extract the actual analysis object
            market_analysis = analysis.get("analysis")
        else:
            market_analysis = analysis

        if market_analysis and isinstance(market_analysis, MarketAnalysis):
            print("\nKey Market Trends:")
            for trend in market_analysis.key_trends:
                print(f"- {trend}")

            print(f"\nMarket Size: {market_analysis.market_size}")

            print("\nMajor Competitors:")
            for competitor in market_analysis.competitors:
                print(f"- {competitor}")
        else:
            print("No structured analysis data available.")
            print("Raw analysis:", analysis)


# Usage example
async def run_flow():
    flow = MarketResearchFlow()
    flow.plot("MarketResearchFlowPlot")
    result = await flow.kickoff_async(inputs={"product": "AI-powered chatbots"})
    return result


# Run the flow
if __name__ == "__main__":
    asyncio.run(run_flow())

1. Structured Output: Using Pydantic models to define the expected output format (MarketAnalysis) ensures type safety and structured data throughout the flow.
2. State Management: The flow state (MarketResearchState) maintains context between steps and stores both inputs and outputs.
3. Tool Integration: Agents can use tools (like WebsiteSearchTool) to enhance their capabilities.

​

Adding Crews to Flows

crewai create flow name_of_flow

​

Folder Structure

​

Building Your Crews

• config/agents.yaml: Defines the agents for the crew.
• config/tasks.yaml: Defines the tasks for the crew.
• poem_crew.py: Contains the crew definition, including agents, tasks, and the crew itself.

​

Connecting Crews in main.py

#!/usr/bin/env python
from random import randint

from pydantic import BaseModel
from crewai.flow.flow import Flow, listen, start
from .crews.poem_crew.poem_crew import PoemCrew

class PoemState(BaseModel):
    sentence_count: int = 1
    poem: str = ""

class PoemFlow(Flow[PoemState]):

    @start()
    def generate_sentence_count(self):
        print("Generating sentence count")
        self.state.sentence_count = randint(1, 5)

    @listen(generate_sentence_count)
    def generate_poem(self):
        print("Generating poem")
        result = PoemCrew().crew().kickoff(inputs={"sentence_count": self.state.sentence_count})

        print("Poem generated", result.raw)
        self.state.poem = result.raw

    @listen(generate_poem)
    def save_poem(self):
        print("Saving poem")
        with open("poem.txt", "w") as f:
            f.write(self.state.poem)

def kickoff():
    poem_flow = PoemFlow()
    poem_flow.kickoff()


def plot():
    poem_flow = PoemFlow()
    poem_flow.plot("PoemFlowPlot")

if __name__ == "__main__":
    kickoff()
    plot()

​

Running the Flow

crewai install

source .venv/bin/activate

crewai flow kickoff

uv run kickoff

​

Plot Flows

​

What are Plots?

​

How to Generate a Plot

​

Option 1: Using the plot() Method

# Assuming you have a flow instance
flow.plot("my_flow_plot")

​

Option 2: Using the Command Line

crewai flow plot

​

Understanding the Plot

​

Conclusion

​

Next Steps

1. Email Auto Responder Flow: This example demonstrates an infinite loop where a background job continually runs to automate email responses. It’s a great use case for tasks that need to be performed repeatedly without manual intervention. View Example
2. Lead Score Flow: This flow showcases adding human-in-the-loop feedback and handling different conditional branches using the router. It’s an excellent example of how to incorporate dynamic decision-making and human oversight into your workflows. View Example
3. Write a Book Flow: This example excels at chaining multiple crews together, where the output of one crew is used by another. Specifically, one crew outlines an entire book, and another crew generates chapters based on the outline. Eventually, everything is connected to produce a complete book. This flow is perfect for complex, multi-step processes that require coordination between different tasks. View Example
4. Meeting Assistant Flow: This flow demonstrates how to broadcast one event to trigger multiple follow-up actions. For instance, after a meeting is completed, the flow can update a Trello board, send a Slack message, and save the results. It’s a great example of handling multiple outcomes from a single event, making it ideal for comprehensive task management and notification systems. View Example

​

Running Flows

​

Using the Flow API

flow = ExampleFlow()
result = flow.kickoff()

​

Using the CLI

crewai run

crewai flow kickoff