crewAI/docs/en/enterprise/guides/prepare-for-deployment.mdx

---
title: "Prepare for Deployment"
description: "Ensure your Crew or Flow is ready for deployment to CrewAI AMP"
icon: "clipboard-check"
mode: "wide"
---

<Note>
  Before deploying to CrewAI AMP, it's crucial to verify your project is correctly structured.
  Both Crews and Flows can be deployed as "automations," but they have different project structures
  and requirements that must be met for successful deployment.
</Note>

## Understanding Automations

In CrewAI AMP, **automations** is the umbrella term for deployable AI projects. An automation can be either:

- **A Crew**: A standalone team of AI agents working together on tasks
- **A Flow**: An orchestrated workflow that can combine multiple crews, direct LLM calls, and procedural logic

Understanding which type you're deploying is essential because they have different project structures and entry points.

## Crews vs Flows: Key Differences

<CardGroup cols={2}>
  <Card title="Crew Projects" icon="users">
    Standalone AI agent teams with a nested `src/` structure. Best for focused, collaborative tasks.
  </Card>
  <Card title="Flow Projects" icon="diagram-project">
    Orchestrated workflows with root-level `main.py`. Best for complex, multi-stage processes.
  </Card>
</CardGroup>

| Aspect | Crew | Flow |
|--------|------|------|
| **Project structure** | Nested `src/project_name/` | Root-level files |
| **Main logic location** | `src/project_name/crew.py` | `main.py` at root |
| **Entry point** | `src/project_name/main.py` | `main.py` at root |
| **pyproject.toml type** | `type = "crew"` | `type = "flow"` |
| **CLI create command** | `crewai create crew name` | `crewai create flow name` |
| **Can contain other crews** | No | Yes (in `crews/` folder) |

## Project Structure Reference

### Crew Project Structure

When you run `crewai create crew my_crew`, you get this structure:

```
my_crew/
├── .gitignore
├── pyproject.toml          # Must have type = "crew"
├── README.md
├── .env
├── uv.lock                  # REQUIRED for deployment
└── src/
    └── my_crew/
        ├── __init__.py
        ├── main.py          # Entry point with run() function
        ├── crew.py          # Crew class with @CrewBase decorator
        ├── tools/
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml  # Agent definitions
            └── tasks.yaml   # Task definitions
```

<Warning>
  The nested `src/project_name/` structure is critical for Crews.
  Placing files at the wrong level will cause deployment failures.
</Warning>

### Flow Project Structure

When you run `crewai create flow my_flow`, you get this structure:

```
my_flow/
├── .gitignore
├── pyproject.toml          # Must have type = "flow"
├── README.md
├── .env
├── uv.lock                  # REQUIRED for deployment
├── main.py                  # Entry point with kickoff() function
├── crews/                   # Embedded crews
│   └── research_crew/
│       ├── config/
│       │   ├── agents.yaml
│       │   └── tasks.yaml
│       └── research_crew.py # Each crew needs @CrewBase decorator
└── tools/
    └── custom_tool.py
```

<Info>
  Flows have `main.py` at the **root level**, not inside a `src/` folder.
  This is a key difference from Crew projects.
</Info>

## Pre-Deployment Checklist

Use this checklist to verify your project is ready for deployment.

### 1. Verify pyproject.toml Configuration

Your `pyproject.toml` must include the correct `[tool.crewai]` section:

<Tabs>
  <Tab title="For Crews">
    ```toml
    [tool.crewai]
    type = "crew"
    ```
  </Tab>
  <Tab title="For Flows">
    ```toml
    [tool.crewai]
    type = "flow"
    ```
  </Tab>
</Tabs>

<Warning>
  If the `type` doesn't match your project structure, the build will fail or
  the automation won't run correctly.
</Warning>

### 2. Ensure uv.lock File Exists

CrewAI uses `uv` for dependency management. The `uv.lock` file ensures reproducible builds and is **required** for deployment.

```bash
# Generate or update the lock file
uv lock

# Verify it exists
ls -la uv.lock
```

If the file doesn't exist, run `uv lock` and commit it to your repository:

```bash
uv lock
git add uv.lock
git commit -m "Add uv.lock for deployment"
git push
```

### 3. Validate CrewBase Decorator Usage

**Every crew class must use the `@CrewBase` decorator.** This applies to:

- Standalone crew projects
- Crews embedded inside Flow projects

```python
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase  # This decorator is REQUIRED
class MyCrew():
    """My crew description"""

    agents: List[BaseAgent]
    tasks: List[Task]

    @agent
    def my_agent(self) -> Agent:
        return Agent(
            config=self.agents_config['my_agent'],  # type: ignore[index]
            verbose=True
        )

    @task
    def my_task(self) -> Task:
        return Task(
            config=self.tasks_config['my_task']  # type: ignore[index]
        )

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True,
        )
```

<Warning>
  If you forget the `@CrewBase` decorator, your deployment will fail with
  errors about missing agents or tasks configurations.
</Warning>

### 4. Check Project Entry Points

Verify your project has the correct entry point function:

<Tabs>
  <Tab title="For Crews">
    The entry point is in `src/project_name/main.py`:

    ```python
    # src/my_crew/main.py
    from my_crew.crew import MyCrew

    def run():
        """Run the crew."""
        inputs = {'topic': 'AI in Healthcare'}
        result = MyCrew().crew().kickoff(inputs=inputs)
        return result

    if __name__ == "__main__":
        run()
    ```
  </Tab>
  <Tab title="For Flows">
    The entry point is in `main.py` at the project root:

    ```python
    # main.py (at project root)
    from crewai.flow.flow import Flow, listen, start

    class MyFlow(Flow):
        @start()
        def begin(self):
            # Flow logic here
            pass

    def kickoff():
        """Run the flow."""
        MyFlow().kickoff()

    if __name__ == "__main__":
        kickoff()
    ```
  </Tab>
</Tabs>

### 5. Prepare Environment Variables

Before deployment, ensure you have:

1. **LLM API keys** ready (OpenAI, Anthropic, Google, etc.)
2. **Tool API keys** if using external tools (Serper, etc.)
3. Variable names that comply with [security requirements](/en/enterprise/guides/deploy-to-amp#environment-variable-security-requirements)

<Tip>
  Test your project locally with the same environment variables before deploying
  to catch configuration issues early.
</Tip>

## Quick Validation Commands

Run these commands from your project root to quickly verify your setup:

```bash
# 1. Check project type in pyproject.toml
grep -A2 "\[tool.crewai\]" pyproject.toml

# 2. Verify uv.lock exists
ls -la uv.lock || echo "ERROR: uv.lock missing! Run 'uv lock'"

# 3. For Crews - verify structure
ls -la src/*/crew.py 2>/dev/null || echo "No crew.py found in src/"

# 4. For Flows - verify structure
ls -la main.py 2>/dev/null || echo "No main.py at root"
ls -la crews/ 2>/dev/null || echo "No crews/ folder (optional for flows)"

# 5. Check for CrewBase usage
grep -r "@CrewBase" . --include="*.py"
```

## Common Setup Mistakes

| Mistake | Symptom | Fix |
|---------|---------|-----|
| Missing `uv.lock` | Build fails during dependency resolution | Run `uv lock` and commit |
| Wrong `type` in pyproject.toml | Build succeeds but runtime fails | Change to correct type |
| Missing `@CrewBase` decorator | "Config not found" errors | Add decorator to all crew classes |
| Crew `main.py` at root level | Entry point not found | Move to `src/project_name/` |
| Flow `main.py` in `src/` | Entry point not found | Move to project root |
| Missing `run()` or `kickoff()` | Cannot start automation | Add correct entry function |

## Next Steps

Once your project passes all checklist items, you're ready to deploy:

<Card title="Deploy to AMP" icon="rocket" href="/en/enterprise/guides/deploy-to-amp">
  Follow the deployment guide to deploy your Crew or Flow to CrewAI AMP using
  the CLI, web interface, or CI/CD integration.
</Card>