+
| Component | Description | Key Features |
@@ -64,7 +64,7 @@ With over 100,000 developers certified through our community courses, CrewAI is
+
| Component | Description | Key Features |
@@ -94,21 +94,21 @@ With over 100,000 developers certified through our community courses, CrewAI is
## When to Use Crews vs. Flows
Get personalized guidance on implementing this integration
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ stop, basta omiti-lo na chamada do LLM:
+
+ ```python
+ from crewai import LLM
+ import os
+
+ os.environ["OPENAI_API_KEY"] = "
+
+
+
+
+
+ - Configure quaisquer ações adicionais necessárias
+ - Revise as etapas do seu workflow para garantir que tudo está configurado corretamente
+ - Ative o workflow
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Próximos Passos
+
+- Personalize o estilo do componente para combinar com o design da sua aplicação
+- Adicione props adicionais para configuração
+- Integre com o gerenciamento de estado da sua aplicação
+- Adicione tratamento de erros e estados de carregamento
\ No newline at end of file
diff --git a/docs/pt-BR/enterprise/guides/salesforce-trigger.mdx b/docs/pt-BR/enterprise/guides/salesforce-trigger.mdx
new file mode 100644
index 000000000..9b44f624a
--- /dev/null
+++ b/docs/pt-BR/enterprise/guides/salesforce-trigger.mdx
@@ -0,0 +1,44 @@
+---
+title: "Trigger Salesforce"
+description: "Dispare equipes CrewAI a partir de fluxos de trabalho do Salesforce para automação de CRM"
+icon: "salesforce"
+---
+
+A CrewAI Enterprise pode ser acionada a partir do Salesforce para automatizar fluxos de trabalho de gestão de relacionamento com o cliente e aprimorar suas operações de vendas.
+
+## Visão Geral
+
+O Salesforce é uma das principais plataformas de gestão de relacionamento com o cliente (CRM), que ajuda empresas a otimizar operações de vendas, atendimento e marketing. Ao configurar triggers da CrewAI a partir do Salesforce, você pode:
+
+- Automatizar a classificação e qualificação de leads
+- Gerar materiais de vendas personalizados
+- Aprimorar o atendimento ao cliente com respostas baseadas em IA
+- Otimizar análise e relatórios de dados
+
+## Demonstração
+
+
+
+
+
+ Verifique se o Slack está listado e conectado.
+
+
+ - Pressione Enter ou selecione a opção "**Kickoff crew**". Uma caixa de diálogo intitulada "**Kickoff an AI Crew**" aparecerá.
+
+
+ - Se o seu crew exigir algum input, clique no botão "**Add Inputs**" para fornecê-los.
+
+
+ - O crew começará a ser executado e você verá os resultados no canal do Slack.
+
+
+
+
+
+
+
+
+
+
+
+ - Clique no botão `Add Role` para adicionar uma nova função.
+ - Insira os detalhes e as permissões da função e clique no botão `Create Role` para criar a função.
+
+
+
+
+
+ - Após o membro aceitar o convite, você poderá adicionar uma função a ele.
+ - Volte para a aba `Roles`
+ - Vá até o membro ao qual deseja adicionar uma função e, na coluna `Role`, clique no menu suspenso
+ - Selecione a função que deseja atribuir ao membro
+ - Clique no botão `Update` para salvar a função
+
+
+
+
+
+
+
+
+ 3. Adicione uma etapa de ação HTTP
+ - Configure a ação como `Send HTTP request`
+ - Use o método `POST`
+ - Defina a URL para o endpoint de kickoff do CrewAI Enterprise
+ - Adicione os headers necessários (ex.: `Bearer Token`)
+
+
+
+
+ - No corpo, inclua o conteúdo JSON conforme configurado na etapa 2
+
+
+
+
+ - O crew será iniciado no horário pré-definido.
+
+
+
+ 2. Adicione uma etapa de webhook como gatilho:
+ - Selecione `Catch Webhook` como tipo de gatilho
+ - Isso irá gerar uma URL única que receberá requisições HTTP e disparará seu flow
+
+
+
+
+ - Configure o e-mail para usar o corpo de texto do webhook do crew
+
+
+
+
+
+
+
+ - Selecione `New Pushed Message` como o Evento de Trigger.
+ - Conecte sua conta Slack, caso ainda não tenha feito isso.
+
+
+
+
+ - Configure as entradas para o Crew usando os dados da mensagem do Slack.
+
+
+
+
+
+
+
+
+
+
+ - Selecione o botão de três pontos e então escolha Push to Zapier
+
+
+
+
+
+
+
+
+
+CrewAI Enterprise expande o poder do framework open-source com funcionalidades projetadas para implantações em produção, colaboração e escalabilidade. Implemente seus crews em uma infraestrutura gerenciada e monitore sua execução em tempo real.
+
+## Principais Funcionalidades
+
+
+
+
+Essa matriz ajuda a visualizar como diferentes abordagens se alinham com os requisitos variados de complexidade e precisão. Vamos explorar o significado de cada quadrante e como isso orienta suas escolhas arquiteturais.
+
+## Explicando a Matriz Complexidade-Precisão
+
+### O que é Complexidade?
+
+No contexto das aplicações CrewAI, **complexidade** refere-se a:
+
+- O número de etapas ou operações distintas necessárias
+- A diversidade de tarefas que precisam ser realizadas
+- As interdependências entre diferentes componentes
+- A necessidade de lógica condicional e ramificações
+- A sofisticação do fluxo de trabalho como um todo
+
+### O que é Precisão?
+
+**Precisão** nesse contexto refere-se a:
+
+- O grau de exatidão exigido no resultado final
+- A necessidade de resultados estruturados e previsíveis
+- A importância da reprodutibilidade
+- O nível de controle necessário sobre cada etapa
+- A tolerância à variação nos resultados
+
+### Os Quatro Quadrantes
+
+#### 1. Baixa Complexidade, Baixa Precisão
+
+**Características:**
+- Tarefas simples e diretas
+- Tolerância a alguma variação nos resultados
+- Número limitado de etapas
+- Aplicações criativas ou exploratórias
+
+**Abordagem Recomendada:** Crews simples com poucos agentes
+
+**Exemplos de Casos de Uso:**
+- Geração básica de conteúdo
+- Brainstorming de ideias
+- Tarefas simples de sumarização
+- Assistência à escrita criativa
+
+#### 2. Baixa Complexidade, Alta Precisão
+
+**Características:**
+- Fluxos de trabalho simples que exigem resultados exatos e estruturados
+- Necessidade de resultados reproduzíveis
+- Poucas etapas, mas alto requisito de precisão
+- Frequentemente envolve processamento ou transformação de dados
+
+**Abordagem Recomendada:** Flows com chamadas diretas a LLM ou Crews simples com saídas estruturadas
+
+**Exemplos de Casos de Uso:**
+- Extração e transformação de dados
+- Preenchimento e validação de formulários
+- Geração estruturada de conteúdo (JSON, XML)
+- Tarefas simples de classificação
+
+#### 3. Alta Complexidade, Baixa Precisão
+
+**Características:**
+- Processos multiestágio com muitas etapas
+- Saídas criativas ou exploratórias
+- Interações complexas entre componentes
+- Tolerância à variação nos resultados finais
+
+**Abordagem Recomendada:** Crews complexas com múltiplos agentes especializados
+
+**Exemplos de Casos de Uso:**
+- Pesquisa e análise
+- Pipelines de criação de conteúdo
+- Análise exploratória de dados
+- Solução criativa de problemas
+
+#### 4. Alta Complexidade, Alta Precisão
+
+**Características:**
+- Fluxos de trabalho complexos que requerem saídas estruturadas
+- Múltiplas etapas interdependentes com rígida exigência de precisão
+- Necessidade tanto de processamento sofisticado quanto de resultados precisos
+- Frequentemente aplicações críticas
+
+**Abordagem Recomendada:** Flows orquestrando múltiplas Crews com etapas de validação
+
+**Exemplos de Casos de Uso:**
+- Sistemas corporativos de suporte à decisão
+- Pipelines complexos de processamento de dados
+- Processamento de documentos em múltiplos estágios
+- Aplicações em indústrias reguladas
+
+## Escolhendo Entre Crews e Flows
+
+### Quando Escolher Crews
+
+Crews são ideais quando:
+
+1. **Você precisa de inteligência colaborativa** - Múltiplos agentes com especializações diferentes precisam trabalhar juntos
+2. **O problema requer pensamento emergente** - A solução se beneficia de diferentes perspectivas e abordagens
+3. **A tarefa é principalmente criativa ou analítica** - O trabalho envolve pesquisa, criação de conteúdo ou análise
+4. **Você valoriza adaptabilidade mais do que estrutura rígida** - O fluxo de trabalho pode se beneficiar da autonomia dos agentes
+5. **O formato da saída pode ser um pouco flexível** - Alguma variação na estrutura do resultado é aceitável
+
+```python
+# Example: Research Crew for market analysis
+from crewai import Agent, Crew, Process, Task
+
+# Create specialized agents
+researcher = Agent(
+ role="Market Research Specialist",
+ goal="Find comprehensive market data on emerging technologies",
+ backstory="You are an expert at discovering market trends and gathering data."
+)
+
+analyst = Agent(
+ role="Market Analyst",
+ goal="Analyze market data and identify key opportunities",
+ backstory="You excel at interpreting market data and spotting valuable insights."
+)
+
+# Define their tasks
+research_task = Task(
+ description="Research the current market landscape for AI-powered healthcare solutions",
+ expected_output="Comprehensive market data including key players, market size, and growth trends",
+ agent=researcher
+)
+
+analysis_task = Task(
+ description="Analyze the market data and identify the top 3 investment opportunities",
+ expected_output="Analysis report with 3 recommended investment opportunities and rationale",
+ agent=analyst,
+ context=[research_task]
+)
+
+# Create the crew
+market_analysis_crew = Crew(
+ agents=[researcher, analyst],
+ tasks=[research_task, analysis_task],
+ process=Process.sequential,
+ verbose=True
+)
+
+# Run the crew
+result = market_analysis_crew.kickoff()
+```
+
+### Quando Escolher Flows
+
+Flows são ideais quando:
+
+1. **Você precisa de controle preciso da execução** - O fluxo de trabalho exige sequenciamento exato e gerenciamento de estado
+2. **A aplicação tem requisitos complexos de estado** - Você precisa manter e transformar estado ao longo de múltiplas etapas
+3. **Você precisa de saídas estruturadas e previsíveis** - A aplicação exige resultados consistentes e formatados
+4. **O fluxo de trabalho envolve lógica condicional** - Caminhos diferentes precisam ser seguidos com base em resultados intermediários
+5. **Você precisa combinar IA com código procedural** - A solução demanda tanto capacidades de IA quanto programação tradicional
+
+```python
+# Example: Customer Support Flow with structured processing
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+from typing import List, Dict
+
+# Define structured state
+class SupportTicketState(BaseModel):
+ ticket_id: str = ""
+ customer_name: str = ""
+ issue_description: str = ""
+ category: str = ""
+ priority: str = "medium"
+ resolution: str = ""
+ satisfaction_score: int = 0
+
+class CustomerSupportFlow(Flow[SupportTicketState]):
+ @start()
+ def receive_ticket(self):
+ # In a real app, this might come from an API
+ self.state.ticket_id = "TKT-12345"
+ self.state.customer_name = "Alex Johnson"
+ self.state.issue_description = "Unable to access premium features after payment"
+ return "Ticket received"
+
+ @listen(receive_ticket)
+ def categorize_ticket(self, _):
+ # Use a direct LLM call for categorization
+ from crewai import LLM
+ llm = LLM(model="openai/gpt-4o-mini")
+
+ prompt = f"""
+ Categorize the following customer support issue into one of these categories:
+ - Billing
+ - Account Access
+ - Technical Issue
+ - Feature Request
+ - Other
+
+ Issue: {self.state.issue_description}
+
+ Return only the category name.
+ """
+
+ self.state.category = llm.call(prompt).strip()
+ return self.state.category
+
+ @router(categorize_ticket)
+ def route_by_category(self, category):
+ # Route to different handlers based on category
+ return category.lower().replace(" ", "_")
+
+ @listen("billing")
+ def handle_billing_issue(self):
+ # Handle billing-specific logic
+ self.state.priority = "high"
+ # More billing-specific processing...
+ return "Billing issue handled"
+
+ @listen("account_access")
+ def handle_access_issue(self):
+ # Handle access-specific logic
+ self.state.priority = "high"
+ # More access-specific processing...
+ return "Access issue handled"
+
+ # Additional category handlers...
+
+ @listen("billing", "account_access", "technical_issue", "feature_request", "other")
+ def resolve_ticket(self, resolution_info):
+ # Final resolution step
+ self.state.resolution = f"Issue resolved: {resolution_info}"
+ return self.state.resolution
+
+# Run the flow
+support_flow = CustomerSupportFlow()
+result = support_flow.kickoff()
+```
+
+### Quando Combinar Crews e Flows
+
+As aplicações mais sofisticadas frequentemente se beneficiam da combinação de Crews e Flows:
+
+1. **Processos complexos em múltiplos estágios** - Use Flows para orquestrar o processo geral e Crews para sub-tarefas complexas
+2. **Aplicações que exigem criatividade e estrutura** - Use Crews para tarefas criativas e Flows para processamento estruturado
+3. **Aplicações corporativas de IA** - Use Flows para gerenciar estado e fluxo de processo enquanto aproveita Crews para tarefas especializadas
+
+```python
+# Example: Content Production Pipeline combining Crews and Flows
+from crewai.flow.flow import Flow, listen, start
+from crewai import Agent, Crew, Process, Task
+from pydantic import BaseModel
+from typing import List, Dict
+
+class ContentState(BaseModel):
+ topic: str = ""
+ target_audience: str = ""
+ content_type: str = ""
+ outline: Dict = {}
+ draft_content: str = ""
+ final_content: str = ""
+ seo_score: int = 0
+
+class ContentProductionFlow(Flow[ContentState]):
+ @start()
+ def initialize_project(self):
+ # Set initial parameters
+ self.state.topic = "Sustainable Investing"
+ self.state.target_audience = "Millennial Investors"
+ self.state.content_type = "Blog Post"
+ return "Project initialized"
+
+ @listen(initialize_project)
+ def create_outline(self, _):
+ # Use a research crew to create an outline
+ researcher = Agent(
+ role="Content Researcher",
+ goal=f"Research {self.state.topic} for {self.state.target_audience}",
+ backstory="You are an expert researcher with deep knowledge of content creation."
+ )
+
+ outliner = Agent(
+ role="Content Strategist",
+ goal=f"Create an engaging outline for a {self.state.content_type}",
+ backstory="You excel at structuring content for maximum engagement."
+ )
+
+ research_task = Task(
+ description=f"Research {self.state.topic} focusing on what would interest {self.state.target_audience}",
+ expected_output="Comprehensive research notes with key points and statistics",
+ agent=researcher
+ )
+
+ outline_task = Task(
+ description=f"Create an outline for a {self.state.content_type} about {self.state.topic}",
+ expected_output="Detailed content outline with sections and key points",
+ agent=outliner,
+ context=[research_task]
+ )
+
+ outline_crew = Crew(
+ agents=[researcher, outliner],
+ tasks=[research_task, outline_task],
+ process=Process.sequential,
+ verbose=True
+ )
+
+ # Run the crew and store the result
+ result = outline_crew.kickoff()
+
+ # Parse the outline (in a real app, you might use a more robust parsing approach)
+ import json
+ try:
+ self.state.outline = json.loads(result.raw)
+ except:
+ # Fallback if not valid JSON
+ self.state.outline = {"sections": result.raw}
+
+ return "Outline created"
+
+ @listen(create_outline)
+ def write_content(self, _):
+ # Use a writing crew to create the content
+ writer = Agent(
+ role="Content Writer",
+ goal=f"Write engaging content for {self.state.target_audience}",
+ backstory="You are a skilled writer who creates compelling content."
+ )
+
+ editor = Agent(
+ role="Content Editor",
+ goal="Ensure content is polished, accurate, and engaging",
+ backstory="You have a keen eye for detail and a talent for improving content."
+ )
+
+ writing_task = Task(
+ description=f"Write a {self.state.content_type} about {self.state.topic} following this outline: {self.state.outline}",
+ expected_output="Complete draft content in markdown format",
+ agent=writer
+ )
+
+ editing_task = Task(
+ description="Edit and improve the draft content for clarity, engagement, and accuracy",
+ expected_output="Polished final content in markdown format",
+ agent=editor,
+ context=[writing_task]
+ )
+
+ writing_crew = Crew(
+ agents=[writer, editor],
+ tasks=[writing_task, editing_task],
+ process=Process.sequential,
+ verbose=True
+ )
+
+ # Run the crew and store the result
+ result = writing_crew.kickoff()
+ self.state.final_content = result.raw
+
+ return "Content created"
+
+ @listen(write_content)
+ def optimize_for_seo(self, _):
+ # Use a direct LLM call for SEO optimization
+ from crewai import LLM
+ llm = LLM(model="openai/gpt-4o-mini")
+
+ prompt = f"""
+ Analyze this content for SEO effectiveness for the keyword "{self.state.topic}".
+ Rate it on a scale of 1-100 and provide 3 specific recommendations for improvement.
+
+ Content: {self.state.final_content[:1000]}... (truncated for brevity)
+
+ Format your response as JSON with the following structure:
+ {{
+ "score": 85,
+ "recommendations": [
+ "Recommendation 1",
+ "Recommendation 2",
+ "Recommendation 3"
+ ]
+ }}
+ """
+
+ seo_analysis = llm.call(prompt)
+
+ # Parse the SEO analysis
+ import json
+ try:
+ analysis = json.loads(seo_analysis)
+ self.state.seo_score = analysis.get("score", 0)
+ return analysis
+ except:
+ self.state.seo_score = 50
+ return {"score": 50, "recommendations": ["Unable to parse SEO analysis"]}
+
+# Run the flow
+content_flow = ContentProductionFlow()
+result = content_flow.kickoff()
+```
+
+## Framework Prático de Avaliação
+
+Para determinar a abordagem certa para seu caso de uso específico, siga este framework passo a passo:
+
+### Passo 1: Avalie a Complexidade
+
+Classifique a complexidade do seu aplicativo numa escala de 1-10 considerando:
+
+1. **Número de etapas**: Quantas operações distintas são necessárias?
+ - 1-3 etapas: Baixa complexidade (1-3)
+ - 4-7 etapas: Média complexidade (4-7)
+ - 8+ etapas: Alta complexidade (8-10)
+
+2. **Interdependências**: Quão interligadas estão as partes diferentes?
+ - Poucas dependências: Baixa complexidade (1-3)
+ - Algumas dependências: Média complexidade (4-7)
+ - Muitas dependências complexas: Alta complexidade (8-10)
+
+3. **Lógica condicional**: Quanto de ramificação e tomada de decisão é necessário?
+ - Processo linear: Baixa complexidade (1-3)
+ - Alguma ramificação: Média complexidade (4-7)
+ - Árvores de decisão complexas: Alta complexidade (8-10)
+
+4. **Conhecimento de domínio**: Quão especializado deve ser o conhecimento requerido?
+ - Conhecimento geral: Baixa complexidade (1-3)
+ - Algum conhecimento especializado: Média complexidade (4-7)
+ - Grande especialização em múltiplos domínios: Alta complexidade (8-10)
+
+Calcule a média das pontuações para determinar sua complexidade geral.
+
+### Passo 2: Avalie os Requisitos de Precisão
+
+Classifique seus requisitos de precisão numa escala de 1-10 considerando:
+
+1. **Estrutura da saída**: Quão estruturado o resultado deve ser?
+ - Texto livre: Baixa precisão (1-3)
+ - Semi-estruturado: Média precisão (4-7)
+ - Estritamente formatado (JSON, XML): Alta precisão (8-10)
+
+2. **Necessidade de exatidão**: Qual a importância da precisão factual?
+ - Conteúdo criativo: Baixa precisão (1-3)
+ - Conteúdo informacional: Média precisão (4-7)
+ - Informação crítica: Alta precisão (8-10)
+
+3. **Reprodutibilidade**: Quão consistentes devem ser os resultados entre execuções?
+ - Variação aceitável: Baixa precisão (1-3)
+ - Alguma consistência necessária: Média precisão (4-7)
+ - Exata reprodutibilidade: Alta precisão (8-10)
+
+4. **Tolerância a erros**: Qual o impacto de erros?
+ - Baixo impacto: Baixa precisão (1-3)
+ - Impacto moderado: Média precisão (4-7)
+ - Alto impacto: Alta precisão (8-10)
+
+Calcule a média das pontuações para determinar seu requisito geral de precisão.
+
+### Passo 3: Mapeie na Matriz
+
+Plote as pontuações de complexidade e precisão na matriz:
+
+- **Baixa Complexidade (1-4), Baixa Precisão (1-4)**: Crews simples
+- **Baixa Complexidade (1-4), Alta Precisão (5-10)**: Flows com chamadas diretas a LLM
+- **Alta Complexidade (5-10), Baixa Precisão (1-4)**: Crews complexas
+- **Alta Complexidade (5-10), Alta Precisão (5-10)**: Flows orquestrando Crews
+
+### Passo 4: Considere Fatores Adicionais
+
+Além de complexidade e precisão, considere:
+
+1. **Tempo de desenvolvimento**: Crews costumam ser mais rápidas para prototipar
+2. **Necessidades de manutenção**: Flows proporcionam melhor manutenção a longo prazo
+3. **Expertise do time**: Considere a familiaridade de sua equipe com as abordagens
+4. **Requisitos de escalabilidade**: Flows normalmente escalam melhor para aplicações complexas
+5. **Necessidades de integração**: Considere como a solução se integrará aos sistemas existentes
+
+## Conclusão
+
+Escolher entre Crews e Flows — ou combiná-los — é uma decisão arquitetônica crítica que impacta a efetividade, manutenibilidade e escalabilidade da sua aplicação CrewAI. Ao avaliar seu caso de uso nas dimensões de complexidade e precisão, você toma decisões inteligentes que alinham-se aos seus requisitos.
+
+Lembre-se de que a melhor abordagem geralmente evolui na medida em que sua aplicação amadurece. Comece com a solução mais simples que atenda às suas necessidades e esteja preparado para refinar sua arquitetura conforme for ganhando experiência e seus requisitos se tornarem mais claros.
+
+
+
+
+
+## Passo 2: Explore a Estrutura do Projeto
+
+Vamos dedicar um momento para entender a estrutura do projeto criada pela CLI. A CrewAI segue boas práticas para projetos Python, tornando fácil manter e estender seu código à medida que suas crews se tornam mais complexas.
+
+```
+research_crew/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+├── .env
+└── src/
+ └── research_crew/
+ ├── __init__.py
+ ├── main.py
+ ├── crew.py
+ ├── tools/
+ │ ├── custom_tool.py
+ │ └── __init__.py
+ └── config/
+ ├── agents.yaml
+ └── tasks.yaml
+```
+
+Esta estrutura segue as melhores práticas para projetos Python e facilita a organização do seu código. A separação dos arquivos de configuração (em YAML) do código de implementação (em Python) permite modificar o comportamento da sua crew sem alterar o código subjacente.
+
+## Passo 3: Configure seus Agentes
+
+Agora vem a parte divertida – definir seus agentes de IA! Na CrewAI, agentes são entidades especializadas com papéis, objetivos e históricos específicos que moldam seu comportamento. Pense neles como personagens em uma peça, cada um com sua personalidade e propósito próprios.
+
+Para nossa crew de pesquisa, vamos criar dois agentes:
+1. Um **pesquisador** que é especialista em encontrar e organizar informações
+2. Um **analista** que pode interpretar os resultados da pesquisa e criar relatórios perspicazes
+
+Vamos modificar o arquivo `agents.yaml` para definir esses agentes especializados. Certifique-se de
+definir `llm` para o provedor que você está utilizando.
+
+```yaml
+# src/research_crew/config/agents.yaml
+researcher:
+ role: >
+ Especialista Sênior em Pesquisa para {topic}
+ goal: >
+ Encontrar informações abrangentes e precisas sobre {topic}
+ com foco em desenvolvimentos recentes e insights chave
+ backstory: >
+ Você é um especialista em pesquisa experiente com talento para
+ encontrar informações relevantes de diversas fontes. Você se destaca em
+ organizar informações de forma clara e estruturada, tornando temas complexos acessíveis para outros.
+ llm: provider/model-id # ex: openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
+
+analyst:
+ role: >
+ Analista de Dados e Redator de Relatórios para {topic}
+ goal: >
+ Analisar os resultados da pesquisa e criar um relatório abrangente e bem estruturado
+ que apresente os insights de forma clara e envolvente
+ backstory: >
+ Você é um analista habilidoso com experiência em interpretação de dados
+ e redação técnica. Tem talento para identificar padrões
+ e extrair insights relevantes dos dados de pesquisa, comunicando esses insights de forma eficaz por meio de relatórios bem elaborados.
+ llm: provider/model-id # ex: openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
+```
+
+Perceba como cada agente tem um papel, objetivo e histórico distintos. Esses elementos não são apenas descritivos – eles efetivamente moldam como o agente aborda suas tarefas. Ao criar cuidadosamente esses detalhes, você pode ter agentes com habilidades e perspectivas que se complementam.
+
+## Passo 4: Defina suas Tarefas
+
+Com nossos agentes definidos, agora precisamos atribuir tarefas específicas para eles realizarem. Tarefas na CrewAI representam o trabalho concreto que os agentes irão executar, com instruções detalhadas e saídas esperadas.
+
+Para nossa crew de pesquisa, vamos definir duas tarefas principais:
+1. Uma **tarefa de pesquisa** para coletar informações abrangentes
+2. Uma **tarefa de análise** para criar um relatório com insights
+
+Vamos modificar o arquivo `tasks.yaml`:
+
+```yaml
+# src/research_crew/config/tasks.yaml
+research_task:
+ description: >
+ Realize uma pesquisa aprofundada sobre {topic}. Foque em:
+ 1. Conceitos e definições chave
+ 2. Desenvolvimento histórico e tendências recentes
+ 3. Principais desafios e oportunidades
+ 4. Aplicações relevantes ou estudos de caso
+ 5. Perspectivas futuras e novos desenvolvimentos
+
+ Certifique-se de organizar seus achados em um formato estruturado, com seções claras.
+ expected_output: >
+ Um documento de pesquisa abrangente com seções bem organizadas cobrindo
+ todos os aspectos solicitados de {topic}. Inclua fatos, números
+ e exemplos específicos sempre que possível.
+ agent: researcher
+
+analysis_task:
+ description: >
+ Analise os resultados da pesquisa e crie um relatório abrangente sobre {topic}.
+ Seu relatório deve:
+ 1. Iniciar com um resumo executivo
+ 2. Incluir todas as informações relevantes da pesquisa
+ 3. Oferecer uma análise perspicaz de tendências e padrões
+ 4. Apresentar recomendações ou considerações futuras
+ 5. Estar formatado de forma profissional, clara e com títulos bem definidos
+ expected_output: >
+ Um relatório profissional, polido e estruturado sobre {topic} com apresentação dos resultados da pesquisa,
+ acrescentando análise e insights. O relatório deve ser bem estruturado,
+ incluindo resumo executivo, sessões principais e conclusão.
+ agent: analyst
+ context:
+ - research_task
+ output_file: output/report.md
+```
+
+Note o campo `context` na tarefa de análise – esse é um recurso poderoso que permite ao analista acessar a saída da tarefa de pesquisa. Isso cria um fluxo de trabalho em que a informação circula naturalmente entre os agentes, como aconteceria em uma equipe humana.
+
+## Passo 5: Configure sua Crew
+
+Agora é hora de juntar tudo configurando nossa crew. A crew é o container que orquestra como os agentes trabalham juntos para completar as tarefas.
+
+Vamos modificar o arquivo `crew.py`:
+
+```python
+# src/research_crew/crew.py
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai_tools import SerperDevTool
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
+
+@CrewBase
+class ResearchCrew():
+ """Research crew for comprehensive topic analysis and reporting"""
+
+ agents: List[BaseAgent]
+ tasks: List[Task]
+
+ @agent
+ def researcher(self) -> Agent:
+ return Agent(
+ config=self.agents_config['researcher'], # type: ignore[index]
+ verbose=True,
+ tools=[SerperDevTool()]
+ )
+
+ @agent
+ def analyst(self) -> Agent:
+ return Agent(
+ config=self.agents_config['analyst'], # type: ignore[index]
+ verbose=True
+ )
+
+ @task
+ def research_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['research_task'] # type: ignore[index]
+ )
+
+ @task
+ def analysis_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['analysis_task'], # type: ignore[index]
+ output_file='output/report.md'
+ )
+
+ @crew
+ def crew(self) -> Crew:
+ """Creates the research crew"""
+ return Crew(
+ agents=self.agents,
+ tasks=self.tasks,
+ process=Process.sequential,
+ verbose=True,
+ )
+```
+
+Neste código, estamos:
+1. Criando o agente pesquisador e equipando-o com o SerperDevTool para buscas web
+2. Criando o agente analista
+3. Definindo as tarefas de pesquisa e análise
+4. Configurando a crew para executar as tarefas sequencialmente (o analista espera o pesquisador terminar)
+
+É aqui que a mágica acontece – com poucas linhas de código, definimos um sistema colaborativo de IA onde agentes especializados trabalham juntos em um processo coordenado.
+
+## Passo 6: Prepare seu Script Principal
+
+Agora, vamos preparar o script principal que irá rodar nossa crew. É aqui que informamos o tema específico que queremos pesquisar.
+
+```python
+#!/usr/bin/env python
+# src/research_crew/main.py
+import os
+from research_crew.crew import ResearchCrew
+
+# Crie o diretório de saída se não existir
+os.makedirs('output', exist_ok=True)
+
+def run():
+ """
+ Rodar a crew de pesquisa.
+ """
+ inputs = {
+ 'topic': 'Inteligência Artificial na Saúde'
+ }
+
+ # Criar e rodar a crew
+ result = ResearchCrew().crew().kickoff(inputs=inputs)
+
+ # Imprimir o resultado
+ print("\n\n=== RELATÓRIO FINAL ===\n\n")
+ print(result.raw)
+
+ print("\n\nRelatório salvo em output/report.md")
+
+if __name__ == "__main__":
+ run()
+```
+
+Este script prepara o ambiente, define o tema de pesquisa e inicia o trabalho da crew. O poder da CrewAI fica evidente em como esse código é simples – toda a complexidade do gerenciamento de múltiplos agentes de IA é tratada pelo framework.
+
+## Passo 7: Defina suas Variáveis de Ambiente
+
+Crie um arquivo `.env` na raiz do seu projeto com suas chaves de API:
+
+```sh
+SERPER_API_KEY=sua_serper_api_key
+# Adicione a chave de API do seu provedor também.
+```
+
+Confira o [guia de configuração do LLM](/pt-BR/concepts/llms#setting-up-your-llm) para detalhes sobre como configurar o provedor de sua escolha. Você pode obter a chave da Serper em [Serper.dev](https://serper.dev/).
+
+## Passo 8: Instale as Dependências
+
+Instale as dependências necessárias usando a CLI da CrewAI:
+
+```bash
+crewai install
+```
+
+Este comando irá:
+1. Ler as dependências da configuração do seu projeto
+2. Criar um ambiente virtual se necessário
+3. Instalar todos os pacotes necessários
+
+## Passo 9: Execute sua Crew
+
+Agora chega o momento empolgante – é hora de rodar sua crew e assistir à colaboração de IA em ação!
+
+```bash
+crewai run
+```
+
+Ao rodar esse comando, você verá sua crew ganhando vida. O pesquisador irá coletar informações sobre o tema especificado, e o analista irá criar um relatório abrangente baseado nessa pesquisa. Você poderá acompanhar em tempo real o raciocínio, as ações e os resultados dos agentes à medida que colaboram para concluir as tarefas.
+
+## Passo 10: Revise o Resultado
+
+Após a conclusão do trabalho da crew, você encontrará o relatório final em `output/report.md`. O relatório incluirá:
+
+1. Um resumo executivo
+2. Informações detalhadas sobre o tema
+3. Análises e insights
+4. Recomendações ou considerações futuras
+
+Tire um momento para valorizar o que você realizou – você criou um sistema no qual múltiplos agentes de IA colaboraram em uma tarefa complexa, cada um contribuindo com suas habilidades especializadas para gerar um resultado maior do que qualquer agente conseguiria sozinho.
+
+## Explorando Outros Comandos da CLI
+
+A CrewAI oferece vários outros comandos úteis de CLI para trabalhar com crews:
+
+```bash
+# Ver todos os comandos disponíveis
+crewai --help
+
+# Rodar a crew
+crewai run
+
+# Testar a crew
+crewai test
+
+# Resetar as memórias da crew
+crewai reset-memories
+
+# Repetir a partir de uma tarefa específica
+crewai replay -t
+
+
+## Passo 2: Entendendo a Estrutura do Projeto
+
+O projeto gerado possui a seguinte estrutura. Reserve um momento para conhecê-la, pois isso ajudará você a criar flows mais complexos no futuro.
+
+```
+guide_creator_flow/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+├── .env
+├── main.py
+├── crews/
+│ └── poem_crew/
+│ ├── config/
+│ │ ├── agents.yaml
+│ │ └── tasks.yaml
+│ └── poem_crew.py
+└── tools/
+ └── custom_tool.py
+```
+
+Esta estrutura oferece uma separação clara entre os diferentes componentes do seu flow:
+- A lógica principal do flow no arquivo `main.py`
+- Crews especializados no diretório `crews`
+- Ferramentas customizadas no diretório `tools`
+
+Vamos modificar esta estrutura para criar nosso flow de criação de guias, que irá orquestrar o processo de geração de guias de aprendizagem abrangentes.
+
+## Passo 3: Adicione um Crew de Redator de Conteúdo
+
+Nosso flow precisará de um crew especializado para lidar com o processo de criação de conteúdo. Vamos usar a CLI do CrewAI para adicionar um crew de redatores de conteúdo:
+
+```bash
+crewai flow add-crew content-crew
+```
+
+Este comando cria automaticamente os diretórios e arquivos de template necessários para seu crew. O crew de redatores será responsável por escrever e revisar seções do nosso guia, trabalhando dentro do flow orquestrado pela aplicação principal.
+
+## Passo 4: Configure o Crew de Redator de Conteúdo
+
+Agora, vamos modificar os arquivos gerados para o crew de redatores. Vamos configurar dois agentes especializados – um escritor e um revisor – que irão colaborar para criar um conteúdo de alta qualidade para o nosso guia.
+
+1. Primeiro, atualize o arquivo de configuração de agents para definir a equipe de criação de conteúdo:
+
+ Lembre-se de configurar o `llm` com o provedor que está utilizando.
+
+```yaml
+# src/guide_creator_flow/crews/content_crew/config/agents.yaml
+content_writer:
+ role: >
+ Redator de Conteúdo Educacional
+ goal: >
+ Criar conteúdo envolvente e informativo que explique completamente o tema proposto
+ e forneça insights valiosos ao leitor
+ backstory: >
+ Você é um talentoso escritor educacional com experiência em criar conteúdo claro
+ e atraente. Você tem facilidade para explicar conceitos complexos em linguagem acessível
+ e organizar as informações de forma a ajudar o leitor a construir seu entendimento.
+ llm: provider/model-id # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
+
+content_reviewer:
+ role: >
+ Revisor(a) e Editor(a) de Conteúdo Educacional
+ goal: >
+ Garantir que o conteúdo seja preciso, abrangente, bem estruturado e mantenha
+ consistência com as seções previamente escritas
+ backstory: >
+ Você é um editor(a) meticuloso(a) com anos de experiência revisando conteúdo educacional.
+ Tem atenção aos detalhes, clareza e coesão. Você se destaca em aprimorar conteúdo
+ mantendo o estilo do autor original e garantindo qualidade consistente em várias seções.
+ llm: provider/model-id # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
+```
+
+Essas definições de agents estabelecem papéis e perspectivas especializadas que irão moldar como nossos agentes de IA abordam a criação de conteúdo. Note como cada agent possui um propósito e expertise distintos.
+
+2. Em seguida, atualize o arquivo de configuração de tarefas para definir as tarefas específicas de escrita e revisão:
+
+```yaml
+# src/guide_creator_flow/crews/content_crew/config/tasks.yaml
+write_section_task:
+ description: >
+ Escreva uma seção abrangente sobre o tema: "{section_title}"
+
+ Descrição da seção: {section_description}
+ Público-alvo: {audience_level} aprendizes
+
+ Seu conteúdo deve:
+ 1. Começar com uma breve introdução ao tema da seção
+ 2. Explicar claramente todos os conceitos principais com exemplos
+ 3. Incluir aplicações práticas ou exercícios onde apropriado
+ 4. Terminar com um resumo dos pontos principais
+ 5. Ter aproximadamente 500-800 palavras
+
+ Formate seu conteúdo em Markdown com títulos, listas e ênfase apropriados.
+
+ Seções previamente escritas:
+ {previous_sections}
+
+ Certifique-se de que seu conteúdo mantenha consistência com as seções já escritas
+ e amplie os conceitos que já foram explicados.
+ expected_output: >
+ Uma seção bem estruturada e abrangente em formato Markdown que explique
+ totalmente o tema e é apropriada para o público-alvo.
+ agent: content_writer
+
+review_section_task:
+ description: >
+ Revise e melhore a seguinte seção sobre "{section_title}":
+
+ {draft_content}
+
+ Público-alvo: {audience_level} aprendizes
+
+ Seções previamente escritas:
+ {previous_sections}
+
+ Sua revisão deve:
+ 1. Corrigir qualquer erro gramatical ou de ortografia
+ 2. Melhorar clareza e legibilidade
+ 3. Garantir que o conteúdo seja abrangente e preciso
+ 4. Verificar a consistência com as seções já escritas
+ 5. Aprimorar a estrutura e o fluxo
+ 6. Adicionar qualquer informação-chave ausente
+
+ Forneça a versão aprimorada da seção em formato Markdown.
+ expected_output: >
+ Uma versão melhorada e refinada da seção, mantendo a estrutura original,
+ mas aprimorando clareza, precisão e consistência.
+ agent: content_reviewer
+ context:
+ - write_section_task
+```
+
+Essas definições de tarefas fornecem instruções detalhadas para nossos agents, garantindo que eles produzam conteúdo que atenda aos padrões de qualidade. Observe como o parâmetro `context` na tarefa de revisão cria um fluxo onde o revisor tem acesso à produção do redator.
+
+3. Agora, atualize o arquivo de implementação do crew para definir como nossos agents e tasks trabalham juntos:
+
+```python
+# src/guide_creator_flow/crews/content_crew/content_crew.py
+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
+class ContentCrew():
+ """Crew de redação de conteúdo"""
+
+ agents: List[BaseAgent]
+ tasks: List[Task]
+
+ @agent
+ def content_writer(self) -> Agent:
+ return Agent(
+ config=self.agents_config['content_writer'], # type: ignore[index]
+ verbose=True
+ )
+
+ @agent
+ def content_reviewer(self) -> Agent:
+ return Agent(
+ config=self.agents_config['content_reviewer'], # type: ignore[index]
+ verbose=True
+ )
+
+ @task
+ def write_section_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['write_section_task'] # type: ignore[index]
+ )
+
+ @task
+ def review_section_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['review_section_task'], # type: ignore[index]
+ context=[self.write_section_task()]
+ )
+
+ @crew
+ def crew(self) -> Crew:
+ """Cria o crew de redação de conteúdo"""
+ return Crew(
+ agents=self.agents,
+ tasks=self.tasks,
+ process=Process.sequential,
+ verbose=True,
+ )
+```
+
+Essa definição de crew estabelece o relacionamento entre nossos agents e tasks, definindo um processo sequencial onde o redator cria o rascunho e o revisor o aprimora. Embora este crew possa funcionar de forma independente, em nosso flow ele será orquestrado como parte de um sistema maior.
+
+## Passo 5: Crie o Flow
+
+Agora vem a parte emocionante – criar o flow que irá orquestrar todo o processo de criação do guia. Aqui iremos combinar código Python regular, chamadas diretas a LLM e nosso crew de criação de conteúdo em um sistema coeso.
+
+Nosso flow irá:
+1. Obter a entrada do usuário sobre o tema e nível do público
+2. Fazer uma chamada direta à LLM para criar um roteiro estruturado do guia
+3. Processar cada seção sequencialmente usando o crew de redatores
+4. Combinar tudo em um documento final abrangente
+
+Vamos criar nosso flow no arquivo `main.py`:
+
+```python
+# [CÓDIGO NÃO TRADUZIDO, MANTER COMO ESTÁ]
+```
+
+Vamos analisar o que está acontecendo neste flow:
+
+1. Definimos modelos Pydantic para dados estruturados, garantindo segurança de tipos e representação clara dos dados.
+2. Criamos uma classe de estado para manter dados entre os diferentes passos do flow.
+3. Implementamos três etapas principais para o flow:
+ - Obtenção da entrada do usuário com o decorator `@start()`
+ - Criação do roteiro do guia com uma chamada direta à LLM
+ - Processamento das seções com nosso crew de conteúdo
+4. Usamos o decorator `@listen()` para estabelecer relações orientadas a eventos entre as etapas
+
+Este é o poder dos flows – combinar diferentes tipos de processamento (interação com usuário, chamadas diretas a IA, tarefas colaborativas com crews) em um sistema orientado a eventos e coeso.
+
+## Passo 6: Configure suas Variáveis de Ambiente
+
+Crie um arquivo `.env` na raiz do projeto com suas chaves de API. Veja o [guia de configuração do LLM](/pt-BR/concepts/llms#setting-up-your-llm) para detalhes sobre como configurar o provedor.
+
+```sh .env
+OPENAI_API_KEY=sua_chave_openai
+# ou
+GEMINI_API_KEY=sua_chave_gemini
+# ou
+ANTHROPIC_API_KEY=sua_chave_anthropic
+```
+
+## Passo 7: Instale as Dependências
+
+Instale as dependências necessárias:
+
+```bash
+crewai install
+```
+
+## Passo 8: Execute Seu Flow
+
+Agora é hora de ver seu flow em ação! Execute-o usando a CLI do CrewAI:
+
+```bash
+crewai flow kickoff
+```
+
+Quando você rodar esse comando, verá seu flow ganhando vida:
+1. Ele solicitará um tema e o nível do público para você
+2. Criará um roteiro estruturado para o seu guia
+3. Processará cada seção, com o redator e o revisor colaborando em cada uma
+4. Por fim, irá compilar tudo em um guia abrangente
+
+Isso demonstra o poder dos flows para orquestrar processos complexos envolvendo múltiplos componentes, tanto de IA quanto não-IA.
+
+## Passo 9: Visualize Seu Flow
+
+Uma das funcionalidades mais poderosas dos flows é a possibilidade de visualizar sua estrutura:
+
+```bash
+crewai flow plot
+```
+
+Isso irá criar um arquivo HTML que mostra a estrutura do seu flow, incluindo os relacionamentos entre etapas e o fluxo de dados. Essa visualização pode ser inestimável para entender e depurar flows complexos.
+
+## Passo 10: Revise o Resultado
+
+Depois que o flow finalizar, você encontrará dois arquivos no diretório `output`:
+
+1. `guide_outline.json`: Contém o roteiro estruturado do guia
+2. `complete_guide.md`: O guia abrangente com todas as seções
+
+Reserve um momento para revisar esses arquivos e apreciar o que você construiu – um sistema que combina entrada do usuário, interações diretas com IA e trabalho colaborativo de agents para produzir um output complexo e de alta qualidade.
+
+## A Arte do Possível: Além do Seu Primeiro Flow
+
+O que você aprendeu neste guia é uma base para criar sistemas de IA muito mais sofisticados. Veja algumas formas de expandir este flow básico:
+
+### Aprimorando a Interação com o Usuário
+
+Você pode criar flows mais interativos com:
+- Interfaces web para entrada e saída de dados
+- Atualizações em tempo real de progresso
+- Loops de feedback e refinamento interativos
+- Interações multi-stage com o usuário
+
+### Adicionando Mais Etapas de Processamento
+
+Você pode expandir seu flow com etapas adicionais para:
+- Pesquisa antes da criação do roteiro
+- Geração de imagens para ilustrações
+- Geração de snippets de código para guias técnicos
+- Garantia de qualidade e checagem final de fatos
+
+### Criando Flows Mais Complexos
+
+Você pode implementar padrões de flow mais sofisticados:
+- Ramificações condicionais com base na preferência do usuário ou tipo de conteúdo
+- Processamento paralelo de seções independentes
+- Loops de refinamento iterativo com feedback
+- Integração a APIs e serviços externos
+
+### Aplicando a Diferentes Domínios
+
+Os mesmos padrões podem ser usados para criar flows de:
+- **Narrativas interativas**: criação de histórias personalizadas com base na entrada do usuário
+- **Inteligência de negócios**: processamento de dados, geração de insights e criação de relatórios
+- **Desenvolvimento de produtos**: facilitação de ideação, design e planejamento
+- **Sistemas educacionais**: criação de experiências de aprendizagem personalizadas
+
+## Principais Funcionalidades Demonstradas
+
+Este flow de criação de guia demonstra diversos recursos poderosos do CrewAI:
+
+1. **Interação com o usuário**: O flow coleta input diretamente do usuário
+2. **Chamadas diretas à LLM**: Usa a classe LLM para interações eficientes e direcionadas com IA
+3. **Dados estruturados com Pydantic**: Usa Pydantic para garantir segurança de tipos
+4. **Processamento sequencial com contexto**: Escreve seções em ordem, fornecendo as anteriores como contexto
+5. **Crews multiagentes**: Utiliza agents especializados (redator e revisor) para criação de conteúdo
+6. **Gerenciamento de estado**: Mantém estado entre diferentes etapas do processo
+7. **Arquitetura orientada a eventos**: Usa o decorator `@listen` para responder a eventos
+
+## Entendendo a Estrutura do Flow
+
+Vamos decompor os principais componentes dos flows para ajudá-lo a entender como construir o seu:
+
+### 1. Chamadas Diretas à LLM
+
+Flows permitem que você faça chamadas diretas a modelos de linguagem quando precisa de respostas simples e estruturadas:
+
+```python
+llm = LLM(
+ model="model-id-here", # gpt-4o, gemini-2.0-flash, anthropic/claude...
+ response_format=GuideOutline
+)
+response = llm.call(messages=messages)
+```
+
+Isso é mais eficiente do que usar um crew quando você precisa de um output específico e estruturado.
+
+### 2. Arquitetura Orientada a Eventos
+
+Flows usam decorators para estabelecer relações entre componentes:
+
+```python
+@start()
+def get_user_input(self):
+ # Primeira etapa no flow
+ # ...
+
+@listen(get_user_input)
+def create_guide_outline(self, state):
+ # Esta roda quando get_user_input é concluída
+ # ...
+```
+
+Isso cria uma estrutura clara e declarativa para sua aplicação.
+
+### 3. Gerenciamento de Estado
+
+Flows mantêm o estado entre as etapas, facilitando o compartilhamento de dados:
+
+```python
+class GuideCreatorState(BaseModel):
+ topic: str = ""
+ audience_level: str = ""
+ guide_outline: GuideOutline = None
+ sections_content: Dict[str, str] = {}
+```
+
+Isso fornece uma maneira segura e tipada de rastrear e transformar dados ao longo do flow.
+
+### 4. Integração com Crews
+
+Flows podem integrar crews para tarefas colaborativas complexas:
+
+```python
+result = ContentCrew().crew().kickoff(inputs={
+ "section_title": section.title,
+ # ...
+})
+```
+
+Assim, você usa a ferramenta certa para cada parte da aplicação – chamadas diretas para tarefas simples e crews para colaboração avançada.
+
+## Próximos Passos
+
+Agora que você construiu seu primeiro flow, pode:
+
+1. Experimentar estruturas e padrões mais complexos de flow
+2. Testar o uso do `@router()` para criar ramificações condicionais em seus flows
+3. Explorar as funções `and_` e `or_` para execuções paralelas e mais complexas
+4. Conectar seu flow a APIs externas, bancos de dados ou interfaces de usuário
+5. Combinar múltiplos crews especializados em um único flow
+
+
+
+
+| Componente | Descrição | Principais Funcionalidades |
+|:-----------|:-----------:|:-------------------------|
+| **Crew** | Organização de mais alto nível | • Gerencia equipes de agentes de IA
+
+
+| Componente | Descrição | Principais Funcionalidades |
+|:-----------|:-----------:|:-------------------------|
+| **Flow** | Orquestração de fluxo de trabalho estruturada | • Gerencia caminhos de execução
+
+
+## Boas Práticas
+
+1. **Seja específico nos prompts de geração de imagem** para obter melhores resultados.
+2. **Considere o tempo de geração** - A geração de imagens pode levar algum tempo, então inclua isso no seu planejamento de tarefas.
+3. **Siga as políticas de uso** - Sempre cumpra as políticas de uso da OpenAI ao gerar imagens.
+
+## Solução de Problemas
+
+1. **Verifique o acesso à API** - Certifique-se de que sua chave de API OpenAI possui acesso ao DALL-E.
+2. **Compatibilidade de versões** - Verifique se você está utilizando a versão mais recente do crewAI e crewai-tools.
+3. **Configuração da ferramenta** - Confirme que a ferramenta DALL-E foi corretamente adicionada à lista de ferramentas do agente.
\ No newline at end of file
diff --git a/docs/pt-BR/learn/force-tool-output-as-result.mdx b/docs/pt-BR/learn/force-tool-output-as-result.mdx
new file mode 100644
index 000000000..56d236381
--- /dev/null
+++ b/docs/pt-BR/learn/force-tool-output-as-result.mdx
@@ -0,0 +1,50 @@
+---
+title: Forçar a Saída da Ferramenta como Resultado
+description: Aprenda como forçar a saída de uma ferramenta como resultado em uma tarefa de Agent no CrewAI.
+icon: wrench-simple
+---
+
+## Introdução
+
+No CrewAI, você pode forçar a saída de uma ferramenta como o resultado de uma tarefa de um agent.
+Esse recurso é útil quando você deseja garantir que a saída da ferramenta seja capturada e retornada como resultado da tarefa, evitando quaisquer modificações pelo agent durante a execução da tarefa.
+
+## Forçando a Saída da Ferramenta como Resultado
+
+Para forçar a saída da ferramenta como resultado da tarefa de um agent, você precisa definir o parâmetro `result_as_answer` como `True` ao adicionar uma ferramenta ao agent.
+Esse parâmetro garante que a saída da ferramenta seja capturada e retornada como resultado da tarefa, sem qualquer modificação pelo agent.
+
+Veja um exemplo de como forçar a saída da ferramenta como resultado da tarefa de um agent:
+
+```python Code
+from crewai.agent import Agent
+from my_tool import MyCustomTool
+
+# Create a coding agent with the custom tool
+coding_agent = Agent(
+ role="Data Scientist",
+ goal="Produce amazing reports on AI",
+ backstory="You work with data and AI",
+ tools=[MyCustomTool(result_as_answer=True)],
+ )
+
+# Assuming the tool's execution and result population occurs within the system
+task_result = coding_agent.execute_task(task)
+```
+
+## Fluxo de Trabalho em Ação
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Funcionalidades
+
+- **Painel Analítico**: Monitore a saúde e desempenho dos seus Agentes com dashboards detalhados que acompanham métricas, custos e interações dos usuários.
+- **SDK de Observabilidade Nativo OpenTelemetry**: SDKs neutros de fornecedor para enviar rastreamentos e métricas para suas ferramentas de observabilidade existentes como Grafana, DataDog e outros.
+- **Rastreamento de Custos para Modelos Customizados e Ajustados**: Adapte estimativas de custo para modelos específicos usando arquivos de precificação customizados para orçamentos precisos.
+- **Painel de Monitoramento de Exceções**: Identifique e solucione rapidamente problemas ao rastrear exceções comuns e erros por meio de um painel de monitoramento.
+- **Conformidade e Segurança**: Detecte ameaças potenciais como profanidade e vazamento de dados sensíveis (PII).
+- **Detecção de Prompt Injection**: Identifique possíveis injeções de código e vazamentos de segredos.
+- **Gerenciamento de Chaves de API e Segredos**: Gerencie suas chaves de API e segredos do LLM de forma centralizada e segura, evitando práticas inseguras.
+- **Gerenciamento de Prompt**: Gerencie e versiona prompts de Agente usando o PromptHub para acesso consistente e fácil entre os agentes.
+- **Model Playground** Teste e compare diferentes modelos para seus agentes CrewAI antes da implantação.
+
+## Instruções de Configuração
+
+
+
+
+
+
+
+
+O Opik oferece suporte abrangente para cada etapa do desenvolvimento da sua aplicação CrewAI:
+
+- **Registrar Traces e Spans**: Acompanhe automaticamente chamadas LLM e lógica da aplicação para depurar e analisar sistemas em desenvolvimento e em produção. Anote manualmente ou programaticamente, visualize e compare respostas entre projetos.
+- **Avalie a Performance da sua Aplicação LLM**: Avalie contra um conjunto de testes personalizado e execute métricas de avaliação nativas ou defina suas próprias métricas via SDK ou UI.
+- **Teste no Pipeline CI/CD**: Estabeleça bases de performance confiáveis com os testes unitários LLM do Opik, baseados em PyTest. Execute avaliações online para monitoramento contínuo em produção.
+- **Monitore & Analise Dados de Produção**: Entenda a performance dos seus modelos em dados inéditos em produção e gere conjuntos de dados para novas iterações de desenvolvimento.
+
+## Configuração
+A Comet oferece uma versão hospedada da plataforma Opik, ou você pode rodar a plataforma localmente.
+
+Para usar a versão hospedada, basta [criar uma conta gratuita na Comet](https://www.comet.com/signup?utm_medium=github&utm_source=crewai_docs) e obter sua chave de API.
+
+Para rodar a plataforma Opik localmente, veja nosso [guia de instalação](https://www.comet.com/docs/opik/self-host/overview/) para mais informações.
+
+Neste guia, utilizaremos o exemplo de início rápido da CrewAI.
+
+
+
+
+
+## Introdução
+
+Portkey aprimora o CrewAI com recursos prontos para produção, transformando seus crews de agentes experimentais em sistemas robustos ao fornecer:
+
+- **Observabilidade completa** de cada etapa do agente, uso de ferramentas e interações
+- **Confiabilidade incorporada** com fallbacks, tentativas automáticas e balanceamento de carga
+- **Rastreamento e otimização de custos** para gerenciar seus gastos com IA
+- **Acesso a mais de 200 LLMs** por meio de uma única integração
+- **Guardrails** para manter o comportamento dos agentes seguro e em conformidade
+- **Prompts versionados** para desempenho consistente dos agentes
+
+
+### Instalação & Configuração
+
+
+
+
+Os traces fornecem uma visão hierárquica da execução do seu crew, mostrando a sequência de chamadas LLM, ativações de ferramentas e transições de estado.
+
+```python
+# Adicione trace_id para habilitar o tracing hierárquico no Portkey
+portkey_llm = LLM(
+ model="gpt-4o",
+ base_url=PORTKEY_GATEWAY_URL,
+ api_key="dummy",
+ extra_headers=createHeaders(
+ api_key="YOUR_PORTKEY_API_KEY",
+ virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
+ trace_id="unique-session-id" # Adicione um trace ID único
+ )
+)
+```
+
+
+
+Portkey registra cada interação com LLMs, incluindo:
+
+- Payloads completos das requisições e respostas
+- Métricas de latência e uso de tokens
+- Cálculos de custo
+- Chamadas de ferramentas e execuções de funções
+
+Todos os logs podem ser filtrados por metadados, trace IDs, modelos e mais, tornando mais fácil depurar execuções específicas do crew.
+
+
+
+Portkey oferece dashboards integrados que ajudam você a:
+
+- Rastrear custos e uso de tokens em todas as execuções do crew
+- Analisar métricas de desempenho, como latência e taxas de sucesso
+- Identificar gargalos nos fluxos de trabalho dos agentes
+- Comparar diferentes configurações de crew e LLMs
+
+Você pode filtrar e segmentar todas as métricas por metadados personalizados para analisar tipos de crew, grupos de usuários ou casos de uso específicos.
+
+
+
+Adicione metadados personalizados à configuração LLM do seu CrewAI para permitir filtragem e segmentação poderosas:
+
+```python
+portkey_llm = LLM(
+ model="gpt-4o",
+ base_url=PORTKEY_GATEWAY_URL,
+ api_key="dummy",
+ extra_headers=createHeaders(
+ api_key="YOUR_PORTKEY_API_KEY",
+ virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
+ metadata={
+ "crew_type": "research_crew",
+ "environment": "production",
+ "_user": "user_123", # Campo especial _user para analytics de usuários
+ "request_source": "mobile_app"
+ }
+ )
+)
+```
+
+Esses metadados podem ser usados para filtrar logs, traces e métricas no painel do Portkey, permitindo analisar execuções específicas do crew, usuários ou ambientes.
+
+
+
+Isso permite:
+- Rastreamento de custos e orçamento por usuário
+- Analytics personalizados por usuário
+- Métricas por equipe ou organização
+- Monitoramento específico por ambiente (homologação x produção)
+
+
+
+
+
+
+
+
+
+
+
+
+ Documentação oficial do CrewAI
+Receba orientação personalizada sobre como implementar essa integração
+
+
+