Merge branch 'main' into lorenze/improve-docs-flows

README.md

@@ -57,7 +57,7 @@
 > It empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario.
 
 - **CrewAI Crews**: Optimize for autonomy and collaborative intelligence.
-- **CrewAI Flows**: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively
+- **CrewAI Flows**: The **enterprise and production architecture** for building and deploying multi-agent systems. Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively
 
 With over 100,000 developers certified through our community courses at [learn.crewai.com](https://learn.crewai.com), CrewAI is rapidly becoming the
 standard for enterprise-ready AI automation.
@@ -166,13 +166,13 @@ Ensure you have Python >=3.10 <3.14 installed on your system. CrewAI uses [UV](h
 First, install CrewAI:
 
 ```shell
-pip install crewai
+uv pip install crewai
 ```
 
 If you want to install the 'crewai' package along with its optional features that include additional tools for agents, you can do so by using the following command:
 
 ```shell
-pip install 'crewai[tools]'
+uv pip install 'crewai[tools]'
 ```
 
 The command above installs the basic package and also adds extra components which require more dependencies to function.
@@ -185,14 +185,14 @@ If you encounter issues during installation or usage, here are some common solut
 
 1. **ModuleNotFoundError: No module named 'tiktoken'**
 
-   - Install tiktoken explicitly: `pip install 'crewai[embeddings]'`
-   - If using embedchain or other tools: `pip install 'crewai[tools]'`
+   - Install tiktoken explicitly: `uv pip install 'crewai[embeddings]'`
+   - If using embedchain or other tools: `uv pip install 'crewai[tools]'`
 2. **Failed building wheel for tiktoken**
 
    - Ensure Rust compiler is installed (see installation steps above)
    - For Windows: Verify Visual C++ Build Tools are installed
-   - Try upgrading pip: `pip install --upgrade pip`
-   - If issues persist, use a pre-built wheel: `pip install tiktoken --prefer-binary`
+   - Try upgrading pip: `uv pip install --upgrade pip`
+   - If issues persist, use a pre-built wheel: `uv pip install tiktoken --prefer-binary`
 
 ### 2. Setting Up Your Crew with the YAML Configuration
 
@@ -611,7 +611,7 @@ uv build
 ### Installing Locally
 
 ```bash
-pip install dist/*.tar.gz
+uv pip install dist/*.tar.gz
 ```
 
 ## Telemetry
@@ -687,13 +687,13 @@ A: CrewAI is a standalone, lean, and fast Python framework built specifically fo
 A: Install CrewAI using pip:
 
 ```shell
-pip install crewai
+uv pip install crewai
 ```
 
 For additional tools, use:
 
 ```shell
-pip install 'crewai[tools]'
+uv pip install 'crewai[tools]'
 ```
 
 ### Q: Does CrewAI depend on LangChain?

docs/docs.json

@@ -116,6 +116,7 @@
                   "en/concepts/tasks",
                   "en/concepts/crews",
                   "en/concepts/flows",
+                  "en/concepts/production-architecture",
                   "en/concepts/knowledge",
                   "en/concepts/llms",
                   "en/concepts/processes",
@@ -558,6 +559,7 @@
                   "pt-BR/concepts/tasks",
                   "pt-BR/concepts/crews",
                   "pt-BR/concepts/flows",
+                  "pt-BR/concepts/production-architecture",
                   "pt-BR/concepts/knowledge",
                   "pt-BR/concepts/llms",
                   "pt-BR/concepts/processes",
@@ -702,6 +704,7 @@
               {
                 "group": "Observabilidade",
                 "pages": [
+                  "pt-BR/observability/tracing",
                   "pt-BR/observability/overview",
                   "pt-BR/observability/arize-phoenix",
                   "pt-BR/observability/braintrust",
@@ -982,6 +985,7 @@
                   "ko/concepts/tasks",
                   "ko/concepts/crews",
                   "ko/concepts/flows",
+                  "ko/concepts/production-architecture",
                   "ko/concepts/knowledge",
                   "ko/concepts/llms",
                   "ko/concepts/processes",
@@ -1138,6 +1142,7 @@
               {
                 "group": "Observability",
                 "pages": [
+                  "ko/observability/tracing",
                   "ko/observability/overview",
                   "ko/observability/arize-phoenix",
                   "ko/observability/braintrust",

docs/en/concepts/production-architecture.mdx

@@ -0,0 +1,154 @@
+---
+title: Production Architecture
+description: Best practices for building production-ready AI applications with CrewAI
+icon: server
+mode: "wide"
+---
+
+# The Flow-First Mindset
+
+When building production AI applications with CrewAI, **we recommend starting with a Flow**.
+
+While it's possible to run individual Crews or Agents, wrapping them in a Flow provides the necessary structure for a robust, scalable application.
+
+## Why Flows?
+
+1.  **State Management**: Flows provide a built-in way to manage state across different steps of your application. This is crucial for passing data between Crews, maintaining context, and handling user inputs.
+2.  **Control**: Flows allow you to define precise execution paths, including loops, conditionals, and branching logic. This is essential for handling edge cases and ensuring your application behaves predictably.
+3.  **Observability**: Flows provide a clear structure that makes it easier to trace execution, debug issues, and monitor performance. We recommend using [CrewAI Tracing](/en/observability/tracing) for detailed insights. Simply run `crewai login` to enable free observability features.
+
+## The Architecture
+
+A typical production CrewAI application looks like this:
+
+```mermaid
+graph TD
+    Start((Start)) --> Flow[Flow Orchestrator]
+    Flow --> State{State Management}
+    State --> Step1[Step 1: Data Gathering]
+    Step1 --> Crew1[Research Crew]
+    Crew1 --> State
+    State --> Step2{Condition Check}
+    Step2 -- "Valid" --> Step3[Step 3: Execution]
+    Step3 --> Crew2[Action Crew]
+    Step2 -- "Invalid" --> End((End))
+    Crew2 --> End
+```
+
+### 1. The Flow Class
+Your `Flow` class is the entry point. It defines the state schema and the methods that execute your logic.
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class AppState(BaseModel):
+    user_input: str = ""
+    research_results: str = ""
+    final_report: str = ""
+
+class ProductionFlow(Flow[AppState]):
+    @start()
+    def gather_input(self):
+        # ... logic to get input ...
+        pass
+
+    @listen(gather_input)
+    def run_research_crew(self):
+        # ... trigger a Crew ...
+        pass
+```
+
+### 2. State Management
+Use Pydantic models to define your state. This ensures type safety and makes it clear what data is available at each step.
+
+- **Keep it minimal**: Store only what you need to persist between steps.
+- **Use structured data**: Avoid unstructured dictionaries when possible.
+
+### 3. Crews as Units of Work
+Delegate complex tasks to Crews. A Crew should be focused on a specific goal (e.g., "Research a topic", "Write a blog post").
+
+- **Don't over-engineer Crews**: Keep them focused.
+- **Pass state explicitly**: Pass the necessary data from the Flow state to the Crew inputs.
+
+```python
+    @listen(gather_input)
+    def run_research_crew(self):
+        crew = ResearchCrew()
+        result = crew.kickoff(inputs={"topic": self.state.user_input})
+        self.state.research_results = result.raw
+```
+
+## Control Primitives
+
+Leverage CrewAI's control primitives to add robustness and control to your Crews.
+
+### 1. Task Guardrails
+Use [Task Guardrails](/en/concepts/tasks#task-guardrails) to validate task outputs before they are accepted. This ensures that your agents produce high-quality results.
+
+```python
+def validate_content(result: TaskOutput) -> Tuple[bool, Any]:
+    if len(result.raw) < 100:
+        return (False, "Content is too short. Please expand.")
+    return (True, result.raw)
+
+task = Task(
+    ...,
+    guardrail=validate_content
+)
+```
+
+### 2. Structured Outputs
+Always use structured outputs (`output_pydantic` or `output_json`) when passing data between tasks or to your application. This prevents parsing errors and ensures type safety.
+
+```python
+class ResearchResult(BaseModel):
+    summary: str
+    sources: List[str]
+
+task = Task(
+    ...,
+    output_pydantic=ResearchResult
+)
+```
+
+### 3. LLM Hooks
+Use [LLM Hooks](/en/learn/llm-hooks) to inspect or modify messages before they are sent to the LLM, or to sanitize responses.
+
+```python
+@before_llm_call
+def log_request(context):
+    print(f"Agent {context.agent.role} is calling the LLM...")
+```
+
+## Deployment Patterns
+
+When deploying your Flow, consider the following:
+
+### CrewAI Enterprise
+The easiest way to deploy your Flow is using CrewAI Enterprise. It handles the infrastructure, authentication, and monitoring for you.
+
+Check out the [Deployment Guide](/en/enterprise/guides/deploy-crew) to get started.
+
+```bash
+crewai deploy create
+```
+
+### Async Execution
+For long-running tasks, use `kickoff_async` to avoid blocking your API.
+
+### Persistence
+Use the `@persist` decorator to save the state of your Flow to a database. This allows you to resume execution if the process crashes or if you need to wait for human input.
+
+```python
+@persist
+class ProductionFlow(Flow[AppState]):
+    # ...
+```
+
+## Summary
+
+- **Start with a Flow.**
+- **Define a clear State.**
+- **Use Crews for complex tasks.**
+- **Deploy with an API and persistence.**

docs/en/introduction.mdx

@@ -7,110 +7,89 @@ mode: "wide"
 
 # What is CrewAI?
 
-**CrewAI is a lean, lightning-fast Python framework built entirely from scratch—completely independent of LangChain or other agent frameworks.**
+**CrewAI is the leading open-source framework for orchestrating autonomous AI agents and building complex workflows.**
 
-CrewAI empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario:
+It empowers developers to build production-ready multi-agent systems by combining the collaborative intelligence of **Crews** with the precise control of **Flows**.
 
-- **[CrewAI Crews](/en/guides/crews/first-crew)**: Optimize for autonomy and collaborative intelligence, enabling you to create AI teams where each agent has specific roles, tools, and goals.
-- **[CrewAI Flows](/en/guides/flows/first-flow)**: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively.
+- **[CrewAI Flows](/en/guides/flows/first-flow)**: The backbone of your AI application. Flows allow you to create structured, event-driven workflows that manage state and control execution. They provide the scaffolding for your AI agents to work within.
+- **[CrewAI Crews](/en/guides/crews/first-crew)**: The units of work within your Flow. Crews are teams of autonomous agents that collaborate to solve specific tasks delegated to them by the Flow.
 
-With over 100,000 developers certified through our community courses, CrewAI is rapidly becoming the standard for enterprise-ready AI automation.
+With over 100,000 developers certified through our community courses, CrewAI is the standard for enterprise-ready AI automation.
 
+## The CrewAI Architecture
 
-## How Crews Work
+CrewAI's architecture is designed to balance autonomy with control.
+
+### 1. Flows: The Backbone
 
 <Note>
-  Just like a company has departments (Sales, Engineering, Marketing) working together under leadership to achieve business goals, CrewAI helps you create an organization of AI agents with specialized roles collaborating to accomplish complex tasks.
-</Note>
-
-<Frame caption="CrewAI Framework Overview">
-  <img src="/images/crews.png" alt="CrewAI Framework Overview" />
-</Frame>
-
-| Component | Description | Key Features |
-|:----------|:-----------:|:------------|
-| **Crew** | The top-level organization | • Manages AI agent teams<br/>• Oversees workflows<br/>• Ensures collaboration<br/>• Delivers outcomes |
-| **AI Agents** | Specialized team members | • Have specific roles (researcher, writer)<br/>• Use designated tools<br/>• Can delegate tasks<br/>• Make autonomous decisions |
-| **Process** | Workflow management system | • Defines collaboration patterns<br/>• Controls task assignments<br/>• Manages interactions<br/>• Ensures efficient execution |
-| **Tasks** | Individual assignments | • Have clear objectives<br/>• Use specific tools<br/>• Feed into larger process<br/>• Produce actionable results |
-
-### How It All Works Together
-
-1. The **Crew** organizes the overall operation
-2. **AI Agents** work on their specialized tasks
-3. The **Process** ensures smooth collaboration
-4. **Tasks** get completed to achieve the goal
-
-## Key Features
-
-<CardGroup cols={2}>
-  <Card title="Role-Based Agents" icon="users">
-    Create specialized agents with defined roles, expertise, and goals - from researchers to analysts to writers
-  </Card>
-  <Card title="Flexible Tools" icon="screwdriver-wrench">
-    Equip agents with custom tools and APIs to interact with external services and data sources
-  </Card>
-  <Card title="Intelligent Collaboration" icon="people-arrows">
-    Agents work together, sharing insights and coordinating tasks to achieve complex objectives
-  </Card>
-  <Card title="Task Management" icon="list-check">
-    Define sequential or parallel workflows, with agents automatically handling task dependencies
-  </Card>
-</CardGroup>
-
-## How Flows Work
-
-<Note>
-  While Crews excel at autonomous collaboration, Flows provide structured automations, offering granular control over workflow execution. Flows ensure tasks are executed reliably, securely, and efficiently, handling conditional logic, loops, and dynamic state management with precision. Flows integrate seamlessly with Crews, enabling you to balance high autonomy with exacting control.
+  Think of a Flow as the "manager" or the "process definition" of your application. It defines the steps, the logic, and how data moves through your system.
 </Note>
 
 <Frame caption="CrewAI Framework Overview">
   <img src="/images/flows.png" alt="CrewAI Framework Overview" />
 </Frame>
 
-| Component | Description | Key Features |
-|:----------|:-----------:|:------------|
-| **Flow** | Structured workflow orchestration | • Manages execution paths<br/>• Handles state transitions<br/>• Controls task sequencing<br/>• Ensures reliable execution |
-| **Events** | Triggers for workflow actions | • Initiate specific processes<br/>• Enable dynamic responses<br/>• Support conditional branching<br/>• Allow for real-time adaptation |
-| **States** | Workflow execution contexts | • Maintain execution data<br/>• Enable persistence<br/>• Support resumability<br/>• Ensure execution integrity |
-| **Crew Support** | Enhances workflow automation | • Injects pockets of agency when needed<br/>• Complements structured workflows<br/>• Balances automation with intelligence<br/>• Enables adaptive decision-making |
+Flows provide:
+- **State Management**: Persist data across steps and executions.
+- **Event-Driven Execution**: Trigger actions based on events or external inputs.
+- **Control Flow**: Use conditional logic, loops, and branching.
 
-### Key Capabilities
+### 2. Crews: The Intelligence
+
+<Note>
+  Crews are the "teams" that do the heavy lifting. Within a Flow, you can trigger a Crew to tackle a complex problem requiring creativity and collaboration.
+</Note>
+
+<Frame caption="CrewAI Framework Overview">
+  <img src="/images/crews.png" alt="CrewAI Framework Overview" />
+</Frame>
+
+Crews provide:
+- **Role-Playing Agents**: Specialized agents with specific goals and tools.
+- **Autonomous Collaboration**: Agents work together to solve tasks.
+- **Task Delegation**: Tasks are assigned and executed based on agent capabilities.
+
+## How It All Works Together
+
+1.  **The Flow** triggers an event or starts a process.
+2.  **The Flow** manages the state and decides what to do next.
+3.  **The Flow** delegates a complex task to a **Crew**.
+4.  **The Crew**'s agents collaborate to complete the task.
+5.  **The Crew** returns the result to the **Flow**.
+6.  **The Flow** continues execution based on the result.
+
+## Key Features
 
 <CardGroup cols={2}>
-  <Card title="Event-Driven Orchestration" icon="bolt">
-    Define precise execution paths responding dynamically to events
+  <Card title="Production-Grade Flows" icon="arrow-progress">
+    Build reliable, stateful workflows that can handle long-running processes and complex logic.
   </Card>
-  <Card title="Fine-Grained Control" icon="sliders">
-    Manage workflow states and conditional execution securely and efficiently
+  <Card title="Autonomous Crews" icon="users">
+    Deploy teams of agents that can plan, execute, and collaborate to achieve high-level goals.
   </Card>
-  <Card title="Native Crew Integration" icon="puzzle-piece">
-    Effortlessly combine with Crews for enhanced autonomy and intelligence
+  <Card title="Flexible Tools" icon="screwdriver-wrench">
+     Connect your agents to any API, database, or local tool.
   </Card>
-  <Card title="Deterministic Execution" icon="route">
-    Ensure predictable outcomes with explicit control flow and error handling
+  <Card title="Enterprise Security" icon="lock">
+    Designed with security and compliance in mind for enterprise deployments.
   </Card>
 </CardGroup>
 
 ## When to Use Crews vs. Flows
 
-<Note>
-  Understanding when to use [Crews](/en/guides/crews/first-crew) versus [Flows](/en/guides/flows/first-flow) is key to maximizing the potential of CrewAI in your applications.
-</Note>
+**The short answer: Use both.**
 
-| Use Case | Recommended Approach | Why? |
-|:---------|:---------------------|:-----|
-| **Open-ended research** | [Crews](/en/guides/crews/first-crew) | When tasks require creative thinking, exploration, and adaptation |
-| **Content generation** | [Crews](/en/guides/crews/first-crew) | For collaborative creation of articles, reports, or marketing materials |
-| **Decision workflows** | [Flows](/en/guides/flows/first-flow) | When you need predictable, auditable decision paths with precise control |
-| **API orchestration** | [Flows](/en/guides/flows/first-flow) | For reliable integration with multiple external services in a specific sequence |
-| **Hybrid applications** | Combined approach | Use [Flows](/en/guides/flows/first-flow) to orchestrate overall process with [Crews](/en/guides/crews/first-crew) handling complex subtasks |
+For any production-ready application, **start with a Flow**.
 
-### Decision Framework
+- **Use a Flow** to define the overall structure, state, and logic of your application.
+- **Use a Crew** within a Flow step when you need a team of agents to perform a specific, complex task that requires autonomy.
 
-- **Choose [Crews](/en/guides/crews/first-crew) when:** You need autonomous problem-solving, creative collaboration, or exploratory tasks
-- **Choose [Flows](/en/guides/flows/first-flow) when:** You require deterministic outcomes, auditability, or precise control over execution
-- **Combine both when:** Your application needs both structured processes and pockets of autonomous intelligence
+| Use Case | Architecture |
+| :--- | :--- |
+| **Simple Automation** | Single Flow with Python tasks |
+| **Complex Research** | Flow managing state -> Crew performing research |
+| **Application Backend** | Flow handling API requests -> Crew generating content -> Flow saving to DB |
 
 ## Why Choose CrewAI?
 
@@ -124,13 +103,6 @@ With over 100,000 developers certified through our community courses, CrewAI is
 ## Ready to Start Building?
 
 <CardGroup cols={2}>
-  <Card
-    title="Build Your First Crew"
-    icon="users-gear"
-    href="/en/guides/crews/first-crew"
-  >
-    Step-by-step tutorial to create a collaborative AI team that works together to solve complex problems.
-  </Card>
   <Card
     title="Build Your First Flow"
     icon="diagram-project"
@@ -138,6 +110,13 @@ With over 100,000 developers certified through our community courses, CrewAI is
   >
     Learn how to create structured, event-driven workflows with precise control over execution.
   </Card>
+  <Card
+    title="Build Your First Crew"
+    icon="users-gear"
+    href="/en/guides/crews/first-crew"
+  >
+    Step-by-step tutorial to create a collaborative AI team that works together to solve complex problems.
+  </Card>
 </CardGroup>
 
 <CardGroup cols={3}>

docs/ko/concepts/production-architecture.mdx

@@ -0,0 +1,154 @@
+---
+title: 프로덕션 아키텍처
+description: CrewAI로 프로덕션 수준의 AI 애플리케이션을 구축하기 위한 모범 사례
+icon: server
+mode: "wide"
+---
+
+# Flow 우선 사고방식 (Flow-First Mindset)
+
+CrewAI로 프로덕션 AI 애플리케이션을 구축할 때는 **Flow로 시작하는 것을 권장합니다**.
+
+개별 Crews나 Agents를 실행하는 것도 가능하지만, 이를 Flow로 감싸면 견고하고 확장 가능한 애플리케이션에 필요한 구조를 제공합니다.
+
+## 왜 Flows인가?
+
+1.  **상태 관리 (State Management)**: Flows는 애플리케이션의 여러 단계에 걸쳐 상태를 관리하는 내장된 방법을 제공합니다. 이는 Crews 간에 데이터를 전달하고, 컨텍스트를 유지하며, 사용자 입력을 처리하는 데 중요합니다.
+2.  **제어 (Control)**: Flows를 사용하면 루프, 조건문, 분기 로직을 포함한 정확한 실행 경로를 정의할 수 있습니다. 이는 예외 상황을 처리하고 애플리케이션이 예측 가능하게 동작하도록 보장하는 데 필수적입니다.
+3.  **관측 가능성 (Observability)**: Flows는 실행을 추적하고, 문제를 디버깅하며, 성능을 모니터링하기 쉽게 만드는 명확한 구조를 제공합니다. 자세한 통찰력을 얻으려면 [CrewAI Tracing](/ko/observability/tracing)을 사용하는 것이 좋습니다. `crewai login`을 실행하여 무료 관측 가능성 기능을 활성화하세요.
+
+## 아키텍처
+
+일반적인 프로덕션 CrewAI 애플리케이션은 다음과 같습니다:
+
+```mermaid
+graph TD
+    Start((시작)) --> Flow[Flow 오케스트레이터]
+    Flow --> State{상태 관리}
+    State --> Step1[1단계: 데이터 수집]
+    Step1 --> Crew1[연구 Crew]
+    Crew1 --> State
+    State --> Step2{조건 확인}
+    Step2 -- "유효함" --> Step3[3단계: 실행]
+    Step3 --> Crew2[액션 Crew]
+    Step2 -- "유효하지 않음" --> End((종료))
+    Crew2 --> End
+```
+
+### 1. Flow 클래스
+`Flow` 클래스는 진입점입니다. 상태 스키마와 로직을 실행하는 메서드를 정의합니다.
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class AppState(BaseModel):
+    user_input: str = ""
+    research_results: str = ""
+    final_report: str = ""
+
+class ProductionFlow(Flow[AppState]):
+    @start()
+    def gather_input(self):
+        # ... 입력 받는 로직 ...
+        pass
+
+    @listen(gather_input)
+    def run_research_crew(self):
+        # ... Crew 트리거 ...
+        pass
+```
+
+### 2. 상태 관리 (State Management)
+Pydantic 모델을 사용하여 상태를 정의하세요. 이는 타입 안전성을 보장하고 각 단계에서 어떤 데이터를 사용할 수 있는지 명확하게 합니다.
+
+- **최소한으로 유지**: 단계 간에 유지해야 할 것만 저장하세요.
+- **구조화된 데이터 사용**: 가능하면 비구조화된 딕셔너리는 피하세요.
+
+### 3. 작업 단위로서의 Crews
+복잡한 작업은 Crews에게 위임하세요. Crew는 특정 목표(예: "주제 연구", "블로그 게시물 작성")에 집중해야 합니다.
+
+- **Crews를 과도하게 설계하지 마세요**: 집중력을 유지하세요.
+- **상태를 명시적으로 전달하세요**: Flow 상태에서 필요한 데이터를 Crew 입력으로 전달하세요.
+
+```python
+    @listen(gather_input)
+    def run_research_crew(self):
+        crew = ResearchCrew()
+        result = crew.kickoff(inputs={"topic": self.state.user_input})
+        self.state.research_results = result.raw
+```
+
+## Control Primitives
+
+CrewAI의 Control Primitives를 활용하여 Crew에 견고함과 제어력을 더하세요.
+
+### 1. Task Guardrails
+[Task Guardrails](/ko/concepts/tasks#task-guardrails)를 사용하여 작업 결과가 수락되기 전에 유효성을 검사하세요. 이를 통해 agent가 고품질 결과를 생성하도록 보장할 수 있습니다.
+
+```python
+def validate_content(result: TaskOutput) -> Tuple[bool, Any]:
+    if len(result.raw) < 100:
+        return (False, "Content is too short. Please expand.")
+    return (True, result.raw)
+
+task = Task(
+    ...,
+    guardrail=validate_content
+)
+```
+
+### 2. 구조화된 출력 (Structured Outputs)
+작업 간에 데이터를 전달하거나 애플리케이션으로 전달할 때는 항상 구조화된 출력(`output_pydantic` 또는 `output_json`)을 사용하세요. 이는 파싱 오류를 방지하고 타입 안전성을 보장합니다.
+
+```python
+class ResearchResult(BaseModel):
+    summary: str
+    sources: List[str]
+
+task = Task(
+    ...,
+    output_pydantic=ResearchResult
+)
+```
+
+### 3. LLM Hooks
+[LLM Hooks](/ko/learn/llm-hooks)를 사용하여 LLM으로 전송되기 전에 메시지를 검사하거나 수정하고, 응답을 정리(sanitize)하세요.
+
+```python
+@before_llm_call
+def log_request(context):
+    print(f"Agent {context.agent.role} is calling the LLM...")
+```
+
+## 배포 패턴
+
+Flow를 배포할 때 다음을 고려하세요:
+
+### CrewAI Enterprise
+Flow를 배포하는 가장 쉬운 방법은 CrewAI Enterprise를 사용하는 것입니다. 인프라, 인증 및 모니터링을 대신 처리합니다.
+
+시작하려면 [배포 가이드](/ko/enterprise/guides/deploy-crew)를 확인하세요.
+
+```bash
+crewai deploy create
+```
+
+### 비동기 실행 (Async Execution)
+장기 실행 작업의 경우 `kickoff_async`를 사용하여 API 차단을 방지하세요.
+
+### 지속성 (Persistence)
+`@persist` 데코레이터를 사용하여 Flow의 상태를 데이터베이스에 저장하세요. 이를 통해 프로세스가 중단되거나 사람의 입력을 기다려야 할 때 실행을 재개할 수 있습니다.
+
+```python
+@persist
+class ProductionFlow(Flow[AppState]):
+    # ...
+```
+
+## 요약
+
+- **Flow로 시작하세요.**
+- **명확한 State를 정의하세요.**
+- **복잡한 작업에는 Crews를 사용하세요.**
+- **API와 지속성을 갖추어 배포하세요.**

docs/ko/introduction.mdx

@@ -7,109 +7,89 @@ mode: "wide"
 
 # CrewAI란 무엇인가?
 
-**CrewAI는 LangChain이나 기타 agent 프레임워크에 의존하지 않고, 완전히 독립적으로 처음부터 스크래치로 개발된 가볍고 매우 빠른 Python 프레임워크입니다.**
+**CrewAI는 자율 AI agent를 조직하고 복잡한 workflow를 구축하기 위한 최고의 오픈 소스 프레임워크입니다.**
 
-CrewAI는 고수준의 간편함과 정밀한 저수준 제어를 모두 제공하여, 어떤 시나리오에도 맞춤화된 자율 AI agent를 만드는 데 이상적입니다:
+**Crews**의 협업 지능과 **Flows**의 정밀한 제어를 결합하여 개발자가 프로덕션 수준의 멀티 에이전트 시스템을 구축할 수 있도록 지원합니다.
 
-- **[CrewAI Crews](/ko/guides/crews/first-crew)**: 자율성과 협업 지능을 극대화하여, 각 agent가 특정 역할, 도구, 목표를 가진 AI 팀을 만들 수 있습니다.
-- **[CrewAI Flows](/ko/guides/flows/first-flow)**: 이벤트 기반의 세밀한 제어와 단일 LLM 호출을 통한 정확한 작업 orchestration을 지원하며, Crews와 네이티브로 통합됩니다.
+- **[CrewAI Flows](/ko/guides/flows/first-flow)**: AI 애플리케이션의 중추(Backbone)입니다. Flows를 사용하면 상태를 관리하고 실행을 제어하는 구조화된 이벤트 기반 workflow를 만들 수 있습니다. AI agent가 작업할 수 있는 기반을 제공합니다.
+- **[CrewAI Crews](/ko/guides/crews/first-crew)**: Flow 내의 작업 단위입니다. Crews는 Flow가 위임한 특정 작업을 해결하기 위해 협력하는 자율 agent 팀입니다.
 
-10만 명이 넘는 개발자가 커뮤니티 과정을 통해 인증을 받았으며, CrewAI는 기업용 AI 자동화의 표준으로 빠르게 자리잡고 있습니다.
+10만 명이 넘는 개발자가 커뮤니티 과정을 통해 인증을 받았으며, CrewAI는 기업용 AI 자동화의 표준입니다.
 
-## Crew의 작동 방식
+## CrewAI 아키텍처
+
+CrewAI의 아키텍처는 자율성과 제어의 균형을 맞추도록 설계되었습니다.
+
+### 1. Flows: 중추 (Backbone)
 
 <Note>
-  회사가 비즈니스 목표를 달성하기 위해 여러 부서(영업, 엔지니어링, 마케팅 등)가 리더십 아래에서 함께 일하는 것처럼, CrewAI는 복잡한 작업을 달성하기 위해 전문화된 역할의 AI agent들이 협력하는 조직을 만들 수 있도록 도와줍니다.
-</Note>
-
-<Frame caption="CrewAI Framework Overview">
-  <img src="/images/crews.png" alt="CrewAI Framework Overview" />
-</Frame>
-
-| 구성 요소 | 설명 | 주요 특징 |
-|:----------|:----:|:----------|
-| **Crew** | 최상위 조직 | • AI agent 팀 관리<br/>• workflow 감독<br/>• 협업 보장<br/>• 결과 전달 |
-| **AI agents** | 전문 팀원 | • 특정 역할 보유(Researcher, Writer 등)<br/>• 지정된 도구 사용<br/>• 작업 위임 가능<br/>• 자율적 의사결정 가능 |
-| **Process** | workflow 관리 시스템 | • 협업 패턴 정의<br/>• 작업 할당 제어<br/>• 상호작용 관리<br/>• 효율적 실행 보장 |
-| **Task** | 개별 할당 | • 명확한 목표 보유<br/>• 특정 도구 사용<br/>• 더 큰 프로세스에 기여<br/>• 실행 가능한 결과 도출 |
-
-### 전체 구조의 동작 방식
-
-1. **Crew**가 전체 운영을 조직합니다
-2. **AI agents**가 자신들의 전문 작업을 수행합니다
-3. **Process**가 원활한 협업을 보장합니다
-4. **Tasks**가 완료되어 목표를 달성합니다
-
-## 주요 기능
-
-<CardGroup cols={2}>
-  <Card title="역할 기반 agent" icon="users">
-    Researcher, Analyst, Writer 등 다양한 역할과 전문성, 목표를 가진 agent를 생성할 수 있습니다
-  </Card>
-  <Card title="유연한 도구" icon="screwdriver-wrench">
-    agent에게 외부 서비스 및 데이터 소스와 상호작용할 수 있는 맞춤형 도구와 API를 제공합니다
-  </Card>
-  <Card title="지능형 협업" icon="people-arrows">
-    agent들이 함께 작업하며, 인사이트를 공유하고 작업을 조율하여 복잡한 목표를 달성합니다
-  </Card>
-  <Card title="작업 관리" icon="list-check">
-    순차적 또는 병렬 workflow를 정의할 수 있으며, agent가 작업 의존성을 자동으로 처리합니다
-  </Card>
-</CardGroup>
-
-## Flow의 작동 원리
-
-<Note>
-  Crew가 자율 협업에 탁월하다면, Flow는 구조화된 자동화를 제공하여 workflow 실행에 대한 세밀한 제어를 제공합니다. Flow는 조건부 로직, 반복문, 동적 상태 관리를 정확하게 처리하면서 작업이 신뢰성 있게, 안전하게, 효율적으로 실행되도록 보장합니다. Flow는 Crew와 원활하게 통합되어 높은 자율성과 엄격한 제어의 균형을 이룰 수 있게 해줍니다.
+  Flow를 애플리케이션의 "관리자" 또는 "프로세스 정의"라고 생각하세요. 단계, 로직, 그리고 시스템 내에서 데이터가 이동하는 방식을 정의합니다.
 </Note>
 
 <Frame caption="CrewAI Framework Overview">
   <img src="/images/flows.png" alt="CrewAI Framework Overview" />
 </Frame>
 
-| 구성 요소 | 설명 | 주요 기능 |
-|:----------|:-----------:|:------------|
-| **Flow** | 구조화된 workflow orchestration | • 실행 경로 관리<br/>• 상태 전환 처리<br/>• 작업 순서 제어<br/>• 신뢰성 있는 실행 보장 |
-| **Events** | workflow 액션 트리거 | • 특정 프로세스 시작<br/>• 동적 응답 가능<br/>• 조건부 분기 지원<br/>• 실시간 적응 허용 |
-| **States** | workflow 실행 컨텍스트 | • 실행 데이터 유지<br/>• 데이터 영속성 지원<br/>• 재개 가능성 보장<br/>• 실행 무결성 확보 |
-| **Crew Support** | workflow 자동화 강화 | • 필요할 때 agency 삽입<br/>• 구조화된 workflow 보완<br/>• 자동화와 인텔리전스의 균형<br/>• 적응적 의사결정 지원 |
+Flows의 기능:
+- **상태 관리**: 단계 및 실행 전반에 걸쳐 데이터를 유지합니다.
+- **이벤트 기반 실행**: 이벤트 또는 외부 입력을 기반으로 작업을 트리거합니다.
+- **제어 흐름**: 조건부 로직, 반복문, 분기를 사용합니다.
 
-### 주요 기능
+### 2. Crews: 지능 (Intelligence)
+
+<Note>
+  Crews는 힘든 일을 처리하는 "팀"입니다. Flow 내에서 창의성과 협업이 필요한 복잡한 문제를 해결하기 위해 Crew를 트리거할 수 있습니다.
+</Note>
+
+<Frame caption="CrewAI Framework Overview">
+  <img src="/images/crews.png" alt="CrewAI Framework Overview" />
+</Frame>
+
+Crews의 기능:
+- **역할 수행 Agent**: 특정 목표와 도구를 가진 전문 agent입니다.
+- **자율 협업**: agent들이 협력하여 작업을 해결합니다.
+- **작업 위임**: agent의 능력에 따라 작업이 할당되고 실행됩니다.
+
+## 전체 작동 방식
+
+1.  **Flow**가 이벤트를 트리거하거나 프로세스를 시작합니다.
+2.  **Flow**가 상태를 관리하고 다음에 무엇을 할지 결정합니다.
+3.  **Flow**가 복잡한 작업을 **Crew**에게 위임합니다.
+4.  **Crew**의 agent들이 협력하여 작업을 완료합니다.
+5.  **Crew**가 결과를 **Flow**에 반환합니다.
+6.  **Flow**가 결과를 바탕으로 실행을 계속합니다.
+
+## 주요 기능
 
 <CardGroup cols={2}>
-  <Card title="이벤트 기반 orchestration" icon="bolt">
-    이벤트에 동적으로 반응하여 정밀한 실행 경로를 정의합니다
+  <Card title="프로덕션 등급 Flows" icon="arrow-progress">
+    장기 실행 프로세스와 복잡한 로직을 처리할 수 있는 신뢰할 수 있고 상태를 유지하는 workflow를 구축합니다.
   </Card>
-  <Card title="세밀한 제어" icon="sliders">
-    workflow 상태와 조건부 실행을 안전하고 효율적으로 관리합니다
+  <Card title="자율 Crews" icon="users">
+    높은 수준의 목표를 달성하기 위해 계획하고, 실행하고, 협력할 수 있는 agent 팀을 배포합니다.
   </Card>
-  <Card title="네이티브 Crew 통합" icon="puzzle-piece">
-    Crews와 손쉽게 결합하여 자율성과 지능을 강화합니다
+  <Card title="유연한 도구" icon="screwdriver-wrench">
+     agent를 모든 API, 데이터베이스 또는 로컬 도구에 연결합니다.
   </Card>
-  <Card title="결정론적 실행" icon="route">
-    명시적 제어 흐름과 오류 처리로 예측 가능한 결과를 보장합니다
+  <Card title="엔터프라이즈 보안" icon="lock">
+    엔터프라이즈 배포를 위한 보안 및 규정 준수를 고려하여 설계되었습니다.
   </Card>
 </CardGroup>
 
-## Crew와 Flow를 언제 사용할까
+## Crews vs Flows 사용 시기
 
-<Note>
-  [Crew](/ko/guides/crews/first-crew)와 [Flow](/ko/guides/flows/first-flow)를 언제 사용할지 이해하는 것은 CrewAI의 잠재력을 애플리케이션에서 극대화하는 데 핵심적입니다.
-</Note>
+**짧은 답변: 둘 다 사용하세요.**
 
-| 사용 사례 | 권장 접근 방식 | 이유 |
-|:---------|:---------------------|:-----|
-| **개방형 연구** | [Crew](/ko/guides/crews/first-crew) | 창의적 사고, 탐색, 적응이 필요한 작업에 적합 |
-| **콘텐츠 생성** | [Crew](/ko/guides/crews/first-crew) | 기사, 보고서, 마케팅 자료 등 협업형 생성에 적합 |
-| **의사결정 workflow** | [Flow](/ko/guides/flows/first-flow) | 예측 가능하고 감사 가능한 의사결정 경로 및 정밀 제어가 필요할 때 |
-| **API orchestration** | [Flow](/ko/guides/flows/first-flow) | 특정 순서로 여러 외부 서비스에 신뢰성 있게 통합할 때 |
-| **하이브리드 애플리케이션** | 혼합 접근 방식 | [Flow](/ko/guides/flows/first-flow)로 전체 프로세스를 orchestration하고, [Crew](/ko/guides/crews/first-crew)로 복잡한 하위 작업을 처리 |
+모든 프로덕션 애플리케이션의 경우, **Flow로 시작하세요**.
 
-### 의사결정 프레임워크
+- 애플리케이션의 전체 구조, 상태, 로직을 정의하려면 **Flow를 사용하세요**.
+- 자율성이 필요한 특정하고 복잡한 작업을 수행하기 위해 agent 팀이 필요할 때 Flow 단계 내에서 **Crew를 사용하세요**.
 
-- **[Crews](/ko/guides/crews/first-crew)를 선택할 때:** 자율적인 문제 해결, 창의적 협업 또는 탐구적 작업이 필요할 때
-- **[Flows](/ko/guides/flows/first-flow)를 선택할 때:** 결정론적 결과, 감사 가능성, 또는 실행에 대한 정밀한 제어가 필요할 때
-- **둘 다 결합할 때:** 애플리케이션에 구조화된 프로세스와 자율적 지능이 모두 필요할 때
+| 사용 사례 | 아키텍처 |
+| :--- | :--- |
+| **간단한 자동화** | Python 작업이 포함된 단일 Flow |
+| **복잡한 연구** | 상태를 관리하는 Flow -> 연구를 수행하는 Crew |
+| **애플리케이션 백엔드** | API 요청을 처리하는 Flow -> 콘텐츠를 생성하는 Crew -> DB에 저장하는 Flow |
 
 ## CrewAI를 선택해야 하는 이유?
 
@@ -123,13 +103,6 @@ CrewAI는 고수준의 간편함과 정밀한 저수준 제어를 모두 제공
 ## 지금 바로 빌드를 시작해보세요!
 
 <CardGroup cols={2}>
-  <Card
-    title="첫 번째 Crew 만들기"
-    icon="users-gear"
-    href="/ko/guides/crews/first-crew"
-  >
-    복잡한 문제를 함께 해결하는 협업 AI 팀을 단계별로 만드는 튜토리얼입니다.
-  </Card>
   <Card
     title="첫 번째 Flow 만들기"
     icon="diagram-project"
@@ -137,6 +110,13 @@ CrewAI는 고수준의 간편함과 정밀한 저수준 제어를 모두 제공
   >
     실행을 정밀하게 제어할 수 있는 구조화된, 이벤트 기반 workflow를 만드는 방법을 배워보세요.
   </Card>
+  <Card
+    title="첫 번째 Crew 만들기"
+    icon="users-gear"
+    href="/ko/guides/crews/first-crew"
+  >
+    복잡한 문제를 함께 해결하는 협업 AI 팀을 단계별로 만드는 튜토리얼입니다.
+  </Card>
 </CardGroup>
 
 <CardGroup cols={3}>
@@ -161,4 +141,4 @@ CrewAI는 고수준의 간편함과 정밀한 저수준 제어를 모두 제공
   >
     다른 개발자와 소통하며, 도움을 받고 CrewAI 경험을 공유해보세요.
   </Card>
-</CardGroup>
+</CardGroup>

docs/ko/observability/tracing.mdx

@@ -0,0 +1,213 @@
+---
+title: CrewAI Tracing
+description: CrewAI AOP 플랫폼을 사용한 CrewAI Crews 및 Flows의 내장 추적
+icon: magnifying-glass-chart
+mode: "wide"
+---
+
+# CrewAI 내장 추적 (Built-in Tracing)
+
+CrewAI는 Crews와 Flows를 실시간으로 모니터링하고 디버깅할 수 있는 내장 추적 기능을 제공합니다. 이 가이드는 CrewAI의 통합 관측 가능성 플랫폼을 사용하여 **Crews**와 **Flows** 모두에 대한 추적을 활성화하는 방법을 보여줍니다.
+
+> **CrewAI Tracing이란?** CrewAI의 내장 추적은 agent 결정, 작업 실행 타임라인, 도구 사용, LLM 호출을 포함한 AI agent에 대한 포괄적인 관측 가능성을 제공하며, 모두 [CrewAI AOP 플랫폼](https://app.crewai.com)을 통해 액세스할 수 있습니다.
+
+![CrewAI Tracing Interface](/images/crewai-tracing.png)
+
+## 사전 요구 사항
+
+CrewAI 추적을 사용하기 전에 다음이 필요합니다:
+
+1. **CrewAI AOP 계정**: [app.crewai.com](https://app.crewai.com)에서 무료 계정에 가입하세요
+2. **CLI 인증**: CrewAI CLI를 사용하여 로컬 환경을 인증하세요
+
+```bash
+crewai login
+```
+
+## 설정 지침
+
+### 1단계: CrewAI AOP 계정 생성
+
+[app.crewai.com](https://app.crewai.com)을 방문하여 무료 계정을 만드세요. 이를 통해 추적, 메트릭을 보고 crews를 관리할 수 있는 CrewAI AOP 플랫폼에 액세스할 수 있습니다.
+
+### 2단계: CrewAI CLI 설치 및 인증
+
+아직 설치하지 않았다면 CLI 도구와 함께 CrewAI를 설치하세요:
+
+```bash
+uv add crewai[tools]
+```
+
+그런 다음 CrewAI AOP 계정으로 CLI를 인증하세요:
+
+```bash
+crewai login
+```
+
+이 명령은 다음을 수행합니다:
+1. 브라우저에서 인증 페이지를 엽니다
+2. 장치 코드를 입력하라는 메시지를 표시합니다
+3. CrewAI AOP 계정으로 로컬 환경을 인증합니다
+4. 로컬 개발을 위한 추적 기능을 활성화합니다
+
+### 3단계: Crew에서 추적 활성화
+
+`tracing` 매개변수를 `True`로 설정하여 Crew에 대한 추적을 활성화할 수 있습니다:
+
+```python
+from crewai import Agent, Crew, Process, Task
+from crewai_tools import SerperDevTool
+
+# Define your agents
+researcher = Agent(
+    role="Senior Research Analyst",
+    goal="Uncover cutting-edge developments in AI and data science",
+    backstory=\"\"\"You work at a leading tech think tank.
+    Your expertise lies in identifying emerging trends.
+    You have a knack for dissecting complex data and presenting actionable insights.\"\"\",
+    verbose=True,
+    tools=[SerperDevTool()],
+)
+
+writer = Agent(
+    role="Tech Content Strategist",
+    goal="Craft compelling content on tech advancements",
+    backstory=\"\"\"You are a renowned Content Strategist, known for your insightful and engaging articles.
+    You transform complex concepts into compelling narratives.\"\"\",
+    verbose=True,
+)
+
+# Create tasks for your agents
+research_task = Task(
+    description=\"\"\"Conduct a comprehensive analysis of the latest advancements in AI in 2024.
+    Identify key trends, breakthrough technologies, and potential industry impacts.\"\"\",
+    expected_output="Full analysis report in bullet points",
+    agent=researcher,
+)
+
+writing_task = Task(
+    description=\"\"\"Using the insights provided, develop an engaging blog
+    post that highlights the most significant AI advancements.
+    Your post should be informative yet accessible, catering to a tech-savvy audience.\"\"\",
+    expected_output="Full blog post of at least 4 paragraphs",
+    agent=writer,
+)
+
+# Enable tracing in your crew
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    process=Process.sequential,
+    tracing=True,  # Enable built-in tracing
+    verbose=True
+)
+
+# Execute your crew
+result = crew.kickoff()
+```
+
+### 4단계: Flow에서 추적 활성화
+
+마찬가지로 CrewAI Flows에 대한 추적을 활성화할 수 있습니다:
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class ExampleState(BaseModel):
+    counter: int = 0
+    message: str = ""
+
+class ExampleFlow(Flow[ExampleState]):
+    def __init__(self):
+        super().__init__(tracing=True)  # Enable tracing for the flow
+
+    @start()
+    def first_method(self):
+        print("Starting the flow")
+        self.state.counter = 1
+        self.state.message = "Flow started"
+        return "continue"
+
+    @listen("continue")
+    def second_method(self):
+        print("Continuing the flow")
+        self.state.counter += 1
+        self.state.message = "Flow continued"
+        return "finish"
+
+    @listen("finish")
+    def final_method(self):
+        print("Finishing the flow")
+        self.state.counter += 1
+        self.state.message = "Flow completed"
+
+# Create and run the flow with tracing enabled
+flow = ExampleFlow(tracing=True)
+result = flow.kickoff()
+```
+
+### 5단계: CrewAI AOP 대시보드에서 추적 보기
+
+crew 또는 flow를 실행한 후 CrewAI AOP 대시보드에서 CrewAI 애플리케이션이 생성한 추적을 볼 수 있습니다. agent 상호 작용, 도구 사용 및 LLM 호출의 세부 단계를 볼 수 있습니다.
+아래 링크를 클릭하여 추적을 보거나 대시보드의 추적 탭으로 이동하세요 [여기](https://app.crewai.com/crewai_plus/trace_batches)
+![CrewAI Tracing Interface](/images/view-traces.png)
+
+
+### 대안: 환경 변수 구성
+
+환경 변수를 설정하여 전역적으로 추적을 활성화할 수도 있습니다:
+
+```bash
+export CREWAI_TRACING_ENABLED=true
+```
+
+또는 `.env` 파일에 추가하세요:
+
+```env
+CREWAI_TRACING_ENABLED=true
+```
+
+이 환경 변수가 설정되면 `tracing=True`를 명시적으로 설정하지 않아도 모든 Crews와 Flows에 자동으로 추적이 활성화됩니다.
+
+## 추적 보기
+
+### CrewAI AOP 대시보드 액세스
+
+1. [app.crewai.com](https://app.crewai.com)을 방문하여 계정에 로그인하세요
+2. 프로젝트 대시보드로 이동하세요
+3. **Traces** 탭을 클릭하여 실행 세부 정보를 확인하세요
+
+### 추적에서 볼 수 있는 내용
+
+CrewAI 추적은 다음에 대한 포괄적인 가시성을 제공합니다:
+
+- **Agent 결정**: agent가 작업을 통해 어떻게 추론하고 결정을 내리는지 확인하세요
+- **작업 실행 타임라인**: 작업 시퀀스 및 종속성의 시각적 표현
+- **도구 사용**: 어떤 도구가 호출되고 그 결과를 모니터링하세요
+- **LLM 호출**: 프롬프트 및 응답을 포함한 모든 언어 모델 상호 작용을 추적하세요
+- **성능 메트릭**: 실행 시간, 토큰 사용량 및 비용
+- **오류 추적**: 세부 오류 정보 및 스택 추적
+
+### 추적 기능
+- **실행 타임라인**: 실행의 다양한 단계를 클릭하여 확인하세요
+- **세부 로그**: 디버깅을 위한 포괄적인 로그에 액세스하세요
+- **성능 분석**: 실행 패턴을 분석하고 성능을 최적화하세요
+- **내보내기 기능**: 추가 분석을 위해 추적을 다운로드하세요
+
+### 인증 문제
+
+인증 문제가 발생하는 경우:
+
+1. 로그인되어 있는지 확인하세요: `crewai login`
+2. 인터넷 연결을 확인하세요
+3. [app.crewai.com](https://app.crewai.com)에서 계정을 확인하세요
+
+### 추적이 나타나지 않음
+
+대시보드에 추적이 표시되지 않는 경우:
+
+1. Crew/Flow에서 `tracing=True`가 설정되어 있는지 확인하세요
+2. 환경 변수를 사용하는 경우 `CREWAI_TRACING_ENABLED=true`인지 확인하세요
+3. `crewai login`으로 인증되었는지 확인하세요
+4. crew/flow가 실제로 실행되고 있는지 확인하세요

docs/pt-BR/concepts/production-architecture.mdx

@@ -0,0 +1,154 @@
+---
+title: Arquitetura de Produção
+description: Melhores práticas para construir aplicações de IA prontas para produção com CrewAI
+icon: server
+mode: "wide"
+---
+
+# A Mentalidade Flow-First
+
+Ao construir aplicações de IA de produção com CrewAI, **recomendamos começar com um Flow**.
+
+Embora seja possível executar Crews ou Agentes individuais, envolvê-los em um Flow fornece a estrutura necessária para uma aplicação robusta e escalável.
+
+## Por que Flows?
+
+1.  **Gerenciamento de Estado**: Flows fornecem uma maneira integrada de gerenciar o estado em diferentes etapas da sua aplicação. Isso é crucial para passar dados entre Crews, manter o contexto e lidar com entradas do usuário.
+2.  **Controle**: Flows permitem definir caminhos de execução precisos, incluindo loops, condicionais e lógica de ramificação. Isso é essencial para lidar com casos extremos e garantir que sua aplicação se comporte de maneira previsível.
+3.  **Observabilidade**: Flows fornecem uma estrutura clara que facilita o rastreamento da execução, a depuração de problemas e o monitoramento do desempenho. Recomendamos o uso do [CrewAI Tracing](/pt-BR/observability/tracing) para insights detalhados. Basta executar `crewai login` para habilitar recursos de observabilidade gratuitos.
+
+## A Arquitetura
+
+Uma aplicação CrewAI de produção típica se parece com isso:
+
+```mermaid
+graph TD
+    Start((Início)) --> Flow[Orquestrador de Flow]
+    Flow --> State{Gerenciamento de Estado}
+    State --> Step1[Etapa 1: Coleta de Dados]
+    Step1 --> Crew1[Crew de Pesquisa]
+    Crew1 --> State
+    State --> Step2{Verificação de Condição}
+    Step2 -- "Válido" --> Step3[Etapa 3: Execução]
+    Step3 --> Crew2[Crew de Ação]
+    Step2 -- "Inválido" --> End((Fim))
+    Crew2 --> End
+```
+
+### 1. A Classe Flow
+Sua classe `Flow` é o ponto de entrada. Ela define o esquema de estado e os métodos que executam sua lógica.
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class AppState(BaseModel):
+    user_input: str = ""
+    research_results: str = ""
+    final_report: str = ""
+
+class ProductionFlow(Flow[AppState]):
+    @start()
+    def gather_input(self):
+        # ... lógica para obter entrada ...
+        pass
+
+    @listen(gather_input)
+    def run_research_crew(self):
+        # ... acionar um Crew ...
+        pass
+```
+
+### 2. Gerenciamento de Estado
+Use modelos Pydantic para definir seu estado. Isso garante a segurança de tipos e deixa claro quais dados estão disponíveis em cada etapa.
+
+- **Mantenha o mínimo**: Armazene apenas o que você precisa persistir entre as etapas.
+- **Use dados estruturados**: Evite dicionários não estruturados quando possível.
+
+### 3. Crews como Unidades de Trabalho
+Delegue tarefas complexas para Crews. Um Crew deve ser focado em um objetivo específico (por exemplo, "Pesquisar um tópico", "Escrever uma postagem no blog").
+
+- **Não superengendre Crews**: Mantenha-os focados.
+- **Passe o estado explicitamente**: Passe os dados necessários do estado do Flow para as entradas do Crew.
+
+```python
+    @listen(gather_input)
+    def run_research_crew(self):
+        crew = ResearchCrew()
+        result = crew.kickoff(inputs={"topic": self.state.user_input})
+        self.state.research_results = result.raw
+```
+
+## Primitivas de Controle
+
+Aproveite as primitivas de controle do CrewAI para adicionar robustez e controle aos seus Crews.
+
+### 1. Task Guardrails
+Use [Task Guardrails](/pt-BR/concepts/tasks#task-guardrails) para validar as saídas das tarefas antes que sejam aceitas. Isso garante que seus agentes produzam resultados de alta qualidade.
+
+```python
+def validate_content(result: TaskOutput) -> Tuple[bool, Any]:
+    if len(result.raw) < 100:
+        return (False, "Content is too short. Please expand.")
+    return (True, result.raw)
+
+task = Task(
+    ...,
+    guardrail=validate_content
+)
+```
+
+### 2. Saídas Estruturadas
+Sempre use saídas estruturadas (`output_pydantic` ou `output_json`) ao passar dados entre tarefas ou para sua aplicação. Isso evita erros de análise e garante a segurança de tipos.
+
+```python
+class ResearchResult(BaseModel):
+    summary: str
+    sources: List[str]
+
+task = Task(
+    ...,
+    output_pydantic=ResearchResult
+)
+```
+
+### 3. LLM Hooks
+Use [LLM Hooks](/pt-BR/learn/llm-hooks) para inspecionar ou modificar mensagens antes que elas sejam enviadas para o LLM, ou para higienizar respostas.
+
+```python
+@before_llm_call
+def log_request(context):
+    print(f"Agent {context.agent.role} is calling the LLM...")
+```
+
+## Padrões de Implantação
+
+Ao implantar seu Flow, considere o seguinte:
+
+### CrewAI Enterprise
+A maneira mais fácil de implantar seu Flow é usando o CrewAI Enterprise. Ele lida com a infraestrutura, autenticação e monitoramento para você.
+
+Confira o [Guia de Implantação](/pt-BR/enterprise/guides/deploy-crew) para começar.
+
+```bash
+crewai deploy create
+```
+
+### Execução Assíncrona
+Para tarefas de longa duração, use `kickoff_async` para evitar bloquear sua API.
+
+### Persistência
+Use o decorador `@persist` para salvar o estado do seu Flow em um banco de dados. Isso permite retomar a execução se o processo falhar ou se você precisar esperar pela entrada humana.
+
+```python
+@persist
+class ProductionFlow(Flow[AppState]):
+    # ...
+```
+
+## Resumo
+
+- **Comece com um Flow.**
+- **Defina um Estado claro.**
+- **Use Crews para tarefas complexas.**
+- **Implante com uma API e persistência.**

docs/pt-BR/introduction.mdx

@@ -7,110 +7,89 @@ mode: "wide"
 
 # O que é CrewAI?
 
-**CrewAI é um framework Python enxuto e ultrarrápido, construído totalmente do zero—completamente independente do LangChain ou de outros frameworks de agentes.**
+**CrewAI é o principal framework open-source para orquestrar agentes de IA autônomos e construir fluxos de trabalho complexos.**
 
-O CrewAI capacita desenvolvedores tanto com simplicidade de alto nível quanto com controle detalhado de baixo nível, ideal para criar agentes de IA autônomos sob medida para qualquer cenário:
+Ele capacita desenvolvedores a construir sistemas multi-agente prontos para produção, combinando a inteligência colaborativa dos **Crews** com o controle preciso dos **Flows**.
 
-- **[Crews do CrewAI](/pt-BR/guides/crews/first-crew)**: Otimizados para autonomia e inteligência colaborativa, permitindo criar equipes de IA onde cada agente possui funções, ferramentas e objetivos específicos.
-- **[Flows do CrewAI](/pt-BR/guides/flows/first-flow)**: Proporcionam controle granular, orientado por eventos, com chamadas LLM individuais para uma orquestração precisa das tarefas, além de suportar Crews nativamente.
+- **[Flows do CrewAI](/pt-BR/guides/flows/first-flow)**: A espinha dorsal da sua aplicação de IA. Flows permitem criar fluxos de trabalho estruturados e orientados a eventos que gerenciam estado e controlam a execução. Eles fornecem a estrutura para seus agentes de IA trabalharem.
+- **[Crews do CrewAI](/pt-BR/guides/crews/first-crew)**: As unidades de trabalho dentro do seu Flow. Crews são equipes de agentes autônomos que colaboram para resolver tarefas específicas delegadas a eles pelo Flow.
 
-Com mais de 100.000 desenvolvedores certificados em nossos cursos comunitários, o CrewAI está se tornando rapidamente o padrão para automação de IA pronta para empresas.
+Com mais de 100.000 desenvolvedores certificados em nossos cursos comunitários, o CrewAI é o padrão para automação de IA pronta para empresas.
 
+## A Arquitetura do CrewAI
 
-## Como funcionam os Crews
+A arquitetura do CrewAI foi projetada para equilibrar autonomia com controle.
+
+### 1. Flows: A Espinha Dorsal
 
 <Note>
-  Assim como uma empresa possui departamentos (Vendas, Engenharia, Marketing) trabalhando juntos sob uma liderança para atingir objetivos de negócio, o CrewAI ajuda você a criar uma “organização” de agentes de IA com funções especializadas colaborando para realizar tarefas complexas.
-</Note>
-
-<Frame caption="Visão Geral do Framework CrewAI">
-  <img src="/images/crews.png" alt="Visão Geral do Framework CrewAI" />
-</Frame>
-
-| Componente | Descrição | Principais Funcionalidades |
-|:-----------|:-----------:|:-------------------------|
-| **Crew** | Organização de mais alto nível | • Gerencia equipes de agentes de IA<br/>• Supervisiona fluxos de trabalho<br/>• Garante colaboração<br/>• Entrega resultados |
-| **Agentes de IA** | Membros especializados da equipe | • Possuem funções específicas (pesquisador, escritor)<br/>• Utilizam ferramentas designadas<br/>• Podem delegar tarefas<br/>• Tomam decisões autônomas |
-| **Process** | Sistema de gestão do fluxo de trabalho | • Define padrões de colaboração<br/>• Controla designação de tarefas<br/>• Gerencia interações<br/>• Garante execução eficiente |
-| **Tasks** | Atribuições individuais | • Objetivos claros<br/>• Utilizam ferramentas específicas<br/>• Alimentam processos maiores<br/>• Geram resultados acionáveis |
-
-### Como tudo trabalha junto
-
-1. O **Crew** organiza toda a operação
-2. **Agentes de IA** realizam tarefas especializadas
-3. O **Process** garante colaboração fluida
-4. **Tasks** são concluídas para alcançar o objetivo
-
-## Principais Funcionalidades
-
-<CardGroup cols={2}>
-  <Card title="Agentes Baseados em Funções" icon="users">
-    Crie agentes especializados com funções, conhecimentos e objetivos definidos – de pesquisadores e analistas a escritores
-  </Card>
-  <Card title="Ferramentas Flexíveis" icon="screwdriver-wrench">
-    Equipe os agentes com ferramentas e APIs personalizadas para interagir com serviços e fontes de dados externas
-  </Card>
-  <Card title="Colaboração Inteligente" icon="people-arrows">
-    Agentes trabalham juntos, compartilhando insights e coordenando tarefas para conquistar objetivos complexos
-  </Card>
-  <Card title="Gerenciamento de Tarefas" icon="list-check">
-    Defina fluxos de trabalho sequenciais ou paralelos, com agentes lidando automaticamente com dependências entre tarefas
-  </Card>
-</CardGroup>
-
-## Como funcionam os Flows
-
-<Note>
-  Enquanto Crews se destacam na colaboração autônoma, Flows proporcionam automações estruturadas, oferecendo controle granular sobre a execução dos fluxos de trabalho. Flows garantem execução confiável, segura e eficiente, lidando com lógica condicional, loops e gerenciamento dinâmico de estados com precisão. Flows se integram perfeitamente com Crews, permitindo equilibrar alta autonomia com controle rigoroso.
+  Pense em um Flow como o "gerente" ou a "definição do processo" da sua aplicação. Ele define as etapas, a lógica e como os dados se movem através do seu sistema.
 </Note>
 
 <Frame caption="Visão Geral do Framework CrewAI">
   <img src="/images/flows.png" alt="Visão Geral do Framework CrewAI" />
 </Frame>
 
-| Componente | Descrição | Principais Funcionalidades |
-|:-----------|:-----------:|:-------------------------|
-| **Flow** | Orquestração de fluxo de trabalho estruturada | • Gerencia caminhos de execução<br/>• Lida com transições de estado<br/>• Controla a sequência de tarefas<br/>• Garante execução confiável |
-| **Events** | Gatilhos para ações nos fluxos | • Iniciam processos específicos<br/>• Permitem respostas dinâmicas<br/>• Suportam ramificações condicionais<br/>• Adaptam-se em tempo real |
-| **States** | Contextos de execução dos fluxos | • Mantêm dados de execução<br/>• Permitem persistência<br/>• Suportam retomada<br/>• Garantem integridade na execução |
-| **Crew Support** | Aprimora automação de fluxos | • Injeta autonomia quando necessário<br/>• Complementa fluxos estruturados<br/>• Equilibra automação e inteligência<br/>• Permite tomada de decisão adaptativa |
+Flows fornecem:
+- **Gerenciamento de Estado**: Persistem dados através de etapas e execuções.
+- **Execução Orientada a Eventos**: Acionam ações com base em eventos ou entradas externas.
+- **Controle de Fluxo**: Usam lógica condicional, loops e ramificações.
 
-### Capacidades-Chave
+### 2. Crews: A Inteligência
+
+<Note>
+  Crews são as "equipes" que fazem o trabalho pesado. Dentro de um Flow, você pode acionar um Crew para lidar com um problema complexo que requer criatividade e colaboração.
+</Note>
+
+<Frame caption="Visão Geral do Framework CrewAI">
+  <img src="/images/crews.png" alt="Visão Geral do Framework CrewAI" />
+</Frame>
+
+Crews fornecem:
+- **Agentes com Funções**: Agentes especializados com objetivos e ferramentas específicas.
+- **Colaboração Autônoma**: Agentes trabalham juntos para resolver tarefas.
+- **Delegação de Tarefas**: Tarefas são atribuídas e executadas com base nas capacidades dos agentes.
+
+## Como Tudo Funciona Junto
+
+1.  **O Flow** aciona um evento ou inicia um processo.
+2.  **O Flow** gerencia o estado e decide o que fazer a seguir.
+3.  **O Flow** delega uma tarefa complexa para um **Crew**.
+4.  Os agentes do **Crew** colaboram para completar a tarefa.
+5.  **O Crew** retorna o resultado para o **Flow**.
+6.  **O Flow** continua a execução com base no resultado.
+
+## Principais Funcionalidades
 
 <CardGroup cols={2}>
-  <Card title="Orquestração Orientada por Eventos" icon="bolt">
-    Defina caminhos de execução precisos respondendo dinamicamente a eventos
+  <Card title="Flows de Nível de Produção" icon="arrow-progress">
+    Construa fluxos de trabalho confiáveis e com estado que podem lidar com processos de longa duração e lógica complexa.
   </Card>
-  <Card title="Controle Detalhado" icon="sliders">
-    Gerencie estados de fluxo de trabalho e execução condicional de forma segura e eficiente
+  <Card title="Crews Autônomos" icon="users">
+    Implante equipes de agentes que podem planejar, executar e colaborar para alcançar objetivos de alto nível.
   </Card>
-  <Card title="Integração Nativa com Crew" icon="puzzle-piece">
-    Combine de forma simples com Crews para maior autonomia e inteligência
+  <Card title="Ferramentas Flexíveis" icon="screwdriver-wrench">
+     Conecte seus agentes a qualquer API, banco de dados ou ferramenta local.
   </Card>
-  <Card title="Execução Determinística" icon="route">
-    Garanta resultados previsíveis com controle explícito de fluxo e tratamento de erros
+  <Card title="Segurança Empresarial" icon="lock">
+    Projetado com segurança e conformidade em mente para implantações empresariais.
   </Card>
 </CardGroup>
 
-## Quando usar Crews versus Flows
+## Quando usar Crews vs. Flows
 
-<Note>
-  Entender quando utilizar [Crews](/pt-BR/guides/crews/first-crew) ou [Flows](/pt-BR/guides/flows/first-flow) é fundamental para maximizar o potencial do CrewAI em suas aplicações.
-</Note>
+**A resposta curta: Use ambos.**
 
-| Caso de uso | Abordagem recomendada | Por quê? |
-|:------------|:---------------------|:---------|
-| **Pesquisa aberta** | [Crews](/pt-BR/guides/crews/first-crew) | Quando as tarefas exigem criatividade, exploração e adaptação |
-| **Geração de conteúdo** | [Crews](/pt-BR/guides/crews/first-crew) | Para criação colaborativa de artigos, relatórios ou materiais de marketing |
-| **Fluxos de decisão** | [Flows](/pt-BR/guides/flows/first-flow) | Quando é necessário caminhos de decisão previsíveis, auditáveis e com controle preciso |
-| **Orquestração de APIs** | [Flows](/pt-BR/guides/flows/first-flow) | Para integração confiável com múltiplos serviços externos em sequência específica |
-| **Aplicações híbridas** | Abordagem combinada | Use [Flows](/pt-BR/guides/flows/first-flow) para orquestrar o processo geral com [Crews](/pt-BR/guides/crews/first-crew) lidando com subtarefas complexas |
+Para qualquer aplicação pronta para produção, **comece com um Flow**.
 
-### Framework de Decisão
+- **Use um Flow** para definir a estrutura geral, estado e lógica da sua aplicação.
+- **Use um Crew** dentro de uma etapa do Flow quando precisar de uma equipe de agentes para realizar uma tarefa específica e complexa que requer autonomia.
 
-- **Escolha [Crews](/pt-BR/guides/crews/first-crew) quando:** Precisa de resolução autônoma de problemas, colaboração criativa ou tarefas exploratórias
-- **Escolha [Flows](/pt-BR/guides/flows/first-flow) quando:** Requer resultados determinísticos, auditabilidade ou controle preciso sobre a execução
-- **Combine ambos quando:** Sua aplicação precisa de processos estruturados e também de bolsões de inteligência autônoma
+| Caso de Uso | Arquitetura |
+| :--- | :--- |
+| **Automação Simples** | Flow único com tarefas Python |
+| **Pesquisa Complexa** | Flow gerenciando estado -> Crew realizando pesquisa |
+| **Backend de Aplicação** | Flow lidando com requisições API -> Crew gerando conteúdo -> Flow salvando no BD |
 
 ## Por que escolher o CrewAI?
 
@@ -124,13 +103,6 @@ Com mais de 100.000 desenvolvedores certificados em nossos cursos comunitários,
 ## Pronto para começar a construir?
 
 <CardGroup cols={2}>
-  <Card
-    title="Crie Seu Primeiro Crew"
-    icon="users-gear"
-    href="/pt-BR/guides/crews/first-crew"
-  >
-    Tutorial passo a passo para criar uma equipe de IA colaborativa que trabalha junto para resolver problemas complexos.
-  </Card>
   <Card
     title="Crie Seu Primeiro Flow"
     icon="diagram-project"
@@ -138,6 +110,13 @@ Com mais de 100.000 desenvolvedores certificados em nossos cursos comunitários,
   >
     Aprenda a criar fluxos de trabalho estruturados e orientados por eventos com controle preciso de execução.
   </Card>
+  <Card
+    title="Crie Seu Primeiro Crew"
+    icon="users-gear"
+    href="/pt-BR/guides/crews/first-crew"
+  >
+    Tutorial passo a passo para criar uma equipe de IA colaborativa que trabalha junto para resolver problemas complexos.
+  </Card>
 </CardGroup>
 
 <CardGroup cols={3}>

docs/pt-BR/observability/tracing.mdx

@@ -0,0 +1,213 @@
+---
+title: CrewAI Tracing
+description: Rastreamento integrado para Crews e Flows do CrewAI com a plataforma CrewAI AOP
+icon: magnifying-glass-chart
+mode: "wide"
+---
+
+# Rastreamento Integrado do CrewAI
+
+O CrewAI fornece recursos de rastreamento integrados que permitem monitorar e depurar seus Crews e Flows em tempo real. Este guia demonstra como habilitar o rastreamento para **Crews** e **Flows** usando a plataforma de observabilidade integrada do CrewAI.
+
+> **O que é o CrewAI Tracing?** O rastreamento integrado do CrewAI fornece observabilidade abrangente para seus agentes de IA, incluindo decisões de agentes, cronogramas de execução de tarefas, uso de ferramentas e chamadas de LLM - tudo acessível através da [plataforma CrewAI AOP](https://app.crewai.com).
+
+![CrewAI Tracing Interface](/images/crewai-tracing.png)
+
+## Pré-requisitos
+
+Antes de usar o rastreamento do CrewAI, você precisa:
+
+1. **Conta CrewAI AOP**: Cadastre-se para uma conta gratuita em [app.crewai.com](https://app.crewai.com)
+2. **Autenticação CLI**: Use a CLI do CrewAI para autenticar seu ambiente local
+
+```bash
+crewai login
+```
+
+## Instruções de Configuração
+
+### Passo 1: Crie sua Conta CrewAI AOP
+
+Visite [app.crewai.com](https://app.crewai.com) e crie sua conta gratuita. Isso lhe dará acesso à plataforma CrewAI AOP, onde você pode visualizar rastreamentos, métricas e gerenciar seus crews.
+
+### Passo 2: Instale a CLI do CrewAI e Autentique
+
+Se você ainda não o fez, instale o CrewAI com as ferramentas CLI:
+
+```bash
+uv add crewai[tools]
+```
+
+Em seguida, autentique sua CLI com sua conta CrewAI AOP:
+
+```bash
+crewai login
+```
+
+Este comando irá:
+1. Abrir seu navegador na página de autenticação
+2. Solicitar que você insira um código de dispositivo
+3. Autenticar seu ambiente local com sua conta CrewAI AOP
+4. Habilitar recursos de rastreamento para seu desenvolvimento local
+
+### Passo 3: Habilite o Rastreamento em seu Crew
+
+Você pode habilitar o rastreamento para seu Crew definindo o parâmetro `tracing` como `True`:
+
+```python
+from crewai import Agent, Crew, Process, Task
+from crewai_tools import SerperDevTool
+
+# Define your agents
+researcher = Agent(
+    role="Senior Research Analyst",
+    goal="Uncover cutting-edge developments in AI and data science",
+    backstory=\"\"\"You work at a leading tech think tank.
+    Your expertise lies in identifying emerging trends.
+    You have a knack for dissecting complex data and presenting actionable insights.\"\"\",
+    verbose=True,
+    tools=[SerperDevTool()],
+)
+
+writer = Agent(
+    role="Tech Content Strategist",
+    goal="Craft compelling content on tech advancements",
+    backstory=\"\"\"You are a renowned Content Strategist, known for your insightful and engaging articles.
+    You transform complex concepts into compelling narratives.\"\"\",
+    verbose=True,
+)
+
+# Create tasks for your agents
+research_task = Task(
+    description=\"\"\"Conduct a comprehensive analysis of the latest advancements in AI in 2024.
+    Identify key trends, breakthrough technologies, and potential industry impacts.\"\"\",
+    expected_output="Full analysis report in bullet points",
+    agent=researcher,
+)
+
+writing_task = Task(
+    description=\"\"\"Using the insights provided, develop an engaging blog
+    post that highlights the most significant AI advancements.
+    Your post should be informative yet accessible, catering to a tech-savvy audience.\"\"\",
+    expected_output="Full blog post of at least 4 paragraphs",
+    agent=writer,
+)
+
+# Enable tracing in your crew
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    process=Process.sequential,
+    tracing=True,  # Enable built-in tracing
+    verbose=True
+)
+
+# Execute your crew
+result = crew.kickoff()
+```
+
+### Passo 4: Habilite o Rastreamento em seu Flow
+
+Da mesma forma, você pode habilitar o rastreamento para Flows do CrewAI:
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class ExampleState(BaseModel):
+    counter: int = 0
+    message: str = ""
+
+class ExampleFlow(Flow[ExampleState]):
+    def __init__(self):
+        super().__init__(tracing=True)  # Enable tracing for the flow
+
+    @start()
+    def first_method(self):
+        print("Starting the flow")
+        self.state.counter = 1
+        self.state.message = "Flow started"
+        return "continue"
+
+    @listen("continue")
+    def second_method(self):
+        print("Continuing the flow")
+        self.state.counter += 1
+        self.state.message = "Flow continued"
+        return "finish"
+
+    @listen("finish")
+    def final_method(self):
+        print("Finishing the flow")
+        self.state.counter += 1
+        self.state.message = "Flow completed"
+
+# Create and run the flow with tracing enabled
+flow = ExampleFlow(tracing=True)
+result = flow.kickoff()
+```
+
+### Passo 5: Visualize os Rastreamentos no Painel CrewAI AOP
+
+Após executar o crew ou flow, você pode visualizar os rastreamentos gerados pela sua aplicação CrewAI no painel CrewAI AOP. Você verá etapas detalhadas das interações dos agentes, usos de ferramentas e chamadas de LLM.
+Basta clicar no link abaixo para visualizar os rastreamentos ou ir para a aba de rastreamentos no painel [aqui](https://app.crewai.com/crewai_plus/trace_batches)
+![CrewAI Tracing Interface](/images/view-traces.png)
+
+
+### Alternativa: Configuração de Variável de Ambiente
+
+Você também pode habilitar o rastreamento globalmente definindo uma variável de ambiente:
+
+```bash
+export CREWAI_TRACING_ENABLED=true
+```
+
+Ou adicione-a ao seu arquivo `.env`:
+
+```env
+CREWAI_TRACING_ENABLED=true
+```
+
+Quando esta variável de ambiente estiver definida, todos os Crews e Flows terão automaticamente o rastreamento habilitado, mesmo sem definir explicitamente `tracing=True`.
+
+## Visualizando seus Rastreamentos
+
+### Acesse o Painel CrewAI AOP
+
+1. Visite [app.crewai.com](https://app.crewai.com) e faça login em sua conta
+2. Navegue até o painel do seu projeto
+3. Clique na aba **Traces** para visualizar os detalhes de execução
+
+### O que Você Verá nos Rastreamentos
+
+O rastreamento do CrewAI fornece visibilidade abrangente sobre:
+
+- **Decisões dos Agentes**: Veja como os agentes raciocinam através das tarefas e tomam decisões
+- **Cronograma de Execução de Tarefas**: Representação visual de sequências e dependências de tarefas
+- **Uso de Ferramentas**: Monitore quais ferramentas são chamadas e seus resultados
+- **Chamadas de LLM**: Rastreie todas as interações do modelo de linguagem, incluindo prompts e respostas
+- **Métricas de Desempenho**: Tempos de execução, uso de tokens e custos
+- **Rastreamento de Erros**: Informações detalhadas de erros e rastreamentos de pilha
+
+### Recursos de Rastreamento
+- **Cronograma de Execução**: Clique através de diferentes estágios de execução
+- **Logs Detalhados**: Acesse logs abrangentes para depuração
+- **Análise de Desempenho**: Analise padrões de execução e otimize o desempenho
+- **Capacidades de Exportação**: Baixe rastreamentos para análise adicional
+
+### Problemas de Autenticação
+
+Se você encontrar problemas de autenticação:
+
+1. Certifique-se de estar logado: `crewai login`
+2. Verifique sua conexão com a internet
+3. Verifique sua conta em [app.crewai.com](https://app.crewai.com)
+
+### Rastreamentos Não Aparecem
+
+Se os rastreamentos não estiverem aparecendo no painel:
+
+1. Confirme que `tracing=True` está definido em seu Crew/Flow
+2. Verifique se `CREWAI_TRACING_ENABLED=true` se estiver usando variáveis de ambiente
+3. Certifique-se de estar autenticado com `crewai login`
+4. Verifique se seu crew/flow está realmente executando