CrewAI Template

Demonstrates the Crew → Agent → Task orchestration pattern where agents and tasks are defined declaratively in YAML configuration files (e.g., gamedesign.yaml) rather than imperative Python code. The framework loads these configs at runtime, instantiates Agent objects with role/goal/backstory, binds them to Task objects with descriptions/expected_output, and chains them into a Crew that executes sequentially. This separates agent behavior specification from execution logic, enabling non-developers to modify agent personas and task workflows without touching Python code.

Implements the traditional Crew execution pattern where tasks are executed sequentially in defined order, with each task's output available as context for subsequent tasks. The framework maintains task state, passes output from one task as input context to the next, and handles error propagation through the chain. This is demonstrated in examples like Game Builder Crew where sequential game development workflow (design → implementation → testing) depends on prior task outputs. The Crew.kickoff() method orchestrates this execution, managing agent assignment and context flow.

Demonstrates a meeting automation workflow using CrewAI Flow that processes meeting transcripts, extracts key information, identifies action items, and generates summaries. The Meeting Assistant Flow example shows how to decompose meeting analysis into specialized tasks: transcription processing, key point extraction, action item identification, and summary generation. The workflow integrates multiple agents with specific responsibilities and produces structured output (summary, action items, attendee assignments). This pattern enables automated meeting documentation and follow-up without manual note-taking.

Demonstrates automated landing page generation using CrewAI where agents analyze requirements, generate copy, create visual descriptions, and produce HTML/CSS output. The Landing Page Generation Flow example shows how to decompose landing page creation into specialized tasks: requirement analysis, headline/copy generation, visual design specification, and code generation. The workflow produces complete landing pages with marketing copy, visual layout descriptions, and implementation code. This pattern enables rapid landing page iteration and A/B testing without manual design and development.

Demonstrates automated book writing using CrewAI Flow with task decomposition where a book outline is broken into chapters, each chapter is written by specialized agents, and content is reviewed and refined. The Write a Book with Flows example shows how to structure book writing as a workflow with planning (outline generation), writing (chapter-by-chapter), and editing (review and refinement) phases. The workflow manages long-form content generation with multiple agents contributing specialized skills (researcher, writer, editor) and produces a complete book manuscript with consistent quality and style.

Implements advanced CrewAI Flow framework for complex workflows with conditional routing, asynchronous processing, and interactive human decision points. Demonstrated in Lead Score Flow, Email Auto-Responder Flow, and Book Writing Flow examples, this pattern uses Flow subclasses that define workflow states, transitions, and decision logic. Workflows can pause for human input (e.g., approving lead scores), route to different agent paths based on conditions, and handle async operations. The Flow framework provides state management, decision routing, and integration points for human oversight without requiring external orchestration tools.

Demonstrates patterns for creating specialized agents with distinct roles (researcher, writer, reviewer, analyst) that integrate external tools and APIs. Examples like Stock Analysis System, Recruitment System, and Trip Planning System show agents with specific responsibilities that call external tools (SEC filing APIs, LinkedIn integration, weather APIs, search APIs). Each agent is configured with tools via the Tool class, enabling function calling to external services. The framework handles tool invocation, result parsing, and context integration back into agent reasoning, allowing agents to gather real-world data and perform specialized tasks.

Demonstrates patterns for integrating multiple LLM providers (OpenAI, Azure OpenAI, NVIDIA NIM, local Ollama models) through a unified agent interface. Examples show Azure OpenAI integration and NVIDIA NIM integration where agents can be configured to use different model providers without changing agent logic. The framework abstracts model selection at the agent level, allowing crews to mix agents using different providers. This enables cost optimization (using cheaper models for simple tasks), latency optimization (using local models), and provider flexibility without refactoring agent code.

Demonstrates integration patterns between CrewAI and LangGraph for combining crew-based agent orchestration with LangGraph's explicit state machine and graph-based workflow capabilities. The CrewAI-LangGraph example shows how to embed CrewAI crews as nodes within LangGraph workflows, enabling more sophisticated control flow, conditional branching, and state management than pure CrewAI. This pattern allows leveraging CrewAI's agent abstraction while using LangGraph's graph visualization and advanced routing capabilities.

Provides reference implementations for domain-specific content generation workflows including marketing strategy generation, job posting creation, Instagram content generation, and book writing. Each example demonstrates a crew composition pattern (e.g., researcher + writer + reviewer for job postings) tailored to the domain's requirements. The patterns show how to structure agents with domain-specific prompts, tools, and task sequences to produce high-quality specialized content. Examples include Marketing Strategy Generators using NVIDIA AI, Job Posting Generator with research/writing/review agents, and Book Writing Flow with chapter-based task decomposition.

Demonstrates reference implementations for complex business workflows including stock analysis (financial data processing), recruitment (candidate matching and scoring), trip planning (multi-constraint optimization), and game design (creative workflow). Each crew shows how to decompose a business process into specialized agent roles with specific responsibilities. Stock Analysis System integrates SEC filing APIs and financial analysis tools; Recruitment System handles LinkedIn integration and profile matching; Trip Planning System manages weather APIs and travel constraints. These examples serve as templates for building similar domain-specific crews.

Demonstrates patterns for building modular, reusable crew components that can be composed into larger systems. The repository structure shows how to organize crews into separate Python packages (game-builder-crew, marketing_strategy, etc.) with consistent entry points (main.py, crew() methods). This enables crews to be imported and composed as building blocks. The pattern uses configuration files to define agents and tasks separately from execution logic, allowing the same crew definition to be used in different contexts. This supports code reuse, testing, and team collaboration on shared crew libraries.

Implements an automated email response system using CrewAI Flow that analyzes incoming emails, classifies them, and routes to appropriate response agents. The Email Auto-Responder Flow example demonstrates conditional routing where email classification determines which agent generates the response (support agent, sales agent, etc.). The workflow integrates email parsing, sentiment analysis, and response generation with conditional branching based on email content. This pattern shows how to build customer-facing automation that handles diverse email types with appropriate responses.