CrewAI Architecture

1"""
2CrewAI vs LangGraph vs AutoGPT
3
4CrewAI:
5- Role-based agent design (personas, backstories)
6- High-level abstraction
7- Built-in collaboration patterns
8- Great for: Team-based workflows, role-playing scenarios
9
10LangGraph:
11- Graph-based state machines
12- Fine-grained control over flow
13- Explicit state management
14- Great for: Complex workflows, precise control
15
16AutoGPT:
17- Fully autonomous goal pursuit
18- Self-prompting loop
19- Minimal human intervention
20- Great for: Open-ended exploration tasks
21"""
22
23# CrewAI focuses on making agent collaboration intuitive
24# by modeling real-world team dynamics

1"""
2The Crew Metaphor in CrewAI
3
4┌────────────────────────────────────────────────────────────┐
5│                          CREW                               │
6│  ┌─────────────────────────────────────────────────────┐   │
7│  │                      PROCESS                         │   │
8│  │                                                      │   │
9│  │   ┌─────────┐    ┌─────────┐    ┌─────────┐        │   │
10│  │   │ Agent 1 │───▶│ Agent 2 │───▶│ Agent 3 │        │   │
11│  │   │  Role   │    │  Role   │    │  Role   │        │   │
12│  │   │ Tools   │    │ Tools   │    │ Tools   │        │   │
13│  │   └─────────┘    └─────────┘    └─────────┘        │   │
14│  │        │              │              │              │   │
15│  │        ▼              ▼              ▼              │   │
16│  │   ┌─────────┐    ┌─────────┐    ┌─────────┐        │   │
17│  │   │ Task 1  │    │ Task 2  │    │ Task 3  │        │   │
18│  │   └─────────┘    └─────────┘    └─────────┘        │   │
19│  │                                                      │   │
20│  └─────────────────────────────────────────────────────┘   │
21│                           │                                 │
22│                           ▼                                 │
23│                    ┌────────────┐                          │
24│                    │   OUTPUT   │                          │
25│                    └────────────┘                          │
26└────────────────────────────────────────────────────────────┘
27"""
28
29# Key components:
30# - Agent: An autonomous unit with role, goal, backstory, and tools
31# - Task: A specific piece of work with description and expected output
32# - Crew: A collection of agents working on tasks
33# - Process: How tasks are executed (sequential or hierarchical)

1"""
2Role-Playing in CrewAI
3
4Each agent has:
51. Role: Their job title (e.g., "Senior Researcher")
62. Goal: What they're trying to achieve
73. Backstory: Context that shapes their behavior
84. Tools: Capabilities they have access to
9
10This persona-based approach leads to more coherent,
11specialized behavior from agents.
12"""
13
14from crewai import Agent
15
16# Example: A researcher agent with clear persona
17researcher = Agent(
18    role="Senior Research Analyst",
19    goal="Uncover cutting-edge developments in AI technology",
20    backstory="""You are a veteran research analyst with 15 years
21    of experience in technology research. You have a PhD in Computer
22    Science and have published numerous papers on AI. You're known
23    for your thorough research and ability to synthesize complex
24    information into actionable insights.""",
25    verbose=True,
26    allow_delegation=False
27)
28
29# The backstory helps the LLM maintain consistent behavior
30# and approach problems from the perspective of an expert

1"""
2CrewAI Core Architecture
3
4                    ┌───────────────────┐
5                    │    CrewAI Core    │
6                    └─────────┬─────────┘
7                              │
8          ┌───────────────────┼───────────────────┐
9          │                   │                   │
10          ▼                   ▼                   ▼
11    ┌───────────┐      ┌───────────┐      ┌───────────┐
12    │   Agent   │      │   Task    │      │   Crew    │
13    └─────┬─────┘      └─────┬─────┘      └─────┬─────┘
14          │                  │                  │
15    ┌─────┴─────┐      ┌─────┴─────┐      ┌─────┴─────┐
16    │  - role   │      │  - desc   │      │  - agents │
17    │  - goal   │      │  - agent  │      │  - tasks  │
18    │  - back   │      │  - output │      │  - process│
19    │  - tools  │      │  - context│      │  - memory │
20    │  - llm    │      │           │      │           │
21    └───────────┘      └───────────┘      └───────────┘
22
23Memory System:
24┌─────────────────────────────────────────────────────┐
25│                    Memory                            │
26│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐  │
27│  │Short-term│  │Long-term │  │Entity Memory     │  │
28│  │(context) │  │(learning)│  │(relationships)   │  │
29│  └──────────┘  └──────────┘  └──────────────────┘  │
30└─────────────────────────────────────────────────────┘
31"""
32
33from crewai import Agent, Task, Crew, Process
34from langchain_openai import ChatOpenAI
35
36# LLM Configuration
37llm = ChatOpenAI(model="gpt-4o", temperature=0.7)
38
39# Agent with full configuration
40agent = Agent(
41    role="Technical Writer",
42    goal="Create clear and comprehensive documentation",
43    backstory="Expert technical writer with 10 years experience",
44    llm=llm,
45    tools=[],  # List of tools
46    verbose=True,
47    allow_delegation=True,
48    max_iter=15,  # Maximum iterations
49    max_rpm=None,  # Rate limiting
50    memory=True   # Enable memory
51)

1"""
2CrewAI Execution Flow
3
41. Crew Initialization
5   └─▶ Load agents, tasks, and configuration
6
72. Task Assignment
8   └─▶ Match tasks to agents based on process type
9
103. For each task:
11   ├─▶ Agent receives task description
12   ├─▶ Agent reasons about approach
13   ├─▶ Agent uses tools if needed
14   ├─▶ Agent may delegate to other agents
15   ├─▶ Agent produces output
16   └─▶ Output becomes context for next task
17
184. Crew produces final output
19   └─▶ Combined results from all tasks
20
21"""
22
23# Example flow with three agents
24from crewai import Crew, Process
25
26# Define crew with sequential process
27crew = Crew(
28    agents=[researcher, analyst, writer],
29    tasks=[research_task, analysis_task, writing_task],
30    process=Process.sequential,  # Tasks run in order
31    verbose=True
32)
33
34# Execute the crew
35result = crew.kickoff()
36
37# Tasks execute in order:
38# 1. researcher does research_task
39# 2. analyst does analysis_task (uses research output)
40# 3. writer does writing_task (uses analysis output)

1# Install CrewAI
2pip install crewai
3
4# Install with extra tools
5pip install 'crewai[tools]'
6
7# Optional: Install LangChain integrations
8pip install langchain-openai langchain-community

1import os
2from crewai import Agent, Task, Crew, Process
3from langchain_openai import ChatOpenAI
4
5# Set up API keys
6os.environ["OPENAI_API_KEY"] = "your-api-key"
7
8# Configure LLM
9llm = ChatOpenAI(
10    model="gpt-4o",
11    temperature=0.7,
12    max_tokens=4000
13)
14
15# Minimal working example
16researcher = Agent(
17    role="Researcher",
18    goal="Find accurate information on given topics",
19    backstory="You are an experienced researcher",
20    llm=llm,
21    verbose=True
22)
23
24research_task = Task(
25    description="Research the current state of AI agents in 2025",
26    expected_output="A comprehensive report on AI agent trends",
27    agent=researcher
28)
29
30crew = Crew(
31    agents=[researcher],
32    tasks=[research_task],
33    process=Process.sequential,
34    verbose=True
35)
36
37# Run the crew
38result = crew.kickoff()
39print(result)

1# Recommended CrewAI project structure
2my_crew_project/
3├── src/
4│   ├── __init__.py
5│   ├── crew.py          # Main crew definition
6│   ├── agents.py        # Agent definitions
7│   ├── tasks.py         # Task definitions
8│   └── tools/
9│       ├── __init__.py
10│       └── custom_tools.py
11├── config/
12│   ├── agents.yaml      # Agent configurations
13│   └── tasks.yaml       # Task configurations
14├── tests/
15│   └── test_crew.py
16├── requirements.txt
17└── main.py              # Entry point