Add pt-BR docs translation (#3039)

* docs: add pt-br translations

Powered by a CrewAI Flow https://github.com/danielfsbarreto/docs_translator

* Update mcp/overview.mdx brazilian docs

Its en-US counterpart was updated after I did a pass,
so now it includes the new section about @CrewBase

docs/pt-BR/tools/ai-ml/aimindtool.mdx

@@ -0,0 +1,118 @@
+---
+title: AI Mind Tool
+description: O `AIMindTool` foi desenvolvido para consultar fontes de dados em linguagem natural.
+icon: brain
+---
+
+# `AIMindTool`
+
+## Descrição
+
+O `AIMindTool` é um wrapper em torno do [AI-Minds](https://mindsdb.com/minds) fornecido pela [MindsDB](https://mindsdb.com/). Ele permite que você consulte fontes de dados em linguagem natural, bastando configurar os parâmetros de conexão. Essa ferramenta é útil quando você precisa de respostas para perguntas utilizando dados armazenados em diversas fontes, incluindo PostgreSQL, MySQL, MariaDB, ClickHouse, Snowflake e Google BigQuery.
+
+Minds são sistemas de IA que funcionam de forma similar aos grandes modelos de linguagem (LLMs), mas vão além ao responder qualquer pergunta sobre qualquer dado. Isso é realizado por meio de:
+- Seleção dos dados mais relevantes para a resposta utilizando busca paramétrica
+- Compreensão do significado e fornecimento de respostas dentro do contexto correto através de busca semântica
+- Entrega de respostas precisas ao analisar dados e utilizar modelos de machine learning (ML)
+
+## Instalação
+
+Para incorporar esta ferramenta ao seu projeto, é necessário instalar o Minds SDK:
+
+```shell
+uv add minds-sdk
+```
+
+## Passos para Começar
+
+Para utilizar o `AIMindTool` de maneira eficaz, siga estes passos:
+
+1. **Instalação de Pacotes**: Verifique se os pacotes `crewai[tools]` e `minds-sdk` estão instalados no seu ambiente Python.
+2. **Obtenção da Chave de API**: Cadastre-se para uma conta Minds [aqui](https://mdb.ai/register) e obtenha uma chave de API.
+3. **Configuração do Ambiente**: Armazene sua chave de API obtida em uma variável de ambiente chamada `MINDS_API_KEY` para facilitar seu uso pela ferramenta.
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma consulta:
+
+```python Code
+from crewai_tools import AIMindTool
+
+# Initialize the AIMindTool
+aimind_tool = AIMindTool(
+    datasources=[
+        {
+            "description": "house sales data",
+            "engine": "postgres",
+            "connection_data": {
+                "user": "demo_user",
+                "password": "demo_password",
+                "host": "samples.mindsdb.com",
+                "port": 5432,
+                "database": "demo",
+                "schema": "demo_data"
+            },
+            "tables": ["house_sales"]
+        }
+    ]
+)
+
+# Run a natural language query
+result = aimind_tool.run("How many 3 bedroom houses were sold in 2008?")
+print(result)
+```
+
+## Parâmetros
+
+O `AIMindTool` aceita os seguintes parâmetros:
+
+- **api_key**: Opcional. Sua chave de API da Minds. Se não for fornecida, será lida da variável de ambiente `MINDS_API_KEY`.
+- **datasources**: Uma lista de dicionários, cada um contendo as seguintes chaves:
+  - **description**: Uma descrição dos dados contidos na fonte de dados.
+  - **engine**: O engine (ou tipo) da fonte de dados.
+  - **connection_data**: Um dicionário contendo os parâmetros de conexão da fonte de dados.
+  - **tables**: Uma lista de tabelas que a fonte de dados irá utilizar. Isso é opcional e pode ser omitido caso todas as tabelas da fonte de dados devam ser utilizadas.
+
+Uma lista das fontes de dados suportadas e seus parâmetros de conexão pode ser encontrada [aqui](https://docs.mdb.ai/docs/data_sources).
+
+## Exemplo de Integração com Agente
+
+Veja como integrar o `AIMindTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent
+from crewai.project import agent
+from crewai_tools import AIMindTool
+
+# Initialize the tool
+aimind_tool = AIMindTool(
+    datasources=[
+        {
+            "description": "sales data",
+            "engine": "postgres",
+            "connection_data": {
+                "user": "your_user",
+                "password": "your_password",
+                "host": "your_host",
+                "port": 5432,
+                "database": "your_db",
+                "schema": "your_schema"
+            },
+            "tables": ["sales"]
+        }
+    ]
+)
+
+# Define an agent with the AIMindTool
+@agent
+def data_analyst(self) -> Agent:
+    return Agent(
+        config=self.agents_config["data_analyst"],
+        allow_delegation=False,
+        tools=[aimind_tool]
+    )
+```
+
+## Conclusão
+
+O `AIMindTool` oferece uma forma poderosa de consultar suas fontes de dados utilizando linguagem natural, facilitando a extração de insights sem a necessidade de escrever consultas SQL complexas. Ao conectar diversas fontes de dados e aproveitar a tecnologia AI-Minds, essa ferramenta permite que agentes acessem e analisem dados de maneira eficiente.

docs/pt-BR/tools/ai-ml/codeinterpretertool.mdx

@@ -0,0 +1,209 @@
+---
+title: Interpretador de Código
+description: O `CodeInterpreterTool` é uma poderosa ferramenta projetada para executar código Python 3 em um ambiente seguro e isolado.
+icon: code-simple
+---
+
+# `CodeInterpreterTool`
+
+## Descrição
+
+O `CodeInterpreterTool` permite que agentes CrewAI executem códigos Python 3 gerados autonomamente. Essa funcionalidade é particularmente valiosa, pois permite que os agentes criem códigos, os executem, obtenham os resultados e usem essas informações para orientar decisões e ações subsequentes.
+
+Há diversas formas de usar esta ferramenta:
+
+### Container Docker (Recomendado)
+
+Esta é a opção principal. O código é executado em um container Docker seguro e isolado, garantindo a segurança independentemente de seu conteúdo.
+Certifique-se de que o Docker esteja instalado e em funcionamento em seu sistema. Se ainda não tiver, você pode instalá-lo a partir [deste link](https://docs.docker.com/get-docker/).
+
+### Ambiente Sandbox
+
+Se o Docker não estiver disponível — seja por não estar instalado ou inacessível por qualquer motivo — o código será executado em um ambiente Python restrito, chamado de sandbox.
+Esse ambiente é bastante limitado, com restrições severas a vários módulos e funções embutidas.
+
+### Execução Não Segura
+
+**NÃO RECOMENDADO PARA PRODUÇÃO**
+Este modo permite a execução de qualquer código Python, inclusive chamadas perigosas para os módulos `sys, os..` e semelhantes. [Veja aqui](/pt-BR/tools/ai-ml/codeinterpretertool#enabling-unsafe-mode) como habilitar este modo.
+
+## Registro de Logs
+
+O `CodeInterpreterTool` registra a estratégia de execução selecionada no STDOUT.
+
+
+## Instalação
+
+Para utilizar esta ferramenta, você precisa instalar o pacote de ferramentas CrewAI:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar o `CodeInterpreterTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew, Process
+from crewai_tools import CodeInterpreterTool
+
+# Initialize the tool
+code_interpreter = CodeInterpreterTool()
+
+# Define an agent that uses the tool
+programmer_agent = Agent(
+    role="Python Programmer",
+    goal="Write and execute Python code to solve problems",
+    backstory="An expert Python programmer who can write efficient code to solve complex problems.",
+    tools=[code_interpreter],
+    verbose=True,
+)
+
+# Example task to generate and execute code
+coding_task = Task(
+    description="Write a Python function to calculate the Fibonacci sequence up to the 10th number and print the result.",
+    expected_output="The Fibonacci sequence up to the 10th number.",
+    agent=programmer_agent,
+)
+
+# Create and run the crew
+crew = Crew(
+    agents=[programmer_agent],
+    tasks=[coding_task],
+    verbose=True,
+    process=Process.sequential,
+)
+result = crew.kickoff()
+```
+
+Você também pode habilitar a execução de código diretamente ao criar um agente:
+
+```python Code
+from crewai import Agent
+
+# Create an agent with code execution enabled
+programmer_agent = Agent(
+    role="Python Programmer",
+    goal="Write and execute Python code to solve problems",
+    backstory="An expert Python programmer who can write efficient code to solve complex problems.",
+    allow_code_execution=True,  # This automatically adds the CodeInterpreterTool
+    verbose=True,
+)
+```
+
+### Habilitando o `unsafe_mode`
+
+```python Code
+from crewai_tools import CodeInterpreterTool
+
+code = """
+import os
+os.system("ls -la")
+"""
+
+CodeInterpreterTool(unsafe_mode=True).run(code=code)
+```
+
+## Parâmetros
+
+O `CodeInterpreterTool` aceita os seguintes parâmetros durante a inicialização:
+
+- **user_dockerfile_path**: Opcional. Caminho para um Dockerfile personalizado a ser utilizado pelo container do interpretador de código.
+- **user_docker_base_url**: Opcional. URL do daemon Docker que será usado para rodar o container.
+- **unsafe_mode**: Opcional. Indica se o código será executado diretamente na máquina hospedeira ao invés de um container Docker ou sandbox. O padrão é `False`. Use com cautela!
+- **default_image_tag**: Opcional. Tag padrão da imagem Docker. O padrão é `code-interpreter:latest`
+
+Ao utilizar a ferramenta com um agente, o agente precisará fornecer:
+
+- **code**: Obrigatório. O código Python 3 a ser executado.
+- **libraries_used**: Opcional. Uma lista de bibliotecas usadas no código que precisam ser instaladas. O padrão é `[]`
+
+## Exemplo de Integração com Agente
+
+Aqui está um exemplo mais detalhado de como integrar o `CodeInterpreterTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import CodeInterpreterTool
+
+# Initialize the tool
+code_interpreter = CodeInterpreterTool()
+
+# Define an agent that uses the tool
+data_analyst = Agent(
+    role="Data Analyst",
+    goal="Analyze data using Python code",
+    backstory="""You are an expert data analyst who specializes in using Python
+    to analyze and visualize data. You can write efficient code to process
+    large datasets and extract meaningful insights.""",
+    tools=[code_interpreter],
+    verbose=True,
+)
+
+# Create a task for the agent
+analysis_task = Task(
+    description="""
+    Write Python code to:
+    1. Generate a random dataset of 100 points with x and y coordinates
+    2. Calculate the correlation coefficient between x and y
+    3. Create a scatter plot of the data
+    4. Print the correlation coefficient and save the plot as 'scatter.png'
+
+    Make sure to handle any necessary imports and print the results.
+    """,
+    expected_output="The correlation coefficient and confirmation that the scatter plot has been saved.",
+    agent=data_analyst,
+)
+
+# Run the task
+crew = Crew(
+    agents=[data_analyst],
+    tasks=[analysis_task],
+    verbose=True,
+    process=Process.sequential,
+)
+result = crew.kickoff()
+```
+
+## Detalhes de Implementação
+
+O `CodeInterpreterTool` utiliza Docker para criar um ambiente seguro para execução de código:
+
+```python Code
+class CodeInterpreterTool(BaseTool):
+    name: str = "Code Interpreter"
+    description: str = "Interprets Python3 code strings with a final print statement."
+    args_schema: Type[BaseModel] = CodeInterpreterSchema
+    default_image_tag: str = "code-interpreter:latest"
+
+    def _run(self, **kwargs) -> str:
+        code = kwargs.get("code", self.code)
+        libraries_used = kwargs.get("libraries_used", [])
+
+        if self.unsafe_mode:
+            return self.run_code_unsafe(code, libraries_used)
+        else:
+            return self.run_code_safety(code, libraries_used)
+```
+
+A ferramenta executa os seguintes passos:
+1. Verifica se a imagem Docker existe ou a constrói, caso necessário
+2. Cria um container Docker com o diretório de trabalho atual montado
+3. Instala quaisquer bibliotecas necessárias especificadas pelo agente
+4. Executa o código Python dentro do container
+5. Retorna a saída da execução do código
+6. Limpa o ambiente, parando e removendo o container
+
+## Considerações de Segurança
+
+Por padrão, o `CodeInterpreterTool` executa o código em um container Docker isolado, fornecendo uma camada de segurança. No entanto, ainda há algumas considerações importantes:
+
+1. O container Docker tem acesso ao diretório de trabalho atual, então arquivos sensíveis podem ser potencialmente acessados.
+2. Caso o container Docker não esteja disponível e o código precise ser executado de forma segura, ele será executado em um ambiente sandbox. Por motivos de segurança, a instalação de bibliotecas arbitrárias não é permitida
+3. O parâmetro `unsafe_mode` permite que códigos sejam executados diretamente na máquina hospedeira, o que deve ser usado apenas em ambientes confiáveis.
+4. Tenha cautela ao permitir que agentes instalem bibliotecas arbitrárias, pois estas podem incluir códigos maliciosos.
+
+## Conclusão
+
+O `CodeInterpreterTool` oferece uma maneira poderosa para que agentes CrewAI executem código Python em um ambiente relativamente seguro. Permitindo que agentes escrevam e executem códigos, ele amplia significativamente sua capacidade de resolução de problemas, especialmente para tarefas que envolvem análise de dados, cálculos ou outros trabalhos computacionais. Esta ferramenta é especialmente útil para agentes que precisam realizar operações complexas que são mais eficientemente expressas em código do que em linguagem natural.

docs/pt-BR/tools/ai-ml/dalletool.mdx

@@ -0,0 +1,51 @@
+---
+title: Ferramenta DALL-E
+description: A `DallETool` é uma ferramenta poderosa projetada para gerar imagens a partir de descrições textuais.
+icon: image
+---
+
+# `DallETool`
+
+## Descrição
+
+Esta ferramenta é utilizada para dar ao Agente a capacidade de gerar imagens usando o modelo DALL-E. Trata-se de um modelo baseado em transformer que gera imagens a partir de descrições textuais.
+Esta ferramenta permite que o Agente gere imagens com base no texto de entrada fornecido pelo usuário.
+
+## Instalação
+
+Instale o pacote crewai_tools
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+Lembre-se de que, ao usar esta ferramenta, o texto deve ser gerado pelo próprio Agente. O texto deve ser uma descrição da imagem que você deseja gerar.
+
+```python Code
+from crewai_tools import DallETool
+
+Agent(
+    ...
+    tools=[DallETool()],
+)
+```
+
+Se necessário, você também pode ajustar os parâmetros do modelo DALL-E passando-os como argumentos para a classe `DallETool`. Por exemplo:
+
+```python Code
+from crewai_tools import DallETool
+
+dalle_tool = DallETool(model="dall-e-3",
+                       size="1024x1024",
+                       quality="standard",
+                       n=1)
+
+Agent(
+    ...
+    tools=[dalle_tool]
+)
+```
+
+Os parâmetros são baseados no método `client.images.generate` da API OpenAI. Para mais informações sobre os parâmetros,
+consulte a [documentação da API OpenAI](https://platform.openai.com/docs/guides/images/introduction?lang=python).

docs/pt-BR/tools/ai-ml/langchaintool.mdx

@@ -0,0 +1,57 @@
+---
+title: Ferramenta LangChain
+description: O `LangChainTool` é um wrapper para ferramentas LangChain e mecanismos de consulta.
+icon: link
+---
+
+## `LangChainTool`
+
+<Info>
+    CrewAI integra-se perfeitamente com a abrangente [lista de ferramentas](https://python.langchain.com/docs/integrations/tools/) do LangChain, todas as quais podem ser usadas com CrewAI.
+</Info>
+
+```python Code
+import os
+from dotenv import load_dotenv
+from crewai import Agent, Task, Crew
+from crewai.tools import BaseTool
+from pydantic import Field
+from langchain_community.utilities import GoogleSerperAPIWrapper
+
+# Set up your SERPER_API_KEY key in an .env file, eg:
+# SERPER_API_KEY=<your api key>
+load_dotenv()
+
+search = GoogleSerperAPIWrapper()
+
+class SearchTool(BaseTool):
+    name: str = "Search"
+    description: str = "Useful for search-based queries. Use this to find current information about markets, companies, and trends."
+    search: GoogleSerperAPIWrapper = Field(default_factory=GoogleSerperAPIWrapper)
+
+    def _run(self, query: str) -> str:
+        """Execute the search query and return results"""
+        try:
+            return self.search.run(query)
+        except Exception as e:
+            return f"Error performing search: {str(e)}"
+
+# Create Agents
+researcher = Agent(
+    role='Research Analyst',
+    goal='Gather current market data and trends',
+    backstory="""You are an expert research analyst with years of experience in
+    gathering market intelligence. You're known for your ability to find
+    relevant and up-to-date market information and present it in a clear,
+    actionable format.""",
+    tools=[SearchTool()],
+    verbose=True
+)
+
+# rest of the code ...
+```
+
+## Conclusão
+
+As ferramentas são fundamentais para ampliar as capacidades dos agentes CrewAI, permitindo que realizem uma ampla variedade de tarefas e colaborem de forma eficaz.
+Ao construir soluções com CrewAI, aproveite tanto ferramentas personalizadas quanto existentes para potencializar seus agentes e aprimorar o ecossistema de IA. Considere utilizar tratamento de erros, mecanismos de cache e a flexibilidade dos argumentos das ferramentas para otimizar o desempenho e as capacidades dos seus agentes.

docs/pt-BR/tools/ai-ml/llamaindextool.mdx

@@ -0,0 +1,146 @@
+---
+title: Ferramenta LlamaIndex
+description: A `LlamaIndexTool` é um wrapper para ferramentas e mecanismos de consulta do LlamaIndex.
+icon: address-book
+---
+
+# `LlamaIndexTool`
+
+## Descrição
+
+A `LlamaIndexTool` foi projetada para ser um wrapper geral em torno das ferramentas e mecanismos de consulta do LlamaIndex, permitindo que você aproveite os recursos do LlamaIndex em pipelines de RAG/agent como ferramentas que podem ser acopladas aos agentes do CrewAI. Essa ferramenta permite integrar de forma transparente as poderosas capacidades de processamento e recuperação de dados do LlamaIndex em seus fluxos de trabalho com o CrewAI.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar o LlamaIndex:
+
+```shell
+uv add llama-index
+```
+
+## Passos para Começar
+
+Para utilizar a `LlamaIndexTool` de forma eficaz, siga os passos abaixo:
+
+1. **Instale o LlamaIndex**: Instale o pacote LlamaIndex usando o comando acima.
+2. **Configure o LlamaIndex**: Siga a [documentação do LlamaIndex](https://docs.llamaindex.ai/) para configurar um pipeline de RAG/agent.
+3. **Crie uma Ferramenta ou Mecanismo de Consulta**: Crie uma ferramenta ou mecanismo de consulta do LlamaIndex que você deseja usar com o CrewAI.
+
+## Exemplo
+
+Os exemplos a seguir demonstram como inicializar a ferramenta a partir de diferentes componentes do LlamaIndex:
+
+### A partir de uma ferramenta do LlamaIndex
+
+```python Code
+from crewai_tools import LlamaIndexTool
+from crewai import Agent
+from llama_index.core.tools import FunctionTool
+
+# Exemplo 1: Inicializando a partir do FunctionTool
+def search_data(query: str) -> str:
+    """Busca por informações nos dados."""
+    # Sua implementação aqui
+    return f"Results for: {query}"
+
+# Criação de um LlamaIndex FunctionTool
+og_tool = FunctionTool.from_defaults(
+    search_data, 
+    name="DataSearchTool",
+    description="Search for information in the data"
+)
+
+# Envolvendo com a LlamaIndexTool
+tool = LlamaIndexTool.from_tool(og_tool)
+
+# Definindo um agente que utiliza a ferramenta
+@agent
+def researcher(self) -> Agent:
+    '''
+    Este agente usa a LlamaIndexTool para buscar informações.
+    '''
+    return Agent(
+        config=self.agents_config["researcher"],
+        tools=[tool]
+    )
+```
+
+### A partir de Ferramentas do LlamaHub
+
+```python Code
+from crewai_tools import LlamaIndexTool
+from llama_index.tools.wolfram_alpha import WolframAlphaToolSpec
+
+# Inicializando a partir das ferramentas do LlamaHub
+wolfram_spec = WolframAlphaToolSpec(app_id="your_app_id")
+wolfram_tools = wolfram_spec.to_tool_list()
+tools = [LlamaIndexTool.from_tool(t) for t in wolfram_tools]
+```
+
+### A partir de um mecanismo de consulta do LlamaIndex
+
+```python Code
+from crewai_tools import LlamaIndexTool
+from llama_index.core import VectorStoreIndex
+from llama_index.core.readers import SimpleDirectoryReader
+
+# Carregar documentos
+documents = SimpleDirectoryReader("./data").load_data()
+
+# Criar um índice
+index = VectorStoreIndex.from_documents(documents)
+
+# Criar um mecanismo de consulta
+query_engine = index.as_query_engine()
+
+# Criar uma LlamaIndexTool a partir do mecanismo de consulta
+query_tool = LlamaIndexTool.from_query_engine(
+    query_engine,
+    name="Company Data Query Tool",
+    description="Use this tool to lookup information in company documents"
+)
+```
+
+## Métodos da Classe
+
+A `LlamaIndexTool` oferece dois métodos de classe principais para criar instâncias:
+
+### from_tool
+
+Cria uma `LlamaIndexTool` a partir de uma ferramenta do LlamaIndex.
+
+```python Code
+@classmethod
+def from_tool(cls, tool: Any, **kwargs: Any) -> "LlamaIndexTool":
+    # Implementation details
+```
+
+### from_query_engine
+
+Cria uma `LlamaIndexTool` a partir de um mecanismo de consulta do LlamaIndex.
+
+```python Code
+@classmethod
+def from_query_engine(
+    cls,
+    query_engine: Any,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    return_direct: bool = False,
+    **kwargs: Any,
+) -> "LlamaIndexTool":
+    # Implementation details
+```
+
+## Parâmetros
+
+O método `from_query_engine` aceita os seguintes parâmetros:
+
+- **query_engine**: Obrigatório. O mecanismo de consulta do LlamaIndex a ser envolvido.
+- **name**: Opcional. O nome da ferramenta.
+- **description**: Opcional. A descrição da ferramenta.
+- **return_direct**: Opcional. Define se deve retornar a resposta diretamente. O padrão é `False`.
+
+## Conclusão
+
+A `LlamaIndexTool` oferece uma maneira poderosa de integrar as capacidades do LlamaIndex aos agentes do CrewAI. Ao envolver ferramentas e mecanismos de consulta do LlamaIndex, ela permite que os agentes utilizem funcionalidades sofisticadas de recuperação e processamento de dados, aprimorando sua capacidade de trabalhar com fontes de informação complexas.

docs/pt-BR/tools/ai-ml/overview.mdx

@@ -0,0 +1,65 @@
+---
+title: "Visão Geral"
+description: "Aproveite serviços de IA, gere imagens, processe visão e construa sistemas inteligentes"
+icon: "face-smile"
+---
+
+Essas ferramentas se integram com serviços de IA e machine learning para aprimorar seus agentes com capacidades avançadas como geração de imagens, processamento de visão e execução inteligente de código.
+
+## **Ferramentas Disponíveis**
+
+<CardGroup cols={2}>
+  <Card title="DALL-E Tool" icon="image" href="/pt-BR/tools/ai-ml/dalletool">
+    Gere imagens com IA utilizando o modelo DALL-E da OpenAI.
+  </Card>
+
+  <Card title="Vision Tool" icon="eye" href="/pt-BR/tools/ai-ml/visiontool">
+    Processe e analise imagens com capacidades de visão computacional.
+  </Card>
+
+  <Card title="AI Mind Tool" icon="brain" href="/pt-BR/tools/ai-ml/aimindtool">
+    Capacidades avançadas de raciocínio e tomada de decisão com IA.
+  </Card>
+
+  <Card title="LlamaIndex Tool" icon="llama" href="/pt-BR/tools/ai-ml/llamaindextool">
+    Construa bases de conhecimento e sistemas de recuperação com LlamaIndex.
+  </Card>
+
+  <Card title="LangChain Tool" icon="link" href="/pt-BR/tools/ai-ml/langchaintool">
+    Integre com LangChain para fluxos de trabalho de IA complexos.
+  </Card>
+
+  <Card title="RAG Tool" icon="database" href="/pt-BR/tools/ai-ml/ragtool">
+    Implemente sistemas de Geração Aumentada por Recuperação (RAG).
+  </Card>
+
+  <Card title="Code Interpreter Tool" icon="code" href="/pt-BR/tools/ai-ml/codeinterpretertool">
+    Execute código Python e realize análises de dados.
+  </Card>
+
+
+</CardGroup>
+
+## **Casos de Uso Comuns**
+
+- **Geração de Conteúdo**: Crie imagens, textos e conteúdo multimídia
+- **Análise de Dados**: Execute código e analise conjuntos de dados complexos
+- **Sistemas de Conhecimento**: Construa sistemas RAG e bancos de dados inteligentes
+- **Visão Computacional**: Processe e compreenda conteúdo visual
+- **Segurança em IA**: Implemente moderação de conteúdo e checagens de segurança
+
+```python
+from crewai_tools import DallETool, VisionTool, CodeInterpreterTool
+
+# Create AI tools
+image_generator = DallETool()
+vision_processor = VisionTool()
+code_executor = CodeInterpreterTool()
+
+# Add to your agent
+agent = Agent(
+    role="AI Specialist",
+    tools=[image_generator, vision_processor, code_executor],
+    goal="Create and analyze content using AI capabilities"
+)
+```

docs/pt-BR/tools/ai-ml/ragtool.mdx

@@ -0,0 +1,172 @@
+---
+title: Ferramenta RAG
+description: O `RagTool` é uma ferramenta dinâmica de base de conhecimento para responder perguntas usando Geração Aumentada por Recuperação.
+icon: vector-square
+---
+
+# `RagTool`
+
+## Descrição
+
+O `RagTool` foi desenvolvido para responder perguntas aproveitando o poder da Geração Aumentada por Recuperação (RAG) através do EmbedChain.
+Ele fornece uma base de conhecimento dinâmica que pode ser consultada para recuperar informações relevantes de várias fontes de dados.
+Esta ferramenta é particularmente útil para aplicações que exigem acesso a uma ampla variedade de informações e precisam fornecer respostas contextualmente relevantes.
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e usá-la com diferentes fontes de dados:
+
+```python Code
+from crewai_tools import RagTool
+
+# Create a RAG tool with default settings
+rag_tool = RagTool()
+
+# Add content from a file
+rag_tool.add(data_type="file", path="path/to/your/document.pdf")
+
+# Add content from a web page
+rag_tool.add(data_type="web_page", url="https://example.com")
+
+# Define an agent with the RagTool
+@agent
+def knowledge_expert(self) -> Agent:
+    '''
+    This agent uses the RagTool to answer questions about the knowledge base.
+    '''
+    return Agent(
+        config=self.agents_config["knowledge_expert"],
+        allow_delegation=False,
+        tools=[rag_tool]
+    )
+```
+
+## Fontes de Dados Suportadas
+
+O `RagTool` pode ser utilizado com uma grande variedade de fontes de dados, incluindo:
+
+- 📰 Arquivos PDF
+- 📊 Arquivos CSV
+- 📃 Arquivos JSON
+- 📝 Texto
+- 📁 Diretórios/Pastas
+- 🌐 Páginas web em HTML
+- 📽️ Canais do YouTube
+- 📺 Vídeos do YouTube
+- 📚 Sites de documentação
+- 📝 Arquivos MDX
+- 📄 Arquivos DOCX
+- 🧾 Arquivos XML
+- 📬 Gmail
+- 📝 Repositórios GitHub
+- 🐘 Bancos de dados PostgreSQL
+- 🐬 Bancos de dados MySQL
+- 🤖 Conversas no Slack
+- 💬 Mensagens do Discord
+- 🗨️ Fóruns Discourse
+- 📝 Newsletters do Substack
+- 🐝 Conteúdo do Beehiiv
+- 💾 Arquivos Dropbox
+- 🖼️ Imagens
+- ⚙️ Fontes de dados personalizadas
+
+## Parâmetros
+
+O `RagTool` aceita os seguintes parâmetros:
+
+- **summarize**: Opcional. Indica se o conteúdo recuperado deve ser resumido. O padrão é `False`.
+- **adapter**: Opcional. Um adaptador personalizado para a base de conhecimento. Se não for fornecido, será utilizado o EmbedchainAdapter.
+- **config**: Opcional. Configuração para o aplicativo EmbedChain subjacente.
+
+## Adicionando Conteúdo
+
+Você pode adicionar conteúdo à base de conhecimento utilizando o método `add`:
+
+```python Code
+# Add a PDF file
+rag_tool.add(data_type="file", path="path/to/your/document.pdf")
+
+# Add a web page
+rag_tool.add(data_type="web_page", url="https://example.com")
+
+# Add a YouTube video
+rag_tool.add(data_type="youtube_video", url="https://www.youtube.com/watch?v=VIDEO_ID")
+
+# Add a directory of files
+rag_tool.add(data_type="directory", path="path/to/your/directory")
+```
+
+## Exemplo de Integração com Agente
+
+Veja como integrar o `RagTool` com um agente do CrewAI:
+
+```python Code
+from crewai import Agent
+from crewai.project import agent
+from crewai_tools import RagTool
+
+# Initialize the tool and add content
+rag_tool = RagTool()
+rag_tool.add(data_type="web_page", url="https://docs.crewai.com")
+rag_tool.add(data_type="file", path="company_data.pdf")
+
+# Define an agent with the RagTool
+@agent
+def knowledge_expert(self) -> Agent:
+    return Agent(
+        config=self.agents_config["knowledge_expert"],
+        allow_delegation=False,
+        tools=[rag_tool]
+    )
+```
+
+## Configuração Avançada
+
+É possível personalizar o comportamento do `RagTool` fornecendo um dicionário de configuração:
+
+```python Code
+from crewai_tools import RagTool
+
+# Create a RAG tool with custom configuration
+config = {
+    "app": {
+        "name": "custom_app",
+    },
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4",
+        }
+    },
+    "embedding_model": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-ada-002"
+        }
+    },
+    "vectordb": {
+        "provider": "elasticsearch",
+        "config": {
+            "collection_name": "my-collection",
+            "cloud_id": "deployment-name:xxxx",
+            "api_key": "your-key",
+            "verify_certs": False
+        }
+    },
+    "chunker": {
+        "chunk_size": 400,
+        "chunk_overlap": 100,
+        "length_function": "len",
+        "min_chunk_size": 0
+    }
+}
+
+rag_tool = RagTool(config=config, summarize=True)
+```
+
+A ferramenta RAG interna utiliza o adaptador Embedchain, possibilitando que você forneça quaisquer opções de configuração suportadas pelo Embedchain.
+Você pode consultar a [documentação do Embedchain](https://docs.embedchain.ai/components/introduction) para mais detalhes.
+Certifique-se de revisar as opções de configuração disponíveis no arquivo .yaml.
+
+## Conclusão
+O `RagTool` oferece uma maneira poderosa de criar e consultar bases de conhecimento a partir de diversas fontes de dados. Ao explorar a Geração Aumentada por Recuperação, ele permite que agentes acessem e recuperem informações relevantes de forma eficiente, ampliando a capacidade de fornecer respostas precisas e contextualmente apropriadas.

docs/pt-BR/tools/ai-ml/visiontool.mdx

@@ -0,0 +1,49 @@
+---
+title: Vision Tool
+description: O `VisionTool` foi projetado para extrair texto de imagens.
+icon: eye
+---
+
+# `VisionTool`
+
+## Descrição
+
+Esta ferramenta é utilizada para extrair texto de imagens. Quando passada para o agente, ela extrai o texto da imagem e depois o utiliza para gerar uma resposta, relatório ou qualquer outra saída.
+A URL ou o CAMINHO da imagem deve ser passado para o Agente.
+
+## Instalação
+
+Instale o pacote crewai_tools
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Uso
+
+Para usar o VisionTool, a chave da API da OpenAI deve ser definida na variável de ambiente `OPENAI_API_KEY`.
+
+```python Code
+from crewai_tools import VisionTool
+
+vision_tool = VisionTool()
+
+@agent
+def researcher(self) -> Agent:
+    '''
+    This agent uses the VisionTool to extract text from images.
+    '''
+    return Agent(
+        config=self.agents_config["researcher"],
+        allow_delegation=False,
+        tools=[vision_tool]
+    )
+```
+
+## Argumentos
+
+O VisionTool requer os seguintes argumentos:
+
+| Argumento           | Tipo     | Descrição                                                                        |
+| :------------------ | :------- | :------------------------------------------------------------------------------- |
+| **image_path_url**  | `string` | **Obrigatório**. O caminho para o arquivo de imagem do qual o texto será extraído. |

docs/pt-BR/tools/automation/apifyactorstool.mdx

@@ -0,0 +1,99 @@
+---
+title: Apify Actors
+description: "`ApifyActorsTool` permite que você execute Apify Actors para adicionar recursos de raspagem de dados na web, coleta, extração de dados e automação web aos seus fluxos de trabalho CrewAI."
+# hack to use custom Apify icon
+icon: "); -webkit-mask-image: url('https://upload.wikimedia.org/wikipedia/commons/a/ae/Apify.svg');/*"
+---
+
+# `ApifyActorsTool`
+
+Integre [Apify Actors](https://apify.com/actors) nos seus fluxos de trabalho CrewAI.
+
+## Descrição
+
+O `ApifyActorsTool` conecta [Apify Actors](https://apify.com/actors), programas em nuvem para raspagem e automação web, aos seus fluxos de trabalho CrewAI.
+Utilize qualquer um dos mais de 4.000 Actors disponíveis na [Apify Store](https://apify.com/store) para casos de uso como extração de dados de redes sociais, motores de busca, mapas online, sites de e-commerce, portais de viagem ou sites em geral.
+
+Para mais detalhes, consulte a [integração Apify CrewAI](https://docs.apify.com/platform/integrations/crewai) na documentação do Apify.
+
+## Passos para começar
+
+<Steps>
+    <Step title="Instale as dependências">
+        Instale `crewai[tools]` e `langchain-apify` usando pip: `pip install 'crewai[tools]' langchain-apify`.
+    </Step>
+    <Step title="Obtenha um token de API do Apify">
+        Cadastre-se no [Apify Console](https://console.apify.com/) e obtenha seu [token de API do Apify](https://console.apify.com/settings/integrations).
+    </Step>
+    <Step title="Configure o ambiente">
+        Defina seu token de API do Apify na variável de ambiente `APIFY_API_TOKEN` para habilitar a funcionalidade da ferramenta.
+    </Step>
+</Steps>
+
+## Exemplo de uso
+
+Use o `ApifyActorsTool` manualmente para executar o [RAG Web Browser Actor](https://apify.com/apify/rag-web-browser) e realizar uma busca na web:
+
+```python
+from crewai_tools import ApifyActorsTool
+
+# Inicialize a ferramenta com um Apify Actor
+tool = ApifyActorsTool(actor_name="apify/rag-web-browser")
+
+# Execute a ferramenta com parâmetros de entrada
+results = tool.run(run_input={"query": "What is CrewAI?", "maxResults": 5})
+
+# Processe os resultados
+for result in results:
+    print(f"URL: {result['metadata']['url']}")
+    print(f"Content: {result.get('markdown', 'N/A')[:100]}...")
+```
+
+### Saída esperada
+
+Veja abaixo a saída do código acima:
+
+```text
+URL: https://www.example.com/crewai-intro
+Content: CrewAI is a framework for building AI-powered workflows...
+URL: https://docs.crewai.com/
+Content: Official documentation for CrewAI...
+```
+
+O `ApifyActorsTool` busca automaticamente a definição do Actor e o esquema de entrada no Apify utilizando o `actor_name` fornecido e então constrói a descrição da ferramenta e o esquema dos argumentos. Isso significa que você só precisa informar um `actor_name` válido, e a ferramenta faz o resto quando usada com agentes—não é necessário especificar o `run_input`. Veja como funciona:
+
+```python
+from crewai import Agent
+from crewai_tools import ApifyActorsTool
+
+rag_browser = ApifyActorsTool(actor_name="apify/rag-web-browser")
+
+agent = Agent(
+    role="Research Analyst",
+    goal="Find and summarize information about specific topics",
+    backstory="You are an experienced researcher with attention to detail",
+    tools=[rag_browser],
+)
+```
+
+Você pode executar outros Actors da [Apify Store](https://apify.com/store) apenas alterando o `actor_name` e, ao usar manualmente, ajustando o `run_input` de acordo com o esquema de entrada do Actor.
+
+Para um exemplo de uso com agentes, consulte o [template CrewAI Actor](https://apify.com/templates/python-crewai).
+
+## Configuração
+
+O `ApifyActorsTool` exige os seguintes inputs para funcionar:
+
+- **`actor_name`**
+  O ID do Apify Actor a ser executado, por exemplo, `"apify/rag-web-browser"`. Explore todos os Actors na [Apify Store](https://apify.com/store).
+- **`run_input`**
+  Um dicionário de parâmetros de entrada para o Actor ao executar a ferramenta manualmente.
+  - Por exemplo, para o Actor `apify/rag-web-browser`: `{"query": "search term", "maxResults": 5}`
+  - Veja o [schema de entrada do Actor](https://apify.com/apify/rag-web-browser/input-schema) para a lista de parâmetros de entrada.
+
+## Recursos
+
+- **[Apify](https://apify.com/)**: Explore a plataforma Apify.
+- **[Como criar um agente de IA no Apify](https://blog.apify.com/how-to-build-an-ai-agent/)** - Um guia completo, passo a passo, para criar, publicar e monetizar agentes de IA na plataforma Apify.
+- **[RAG Web Browser Actor](https://apify.com/apify/rag-web-browser)**: Um Actor popular para busca na web para LLMs.
+- **[Guia de Integração CrewAI](https://docs.apify.com/platform/integrations/crewai)**: Siga o guia oficial para integrar Apify e CrewAI.

docs/pt-BR/tools/automation/composiotool.mdx

@@ -0,0 +1,118 @@
+---
+title: Ferramenta Composio
+description: O Composio oferece mais de 250 ferramentas prontas para produção para agentes de IA com gerenciamento de autenticação flexível.
+icon: gear-code
+---
+
+# `ComposioToolSet`
+
+## Descrição
+Composio é uma plataforma de integração que permite conectar seus agentes de IA a mais de 250 ferramentas. Os principais recursos incluem:
+
+- **Autenticação de Nível Empresarial**: Suporte integrado para OAuth, Chaves de API, JWT com atualização automática de token
+- **Observabilidade Completa**: Logs detalhados de uso das ferramentas, registros de execução, e muito mais
+
+## Instalação
+
+Para incorporar as ferramentas Composio em seu projeto, siga as instruções abaixo:
+
+```shell
+pip install composio-crewai
+pip install crewai
+```
+
+Após a conclusão da instalação, execute `composio login` ou exporte sua chave de API do composio como `COMPOSIO_API_KEY`. Obtenha sua chave de API Composio [aqui](https://app.composio.dev)
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma ação do github:
+
+1. Inicialize o conjunto de ferramentas Composio
+
+```python Code
+from composio_crewai import ComposioToolSet, App, Action
+from crewai import Agent, Task, Crew
+
+toolset = ComposioToolSet()
+```
+
+2. Conecte sua conta do GitHub
+<CodeGroup>
+```shell CLI
+composio add github
+```
+```python Code
+request = toolset.initiate_connection(app=App.GITHUB)
+print(f"Open this URL to authenticate: {request.redirectUrl}")
+```
+</CodeGroup>
+
+3. Obtenha ferramentas
+
+- Recuperando todas as ferramentas de um app (não recomendado em produção):
+```python Code
+tools = toolset.get_tools(apps=[App.GITHUB])
+```
+
+- Filtrando ferramentas com base em tags:
+```python Code
+tag = "users"
+
+filtered_action_enums = toolset.find_actions_by_tags(
+    App.GITHUB,
+    tags=[tag], 
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+
+- Filtrando ferramentas com base no caso de uso:
+```python Code
+use_case = "Star a repository on GitHub"
+
+filtered_action_enums = toolset.find_actions_by_use_case(
+    App.GITHUB, use_case=use_case, advanced=False
+)
+
+tools = toolset.get_tools(actions=filtered_action_enums)
+```
+<Tip>Defina `advanced` como True para obter ações para casos de uso complexos</Tip>
+
+- Usando ferramentas específicas:
+
+Neste exemplo, usaremos a ação `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` do app GitHub.
+```python Code
+tools = toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
+)
+```
+Saiba mais sobre como filtrar ações [aqui](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)
+
+4. Defina o agente
+
+```python Code
+crewai_agent = Agent(
+    role="GitHub Agent",
+    goal="You take action on GitHub using GitHub APIs",
+    backstory="You are AI agent that is responsible for taking actions on GitHub on behalf of users using GitHub APIs",
+    verbose=True,
+    tools=tools,
+    llm= # pass an llm
+)
+```
+
+5. Execute a tarefa
+
+```python Code
+task = Task(
+    description="Star a repo composiohq/composio on GitHub",
+    agent=crewai_agent,
+    expected_output="Status of the operation",
+)
+
+crew = Crew(agents=[crewai_agent], tasks=[task])
+
+crew.kickoff()
+```
+
+* Uma lista mais detalhada de ferramentas pode ser encontrada [aqui](https://app.composio.dev)

docs/pt-BR/tools/automation/multiontool.mdx

@@ -0,0 +1,126 @@
+---
+title: MultiOn Tool
+description: O `MultiOnTool` permite que agentes CrewAI naveguem e interajam com a web por meio de instruções em linguagem natural.
+icon: globe
+---
+
+## Visão Geral
+
+O `MultiOnTool` foi projetado para envolver as capacidades de navegação web do [MultiOn](https://docs.multion.ai/welcome), permitindo que agentes CrewAI controlem navegadores web usando instruções em linguagem natural. Esta ferramenta facilita a navegação fluida, tornando-se um recurso essencial para projetos que requerem interação dinâmica com dados web e automação de tarefas baseadas na web.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar o pacote MultiOn:
+
+```shell
+uv add multion
+```
+
+Você também precisará instalar a extensão de navegador do MultiOn e habilitar o uso da API.
+
+## Passos para Começar
+
+Para usar o `MultiOnTool` de forma eficaz, siga estes passos:
+
+1. **Instale o CrewAI**: Certifique-se de que o pacote `crewai[tools]` esteja instalado em seu ambiente Python.
+2. **Instale e utilize o MultiOn**: Siga a [documentação do MultiOn](https://docs.multion.ai/learn/browser-extension) para instalar a extensão de navegador do MultiOn.
+3. **Habilite o Uso da API**: Clique na extensão do MultiOn na pasta de extensões do seu navegador (não no ícone flutuante do MultiOn na página web) para abrir as configurações da extensão. Clique na opção para habilitar a API (API Enabled).
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma tarefa de navegação web:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import MultiOnTool
+
+# Initialize the tool
+multion_tool = MultiOnTool(api_key="YOUR_MULTION_API_KEY", local=False)
+
+# Define an agent that uses the tool
+browser_agent = Agent(
+    role="Browser Agent",
+    goal="Control web browsers using natural language",
+    backstory="An expert browsing agent.",
+    tools=[multion_tool],
+    verbose=True,
+)
+
+# Example task to search and summarize news
+browse_task = Task(
+    description="Summarize the top 3 trending AI News headlines",
+    expected_output="A summary of the top 3 trending AI News headlines",
+    agent=browser_agent,
+)
+
+# Create and run the crew
+crew = Crew(agents=[browser_agent], tasks=[browse_task])
+result = crew.kickoff()
+```
+
+## Parâmetros
+
+O `MultiOnTool` aceita os seguintes parâmetros durante a inicialização:
+
+- **api_key**: Opcional. Especifica a chave da API do MultiOn. Se não for fornecida, a ferramenta procurará pela variável de ambiente `MULTION_API_KEY`.
+- **local**: Opcional. Defina como `True` para executar o agente localmente em seu navegador. Certifique-se de que a extensão do MultiOn está instalada e a opção API Enabled está marcada. O padrão é `False`.
+- **max_steps**: Opcional. Define o número máximo de etapas que o agente MultiOn pode executar para um comando. O padrão é `3`.
+
+## Uso
+
+Ao utilizar o `MultiOnTool`, o agente fornecerá instruções em linguagem natural que a ferramenta traduzirá em ações de navegação web. A ferramenta retorna os resultados da sessão de navegação juntamente com um status.
+
+```python Code
+# Example of using the tool with an agent
+browser_agent = Agent(
+    role="Web Browser Agent",
+    goal="Search for and summarize information from the web",
+    backstory="An expert at finding and extracting information from websites.",
+    tools=[multion_tool],
+    verbose=True,
+)
+
+# Create a task for the agent
+search_task = Task(
+    description="Search for the latest AI news on TechCrunch and summarize the top 3 headlines",
+    expected_output="A summary of the top 3 AI news headlines from TechCrunch",
+    agent=browser_agent,
+)
+
+# Run the task
+crew = Crew(agents=[browser_agent], tasks=[search_task])
+result = crew.kickoff()
+```
+
+Se o status retornado for `CONTINUE`, o agente deve ser instruído a reenviar a mesma instrução para continuar a execução.
+
+## Detalhes de Implementação
+
+O `MultiOnTool` é implementado como uma subclasse de `BaseTool` do CrewAI. Ele envolve o cliente MultiOn para fornecer capacidades de navegação web:
+
+```python Code
+class MultiOnTool(BaseTool):
+    """Tool to wrap MultiOn Browse Capabilities."""
+
+    name: str = "Multion Browse Tool"
+    description: str = """Multion gives the ability for LLMs to control web browsers using natural language instructions.
+            If the status is 'CONTINUE', reissue the same instruction to continue execution
+        """
+    
+    # Implementation details...
+    
+    def _run(self, cmd: str, *args: Any, **kwargs: Any) -> str:
+        """
+        Run the Multion client with the given command.
+        
+        Args:
+            cmd (str): The detailed and specific natural language instruction for web browsing
+            *args (Any): Additional arguments to pass to the Multion client
+            **kwargs (Any): Additional keyword arguments to pass to the Multion client
+        """
+        # Implementation details...
+```
+
+## Conclusão
+
+O `MultiOnTool` oferece uma maneira poderosa de integrar capacidades de navegação web em agentes CrewAI. Ao permitir que agentes interajam com sites por meio de instruções em linguagem natural, amplia significativamente as possibilidades para tarefas baseadas na web, desde coleta de dados e pesquisa até interações automatizadas com serviços online.

docs/pt-BR/tools/automation/overview.mdx

@@ -0,0 +1,55 @@
+---
+title: "Visão Geral"
+description: "Automatize fluxos de trabalho e integre com plataformas e serviços externos"
+icon: "face-smile"
+---
+
+Essas ferramentas permitem que seus agentes automatizem fluxos de trabalho, integrem com plataformas externas e conectem-se a diversos serviços de terceiros para funcionalidades aprimoradas.
+
+## **Ferramentas Disponíveis**
+
+<CardGroup cols={2}>
+  <Card title="Apify Actor Tool" icon="spider" href="/pt-BR/tools/automation/apifyactorstool">
+    Execute atores do Apify para tarefas de automação e raspagem de dados web.
+  </Card>
+
+  <Card title="Composio Tool" icon="puzzle-piece" href="/pt-BR/tools/automation/composiotool">
+    Integre com centenas de aplicativos e serviços através do Composio.
+  </Card>
+
+  <Card title="Multion Tool" icon="window-restore" href="/pt-BR/tools/automation/multiontool">
+    Automatize interações no navegador e fluxos de trabalho baseados na web.
+  </Card>
+</CardGroup>
+
+## **Casos de Uso Comuns**
+
+- **Automação de Fluxos de Trabalho**: Automatize tarefas e processos repetitivos
+- **Integração com APIs**: Conecte-se a APIs e serviços externos
+- **Sincronização de Dados**: Sincronize dados entre diferentes plataformas
+- **Orquestração de Processos**: Coordene fluxos de trabalho complexos e com múltiplas etapas
+- **Serviços de Terceiros**: Aproveite ferramentas e plataformas externas
+
+```python
+from crewai_tools import ApifyActorTool, ComposioTool, MultiOnTool
+
+# Create automation tools
+apify_automation = ApifyActorTool()
+platform_integration = ComposioTool()
+browser_automation = MultiOnTool()
+
+# Add to your agent
+agent = Agent(
+    role="Automation Specialist",
+    tools=[apify_automation, platform_integration, browser_automation],
+    goal="Automate workflows and integrate systems"
+)
+```
+
+## **Benefícios da Integração**
+
+- **Eficiência**: Reduza o trabalho manual por meio da automação
+- **Escalabilidade**: Gerencie cargas de trabalho crescentes automaticamente
+- **Confiabilidade**: Execução consistente de fluxos de trabalho
+- **Conectividade**: Integre diferentes sistemas e plataformas
+- **Produtividade**: Foque em tarefas de alto valor enquanto a automação cuida das rotinas

docs/pt-BR/tools/cloud-storage/bedrockinvokeagenttool.mdx

@@ -0,0 +1,187 @@
+---
+title: Ferramenta Bedrock Invoke Agent
+description: Permite que agentes CrewAI invoquem Amazon Bedrock Agents e aproveitem suas capacidades em seus fluxos de trabalho
+icon: aws
+---
+
+# `BedrockInvokeAgentTool`
+
+A `BedrockInvokeAgentTool` permite que agentes CrewAI invoquem Amazon Bedrock Agents e aproveitem suas capacidades em seus fluxos de trabalho.
+
+## Instalação
+
+```bash
+uv pip install 'crewai[tools]'
+```
+
+## Requisitos
+
+- Credenciais AWS configuradas (através de variáveis de ambiente ou AWS CLI)
+- Pacotes `boto3` e `python-dotenv`
+- Acesso aos Amazon Bedrock Agents
+
+## Uso
+
+Veja como usar a ferramenta com um agente CrewAI:
+
+```python {2, 4-8}
+from crewai import Agent, Task, Crew
+from crewai_tools.aws.bedrock.agents.invoke_agent_tool import BedrockInvokeAgentTool
+
+# Initialize the tool
+agent_tool = BedrockInvokeAgentTool(
+    agent_id="your-agent-id",
+    agent_alias_id="your-agent-alias-id"
+)
+
+# Create a CrewAI agent that uses the tool
+aws_expert = Agent(
+    role='AWS Service Expert',
+    goal='Help users understand AWS services and quotas',
+    backstory='I am an expert in AWS services and can provide detailed information about them.',
+    tools=[agent_tool],
+    verbose=True
+)
+
+# Create a task for the agent
+quota_task = Task(
+    description="Find out the current service quotas for EC2 in us-west-2 and explain any recent changes.",
+    agent=aws_expert
+)
+
+# Create a crew with the agent
+crew = Crew(
+    agents=[aws_expert],
+    tasks=[quota_task],
+    verbose=2
+)
+
+# Run the crew
+result = crew.kickoff()
+print(result)
+```
+
+## Argumentos da Ferramenta
+
+| Argumento | Tipo | Obrigatório | Padrão   | Descrição                                           |
+|:----------|:-----|:------------|:---------|:----------------------------------------------------|
+| **agent_id** | `str` | Sim       | None     | O identificador único do agente Bedrock              |
+| **agent_alias_id** | `str` | Sim  | None     | O identificador único do alias do agente             |
+| **session_id** | `str` | Não     | timestamp | O identificador único da sessão                      |
+| **enable_trace** | `bool` | Não  | False    | Define se o trace deve ser habilitado para debug     |
+| **end_session** | `bool` | Não   | False    | Define se a sessão deve ser encerrada após invocação |
+| **description** | `str` | Não    | None     | Descrição personalizada para a ferramenta            |
+
+## Variáveis de Ambiente
+
+```bash
+BEDROCK_AGENT_ID=your-agent-id           # Alternativa para passar agent_id
+BEDROCK_AGENT_ALIAS_ID=your-agent-alias-id # Alternativa para passar agent_alias_id
+AWS_REGION=your-aws-region               # Padrão é us-west-2
+AWS_ACCESS_KEY_ID=your-access-key        # Necessário para autenticação AWS
+AWS_SECRET_ACCESS_KEY=your-secret-key    # Necessário para autenticação AWS
+```
+
+## Uso Avançado
+
+### Fluxo de Trabalho Multiagente com Gerenciamento de Sessão
+
+```python {2, 4-22}
+from crewai import Agent, Task, Crew, Process
+from crewai_tools.aws.bedrock.agents.invoke_agent_tool import BedrockInvokeAgentTool
+
+# Initialize tools with session management
+initial_tool = BedrockInvokeAgentTool(
+    agent_id="your-agent-id",
+    agent_alias_id="your-agent-alias-id",
+    session_id="custom-session-id"
+)
+
+followup_tool = BedrockInvokeAgentTool(
+    agent_id="your-agent-id",
+    agent_alias_id="your-agent-alias-id",
+    session_id="custom-session-id"
+)
+
+final_tool = BedrockInvokeAgentTool(
+    agent_id="your-agent-id",
+    agent_alias_id="your-agent-alias-id",
+    session_id="custom-session-id",
+    end_session=True
+)
+
+# Create agents for different stages
+researcher = Agent(
+    role='AWS Service Researcher',
+    goal='Gather information about AWS services',
+    backstory='I am specialized in finding detailed AWS service information.',
+    tools=[initial_tool]
+)
+
+analyst = Agent(
+    role='Service Compatibility Analyst',
+    goal='Analyze service compatibility and requirements',
+    backstory='I analyze AWS services for compatibility and integration possibilities.',
+    tools=[followup_tool]
+)
+
+summarizer = Agent(
+    role='Technical Documentation Writer',
+    goal='Create clear technical summaries',
+    backstory='I specialize in creating clear, concise technical documentation.',
+    tools=[final_tool]
+)
+
+# Create tasks
+research_task = Task(
+    description="Find all available AWS services in us-west-2 region.",
+    agent=researcher
+)
+
+analysis_task = Task(
+    description="Analyze which services support IPv6 and their implementation requirements.",
+    agent=analyst
+)
+
+summary_task = Task(
+    description="Create a summary of IPv6-compatible services and their key features.",
+    agent=summarizer
+)
+
+# Create a crew with the agents and tasks
+crew = Crew(
+    agents=[researcher, analyst, summarizer],
+    tasks=[research_task, analysis_task, summary_task],
+    process=Process.sequential,
+    verbose=2
+)
+
+# Run the crew
+result = crew.kickoff()
+```
+
+## Casos de Uso
+
+### Colaborações Híbridas Multiagente
+- Crie fluxos de trabalho onde agentes CrewAI colaboram com agentes Bedrock gerenciados executando como serviços na AWS
+- Permita cenários em que o processamento de dados sensíveis ocorre dentro do seu ambiente AWS enquanto outros agentes operam externamente
+- Conecte agentes CrewAI on-premises a agentes Bedrock baseados na nuvem para fluxos de trabalho distribuídos de inteligência
+
+### Soberania e Conformidade de Dados
+- Mantenha fluxos de trabalho agentivos sensíveis a dados dentro do seu ambiente AWS enquanto permite que agentes CrewAI externos orquestrem tarefas
+- Mantenha conformidade com requisitos de residência de dados processando informações sensíveis somente em sua conta AWS
+- Permita colaborações multiagentes seguras onde alguns agentes não podem acessar dados privados da sua organização
+
+### Integração Transparente com Serviços AWS
+- Acesse qualquer serviço AWS por meio do Amazon Bedrock Actions sem escrever código de integração complexo
+- Permita que agentes CrewAI interajam com serviços AWS usando solicitações em linguagem natural
+- Aproveite as capacidades pré-construídas dos agentes Bedrock para interagir com serviços AWS como Bedrock Knowledge Bases, Lambda e outros
+
+### Arquiteturas de Agentes Híbridos Escaláveis
+- Realize tarefas computacionalmente intensivas em agentes Bedrock gerenciados enquanto tarefas leves rodam em CrewAI
+- Escale o processamento de agentes distribuindo cargas de trabalho entre agentes CrewAI locais e agentes Bedrock na nuvem
+
+### Colaboração de Agentes Entre Organizações
+- Permita colaboração segura entre agentes CrewAI da sua organização e agentes Bedrock de organizações parceiras
+- Crie fluxos de trabalho onde a expertise externa de agentes Bedrock pode ser incorporada sem expor dados sensíveis
+- Construa ecossistemas de agentes que abrangem fronteiras organizacionais mantendo segurança e controle de dados

docs/pt-BR/tools/cloud-storage/bedrockkbretriever.mdx

@@ -0,0 +1,165 @@
+---
+title: 'Bedrock Knowledge Base Retriever'
+description: 'Recupere informações das Bases de Conhecimento do Amazon Bedrock usando consultas em linguagem natural'
+icon: aws
+---
+
+# `BedrockKBRetrieverTool`
+
+A `BedrockKBRetrieverTool` permite que agentes CrewAI recuperem informações das Bases de Conhecimento do Amazon Bedrock usando consultas em linguagem natural.
+
+## Instalação
+
+```bash
+uv pip install 'crewai[tools]'
+```
+
+## Requisitos
+
+- Credenciais AWS configuradas (via variáveis de ambiente ou AWS CLI)
+- Pacotes `boto3` e `python-dotenv`
+- Acesso à Base de Conhecimento do Amazon Bedrock
+
+## Uso
+
+Veja como utilizar a ferramenta com um agente CrewAI:
+
+```python {2, 4-17}
+from crewai import Agent, Task, Crew
+from crewai_tools.aws.bedrock.knowledge_base.retriever_tool import BedrockKBRetrieverTool
+
+# Initialize the tool
+kb_tool = BedrockKBRetrieverTool(
+    knowledge_base_id="your-kb-id",
+    number_of_results=5
+)
+
+# Create a CrewAI agent that uses the tool
+researcher = Agent(
+    role='Knowledge Base Researcher',
+    goal='Find information about company policies',
+    backstory='I am a researcher specialized in retrieving and analyzing company documentation.',
+    tools=[kb_tool],
+    verbose=True
+)
+
+# Create a task for the agent
+research_task = Task(
+    description="Find our company's remote work policy and summarize the key points.",
+    agent=researcher
+)
+
+# Create a crew with the agent
+crew = Crew(
+    agents=[researcher],
+    tasks=[research_task],
+    verbose=2
+)
+
+# Run the crew
+result = crew.kickoff()
+print(result)   
+```
+
+## Argumentos da Ferramenta
+
+| Argumento | Tipo | Obrigatório | Padrão | Descrição |
+|:----------|:-----|:------------|:-------|:----------|
+| **knowledge_base_id** | `str` | Sim | Nenhum | O identificador único da base de conhecimento (0-10 caracteres alfanuméricos) |
+| **number_of_results** | `int` | Não | 5 | Número máximo de resultados a serem retornados |
+| **retrieval_configuration** | `dict` | Não | Nenhum | Configurações personalizadas para a consulta da base de conhecimento |
+| **guardrail_configuration** | `dict` | Não | Nenhum | Configurações de filtragem de conteúdo |
+| **next_token** | `str` | Não | Nenhum | Token para paginação |
+
+## Variáveis de Ambiente
+
+```bash
+BEDROCK_KB_ID=your-knowledge-base-id  # Alternativa ao uso de knowledge_base_id
+AWS_REGION=your-aws-region            # Padrão: us-east-1
+AWS_ACCESS_KEY_ID=your-access-key     # Obrigatório para autenticação AWS
+AWS_SECRET_ACCESS_KEY=your-secret-key # Obrigatório para autenticação AWS
+```
+
+## Formato da Resposta
+
+A ferramenta retorna resultados em formato JSON:
+
+```json
+{
+  "results": [
+    {
+      "content": "Retrieved text content",
+      "content_type": "text",
+      "source_type": "S3",
+      "source_uri": "s3://bucket/document.pdf",
+      "score": 0.95,
+      "metadata": {
+        "additional": "metadata"
+      }
+    }
+  ],
+  "nextToken": "pagination-token",
+  "guardrailAction": "NONE"
+}
+```
+
+## Uso Avançado
+
+### Configuração de Recuperação Personalizada
+
+```python
+kb_tool = BedrockKBRetrieverTool(
+    knowledge_base_id="your-kb-id",
+    retrieval_configuration={
+        "vectorSearchConfiguration": {
+            "numberOfResults": 10,
+            "overrideSearchType": "HYBRID"
+        }
+    }
+)
+
+policy_expert = Agent(
+    role='Policy Expert',
+    goal='Analyze company policies in detail',
+    backstory='I am an expert in corporate policy analysis with deep knowledge of regulatory requirements.',
+    tools=[kb_tool]
+)
+```
+
+## Fontes de Dados Suportadas
+
+- Amazon S3
+- Confluence
+- Salesforce
+- SharePoint
+- Páginas web
+- Locais de documentos personalizados
+- Amazon Kendra
+- Bancos de dados SQL
+
+## Casos de Uso
+
+### Integração de Conhecimento Corporativo
+- Permita que agentes CrewAI acessem o conhecimento proprietário da sua organização sem expor dados sensíveis
+- Permita que agentes tomem decisões baseadas nas políticas, procedimentos e documentações específicas da sua empresa
+- Crie agentes capazes de responder perguntas com base na sua documentação interna mantendo a segurança dos dados
+
+### Conhecimento Especializado de Domínio
+- Conecte agentes CrewAI a bases de conhecimento específicas do domínio (jurídico, médico, técnico) sem re-treinamento de modelos
+- Aproveite repositórios de conhecimento existentes que já são mantidos no seu ambiente AWS
+- Combine o raciocínio do CrewAI com informações de domínio provenientes das suas bases de conhecimento
+
+### Tomada de Decisão Orientada por Dados
+- Baseie as respostas dos agentes CrewAI nos dados reais da sua empresa, e não apenas em conhecimento geral
+- Assegure que os agentes forneçam recomendações baseadas no contexto e documentação do seu negócio
+- Reduza alucinações ao recuperar informações factuais das suas bases de conhecimento
+
+### Acesso Escalável à Informação
+- Acesse terabytes de conhecimento organizacional sem precisar incorporar tudo aos seus modelos
+- Consulte dinamicamente apenas as informações relevantes conforme a necessidade de cada tarefa
+- Aproveite a infraestrutura escalável da AWS para lidar com grandes bases de conhecimento de forma eficiente
+
+### Conformidade e Governança
+- Garanta que agentes CrewAI forneçam respostas alinhadas com a documentação aprovada da sua empresa
+- Crie trilhas de auditoria das fontes de informação usadas pelos agentes
+- Mantenha controle sobre quais fontes de informação os seus agentes podem acessar

docs/pt-BR/tools/cloud-storage/overview.mdx

@@ -0,0 +1,51 @@
+---
+title: "Visão Geral"
+description: "Interaja com serviços em nuvem, sistemas de armazenamento e plataformas de IA baseadas em nuvem"
+icon: "face-smile"
+---
+
+Essas ferramentas permitem que seus agentes interajam com serviços em nuvem, acessem o armazenamento em nuvem e aproveitem plataformas de IA baseadas em nuvem para operações em escala.
+
+## **Ferramentas Disponíveis**
+
+<CardGroup cols={2}>
+  <Card title="S3 Reader Tool" icon="cloud" href="/pt-BR/tools/cloud-storage/s3readertool">
+    Leia arquivos e dados de buckets Amazon S3.
+  </Card>
+
+  <Card title="S3 Writer Tool" icon="cloud-arrow-up" href="/pt-BR/tools/cloud-storage/s3writertool">
+    Escreva e faça upload de arquivos para o armazenamento Amazon S3.
+  </Card>
+
+  <Card title="Bedrock Invoke Agent" icon="aws" href="/pt-BR/tools/cloud-storage/bedrockinvokeagenttool">
+    Acione agentes Amazon Bedrock para tarefas orientadas por IA.
+  </Card>
+
+  <Card title="Bedrock KB Retriever" icon="database" href="/pt-BR/tools/cloud-storage/bedrockkbretriever">
+    Recupere informações das bases de conhecimento Amazon Bedrock.
+  </Card>
+</CardGroup>
+
+## **Casos de Uso Comuns**
+
+- **Armazenamento de Arquivos**: Armazene e recupere arquivos de sistemas de armazenamento em nuvem
+- **Backup de Dados**: Faça backup de dados importantes no armazenamento em nuvem
+- **Serviços de IA**: Acesse modelos e serviços de IA baseados em nuvem
+- **Recuperação de Conhecimento**: Consulte bases de conhecimento hospedadas na nuvem
+- **Operações Escaláveis**: Aproveite a infraestrutura de nuvem para processamento
+
+```python
+from crewai_tools import S3ReaderTool, S3WriterTool, BedrockInvokeAgentTool
+
+# Create cloud tools
+s3_reader = S3ReaderTool()
+s3_writer = S3WriterTool()
+bedrock_agent = BedrockInvokeAgentTool()
+
+# Add to your agent
+agent = Agent(
+    role="Cloud Operations Specialist",
+    tools=[s3_reader, s3_writer, bedrock_agent],
+    goal="Manage cloud resources and AI services"
+)
+```

docs/pt-BR/tools/cloud-storage/s3readertool.mdx

@@ -0,0 +1,144 @@
+---
+title: S3 Reader Tool
+description: O `S3ReaderTool` permite que agentes CrewAI leiam arquivos de buckets Amazon S3.
+icon: aws
+---
+
+# `S3ReaderTool`
+
+## Descrição
+
+O `S3ReaderTool` foi projetado para ler arquivos de buckets Amazon S3. Esta ferramenta permite que os agentes CrewAI acessem e recuperem conteúdos armazenados no S3, tornando-a ideal para fluxos de trabalho que exigem leitura de dados, arquivos de configuração ou qualquer outro conteúdo armazenado no AWS S3.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar as dependências requeridas:
+
+```shell
+uv add boto3
+```
+
+## Passos para Começar
+
+Para usar o `S3ReaderTool` efetivamente, siga estes passos:
+
+1. **Instale as Dependências**: Instale os pacotes necessários usando o comando acima.
+2. **Configure as Credenciais AWS**: Defina suas credenciais AWS como variáveis de ambiente.
+3. **Inicialize a Ferramenta**: Crie uma instância da ferramenta.
+4. **Especifique o Caminho S3**: Forneça o caminho S3 do arquivo que deseja ler.
+
+## Exemplo
+
+O exemplo a seguir demonstra como utilizar o `S3ReaderTool` para ler um arquivo de um bucket S3:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools.aws.s3 import S3ReaderTool
+
+# Initialize the tool
+s3_reader_tool = S3ReaderTool()
+
+# Define an agent that uses the tool
+file_reader_agent = Agent(
+    role="File Reader",
+    goal="Read files from S3 buckets",
+    backstory="An expert in retrieving and processing files from cloud storage.",
+    tools=[s3_reader_tool],
+    verbose=True,
+)
+
+# Example task to read a configuration file
+read_task = Task(
+    description="Read the configuration file from {my_bucket} and summarize its contents.",
+    expected_output="A summary of the configuration file contents.",
+    agent=file_reader_agent,
+)
+
+# Create and run the crew
+crew = Crew(agents=[file_reader_agent], tasks=[read_task])
+result = crew.kickoff(inputs={"my_bucket": "s3://my-bucket/config/app-config.json"})
+```
+
+## Parâmetros
+
+O `S3ReaderTool` aceita o seguinte parâmetro quando utilizado por um agente:
+
+- **file_path**: Obrigatório. O caminho do arquivo S3 no formato `s3://nome-do-bucket/nome-do-arquivo`.
+
+## Credenciais AWS
+
+A ferramenta requer credenciais AWS para acessar buckets S3. Você pode configurar essas credenciais usando variáveis de ambiente:
+
+- **CREW_AWS_REGION**: Região AWS onde seu bucket S3 está localizado. O padrão é `us-east-1`.
+- **CREW_AWS_ACCESS_KEY_ID**: Sua AWS access key ID.
+- **CREW_AWS_SEC_ACCESS_KEY**: Sua AWS secret access key.
+
+## Uso
+
+Ao utilizar o `S3ReaderTool` com um agente, o agente deverá fornecer o caminho do arquivo S3:
+
+```python Code
+# Example of using the tool with an agent
+file_reader_agent = Agent(
+    role="File Reader",
+    goal="Read files from S3 buckets",
+    backstory="An expert in retrieving and processing files from cloud storage.",
+    tools=[s3_reader_tool],
+    verbose=True,
+)
+
+# Create a task for the agent to read a specific file
+read_config_task = Task(
+    description="Read the application configuration file from {my_bucket} and extract the database connection settings.",
+    expected_output="The database connection settings from the configuration file.",
+    agent=file_reader_agent,
+)
+
+# Run the task
+crew = Crew(agents=[file_reader_agent], tasks=[read_config_task])
+result = crew.kickoff(inputs={"my_bucket": "s3://my-bucket/config/app-config.json"})
+```
+
+## Tratamento de Erros
+
+O `S3ReaderTool` inclui tratamento para erros comuns do S3:
+
+- Formato inválido de caminho S3
+- Arquivos ausentes ou inacessíveis
+- Problemas de permissão
+- Problemas com credenciais AWS
+
+Quando um erro ocorre, a ferramenta retorna uma mensagem de erro com detalhes sobre o problema.
+
+## Detalhes da Implementação
+
+O `S3ReaderTool` utiliza o AWS SDK for Python (boto3) para interagir com o S3:
+
+```python Code
+class S3ReaderTool(BaseTool):
+    name: str = "S3 Reader Tool"
+    description: str = "Reads a file from Amazon S3 given an S3 file path"
+    
+    def _run(self, file_path: str) -> str:
+        try:
+            bucket_name, object_key = self._parse_s3_path(file_path)
+
+            s3 = boto3.client(
+                's3',
+                region_name=os.getenv('CREW_AWS_REGION', 'us-east-1'),
+                aws_access_key_id=os.getenv('CREW_AWS_ACCESS_KEY_ID'),
+                aws_secret_access_key=os.getenv('CREW_AWS_SEC_ACCESS_KEY')
+            )
+
+            # Read file content from S3
+            response = s3.get_object(Bucket=bucket_name, Key=object_key)
+            file_content = response['Body'].read().decode('utf-8')
+
+            return file_content
+        except ClientError as e:
+            return f"Error reading file from S3: {str(e)}"
+```
+
+## Conclusão
+
+O `S3ReaderTool` oferece uma maneira simples de ler arquivos de buckets Amazon S3. Ao permitir que agentes acessem conteúdos armazenados no S3, facilita fluxos de trabalho que necessitam de acesso a arquivos na nuvem. Esta ferramenta é especialmente útil para processamento de dados, gestão de configurações e qualquer tarefa que envolva a obtenção de informações do armazenamento AWS S3.

docs/pt-BR/tools/cloud-storage/s3writertool.mdx

@@ -0,0 +1,150 @@
+---
+title: Ferramenta S3 Writer
+description: A `S3WriterTool` permite que agentes CrewAI escrevam conteúdo em arquivos em buckets Amazon S3.
+icon: aws
+---
+
+# `S3WriterTool`
+
+## Descrição
+
+A `S3WriterTool` foi projetada para escrever conteúdo em arquivos em buckets Amazon S3. Esta ferramenta permite que agentes CrewAI criem ou atualizem arquivos no S3, tornando-a ideal para fluxos de trabalho que exigem armazenamento de dados, salvamento de arquivos de configuração ou persistência de qualquer outro conteúdo no armazenamento AWS S3.
+
+## Instalação
+
+Para usar esta ferramenta, você precisa instalar as dependências necessárias:
+
+```shell
+uv add boto3
+```
+
+## Passos para Começar
+
+Para usar a `S3WriterTool` de forma eficaz, siga estes passos:
+
+1. **Instale as Dependências**: Instale os pacotes necessários usando o comando acima.
+2. **Configure as Credenciais AWS**: Defina suas credenciais AWS como variáveis de ambiente.
+3. **Inicialize a Ferramenta**: Crie uma instância da ferramenta.
+4. **Especifique o Caminho no S3 e o Conteúdo**: Forneça o caminho no S3 onde deseja gravar o arquivo e o conteúdo a ser escrito.
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar a `S3WriterTool` para gravar conteúdo em um arquivo em um bucket S3:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools.aws.s3 import S3WriterTool
+
+# Initialize the tool
+s3_writer_tool = S3WriterTool()
+
+# Define an agent that uses the tool
+file_writer_agent = Agent(
+    role="File Writer",
+    goal="Write content to files in S3 buckets",
+    backstory="An expert in storing and managing files in cloud storage.",
+    tools=[s3_writer_tool],
+    verbose=True,
+)
+
+# Example task to write a report
+write_task = Task(
+    description="Generate a summary report of the quarterly sales data and save it to {my_bucket}.",
+    expected_output="Confirmation that the report was successfully saved to S3.",
+    agent=file_writer_agent,
+)
+
+# Create and run the crew
+crew = Crew(agents=[file_writer_agent], tasks=[write_task])
+result = crew.kickoff(inputs={"my_bucket": "s3://my-bucket/reports/quarterly-summary.txt"})
+```
+
+## Parâmetros
+
+A `S3WriterTool` aceita os seguintes parâmetros quando utilizada por um agente:
+
+- **file_path**: Obrigatório. O caminho do arquivo S3 no formato `s3://bucket-name/file-name`.
+- **content**: Obrigatório. O conteúdo a ser escrito no arquivo.
+
+## Credenciais AWS
+
+A ferramenta requer credenciais AWS para acessar os buckets S3. Você pode configurar essas credenciais usando variáveis de ambiente:
+
+- **CREW_AWS_REGION**: A região AWS onde seu bucket S3 está localizado. O padrão é `us-east-1`.
+- **CREW_AWS_ACCESS_KEY_ID**: Sua AWS access key ID.
+- **CREW_AWS_SEC_ACCESS_KEY**: Sua AWS secret access key.
+
+## Uso
+
+Ao usar a `S3WriterTool` com um agente, o agente precisará fornecer tanto o caminho do arquivo no S3 quanto o conteúdo a ser gravado:
+
+```python Code
+# Example of using the tool with an agent
+file_writer_agent = Agent(
+    role="File Writer",
+    goal="Write content to files in S3 buckets",
+    backstory="An expert in storing and managing files in cloud storage.",
+    tools=[s3_writer_tool],
+    verbose=True,
+)
+
+# Create a task for the agent to write a specific file
+write_config_task = Task(
+    description="""
+    Create a configuration file with the following database settings:
+    - host: db.example.com
+    - port: 5432
+    - username: app_user
+    - password: secure_password
+    
+    Save this configuration as JSON to {my_bucket}.
+    """,
+    expected_output="Confirmation that the configuration file was successfully saved to S3.",
+    agent=file_writer_agent,
+)
+
+# Run the task
+crew = Crew(agents=[file_writer_agent], tasks=[write_config_task])
+result = crew.kickoff(inputs={"my_bucket": "s3://my-bucket/config/db-config.json"})
+```
+
+## Tratamento de Erros
+
+A `S3WriterTool` inclui tratamento de erros para problemas comuns no S3:
+
+- Formato de caminho S3 inválido
+- Problemas de permissão (ex: sem acesso de gravação ao bucket)
+- Problemas com credenciais AWS
+- Bucket inexistente
+
+Quando ocorre um erro, a ferramenta retorna uma mensagem de erro que inclui detalhes sobre o problema.
+
+## Detalhes de Implementação
+
+A `S3WriterTool` utiliza o AWS SDK para Python (boto3) para interagir com o S3:
+
+```python Code
+class S3WriterTool(BaseTool):
+    name: str = "S3 Writer Tool"
+    description: str = "Writes content to a file in Amazon S3 given an S3 file path"
+    
+    def _run(self, file_path: str, content: str) -> str:
+        try:
+            bucket_name, object_key = self._parse_s3_path(file_path)
+
+            s3 = boto3.client(
+                's3',
+                region_name=os.getenv('CREW_AWS_REGION', 'us-east-1'),
+                aws_access_key_id=os.getenv('CREW_AWS_ACCESS_KEY_ID'),
+                aws_secret_access_key=os.getenv('CREW_AWS_SEC_ACCESS_KEY')
+            )
+
+            s3.put_object(Bucket=bucket_name, Key=object_key, Body=content.encode('utf-8'))
+            return f"Successfully wrote content to {file_path}"
+        except ClientError as e:
+            return f"Error writing file to S3: {str(e)}"
+```
+
+## Conclusão
+
+A `S3WriterTool` oferece uma maneira direta de gravar conteúdo em arquivos em buckets Amazon S3. Ao permitir que agentes criem e atualizem arquivos no S3, ela facilita fluxos de trabalho que exigem armazenamento de arquivos em nuvem. Esta ferramenta é particularmente útil para persistência de dados, gerenciamento de configurações, geração de relatórios e qualquer tarefa que envolva armazenar informações no AWS S3.

docs/pt-BR/tools/database-data/mysqltool.mdx

@@ -0,0 +1,69 @@
+---
+title: Busca RAG no MySQL
+description: O `MySQLSearchTool` foi projetado para buscar em bancos de dados MySQL e retornar os resultados mais relevantes.
+icon: database
+---
+
+## Visão Geral
+
+Esta ferramenta foi desenvolvida para facilitar buscas semânticas em tabelas de bancos de dados MySQL. Utilizando a tecnologia RAG (Retrieve and Generate),
+o MySQLSearchTool oferece aos usuários um meio eficiente de consultar o conteúdo de tabelas do banco de dados, especificamente adaptado para bancos MySQL.
+Ela simplifica o processo de encontrar dados relevantes por meio de consultas de busca semântica, tornando-se um recurso valioso para quem precisa
+realizar consultas avançadas em grandes conjuntos de dados dentro de um banco de dados MySQL.
+
+## Instalação
+
+Para instalar o pacote `crewai_tools` e utilizar o MySQLSearchTool, execute o seguinte comando no seu terminal:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+Abaixo está um exemplo demonstrando como usar o MySQLSearchTool para realizar uma busca semântica em uma tabela de um banco de dados MySQL:
+
+```python Code
+from crewai_tools import MySQLSearchTool
+
+# Inicialize a ferramenta com o URI do banco de dados e o nome da tabela de destino
+tool = MySQLSearchTool(
+    db_uri='mysql://user:password@localhost:3306/mydatabase',
+    table_name='employees'
+)
+```
+
+## Argumentos
+
+O MySQLSearchTool requer os seguintes argumentos para sua operação:
+
+- `db_uri`: Uma string representando o URI do banco de dados MySQL a ser consultado. Este argumento é obrigatório e deve incluir os detalhes de autenticação necessários e o local do banco de dados.
+- `table_name`: Uma string especificando o nome da tabela dentro do banco de dados na qual será realizada a busca semântica. Este argumento é obrigatório.
+
+## Modelo e embeddings personalizados
+
+Por padrão, a ferramenta utiliza o OpenAI tanto para embeddings quanto para sumarização. Para customizar o modelo, você pode usar um dicionário de configuração conforme o exemplo:
+
+```python Code
+tool = MySQLSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/database-data/nl2sqltool.mdx

@@ -0,0 +1,76 @@
+---
+title: NL2SQL Tool
+description: O `NL2SQLTool` foi projetado para converter linguagem natural em consultas SQL.
+icon: language
+---
+
+## Visão Geral
+
+Esta ferramenta é utilizada para converter linguagem natural em consultas SQL. Quando passada para o agente, ela irá gerar as consultas e, em seguida, utilizá-las para interagir com o banco de dados.
+
+Isso possibilita múltiplos fluxos de trabalho, como por exemplo ter um Agente acessando o banco de dados para buscar informações com base em um objetivo e, então, usar essas informações para gerar uma resposta, relatório ou qualquer outro tipo de saída. Além disso, permite que o Agente atualize o banco de dados de acordo com seu objetivo.
+
+**Atenção**: Certifique-se de que o Agente tenha acesso a um Read-Replica ou que seja permitido que o Agente execute consultas de inserção/atualização no banco de dados.
+
+## Requisitos
+
+- SqlAlchemy
+- Qualquer biblioteca compatível com o banco de dados (ex.: psycopg2, mysql-connector-python)
+
+## Instalação
+
+Instale o pacote crewai_tools
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Uso
+
+Para utilizar o NL2SQLTool, você precisa passar a URI do banco de dados para a ferramenta. O formato da URI deve ser `dialect+driver://username:password@host:port/database`.
+
+```python Code
+from crewai_tools import NL2SQLTool
+
+# psycopg2 foi instalado para rodar este exemplo com PostgreSQL
+nl2sql = NL2SQLTool(db_uri="postgresql://example@localhost:5432/test_db")
+
+@agent
+def researcher(self) -> Agent:
+    return Agent(
+        config=self.agents_config["researcher"],
+        allow_delegation=False,
+        tools=[nl2sql]
+    )
+```
+
+## Exemplo
+
+O objetivo principal da tarefa era:
+
+"Recupere a receita mensal média, máxima e mínima para cada cidade, mas inclua apenas cidades que tenham mais de um usuário. Além disso, conte o número de usuários em cada cidade e classifique os resultados pela receita mensal média em ordem decrescente"
+
+Assim, o Agente tentou obter informações do banco de dados; a primeira vez está errada, então o Agente tenta novamente, consegue a informação correta e repassa para o próximo agente.
+
+![alt text](https://github.com/crewAIInc/crewAI-tools/blob/main/crewai_tools/tools/nl2sql/images/image-2.png?raw=true)
+![alt text](https://github.com/crewAIInc/crewAI-tools/raw/main/crewai_tools/tools/nl2sql/images/image-3.png)
+
+O segundo objetivo da tarefa foi:
+
+"Revise os dados e crie um relatório detalhado e, em seguida, crie a tabela no banco de dados com os campos baseados nos dados fornecidos. Inclua informações sobre a receita mensal média, máxima e mínima para cada cidade, mas apenas inclua cidades que possuam mais de um usuário. Também conte o número de usuários em cada cidade e classifique os resultados pela receita mensal média em ordem decrescente."
+
+Agora as coisas começam a ficar interessantes: o Agente gera a consulta SQL não só para criar a tabela, mas também inserir os dados na tabela. E, ao final, o Agente ainda retorna o relatório final que condiz exatamente com o que estava no banco de dados.
+
+![alt text](https://github.com/crewAIInc/crewAI-tools/raw/main/crewai_tools/tools/nl2sql/images/image-4.png)
+![alt text](https://github.com/crewAIInc/crewAI-tools/raw/main/crewai_tools/tools/nl2sql/images/image-5.png)
+
+![alt text](https://github.com/crewAIInc/crewAI-tools/raw/main/crewai_tools/tools/nl2sql/images/image-9.png)
+![alt text](https://github.com/crewAIInc/crewAI-tools/raw/main/crewai_tools/tools/nl2sql/images/image-7.png)
+
+Este é um exemplo simples de como o NL2SQLTool pode ser utilizado para interagir com o banco de dados e gerar relatórios baseados nos dados do banco.
+
+A ferramenta oferece possibilidades infinitas para a lógica do Agente e como ele pode interagir com o banco de dados.
+
+```md
+ DB -> Agent -> ... -> Agent -> DB
+```

docs/pt-BR/tools/database-data/overview.mdx

@@ -0,0 +1,58 @@
+---
+title: "Visão Geral"
+description: "Conecte-se a bancos de dados, armazenamentos vetoriais e data warehouses para acesso abrangente aos dados"
+icon: "face-smile"
+---
+
+Essas ferramentas permitem que seus agentes interajam com diversos sistemas de banco de dados, desde bancos de dados SQL tradicionais até armazenamentos vetoriais modernos e data warehouses.
+
+## **Ferramentas Disponíveis**
+
+<CardGroup cols={2}>
+  <Card title="MySQL Tool" icon="database" href="/pt-BR/tools/database-data/mysqltool">
+    Conecte-se e faça consultas a bancos de dados MySQL com operações SQL.
+  </Card>
+
+  <Card title="PostgreSQL Search" icon="elephant" href="/pt-BR/tools/database-data/pgsearchtool">
+    Pesquise e consulte bancos de dados PostgreSQL de forma eficiente.
+  </Card>
+
+  <Card title="Snowflake Search" icon="snowflake" href="/pt-BR/tools/database-data/snowflakesearchtool">
+    Acesse o data warehouse Snowflake para análises e relatórios.
+  </Card>
+
+  <Card title="NL2SQL Tool" icon="language" href="/pt-BR/tools/database-data/nl2sqltool">
+    Converta automaticamente consultas em linguagem natural para comandos SQL.
+  </Card>
+
+  <Card title="Qdrant Vector Search" icon="vector-square" href="/pt-BR/tools/database-data/qdrantvectorsearchtool">
+    Pesquise embeddings vetoriais usando o banco de dados vetorial Qdrant.
+  </Card>
+
+  <Card title="Weaviate Vector Search" icon="network-wired" href="/pt-BR/tools/database-data/weaviatevectorsearchtool">
+    Realize buscas semânticas com o banco de dados vetorial Weaviate.
+  </Card>
+</CardGroup>
+
+## **Casos de Uso Comuns**
+
+- **Análise de Dados**: Consulte bancos de dados para inteligência de negócios e relatórios
+- **Busca Vetorial**: Encontre conteúdos similares utilizando embeddings semânticos
+- **Operações ETL**: Extraia, transforme e carregue dados entre sistemas
+- **Análise em Tempo Real**: Acesse dados ao vivo para tomada de decisões
+
+```python
+from crewai_tools import MySQLTool, QdrantVectorSearchTool, NL2SQLTool
+
+# Create database tools
+mysql_db = MySQLTool()
+vector_search = QdrantVectorSearchTool()
+nl_to_sql = NL2SQLTool()
+
+# Add to your agent
+agent = Agent(
+    role="Data Analyst",
+    tools=[mysql_db, vector_search, nl_to_sql],
+    goal="Extract insights from various data sources"
+)
+```

docs/pt-BR/tools/database-data/pgsearchtool.mdx

@@ -0,0 +1,82 @@
+---
+title: PG RAG Search
+description: O `PGSearchTool` foi desenvolvido para pesquisar bancos de dados PostgreSQL e retornar os resultados mais relevantes.
+icon: elephant
+---
+
+## Visão geral
+
+<Note>
+    O PGSearchTool está atualmente em desenvolvimento. Este documento descreve a funcionalidade e a interface pretendidas.
+    Conforme o desenvolvimento avança, esteja ciente de que alguns recursos podem não estar disponíveis ou podem mudar.
+</Note>
+
+## Descrição
+
+O PGSearchTool é concebido como uma ferramenta poderosa para facilitar buscas semânticas em tabelas de bancos de dados PostgreSQL. Aproveitando tecnologia avançada de Recuperação e Geração (RAG), 
+ele visa fornecer um meio eficiente para consultar o conteúdo de tabelas de banco de dados, especificamente voltado para bancos de dados PostgreSQL.
+O objetivo da ferramenta é simplificar o processo de encontrar dados relevantes por meio de consultas semânticas, oferecendo um recurso valioso para usuários que precisam realizar buscas avançadas em
+grandes volumes de dados dentro de um ambiente PostgreSQL.
+
+## Instalação
+
+O pacote `crewai_tools`, que incluirá o PGSearchTool assim que for lançado, pode ser instalado usando o comando abaixo:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+<Note>
+    O PGSearchTool ainda não está disponível na versão atual do pacote `crewai_tools`. Este comando de instalação será atualizado assim que a ferramenta for lançada.
+</Note>
+
+## Exemplo de Uso
+
+Abaixo está um exemplo proposto mostrando como utilizar o PGSearchTool para realizar uma busca semântica em uma tabela dentro de um banco de dados PostgreSQL:
+
+```python Code
+from crewai_tools import PGSearchTool
+
+# Inicialize a ferramenta com a URI do banco de dados e o nome da tabela alvo
+tool = PGSearchTool(
+    db_uri='postgresql://user:password@localhost:5432/mydatabase', 
+    table_name='employees'
+)
+```
+
+## Argumentos
+
+O PGSearchTool foi projetado para exigir os seguintes argumentos para seu funcionamento:
+
+| Argumento      | Tipo      | Descrição                                                                                                                        |
+|:---------------|:---------|:---------------------------------------------------------------------------------------------------------------------------------|
+| **db_uri**     | `string` | **Obrigatório**. Uma string que representa a URI do banco de dados PostgreSQL a ser consultado. Este argumento será obrigatório e deve incluir os detalhes necessários de autenticação e a localização do banco de dados. |
+| **table_name** | `string` | **Obrigatório**. Uma string que especifica o nome da tabela dentro do banco de dados na qual a busca semântica será realizada. Este argumento também será obrigatório. |
+
+## Modelo Personalizado e Embeddings
+
+A ferramenta pretende usar OpenAI tanto para embeddings quanto para sumarização por padrão. Os usuários terão a opção de personalizar o modelo usando um dicionário de configuração, conforme mostrado abaixo:
+
+```python Code
+tool = PGSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/database-data/qdrantvectorsearchtool.mdx

@@ -0,0 +1,272 @@
+---
+title: 'Qdrant Vector Search Tool'
+description: 'Capacidades de busca semântica para agentes CrewAI usando o banco de dados vetorial Qdrant'
+icon: vector-square
+---
+
+## Visão Geral
+
+A ferramenta Qdrant Vector Search permite adicionar capacidades de busca semântica aos seus agentes CrewAI utilizando o [Qdrant](https://qdrant.tech/), um mecanismo de busca por similaridade vetorial. Com essa ferramenta, seus agentes podem pesquisar em documentos armazenados em uma coleção Qdrant usando similaridade semântica.
+
+## Instalação
+
+Instale os pacotes necessários:
+
+```bash
+uv add qdrant-client
+```
+
+## Uso Básico
+
+Veja um exemplo mínimo de como utilizar a ferramenta:
+
+```python
+from crewai import Agent
+from crewai_tools import QdrantVectorSearchTool
+
+# Inicialize a ferramenta
+qdrant_tool = QdrantVectorSearchTool(
+    qdrant_url="your_qdrant_url",
+    qdrant_api_key="your_qdrant_api_key",
+    collection_name="your_collection"
+)
+
+# Crie um agente que utiliza a ferramenta
+agent = Agent(
+    role="Research Assistant",
+    goal="Find relevant information in documents",
+    tools=[qdrant_tool]
+)
+
+# A ferramenta usará automaticamente embeddings da OpenAI
+# e retornará os 3 resultados mais relevantes com pontuação > 0.35
+```
+
+## Exemplo Completo e Funcional
+
+Veja um exemplo completo mostrando como:
+1. Extrair texto de um PDF
+2. Gerar embeddings usando OpenAI
+3. Armazenar no Qdrant
+4. Criar um fluxo de trabalho RAG agente CrewAI para busca semântica
+
+```python
+import os
+import uuid
+import pdfplumber
+from openai import OpenAI
+from dotenv import load_dotenv
+from crewai import Agent, Task, Crew, Process, LLM
+from crewai_tools import QdrantVectorSearchTool
+from qdrant_client import QdrantClient
+from qdrant_client.models import PointStruct, Distance, VectorParams
+
+# Carregar variáveis de ambiente
+load_dotenv()
+
+# Inicializar cliente OpenAI
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+# Extrair texto do PDF
+def extract_text_from_pdf(pdf_path):
+    text = []
+    with pdfplumber.open(pdf_path) as pdf:
+        for page in pdf.pages:
+            page_text = page.extract_text()
+            if page_text:
+                text.append(page_text.strip())
+    return text
+
+# Gerar embeddings da OpenAI
+def get_openai_embedding(text):
+    response = client.embeddings.create(
+        input=text,
+        model="text-embedding-3-small"
+    )
+    return response.data[0].embedding
+
+# Armazenar texto e embeddings no Qdrant
+def load_pdf_to_qdrant(pdf_path, qdrant, collection_name):
+    # Extrair texto do PDF
+    text_chunks = extract_text_from_pdf(pdf_path)
+    
+    # Criar coleção no Qdrant
+    if qdrant.collection_exists(collection_name):
+        qdrant.delete_collection(collection_name)
+    qdrant.create_collection(
+        collection_name=collection_name,
+        vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
+    )
+
+    # Armazenar embeddings
+    points = []
+    for chunk in text_chunks:
+        embedding = get_openai_embedding(chunk)
+        points.append(PointStruct(
+            id=str(uuid.uuid4()),
+            vector=embedding,
+            payload={"text": chunk}
+        ))
+    qdrant.upsert(collection_name=collection_name, points=points)
+
+# Inicializar cliente Qdrant e carregar dados
+qdrant = QdrantClient(
+    url=os.getenv("QDRANT_URL"),
+    api_key=os.getenv("QDRANT_API_KEY")
+)
+collection_name = "example_collection"
+pdf_path = "path/to/your/document.pdf"
+load_pdf_to_qdrant(pdf_path, qdrant, collection_name)
+
+# Inicializar ferramenta de busca Qdrant
+qdrant_tool = QdrantVectorSearchTool(
+    qdrant_url=os.getenv("QDRANT_URL"),
+    qdrant_api_key=os.getenv("QDRANT_API_KEY"),
+    collection_name=collection_name,
+    limit=3,
+    score_threshold=0.35
+)
+
+# Criar agentes CrewAI
+search_agent = Agent(
+    role="Senior Semantic Search Agent",
+    goal="Find and analyze documents based on semantic search",
+    backstory="""You are an expert research assistant who can find relevant 
+    information using semantic search in a Qdrant database.""",
+    tools=[qdrant_tool],
+    verbose=True
+)
+
+answer_agent = Agent(
+    role="Senior Answer Assistant",
+    goal="Generate answers to questions based on the context provided",
+    backstory="""You are an expert answer assistant who can generate 
+    answers to questions based on the context provided.""",
+    tools=[qdrant_tool],
+    verbose=True
+)
+
+# Definir tarefas
+search_task = Task(
+    description="""Search for relevant documents about the {query}.
+    Your final answer should include:
+    - The relevant information found
+    - The similarity scores of the results
+    - The metadata of the relevant documents""",
+    agent=search_agent
+)
+
+answer_task = Task(
+    description="""Given the context and metadata of relevant documents,
+    generate a final answer based on the context.""",
+    agent=answer_agent
+)
+
+# Executar fluxo CrewAI
+crew = Crew(
+    agents=[search_agent, answer_agent],
+    tasks=[search_task, answer_task],
+    process=Process.sequential,
+    verbose=True
+)
+
+result = crew.kickoff(
+    inputs={"query": "What is the role of X in the document?"}
+)
+print(result)
+```
+
+## Parâmetros da Ferramenta
+
+### Parâmetros Obrigatórios
+- `qdrant_url` (str): URL do seu servidor Qdrant
+- `qdrant_api_key` (str): Chave de API para autenticação com o Qdrant
+- `collection_name` (str): Nome da coleção Qdrant a ser pesquisada
+
+### Parâmetros Opcionais
+- `limit` (int): Número máximo de resultados a serem retornados (padrão: 3)
+- `score_threshold` (float): Limite mínimo de similaridade (padrão: 0.35)
+- `custom_embedding_fn` (Callable[[str], list[float]]): Função personalizada para vetorização de textos
+
+## Parâmetros de Busca
+
+A ferramenta aceita estes parâmetros em seu schema:
+- `query` (str): Consulta de busca para encontrar documentos similares
+- `filter_by` (str, opcional): Campo de metadado para filtrar
+- `filter_value` (str, opcional): Valor para filtrar
+
+## Formato de Retorno
+
+A ferramenta retorna resultados no formato JSON:
+
+```json
+[
+  {
+    "metadata": {
+      // Todos os metadados armazenados junto com o documento
+    },
+    "context": "O conteúdo textual real do documento",
+    "distance": 0.95  // Pontuação de similaridade
+  }
+]
+```
+
+## Embedding Padrão
+
+Por padrão, a ferramenta utiliza o modelo `text-embedding-3-small` da OpenAI para vetorização. Isso requer:
+- Chave de API da OpenAI definida na variável de ambiente: `OPENAI_API_KEY`
+
+## Embeddings Personalizados
+
+Em vez de utilizar o modelo padrão de embeddings, você pode utilizar sua própria função de embeddings nos casos em que:
+
+1. Deseja usar um modelo de embeddings diferente (ex: Cohere, HuggingFace, modelos Ollama)
+2. Precisa reduzir custos utilizando modelos de código aberto
+3. Tem requisitos específicos quanto à dimensão dos vetores ou à qualidade dos embeddings
+4. Deseja utilizar embeddings específicos para determinado domínio (ex: textos médicos ou jurídicos)
+
+Veja um exemplo utilizando um modelo HuggingFace:
+
+```python
+from transformers import AutoTokenizer, AutoModel
+import torch
+
+# Carregar modelo e tokenizer
+tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+model = AutoModel.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+
+def custom_embeddings(text: str) -> list[float]:
+    # Tokenizar e obter saídas do modelo
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
+    outputs = model(**inputs)
+    
+    # Usar mean pooling para obter o embedding do texto
+    embeddings = outputs.last_hidden_state.mean(dim=1)
+    
+    # Converter para lista de floats e retornar
+    return embeddings[0].tolist()
+
+# Usar embeddings personalizados com a ferramenta
+tool = QdrantVectorSearchTool(
+    qdrant_url="your_url",
+    qdrant_api_key="your_key",
+    collection_name="your_collection",
+    custom_embedding_fn=custom_embeddings  # Passe sua função personalizada
+)
+```
+
+## Tratamento de Erros
+
+A ferramenta trata os seguintes erros específicos:
+- Lança ImportError se `qdrant-client` não estiver instalado (com opção de instalar automaticamente)
+- Lança ValueError se `QDRANT_URL` não estiver definido
+- Solicita instalação de `qdrant-client` se estiver ausente utilizando `uv add qdrant-client`
+
+## Variáveis de Ambiente
+
+Variáveis de ambiente obrigatórias:
+```bash
+export QDRANT_URL="your_qdrant_url"  # Se não for informado no construtor
+export QDRANT_API_KEY="your_api_key"  # Se não for informado no construtor
+export OPENAI_API_KEY="your_openai_key"  # Se estiver usando embeddings padrão
+```

docs/pt-BR/tools/database-data/snowflakesearchtool.mdx

@@ -0,0 +1,202 @@
+---
+title: Snowflake Search Tool
+description: O `SnowflakeSearchTool` permite que agentes CrewAI executem consultas SQL e realizem buscas semânticas em data warehouses Snowflake.
+icon: snowflake
+---
+
+# `SnowflakeSearchTool`
+
+## Descrição
+
+O `SnowflakeSearchTool` foi desenvolvido para conectar-se a data warehouses Snowflake e executar consultas SQL com recursos avançados como pool de conexões, lógica de tentativas e execução assíncrona. Esta ferramenta permite que agentes CrewAI interajam com bases de dados Snowflake, sendo ideal para tarefas de análise de dados, relatórios e inteligência de negócios que requerem acesso a dados empresariais armazenados no Snowflake.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar as dependências requeridas:
+
+```shell
+uv add cryptography snowflake-connector-python snowflake-sqlalchemy
+```
+
+Ou, alternativamente:
+
+```shell
+uv sync --extra snowflake
+```
+
+## Passos para Começar
+
+Para usar eficazmente o `SnowflakeSearchTool`, siga estes passos:
+
+1. **Instale as Dependências**: Instale os pacotes necessários usando um dos comandos acima.
+2. **Configure a Conexão com o Snowflake**: Crie um objeto `SnowflakeConfig` com suas credenciais do Snowflake.
+3. **Inicialize a Ferramenta**: Crie uma instância da ferramenta com a configuração necessária.
+4. **Execute Consultas**: Utilize a ferramenta para rodar consultas SQL no seu banco de dados Snowflake.
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar o `SnowflakeSearchTool` para consultar dados de um banco de dados Snowflake:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import SnowflakeSearchTool, SnowflakeConfig
+
+# Create Snowflake configuration
+config = SnowflakeConfig(
+    account="your_account",
+    user="your_username",
+    password="your_password",
+    warehouse="COMPUTE_WH",
+    database="your_database",
+    snowflake_schema="your_schema"
+)
+
+# Initialize the tool
+snowflake_tool = SnowflakeSearchTool(config=config)
+
+# Define an agent that uses the tool
+data_analyst_agent = Agent(
+    role="Data Analyst",
+    goal="Analyze data from Snowflake database",
+    backstory="An expert data analyst who can extract insights from enterprise data.",
+    tools=[snowflake_tool],
+    verbose=True,
+)
+
+# Example task to query sales data
+query_task = Task(
+    description="Query the sales data for the last quarter and summarize the top 5 products by revenue.",
+    expected_output="A summary of the top 5 products by revenue for the last quarter.",
+    agent=data_analyst_agent,
+)
+
+# Create and run the crew
+crew = Crew(agents=[data_analyst_agent], 
+            tasks=[query_task])
+result = crew.kickoff()
+```
+
+Você também pode customizar a ferramenta com parâmetros adicionais:
+
+```python Code
+# Initialize the tool with custom parameters
+snowflake_tool = SnowflakeSearchTool(
+    config=config,
+    pool_size=10,
+    max_retries=5,
+    retry_delay=2.0,
+    enable_caching=True
+)
+```
+
+## Parâmetros
+
+### Parâmetros do SnowflakeConfig
+
+A classe `SnowflakeConfig` aceita os seguintes parâmetros:
+
+- **account**: Obrigatório. Identificador da conta Snowflake.
+- **user**: Obrigatório. Nome de usuário do Snowflake.
+- **password**: Opcional*. Senha do Snowflake.
+- **private_key_path**: Opcional*. Caminho para o arquivo de chave privada (alternativa à senha).
+- **warehouse**: Obrigatório. Nome do warehouse do Snowflake.
+- **database**: Obrigatório. Banco de dados padrão.
+- **snowflake_schema**: Obrigatório. Schema padrão.
+- **role**: Opcional. Papel de usuário Snowflake.
+- **session_parameters**: Opcional. Parâmetros de sessão personalizados como dicionário.
+
+*É necessário fornecer `password` ou `private_key_path`.
+
+### Parâmetros do SnowflakeSearchTool
+
+O `SnowflakeSearchTool` aceita os seguintes parâmetros durante a inicialização:
+
+- **config**: Obrigatório. Um objeto `SnowflakeConfig` contendo detalhes da conexão.
+- **pool_size**: Opcional. Número de conexões no pool. O padrão é 5.
+- **max_retries**: Opcional. Número máximo de tentativas para consultas que falharem. Padrão é 3.
+- **retry_delay**: Opcional. Intervalo entre tentativas em segundos. Padrão é 1.0.
+- **enable_caching**: Opcional. Define se o cache de resultados de consultas será habilitado. Padrão é True.
+
+## Uso
+
+Ao utilizar o `SnowflakeSearchTool`, você deve fornecer os seguintes parâmetros:
+
+- **query**: Obrigatório. Consulta SQL a ser executada.
+- **database**: Opcional. Sobrescreve o banco de dados padrão especificado na configuração.
+- **snowflake_schema**: Opcional. Sobrescreve o schema padrão especificado na configuração.
+- **timeout**: Opcional. Tempo limite da consulta em segundos. O padrão é 300.
+
+A ferramenta retornará os resultados da consulta como uma lista de dicionários, onde cada dicionário representa uma linha com os nomes das colunas como chaves.
+
+```python Code
+# Example of using the tool with an agent
+data_analyst = Agent(
+    role="Data Analyst",
+    goal="Analyze sales data from Snowflake",
+    backstory="An expert data analyst with experience in SQL and data visualization.",
+    tools=[snowflake_tool],
+    verbose=True
+)
+
+# The agent will use the tool with parameters like:
+# query="SELECT product_name, SUM(revenue) as total_revenue FROM sales GROUP BY product_name ORDER BY total_revenue DESC LIMIT 5"
+# timeout=600
+
+# Create a task for the agent
+analysis_task = Task(
+    description="Query the sales database and identify the top 5 products by revenue for the last quarter.",
+    expected_output="A detailed analysis of the top 5 products by revenue.",
+    agent=data_analyst
+)
+
+# Run the task
+crew = Crew(
+    agents=[data_analyst], 
+    tasks=[analysis_task]
+)
+result = crew.kickoff()
+```
+
+## Recursos Avançados
+
+### Pool de Conexões
+
+O `SnowflakeSearchTool` implementa pool de conexões para melhorar a performance reutilizando conexões com o banco de dados. Você pode controlar o tamanho do pool com o parâmetro `pool_size`.
+
+### Tentativas Automáticas
+
+A ferramenta tenta novamente consultas que falharem automaticamente, usando backoff exponencial. O comportamento das tentativas pode ser ajustado pelos parâmetros `max_retries` e `retry_delay`.
+
+### Cache de Resultados de Consultas
+
+Para melhorar a performance em consultas repetidas, a ferramenta pode armazenar resultados em cache. Este recurso está habilitado por padrão, mas pode ser desativado ao definir `enable_caching=False`.
+
+### Autenticação por Par de Chaves
+
+Além de autenticação por senha, a ferramenta também suporta autenticação por par de chaves para maior segurança:
+
+```python Code
+config = SnowflakeConfig(
+    account="your_account",
+    user="your_username",
+    private_key_path="/path/to/your/private/key.p8",
+    warehouse="COMPUTE_WH",
+    database="your_database",
+    snowflake_schema="your_schema"
+)
+```
+
+## Tratamento de Erros
+
+O `SnowflakeSearchTool` inclui uma gestão abrangente de erros para situações comuns no Snowflake:
+
+- Falhas de conexão
+- Timeout de consultas
+- Erros de autenticação
+- Erros de banco de dados e schema
+
+Quando um erro ocorrer, a ferramenta tentará repetir a operação (se estiver configurado) e fornecerá informações detalhadas sobre o erro.
+
+## Conclusão
+
+O `SnowflakeSearchTool` oferece uma maneira poderosa de integrar data warehouses Snowflake com agentes CrewAI. Com recursos como pool de conexões, tentativas automáticas e cache de consultas, ele possibilita acesso eficiente e confiável aos dados empresariais. Esta ferramenta é particularmente útil para tarefas de análise de dados, relatórios e inteligência de negócios que demandam acesso a dados estruturados armazenados no Snowflake.

docs/pt-BR/tools/database-data/weaviatevectorsearchtool.mdx

@@ -0,0 +1,162 @@
+---
+title: Busca Vetorial Weaviate
+description: O `WeaviateVectorSearchTool` foi projetado para buscar documentos semanticamente similares em um banco de dados vetorial Weaviate.
+icon: network-wired
+---
+
+## Visão Geral
+
+O `WeaviateVectorSearchTool` foi especificamente desenvolvido para realizar buscas semânticas em documentos armazenados em um banco de dados vetorial Weaviate. Essa ferramenta permite encontrar documentos semanticamente similares a uma determinada consulta, aproveitando o poder das embeddings vetoriais para resultados de busca mais precisos e contextualmente relevantes.
+
+[Weaviate](https://weaviate.io/) é um banco de dados vetorial que armazena e consulta embeddings vetoriais, possibilitando recursos de busca semântica.
+
+## Instalação
+
+Para incorporar esta ferramenta ao seu projeto, é necessário instalar o cliente Weaviate:
+
+```shell
+uv add weaviate-client
+```
+
+## Etapas para Começar
+
+Para utilizar efetivamente o `WeaviateVectorSearchTool`, siga as etapas abaixo:
+
+1. **Instalação dos Pacotes**: Confirme que os pacotes `crewai[tools]` e `weaviate-client` estão instalados em seu ambiente Python.
+2. **Configuração do Weaviate**: Configure um cluster Weaviate. Você pode seguir as instruções na [documentação do Weaviate](https://weaviate.io/developers/wcs/manage-clusters/connect).
+3. **Chaves de API**: Obtenha a URL do seu cluster Weaviate e a chave de API correspondente.
+4. **Chave de API da OpenAI**: Certifique-se de que você tenha uma chave de API da OpenAI definida nas variáveis de ambiente como `OPENAI_API_KEY`.
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma busca:
+
+```python Code
+from crewai_tools import WeaviateVectorSearchTool
+
+# Inicializar a ferramenta
+tool = WeaviateVectorSearchTool(
+    collection_name='example_collections',
+    limit=3,
+    weaviate_cluster_url="https://your-weaviate-cluster-url.com",
+    weaviate_api_key="your-weaviate-api-key",
+)
+
+@agent
+def search_agent(self) -> Agent:
+    '''
+    Este agente utiliza o WeaviateVectorSearchTool para buscar 
+    documentos semanticamente similares em um banco de dados vetorial Weaviate.
+    '''
+    return Agent(
+        config=self.agents_config["search_agent"],
+        tools=[tool]
+    )
+```
+
+## Parâmetros
+
+O `WeaviateVectorSearchTool` aceita os seguintes parâmetros:
+
+- **collection_name**: Obrigatório. O nome da coleção a ser pesquisada.
+- **weaviate_cluster_url**: Obrigatório. A URL do cluster Weaviate.
+- **weaviate_api_key**: Obrigatório. A chave de API para o cluster Weaviate.
+- **limit**: Opcional. O número de resultados a serem retornados. O padrão é `3`.
+- **vectorizer**: Opcional. O vetorizador a ser utilizado. Se não for informado, será utilizado o `text2vec_openai` com o modelo `nomic-embed-text`.
+- **generative_model**: Opcional. O modelo generativo a ser utilizado. Se não for informado, será utilizado o `gpt-4o` da OpenAI.
+
+## Configuração Avançada
+
+Você pode personalizar o vetorizador e o modelo generativo utilizados pela ferramenta:
+
+```python Code
+from crewai_tools import WeaviateVectorSearchTool
+from weaviate.classes.config import Configure
+
+# Configurar modelo personalizado para vetorizador e modelo generativo
+tool = WeaviateVectorSearchTool(
+    collection_name='example_collections',
+    limit=3,
+    vectorizer=Configure.Vectorizer.text2vec_openai(model="nomic-embed-text"),
+    generative_model=Configure.Generative.openai(model="gpt-4o-mini"),
+    weaviate_cluster_url="https://your-weaviate-cluster-url.com",
+    weaviate_api_key="your-weaviate-api-key",
+)
+```
+
+## Pré-carregando Documentos
+
+Você pode pré-carregar seu banco de dados Weaviate com documentos antes de utilizar a ferramenta:
+
+```python Code
+import os
+from crewai_tools import WeaviateVectorSearchTool
+import weaviate
+from weaviate.classes.init import Auth
+
+# Conectar ao Weaviate
+client = weaviate.connect_to_weaviate_cloud(
+    cluster_url="https://your-weaviate-cluster-url.com",
+    auth_credentials=Auth.api_key("your-weaviate-api-key"),
+    headers={"X-OpenAI-Api-Key": "your-openai-api-key"}
+)
+
+# Obter ou criar coleção
+test_docs = client.collections.get("example_collections")
+if not test_docs:
+    test_docs = client.collections.create(
+        name="example_collections",
+        vectorizer_config=Configure.Vectorizer.text2vec_openai(model="nomic-embed-text"),
+        generative_config=Configure.Generative.openai(model="gpt-4o"),
+    )
+
+# Carregar documentos
+docs_to_load = os.listdir("knowledge")
+with test_docs.batch.dynamic() as batch:
+    for d in docs_to_load:
+        with open(os.path.join("knowledge", d), "r") as f:
+            content = f.read()
+        batch.add_object(
+            {
+                "content": content,
+                "year": d.split("_")[0],
+            }
+        )
+
+# Inicializar a ferramenta
+tool = WeaviateVectorSearchTool(
+    collection_name='example_collections', 
+    limit=3,
+    weaviate_cluster_url="https://your-weaviate-cluster-url.com",
+    weaviate_api_key="your-weaviate-api-key",
+)
+```
+
+## Exemplo de Integração com Agente
+
+Veja como integrar o `WeaviateVectorSearchTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent
+from crewai_tools import WeaviateVectorSearchTool
+
+# Inicializar a ferramenta
+weaviate_tool = WeaviateVectorSearchTool(
+    collection_name='example_collections',
+    limit=3,
+    weaviate_cluster_url="https://your-weaviate-cluster-url.com",
+    weaviate_api_key="your-weaviate-api-key",
+)
+
+# Criar um agente com a ferramenta
+rag_agent = Agent(
+    name="rag_agent",
+    role="Você é um assistente útil que pode responder perguntas com a ajuda do WeaviateVectorSearchTool.",
+    llm="gpt-4o-mini",
+    tools=[weaviate_tool],
+)
+```
+
+## Conclusão
+
+O `WeaviateVectorSearchTool` fornece uma maneira poderosa de buscar documentos semanticamente similares em um banco de dados vetorial Weaviate. Ao utilizar embeddings vetoriais, ele permite resultados de busca mais precisos e relevantes em termos de contexto, quando comparado a buscas tradicionais baseadas em palavras-chave. Essa ferramenta é especialmente útil para aplicações que precisam encontrar informações a partir do significado e não apenas de correspondências exatas.

docs/pt-BR/tools/file-document/csvsearchtool.mdx

@@ -0,0 +1,77 @@
+---
+title: Busca RAG em CSV
+description: O `CSVSearchTool` é uma poderosa ferramenta RAG (Geração com Recuperação Aprimorada) projetada para buscas semânticas no conteúdo de arquivos CSV.
+icon: file-csv
+---
+
+# `CSVSearchTool`
+
+<Note>
+    **Experimental**: Ainda estamos trabalhando na melhoria das ferramentas, portanto podem ocorrer comportamentos inesperados ou mudanças futuras.
+</Note>
+
+## Descrição
+
+Esta ferramenta é utilizada para realizar buscas RAG (Geração com Recuperação Aprimorada) no conteúdo de um arquivo CSV. Ela permite que usuários façam buscas semânticas por consultas no conteúdo de um arquivo CSV especificado. 
+Este recurso é particularmente útil para extrair informações de grandes datasets CSV, em que métodos de busca tradicionais poderiam ser ineficientes. Todas as ferramentas com "Search" no nome, incluindo o CSVSearchTool, 
+são ferramentas RAG projetadas para busca em diferentes fontes de dados.
+
+## Instalação
+
+Instale o pacote crewai_tools
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+```python Code
+from crewai_tools import CSVSearchTool
+
+# Inicialize a ferramenta com um arquivo CSV específico.
+# Esta configuração permite que o agente busque somente no arquivo CSV fornecido.
+tool = CSVSearchTool(csv='path/to/your/csvfile.csv')
+
+# OU
+
+# Inicialize a ferramenta sem um arquivo CSV específico.
+# O agente precisará informar o caminho do CSV em tempo de execução.
+tool = CSVSearchTool()
+```
+
+## Argumentos
+
+Os seguintes parâmetros podem ser utilizados para personalizar o comportamento do `CSVSearchTool`:
+
+| Argumento      | Tipo      | Descrição                                                                                                                         |
+|:---------------|:----------|:----------------------------------------------------------------------------------------------------------------------------------|
+| **csv**        | `string`  | _Opcional_. O caminho para o arquivo CSV que você deseja buscar. Este é um argumento obrigatório se a ferramenta for inicializada sem um arquivo CSV específico; caso contrário, é opcional.                                                              |
+
+## Modelo e embeddings personalizados
+
+Por padrão, a ferramenta utiliza OpenAI tanto para embeddings quanto para sumarização. Para personalizar o modelo, você pode usar um dicionário de configuração como segue:
+
+```python Code
+tool = CSVSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/file-document/directoryreadtool.mdx

@@ -0,0 +1,53 @@
+---
+title: Leitura de Diretório
+description: O `DirectoryReadTool` é uma poderosa utilidade projetada para fornecer uma listagem abrangente do conteúdo de diretórios.
+icon: folder-tree
+---
+
+# `DirectoryReadTool`
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, então pode haver comportamentos inesperados ou alterações no futuro.
+</Note>
+
+## Descrição
+
+O DirectoryReadTool é uma poderosa utilidade projetada para fornecer uma listagem abrangente do conteúdo de diretórios. 
+Ele pode navegar recursivamente pelo diretório especificado, oferecendo aos usuários uma enumeração detalhada de todos os arquivos, incluindo aqueles que estão dentro de subdiretórios. 
+Essa ferramenta é fundamental para tarefas que exigem um inventário completo das estruturas de diretórios ou para validar a organização de arquivos em diretórios.
+
+## Instalação
+
+Para utilizar o DirectoryReadTool em seu projeto, instale o pacote `crewai_tools`. Se este pacote ainda não faz parte do seu ambiente, você pode instalá-lo usando o pip com o comando abaixo:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+Esse comando instala a versão mais recente do pacote `crewai_tools`, permitindo o acesso ao DirectoryReadTool, entre outras utilidades.
+
+## Exemplo
+
+Empregar o DirectoryReadTool é simples. O snippet de código a seguir demonstra como configurá-lo e usar a ferramenta para listar o conteúdo de um diretório especificado:
+
+```python Code
+from crewai_tools import DirectoryReadTool
+
+# Initialize the tool so the agent can read any directory's content 
+# it learns about during execution
+tool = DirectoryReadTool()
+
+# OR
+
+# Initialize the tool with a specific directory, 
+# so the agent can only read the content of the specified directory
+tool = DirectoryReadTool(directory='/path/to/your/directory')
+```
+
+## Argumentos
+
+Os seguintes parâmetros podem ser usados para personalizar o comportamento do `DirectoryReadTool`:
+
+| Argumento      | Tipo     | Descrição                                                                                                                         |
+|:---------------|:---------|:----------------------------------------------------------------------------------------------------------------------------------|
+| **directory**  | `string` | _Opcional_. Um argumento que especifica o caminho para o diretório cujo conteúdo você deseja listar. Aceita caminhos absolutos e relativos, direcionando a ferramenta para o diretório desejado para a listagem do conteúdo. |

docs/pt-BR/tools/file-document/directorysearchtool.mdx

@@ -0,0 +1,67 @@
+---
+title: Busca RAG em Diretório
+description: O `DirectorySearchTool` é uma poderosa ferramenta RAG (Retrieval-Augmented Generation) desenvolvida para buscas semânticas no conteúdo de um diretório.
+icon: address-book
+---
+
+# `DirectorySearchTool`
+
+<Note>
+    **Experimental**: O DirectorySearchTool está em desenvolvimento contínuo. As funcionalidades e recursos podem evoluir, e comportamentos inesperados podem ocorrer enquanto aprimoramos a ferramenta.
+</Note>
+
+## Descrição
+
+O DirectorySearchTool permite a busca semântica dentro do conteúdo de diretórios especificados, aproveitando a metodologia de Recuperação com Geração Aumentada (RAG) para uma navegação eficiente entre arquivos. Projetada para flexibilidade, a ferramenta possibilita que usuários especifiquem dinamicamente os diretórios de busca em tempo de execução ou definam um diretório fixo durante a configuração inicial.
+
+## Instalação
+
+Para utilizar o DirectorySearchTool, comece instalando o pacote crewai_tools. Execute o seguinte comando no seu terminal:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Inicialização e Uso
+
+Importe o DirectorySearchTool do pacote `crewai_tools` para começar. Você pode inicializar a ferramenta sem especificar um diretório, permitindo definir o diretório de busca em tempo de execução. Alternativamente, a ferramenta pode ser inicializada já com um diretório predefinido.
+
+```python Code
+from crewai_tools import DirectorySearchTool
+
+# Para especificação dinâmica de diretório em tempo de execução
+tool = DirectorySearchTool()
+
+# Para buscas em diretório fixo
+tool = DirectorySearchTool(directory='/path/to/directory')
+```
+
+## Argumentos
+
+- `directory`: Um argumento do tipo string que especifica o diretório de busca. Este parâmetro é opcional durante a inicialização, mas obrigatório para buscas caso não tenha sido definido inicialmente.
+
+## Modelo Personalizado e Embeddings
+
+O DirectorySearchTool utiliza OpenAI para embeddings e sumarização por padrão. As opções de personalização dessas configurações incluem a alteração do provedor de modelo e configurações, ampliando a flexibilidade para usuários avançados.
+
+```python Code
+tool = DirectorySearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # As opções incluem ollama, google, anthropic, llama2 e mais
+            config=dict(
+                model="llama2",
+                # Configurações adicionais aqui
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/file-document/docxsearchtool.mdx

@@ -0,0 +1,79 @@
+---
+title: Pesquisa RAG em DOCX
+description: A `DOCXSearchTool` é uma ferramenta RAG projetada para busca semântica em documentos DOCX.
+icon: file-word
+---
+
+# `DOCXSearchTool`
+
+<Note>
+    Ainda estamos trabalhando na melhoria das ferramentas, portanto pode haver comportamentos inesperados ou alterações no futuro.
+</Note>
+
+## Descrição
+
+A `DOCXSearchTool` é uma ferramenta RAG desenvolvida para buscas semânticas dentro de documentos DOCX.
+Ela permite que os usuários pesquisem e extraiam informações relevantes de arquivos DOCX de forma eficiente, utilizando buscas baseadas em consultas.
+Esta ferramenta é inestimável para análise de dados, gestão da informação e tarefas de pesquisa,
+otimizando o processo de encontrar informações específicas em grandes coleções de documentos.
+
+## Instalação
+
+Instale o pacote crewai_tools executando o seguinte comando no seu terminal:
+
+```shell
+uv pip install docx2txt 'crewai[tools]'
+```
+
+## Exemplo
+
+O exemplo a seguir demonstra a inicialização da DOCXSearchTool para buscar dentro do conteúdo de qualquer arquivo DOCX ou com o caminho de um arquivo DOCX específico.
+
+```python Code
+from crewai_tools import DOCXSearchTool
+
+# Inicialize a ferramenta para buscar dentro do conteúdo de qualquer arquivo DOCX
+tool = DOCXSearchTool()
+
+# OU
+
+# Inicialize a ferramenta com um arquivo DOCX específico,
+# assim o agente só poderá buscar dentro do conteúdo do arquivo DOCX especificado
+tool = DOCXSearchTool(docx='path/to/your/document.docx')
+```
+
+## Argumentos
+
+Os seguintes parâmetros podem ser usados para customizar o comportamento da `DOCXSearchTool`:
+
+| Argumento      | Tipo      | Descrição                                                                                                                           |
+|:---------------|:----------|:------------------------------------------------------------------------------------------------------------------------------------|
+| **docx**        | `string`  | _Opcional_. Um argumento que especifica o caminho para o arquivo DOCX que você deseja pesquisar. Se não for fornecido durante a inicialização, a ferramenta permite a especificação posterior do caminho de qualquer arquivo DOCX para busca. |
+
+## Modelo e embeddings personalizados
+
+Por padrão, a ferramenta utiliza o OpenAI tanto para embeddings quanto para sumarização. Para customizar o modelo, você pode usar um dicionário de configuração como no exemplo:
+
+```python Code
+tool = DOCXSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/file-document/filereadtool.mdx

@@ -0,0 +1,44 @@
+---
+title: Leitura de Arquivo
+description: O `FileReadTool` foi desenvolvido para ler arquivos do sistema de arquivos local.
+icon: folders
+---
+
+## Visão Geral
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, portanto pode haver comportamentos inesperados ou alterações no futuro.
+</Note>
+
+O FileReadTool representa conceitualmente um conjunto de funcionalidades dentro do pacote crewai_tools voltadas para facilitar a leitura e a recuperação de conteúdo de arquivos.
+Esse conjunto inclui ferramentas para processar arquivos de texto em lote, ler arquivos de configuração em tempo de execução e importar dados para análise.
+Ele suporta uma variedade de formatos de arquivo baseados em texto, como `.txt`, `.csv`, `.json` e outros. Dependendo do tipo de arquivo, o conjunto oferece funcionalidades especializadas,
+como converter conteúdo JSON em um dicionário Python para facilitar o uso.
+
+## Instalação
+
+Para utilizar as funcionalidades anteriormente atribuídas ao FileReadTool, instale o pacote crewai_tools:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo de Uso
+
+Para começar a usar o FileReadTool:
+
+```python Code
+from crewai_tools import FileReadTool
+
+# Inicialize a ferramenta para ler quaisquer arquivos que os agentes conhecem ou informe o caminho para
+file_read_tool = FileReadTool()
+
+# OU
+
+# Inicialize a ferramenta com um caminho de arquivo específico, assim o agente poderá ler apenas o conteúdo do arquivo especificado
+file_read_tool = FileReadTool(file_path='path/to/your/file.txt')
+```
+
+## Argumentos
+
+- `file_path`: O caminho para o arquivo que você deseja ler. Aceita caminhos absolutos e relativos. Certifique-se de que o arquivo exista e de que você tenha as permissões necessárias para acessá-lo.

docs/pt-BR/tools/file-document/filewritetool.mdx

@@ -0,0 +1,50 @@
+---
+title: Escrita de Arquivo
+description: O `FileWriterTool` foi projetado para escrever conteúdo em arquivos.
+icon: file-pen
+---
+
+# `FileWriterTool`
+
+## Descrição
+
+O `FileWriterTool` é um componente do pacote crewai_tools, projetado para simplificar o processo de escrita de conteúdo em arquivos com compatibilidade multiplataforma (Windows, Linux, macOS).  
+É particularmente útil em cenários como geração de relatórios, salvamento de logs, criação de arquivos de configuração e mais.  
+Essa ferramenta lida com diferenças de caminhos entre sistemas operacionais, suporta codificação UTF-8 e cria diretórios automaticamente caso eles não existam, facilitando a organização da sua saída de forma confiável em diferentes plataformas.
+
+## Instalação
+
+Instale o pacote crewai_tools para utilizar o `FileWriterTool` em seus projetos:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+Para começar a usar o `FileWriterTool`:
+
+```python Code
+from crewai_tools import FileWriterTool
+
+# Inicialize a ferramenta
+file_writer_tool = FileWriterTool()
+
+# Escreva conteúdo em um arquivo em um diretório especificado
+result = file_writer_tool._run('example.txt', 'This is a test content.', 'test_directory')
+print(result)
+```
+
+## Argumentos
+
+- `filename`: O nome do arquivo que você deseja criar ou sobrescrever.
+- `content`: O conteúdo a ser escrito no arquivo.
+- `directory` (opcional): O caminho para o diretório onde o arquivo será criado. Por padrão, utiliza o diretório atual (`.`). Se o diretório não existir, ele será criado.
+
+## Conclusão
+
+Ao integrar o `FileWriterTool` aos seus crews, os agentes podem escrever conteúdo em arquivos de forma confiável em diferentes sistemas operacionais.  
+Esta ferramenta é essencial para tarefas que exigem salvamento de dados de saída, criação de sistemas de arquivos estruturados e manipulação de operações de arquivos multiplataforma.  
+É especialmente recomendada para usuários do Windows que possam enfrentar problemas ao escrever arquivos com as operações padrão do Python.
+
+Seguindo as orientações de configuração e uso fornecidas, incorporar essa ferramenta em projetos é simples e garante um comportamento consistente de escrita de arquivos em todas as plataformas.

docs/pt-BR/tools/file-document/jsonsearchtool.mdx

@@ -0,0 +1,75 @@
+---
+title: Busca JSON RAG
+description: O `JSONSearchTool` foi projetado para buscar arquivos JSON e retornar os resultados mais relevantes.
+icon: file-code
+---
+
+# `JSONSearchTool`
+
+<Note>
+  O JSONSearchTool está atualmente em fase experimental. Isso significa que a ferramenta
+  está em desenvolvimento ativo, e os usuários podem encontrar comportamentos inesperados ou
+  alterações. Incentivamos fortemente o envio de feedback sobre quaisquer problemas ou sugestões de
+  melhorias.
+</Note>
+
+## Descrição
+
+O JSONSearchTool foi projetado para facilitar buscas eficientes e precisas dentro do conteúdo de arquivos JSON. Ele utiliza um mecanismo de busca RAG (Retrieve and Generate), permitindo que os usuários especifiquem um caminho JSON para buscas direcionadas dentro de um arquivo JSON específico. Essa capacidade melhora significativamente a precisão e relevância dos resultados de busca.
+
+## Instalação
+
+Para instalar o JSONSearchTool, utilize o seguinte comando pip:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplos de Uso
+
+Aqui estão exemplos atualizados de como utilizar o JSONSearchTool de forma eficaz para buscar dentro de arquivos JSON. Esses exemplos consideram a implementação e padrões de uso atuais identificados na base de código.
+
+```python Code
+from crewai_tools import JSONSearchTool
+
+# Busca geral em conteúdo JSON
+# Esta abordagem é adequada quando o caminho JSON já é conhecido ou pode ser identificado dinamicamente.
+tool = JSONSearchTool()
+
+# Restringindo a busca a um arquivo JSON específico
+# Use este método de inicialização quando desejar limitar o escopo de busca a um arquivo específico.
+tool = JSONSearchTool(json_path='./path/to/your/file.json')
+```
+
+## Argumentos
+
+- `json_path` (str, opcional): Especifica o caminho para o arquivo JSON a ser buscado. Este argumento não é obrigatório se a ferramenta for inicializada para uma busca geral. Quando fornecido, limita a busca ao arquivo JSON especificado.
+
+## Opções de Configuração
+
+O JSONSearchTool oferece ampla personalização através de um dicionário de configuração. Isso permite que os usuários selecionem diferentes modelos para embeddings e sumarização conforme suas necessidades.
+
+```python Code
+tool = JSONSearchTool(
+    config={
+        "llm": {
+            "provider": "ollama",  # Outras opções incluem google, openai, anthropic, llama2, etc.
+            "config": {
+                "model": "llama2",
+                # Configurações opcionais adicionais podem ser especificadas aqui.
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            },
+        },
+        "embedding_model": {
+            "provider": "google", # ou openai, ollama, ...
+            "config": {
+                "model": "models/embedding-001",
+                "task_type": "retrieval_document",
+                # Mais opções de personalização podem ser adicionadas aqui.
+            },
+        },
+    }
+)
+```

docs/pt-BR/tools/file-document/mdxsearchtool.mdx

@@ -0,0 +1,73 @@
+---
+title: Pesquisa MDX RAG
+description: O `MDXSearchTool` foi projetado para pesquisar arquivos MDX e retornar os resultados mais relevantes.
+icon: markdown
+---
+
+# `MDXSearchTool`
+
+<Note>
+    O MDXSearchTool está em desenvolvimento contínuo. Recursos podem ser adicionados ou removidos, e a funcionalidade pode mudar de forma imprevisível à medida que refinamos a ferramenta.
+</Note>
+
+## Descrição
+
+A Ferramenta de Pesquisa MDX é um componente do pacote `crewai_tools` focado em facilitar a extração avançada de dados do markdown. Ela permite que usuários pesquisem e extraiam informações relevantes de arquivos MD utilizando buscas baseadas em consulta. Esta ferramenta é indispensável para análise de dados, gestão de informações e tarefas de pesquisa, agilizando o processo de encontrar informações específicas em grandes coleções de documentos.
+
+## Instalação
+
+Antes de utilizar a Ferramenta de Pesquisa MDX, certifique-se de que o pacote `crewai_tools` está instalado. Caso não esteja, você pode instalá-lo com o comando abaixo:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo de Uso
+
+Para utilizar a Ferramenta de Pesquisa MDX, primeiro defina as variáveis de ambiente necessárias. Em seguida, integre a ferramenta ao seu projeto crewAI para começar sua pesquisa de mercado. Veja abaixo um exemplo básico de como fazer isso:
+
+```python Code
+from crewai_tools import MDXSearchTool
+
+# Inicialize a ferramenta para pesquisar qualquer conteúdo MDX que ela conheça durante a execução
+tool = MDXSearchTool()
+
+# OU
+
+# Inicialize a ferramenta com um caminho específico para o arquivo MDX, realizando buscas exclusivamente neste documento
+tool = MDXSearchTool(mdx='path/to/your/document.mdx')
+```
+
+## Parâmetros
+
+- mdx: **Opcional**. Especifica o caminho do arquivo MDX para pesquisa. Pode ser informado durante a inicialização.
+
+## Personalização do Modelo e Embeddings
+
+A ferramenta utiliza, por padrão, o OpenAI para embeddings e sumarização. Para personalizar, utilize um dicionário de configuração conforme exemplo abaixo:
+
+```python Code
+tool = MDXSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # As opções incluem google, openai, anthropic, llama2, etc.
+            config=dict(
+                model="llama2",
+                # Parâmetros opcionais podem ser incluídos aqui.
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # Um título opcional para os embeddings pode ser adicionado aqui.
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/file-document/overview.mdx

@@ -0,0 +1,88 @@
+---
+title: "Visão Geral"
+description: "Leia, escreva e pesquise em diversos formatos de arquivos com as ferramentas de processamento de documentos do CrewAI"
+icon: "face-smile"
+---
+
+Estas ferramentas permitem que seus agentes trabalhem com diversos formatos e tipos de documentos. De leitura de PDFs ao processamento de dados em JSON, essas ferramentas atendem a todas as suas necessidades de processamento de documentos.
+
+## **Ferramentas Disponíveis**
+
+<CardGroup cols={2}>
+  <Card title="Ferramenta de Leitura de Arquivos" icon="folders" href="/pt-BR/tools/file-document/filereadtool">
+    Leia conteúdo de qualquer tipo de arquivo, incluindo texto, markdown e mais.
+  </Card>
+
+  <Card title="Ferramenta de Escrita de Arquivos" icon="file-pen" href="/pt-BR/tools/file-document/filewritetool">
+    Escreva conteúdo em arquivos, crie novos documentos e salve dados processados.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em PDF" icon="file-pdf" href="/pt-BR/tools/file-document/pdfsearchtool">
+    Pesquise e extraia conteúdo de texto de documentos PDF de forma eficiente.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em DOCX" icon="file-word" href="/pt-BR/tools/file-document/docxsearchtool">
+    Pesquise em documentos do Microsoft Word e extraia conteúdo relevante.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em JSON" icon="brackets-curly" href="/pt-BR/tools/file-document/jsonsearchtool">
+    Faça a análise e pesquisa em arquivos JSON com recursos avançados de consulta.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em CSV" icon="table" href="/pt-BR/tools/file-document/csvsearchtool">
+    Processe e pesquise em arquivos CSV, extraia linhas e colunas específicas.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em XML" icon="code" href="/pt-BR/tools/file-document/xmlsearchtool">
+    Analise arquivos XML e pesquise elementos e atributos específicos.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em MDX" icon="markdown" href="/pt-BR/tools/file-document/mdxsearchtool">
+    Pesquise em arquivos MDX e extraia conteúdo de documentações.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em TXT" icon="file-lines" href="/pt-BR/tools/file-document/txtsearchtool">
+    Pesquise em arquivos de texto simples com recursos de busca por padrões.
+  </Card>
+
+  <Card title="Ferramenta de Pesquisa em Diretório" icon="folder-open" href="/pt-BR/tools/file-document/directorysearchtool">
+    Pesquise arquivos e pastas dentro de estruturas de diretórios.
+  </Card>
+
+  <Card title="Ferramenta de Leitura de Diretório" icon="folder" href="/pt-BR/tools/file-document/directoryreadtool">
+    Leia e liste conteúdos de diretórios, estruturas de arquivos e metadados.
+  </Card>
+</CardGroup>
+
+## **Casos de Uso Comuns**
+
+- **Processamento de Documentos**: Extraia e analise conteúdo de vários formatos de arquivos
+- **Importação de Dados**: Leia dados estruturados de arquivos CSV, JSON e XML
+- **Busca por Conteúdo**: Encontre informações específicas em grandes coleções de documentos
+- **Gerenciamento de Arquivos**: Organize e manipule arquivos e diretórios
+- **Exportação de Dados**: Salve os resultados processados em vários formatos de arquivo
+
+## **Exemplo Rápido de Início**
+
+```python
+from crewai_tools import FileReadTool, PDFSearchTool, JSONSearchTool
+
+# Create tools
+file_reader = FileReadTool()
+pdf_searcher = PDFSearchTool()
+json_processor = JSONSearchTool()
+
+# Add to your agent
+agent = Agent(
+    role="Document Analyst",
+    tools=[file_reader, pdf_searcher, json_processor],
+    goal="Process and analyze various document types"
+)
+```
+
+## **Dicas para Processamento de Documentos**
+
+- **Permissões de Arquivo**: Certifique-se de que seu agente possui as permissões adequadas de leitura/escrita
+- **Arquivos Grandes**: Considere dividir documentos muito grandes em partes menores
+- **Suporte de Formatos**: Consulte a documentação da ferramenta para saber quais formatos de arquivos são suportados
+- **Tratamento de Erros**: Implemente tratamento de erros adequado para arquivos corrompidos ou inacessíveis

docs/pt-BR/tools/file-document/pdfsearchtool.mdx

@@ -0,0 +1,71 @@
+---
+title: Busca RAG em PDF
+description: O `PDFSearchTool` é projetado para pesquisar arquivos PDF e retornar os resultados mais relevantes.
+icon: file-pdf
+---
+
+# `PDFSearchTool`
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, então pode haver comportamentos inesperados ou mudanças futuras.
+</Note>
+
+## Descrição
+
+O PDFSearchTool é uma ferramenta RAG projetada para buscas semânticas dentro do conteúdo de PDFs. Ela permite inserir uma consulta de busca e um documento PDF, aproveitando técnicas avançadas de busca para encontrar conteúdos relevantes de forma eficiente.
+Essa capacidade a torna especialmente útil para extrair informações específicas de arquivos PDF grandes rapidamente.
+
+## Instalação
+
+Para começar a usar o PDFSearchTool, primeiro, garanta que o pacote crewai_tools está instalado com o seguinte comando:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+Veja como utilizar o PDFSearchTool para buscar dentro de um documento PDF:
+
+```python Code
+from crewai_tools import PDFSearchTool
+
+# Inicialize a ferramenta permitindo buscas em qualquer conteúdo PDF caso o caminho seja informado durante a execução
+tool = PDFSearchTool()
+
+# OU
+
+# Inicialize a ferramenta com um caminho PDF específico para buscas exclusivas naquele documento
+tool = PDFSearchTool(pdf='path/to/your/document.pdf')
+```
+
+## Argumentos
+
+- `pdf`: **Opcional** O caminho do PDF para busca. Pode ser fornecido na inicialização ou nos argumentos do método `run`. Caso seja fornecido na inicialização, a ferramenta confinará suas buscas ao documento especificado.
+
+## Modelo e embeddings personalizados
+
+Por padrão, a ferramenta utiliza OpenAI tanto para embeddings quanto para sumarização. Para personalizar o modelo, você pode usar um dicionário de configuração como no exemplo abaixo:
+
+```python Code
+tool = PDFSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/file-document/txtsearchtool.mdx

@@ -0,0 +1,80 @@
+---
+title: Pesquisa TXT RAG
+description: O `TXTSearchTool` foi projetado para realizar uma busca RAG (Geração Aumentada por Recuperação) dentro do conteúdo de um arquivo de texto.
+icon: file-lines
+---
+
+## Visão Geral
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, por isso pode haver comportamentos inesperados ou mudanças no futuro.
+</Note>
+
+Esta ferramenta é utilizada para realizar uma busca RAG (Geração Aumentada por Recuperação) dentro do conteúdo de um arquivo de texto.
+Ela permite uma busca semântica de uma consulta dentro do conteúdo de um arquivo de texto especificado,
+tornando-se um recurso valioso para extrair rapidamente informações ou encontrar seções específicas do texto com base na consulta fornecida.
+
+## Instalação
+
+Para usar o `TXTSearchTool`, primeiro é necessário instalar o pacote `crewai_tools`.
+Isso pode ser feito usando o pip, um gerenciador de pacotes para Python.
+Abra seu terminal ou prompt de comando e digite o seguinte comando:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+Este comando fará o download e instalará o TXTSearchTool junto com todas as dependências necessárias.
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar o TXTSearchTool para pesquisar dentro de um arquivo de texto.
+Este exemplo mostra tanto a inicialização da ferramenta com um arquivo de texto específico quanto a pesquisa subsequente dentro do conteúdo desse arquivo.
+
+```python Code
+from crewai_tools import TXTSearchTool
+
+# Inicialize a ferramenta para pesquisar no conteúdo de qualquer arquivo de texto
+# que o agente aprender durante sua execução
+tool = TXTSearchTool()
+
+# OU
+
+# Inicialize a ferramenta com um arquivo de texto específico,
+# para que o agente possa pesquisar dentro do conteúdo desse arquivo de texto
+tool = TXTSearchTool(txt='path/to/text/file.txt')
+```
+
+## Argumentos
+- `txt` (str): **Opcional**. O caminho para o arquivo de texto que você deseja pesquisar.
+Este argumento só é necessário se a ferramenta não foi inicializada com um arquivo de texto específico;
+caso contrário, a pesquisa será realizada no arquivo de texto fornecido inicialmente.
+
+## Modelo e embeddings personalizados
+
+Por padrão, a ferramenta utiliza o OpenAI tanto para embeddings quanto para sumarização.
+Para personalizar o modelo, você pode usar um dicionário de configuração como o exemplo a seguir:
+
+```python Code
+tool = TXTSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/file-document/xmlsearchtool.mdx

@@ -0,0 +1,77 @@
+---
+title: Busca RAG em XML
+description: O `XMLSearchTool` foi projetado para realizar uma busca RAG (Geração Aumentada por Recuperação) dentro do conteúdo de um arquivo XML.
+icon: file-xml
+---
+
+# `XMLSearchTool`
+
+<Note>
+    Ainda estamos trabalhando na melhoria das ferramentas, então pode haver comportamentos inesperados ou mudanças no futuro.
+</Note>
+
+## Descrição
+
+O XMLSearchTool é uma ferramenta RAG de ponta, desenvolvida para realizar buscas semânticas em arquivos XML.
+Ideal para usuários que precisam analisar e extrair informações do conteúdo XML de forma eficiente, esta ferramenta permite inserir uma consulta de busca e um caminho opcional para o arquivo XML.
+Ao especificar um caminho de arquivo XML, o usuário pode direcionar sua busca de forma mais precisa ao conteúdo daquele arquivo, obtendo assim resultados mais relevantes.
+
+## Instalação
+
+Para começar a usar o XMLSearchTool, é necessário instalar primeiro o pacote crewai_tools. Isso pode ser feito facilmente com o seguinte comando:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+Aqui estão dois exemplos demonstrando como usar o XMLSearchTool.
+O primeiro exemplo mostra a busca dentro de um arquivo XML específico, enquanto o segundo exemplo ilustra como iniciar uma busca sem definir previamente um caminho XML, oferecendo flexibilidade no escopo da busca.
+
+```python Code
+from crewai_tools import XMLSearchTool
+
+# Permite que agentes busquem no conteúdo de qualquer arquivo XML
+# conforme aprendem seus caminhos durante a execução
+tool = XMLSearchTool()
+
+# OU
+
+# Inicializa a ferramenta com um caminho específico para arquivo XML
+# para busca exclusiva dentro desse documento
+tool = XMLSearchTool(xml='path/to/your/xmlfile.xml')
+```
+
+## Argumentos
+
+- `xml`: Este é o caminho para o arquivo XML que você deseja buscar.
+Este parâmetro é opcional durante a inicialização da ferramenta, mas deve ser fornecido ou na inicialização ou como parte dos argumentos do método `run` para executar a busca.
+
+## Modelo customizado e embeddings
+
+Por padrão, a ferramenta utiliza a OpenAI tanto para embeddings quanto para sumarização. Para personalizar o modelo, você pode usar um dicionário de configuração conforme o exemplo a seguir:
+
+```python Code  
+tool = XMLSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/overview.mdx

@@ -0,0 +1,120 @@
+---
+title: "Visão Geral das Ferramentas"
+description: "Descubra a vasta biblioteca do CrewAI com mais de 40 ferramentas para potencializar seus agentes de IA"
+icon: "toolbox"
+---
+
+O CrewAI oferece uma biblioteca extensa de ferramentas pré-construídas para aprimorar as capacidades dos seus agentes. De processamento de arquivos a web scraping, consultas em bancos de dados a serviços de IA — temos tudo o que você precisa.
+
+## **Categorias de Ferramentas**
+
+<CardGroup cols={2}>
+  <Card
+    title="Arquivo & Documento"
+    icon="file-check"
+    href="/pt-BR/tools/file-document/overview"
+    color="#3B82F6"
+  >
+    Leia, escreva e pesquise em diversos formatos de arquivo, incluindo PDF, DOCX, JSON, CSV e muito mais. Perfeito para fluxos de processamento de documentos.
+  </Card>
+
+  <Card
+    title="Web Scraping & Navegação"
+    icon="globe"
+    href="/pt-BR/tools/web-scraping/overview"
+    color="#10B981"
+  >
+    Extraia dados de sites, automatize interações com navegadores e faça scraping de conteúdo em escala com ferramentas como Firecrawl, Selenium e outras.
+  </Card>
+
+  <Card
+    title="Pesquisa & Busca"
+    icon="magnifying-glass"
+    href="/pt-BR/tools/search-research/overview"
+    color="#F59E0B"
+  >
+    Realize buscas na web, encontre repositórios de código, pesquise conteúdo no YouTube e descubra informações em toda a internet.
+  </Card>
+
+  <Card
+    title="Banco de Dados & Dados"
+    icon="database"
+    href="/pt-BR/tools/database-data/overview"
+    color="#8B5CF6"
+  >
+    Conecte-se a bancos de dados SQL, repositórios vetoriais e data warehouses. Consulte MySQL, PostgreSQL, Snowflake, Qdrant e Weaviate.
+  </Card>
+
+  <Card
+    title="IA & Aprendizado de Máquina"
+    icon="brain"
+    href="/pt-BR/tools/ai-ml/overview"
+    color="#EF4444"
+  >
+    Gere imagens com DALL-E, execute tarefas de visão computacional, integre com LangChain, construa sistemas RAG e aproveite interpretadores de código.
+  </Card>
+
+  <Card
+    title="Nuvem & Armazenamento"
+    icon="cloud"
+    href="/pt-BR/tools/cloud-storage/overview"
+    color="#06B6D4"
+  >
+    Interaja com serviços em nuvem incluindo AWS S3, Amazon Bedrock e outros serviços de armazenamento e IA na nuvem.
+  </Card>
+
+  <Card
+    title="Automação & Integração"
+    icon="bolt"
+    href="/pt-BR/tools/automation/overview"
+    color="#84CC16"
+  >
+    Automatize fluxos de trabalho com Apify, Composio e outras plataformas de integração para conectar seus agentes a serviços externos.
+  </Card>
+</CardGroup>
+
+## **Acesso Rápido**
+
+Precisa de uma ferramenta específica? Aqui estão algumas opções populares:
+
+<CardGroup cols={3}>
+  <Card title="RAG Tool" icon="image" href="/pt-BR/tools/ai-ml/ragtool">
+    Implemente Geração com Recuperação de Dados (RAG)
+  </Card>
+  <Card title="Serper Dev" icon="book-atlas" href="/pt-BR/tools/search-research/serperdevtool">
+    API de busca do Google
+  </Card>
+  <Card title="File Read" icon="file" href="/pt-BR/tools/file-document/filereadtool">
+    Leia qualquer tipo de arquivo
+  </Card>
+  <Card title="Scrape Website" icon="globe" href="/pt-BR/tools/web-scraping/scrapewebsitetool">
+    Extraia conteúdo da web
+  </Card>
+  <Card title="Code Interpreter" icon="code" href="/pt-BR/tools/ai-ml/codeinterpretertool">
+    Execute código Python
+  </Card>
+  <Card title="S3 Reader" icon="cloud" href="/pt-BR/tools/cloud-storage/s3readertool">
+    Acesse arquivos no AWS S3
+  </Card>
+</CardGroup>
+
+## **Primeiros Passos**
+
+Para usar qualquer ferramenta em seu projeto CrewAI:
+
+1. **Importe** a ferramenta na configuração da sua crew
+2. **Adicione** à lista de ferramentas do seu agente
+3. **Configure** as chaves de API ou ajustes necessários
+
+```python
+from crewai_tools import FileReadTool, SerperDevTool
+
+# Adicione as ferramentas ao seu agente
+agent = Agent(
+    role="Research Analyst",
+    tools=[FileReadTool(), SerperDevTool()],
+    # ... outrAs configurações
+)
+```
+
+Pronto para explorar? Escolha uma categoria acima para descobrir as ferramentas que se encaixam no seu caso de uso!

docs/pt-BR/tools/search-research/bravesearchtool.mdx

@@ -0,0 +1,96 @@
+---
+title: Brave Search
+description: O `BraveSearchTool` foi projetado para pesquisar na internet usando a Brave Search API.
+icon: searchengin
+---
+
+# `BraveSearchTool`
+
+## Descrição
+
+Esta ferramenta foi desenvolvida para realizar buscas na web utilizando a Brave Search API. Ela permite que você pesquise na internet com uma consulta especificada e recupere resultados relevantes. A ferramenta suporta a personalização do número de resultados e buscas específicas por país.
+
+## Instalação
+
+Para incorporar esta ferramenta ao seu projeto, siga as instruções de instalação abaixo:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Passos para Começar
+
+Para utilizar o `BraveSearchTool` de forma eficaz, siga estes passos:
+
+1. **Instalação do Pacote**: Confirme que o pacote `crewai[tools]` está instalado no seu ambiente Python.
+2. **Obtenção da Chave de API**: Obtenha uma chave de API do Brave Search registrando-se em [Brave Search API](https://api.search.brave.com/app/keys).
+3. **Configuração do Ambiente**: Armazene a chave de API obtida em uma variável de ambiente chamada `BRAVE_API_KEY` para facilitar seu uso pela ferramenta.
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma busca com uma determinada consulta:
+
+```python Code
+from crewai_tools import BraveSearchTool
+
+# Inicialize a ferramenta para capacidades de busca na internet
+tool = BraveSearchTool()
+
+# Execute uma busca
+results = tool.run(search_query="CrewAI agent framework")
+print(results)
+```
+
+## Parâmetros
+
+O `BraveSearchTool` aceita os seguintes parâmetros:
+
+- **search_query**: Obrigatório. A consulta de pesquisa que você deseja usar para pesquisar na internet.
+- **country**: Opcional. Especifique o país dos resultados da pesquisa. O padrão é string vazia.
+- **n_results**: Opcional. Número de resultados de pesquisa a serem retornados. O padrão é `10`.
+- **save_file**: Opcional. Se os resultados da pesquisa devem ser salvos em um arquivo. O padrão é `False`.
+
+## Exemplo com Parâmetros
+
+Veja um exemplo demonstrando como usar a ferramenta com parâmetros adicionais:
+
+```python Code
+from crewai_tools import BraveSearchTool
+
+# Inicialize a ferramenta com parâmetros personalizados
+tool = BraveSearchTool(
+    country="US",
+    n_results=5,
+    save_file=True
+)
+
+# Execute uma busca
+results = tool.run(search_query="Latest AI developments")
+print(results)
+```
+
+## Exemplo de Integração com Agente
+
+Veja como integrar o `BraveSearchTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent
+from crewai.project import agent
+from crewai_tools import BraveSearchTool
+
+# Inicialize a ferramenta
+brave_search_tool = BraveSearchTool()
+
+# Defina um agente com o BraveSearchTool
+@agent
+def researcher(self) -> Agent:
+    return Agent(
+        config=self.agents_config["researcher"],
+        allow_delegation=False,
+        tools=[brave_search_tool]
+    )
+```
+
+## Conclusão
+
+Ao integrar o `BraveSearchTool` em projetos Python, os usuários ganham a capacidade de realizar buscas em tempo real e relevantes na internet diretamente de suas aplicações. A ferramenta oferece uma interface simples para a poderosa Brave Search API, facilitando a recuperação e o processamento programático dos resultados de pesquisa. Seguindo as orientações de configuração e uso fornecidas, a incorporação desta ferramenta em projetos é simplificada e direta.

docs/pt-BR/tools/search-research/codedocssearchtool.mdx

@@ -0,0 +1,84 @@
+---
+title: Pesquisa com RAG em Documentação de Código
+description: O `CodeDocsSearchTool` é uma poderosa ferramenta RAG (Geração Aumentada por Recuperação) projetada para buscas semânticas em documentação de código.
+icon: code
+---
+
+# `CodeDocsSearchTool`
+
+<Note>
+    **Experimental**: Ainda estamos trabalhando para melhorar as ferramentas, então pode haver comportamentos inesperados ou mudanças no futuro.
+</Note>
+
+## Descrição
+
+O CodeDocsSearchTool é uma poderosa ferramenta RAG (Geração Aumentada por Recuperação) projetada para buscas semânticas em documentação de código.
+Ela permite que usuários encontrem de forma eficiente informações ou tópicos específicos dentro da documentação de código. Ao fornecer um `docs_url` durante a inicialização,
+a ferramenta restringe a busca àquele site de documentação em particular. Alternativamente, sem um `docs_url` específico,
+ela realiza buscas em uma ampla variedade de documentações de código conhecidas ou descobertas durante sua execução, tornando-a versátil para diversas necessidades de busca em documentação.
+
+## Instalação
+
+Para começar a usar o CodeDocsSearchTool, primeiro instale o pacote crewai_tools via pip:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+Utilize o CodeDocsSearchTool conforme abaixo para realizar buscas em documentação de código:
+
+```python Code
+from crewai_tools import CodeDocsSearchTool
+
+# Para buscar qualquer conteúdo de documentação de código 
+# se a URL for conhecida ou descoberta durante a execução:
+tool = CodeDocsSearchTool()
+
+# OU
+
+# Para focar sua busca especificamente em um site de documentação 
+# fornecendo sua URL:
+tool = CodeDocsSearchTool(docs_url='https://docs.example.com/reference')
+```
+<Note>  
+    Substitua 'https://docs.example.com/reference' pela URL da documentação desejada
+    e 'How to use search tool' pela consulta de busca relevante às suas necessidades.
+</Note>
+
+## Argumentos
+
+Os seguintes parâmetros podem ser usados para personalizar o comportamento do `CodeDocsSearchTool`:
+
+| Argumento       | Tipo     | Descrição                                                                                                                            |
+|:----------------|:---------|:-------------------------------------------------------------------------------------------------------------------------------------|
+| **docs_url**    | `string` | _Opcional_. Especifica a URL da documentação de código a ser pesquisada.                                              | 
+
+## Modelo e embeddings personalizados
+
+Por padrão, a ferramenta utiliza a OpenAI tanto para embeddings quanto para sumarização. Para customizar o modelo, você pode usar um dicionário de configuração conforme abaixo:
+
+```python Code
+tool = CodeDocsSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/search-research/exasearchtool.mdx

@@ -0,0 +1,52 @@
+---
+title: Carregador Web EXA Search
+description: O `EXASearchTool` foi projetado para realizar uma busca semântica para uma consulta especificada a partir do conteúdo de um texto em toda a internet.
+icon: globe-pointer
+---
+
+# `EXASearchTool`
+
+## Descrição
+
+O EXASearchTool foi projetado para realizar uma busca semântica para uma consulta especificada a partir do conteúdo de um texto em toda a internet.
+Ele utiliza a API da [exa.ai](https://exa.ai/) para buscar e exibir os resultados de pesquisa mais relevantes com base na consulta fornecida pelo usuário.
+
+## Instalação
+
+Para incorporar esta ferramenta em seu projeto, siga as instruções de instalação abaixo:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma busca com uma consulta determinada:
+
+```python Code
+from crewai_tools import EXASearchTool
+
+# Initialize the tool for internet searching capabilities
+tool = EXASearchTool()
+```
+
+## Etapas para Começar
+
+Para usar o EXASearchTool de forma eficaz, siga estas etapas:
+
+<Steps>
+    <Step title="Instalação do Pacote">
+        Confirme se o pacote `crewai[tools]` está instalado em seu ambiente Python.
+    </Step>
+    <Step title="Obtenção da Chave de API">
+        Adquira uma chave de API da [exa.ai](https://exa.ai/) registrando-se gratuitamente em [exa.ai](https://exa.ai/).
+    </Step>
+    <Step title="Configuração de Ambiente">
+        Armazene a chave de API obtida em uma variável de ambiente chamada `EXA_API_KEY` para facilitar o uso pela ferramenta.
+    </Step>
+</Steps>
+
+## Conclusão
+
+Ao integrar o `EXASearchTool` em projetos Python, os usuários ganham a capacidade de realizar buscas relevantes e em tempo real pela internet diretamente de suas aplicações.
+Seguindo as orientações de configuração e uso fornecidas, a incorporação desta ferramenta em projetos torna-se simples e direta.

docs/pt-BR/tools/search-research/githubsearchtool.mdx

@@ -0,0 +1,84 @@
+---
+title: Github Search
+description: O `GithubSearchTool` foi desenvolvido para pesquisar sites e convertê-los em markdown limpo ou dados estruturados.
+icon: github
+---
+
+# `GithubSearchTool`
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, portanto pode haver comportamentos inesperados ou mudanças no futuro.
+</Note>
+
+## Descrição
+
+O GithubSearchTool é uma ferramenta de Recuperação Aprimorada por Geração (RAG) especificamente projetada para realizar buscas semânticas em repositórios GitHub. Utilizando funcionalidades avançadas de busca semântica, ele examina códigos, pull requests, issues e repositórios, tornando-se uma ferramenta essencial para desenvolvedores, pesquisadores ou qualquer pessoa que precise de informações precisas do GitHub.
+
+## Instalação
+
+Para usar o GithubSearchTool, primeiro certifique-se de que o pacote crewai_tools está instalado em seu ambiente Python:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+Esse comando instala o pacote necessário para rodar o GithubSearchTool juntamente com outras ferramentas incluídas no pacote crewai_tools.
+
+## Exemplo
+
+Veja como você pode usar o GithubSearchTool para realizar buscas semânticas dentro de um repositório GitHub:
+
+```python Code
+from crewai_tools import GithubSearchTool
+
+# Inicialize a ferramenta para buscas semânticas em um repositório GitHub específico
+tool = GithubSearchTool(
+	github_repo='https://github.com/example/repo',
+	gh_token='your_github_personal_access_token',
+	content_types=['code', 'issue'] # Opções: code, repo, pr, issue
+)
+
+# OU
+
+# Inicialize a ferramenta para buscas semânticas em um repositório GitHub específico, permitindo que o agente pesquise em qualquer repositório caso tome conhecimento durante a execução
+tool = GithubSearchTool(
+	gh_token='your_github_personal_access_token',
+	content_types=['code', 'issue'] # Opções: code, repo, pr, issue
+)
+```
+
+## Argumentos
+
+- `github_repo` : A URL do repositório GitHub onde a busca será realizada. Este é um campo obrigatório e especifica o repositório alvo para sua pesquisa.
+- `gh_token` : Seu Personal Access Token (PAT) do GitHub necessário para autenticação. Você pode criar um nas configurações da sua conta GitHub em Developer Settings > Personal Access Tokens.
+- `content_types` : Especifica os tipos de conteúdo a serem incluídos na busca. É necessário fornecer uma lista dos tipos de conteúdo das seguintes opções: `code` para pesquisar dentro do código, 
+`repo` para pesquisar nas informações gerais do repositório, `pr` para pesquisar em pull requests, e `issue` para pesquisar nas issues. 
+Este campo é obrigatório e permite adaptar a busca para tipos específicos de conteúdo dentro do repositório GitHub.
+
+## Modelo e embeddings personalizados
+
+Por padrão, a ferramenta utiliza o OpenAI tanto para embeddings quanto para sumarização. Para personalizar o modelo, você pode usar um dicionário de configuração como no exemplo:
+
+```python Code
+tool = GithubSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/search-research/linkupsearchtool.mdx

@@ -0,0 +1,112 @@
+---
+title: Linkup Search Tool
+description: O `LinkupSearchTool` permite consultar a API do Linkup para obter informações contextuais.
+icon: link
+---
+
+# `LinkupSearchTool`
+
+## Descrição
+
+O `LinkupSearchTool` fornece a capacidade de consultar a API do Linkup para obter informações contextuais e recuperar resultados estruturados. Esta ferramenta é ideal para enriquecer fluxos de trabalho com informações atualizadas e confiáveis do Linkup, permitindo que agentes acessem dados relevantes durante a execução de suas tarefas.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar o Linkup SDK:
+
+```shell
+uv add linkup-sdk
+```
+
+## Passos para começar
+
+Para usar efetivamente o `LinkupSearchTool`, siga estes passos:
+
+1. **Chave de API**: Obtenha uma chave de API do Linkup.
+2. **Configuração do Ambiente**: Configure seu ambiente com a chave de API.
+3. **Instalar SDK**: Instale o Linkup SDK usando o comando acima.
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e usá-la em um agente:
+
+```python Code
+from crewai_tools import LinkupSearchTool
+from crewai import Agent
+import os
+
+# Initialize the tool with your API key
+linkup_tool = LinkupSearchTool(api_key=os.getenv("LINKUP_API_KEY"))
+
+# Define an agent that uses the tool
+@agent
+def researcher(self) -> Agent:
+    '''
+    This agent uses the LinkupSearchTool to retrieve contextual information
+    from the Linkup API.
+    '''
+    return Agent(
+        config=self.agents_config["researcher"],
+        tools=[linkup_tool]
+    )
+```
+
+## Parâmetros
+
+O `LinkupSearchTool` aceita os seguintes parâmetros:
+
+### Parâmetros do Construtor
+- **api_key**: Obrigatório. Sua chave de API do Linkup.
+
+### Parâmetros de Execução
+- **query**: Obrigatório. O termo ou frase de busca.
+- **depth**: Opcional. A profundidade da busca. O padrão é "standard".
+- **output_type**: Opcional. O tipo de saída. O padrão é "searchResults".
+
+## Uso Avançado
+
+Você pode personalizar os parâmetros de busca para resultados mais específicos:
+
+```python Code
+# Perform a search with custom parameters
+results = linkup_tool.run(
+    query="Women Nobel Prize Physics",
+    depth="deep",
+    output_type="searchResults"
+)
+```
+
+## Formato de Retorno
+
+A ferramenta retorna resultados no seguinte formato:
+
+```json
+{
+  "success": true,
+  "results": [
+    {
+      "name": "Result Title",
+      "url": "https://example.com/result",
+      "content": "Content of the result..."
+    },
+    // Additional results...
+  ]
+}
+```
+
+Se ocorrer um erro, a resposta será:
+
+```json
+{
+  "success": false,
+  "error": "Error message"
+}
+```
+
+## Tratamento de Erros
+
+A ferramenta lida com erros de API de forma amigável e fornece feedback estruturado. Se a requisição à API falhar, a ferramenta retornará um dicionário com `success: false` e uma mensagem de erro.
+
+## Conclusão
+
+O `LinkupSearchTool` oferece uma forma integrada de incorporar as capacidades de busca de informações contextuais do Linkup aos seus agentes CrewAI. Ao utilizar esta ferramenta, os agentes podem acessar informações relevantes e atualizadas para aprimorar sua tomada de decisão e execução de tarefas.

docs/pt-BR/tools/search-research/overview.mdx

@@ -0,0 +1,71 @@
+---
+title: "Visão Geral"
+description: "Realize pesquisas na web, encontre repositórios e pesquise informações em toda a internet"
+icon: "face-smile"
+---
+
+Essas ferramentas permitem que seus agentes pesquisem na web, explorem tópicos e encontrem informações em diversas plataformas, incluindo motores de busca, GitHub e YouTube.
+
+## **Ferramentas Disponíveis**
+
+<CardGroup cols={2}>
+  <Card title="Serper Dev Tool" icon="google" href="/pt-BR/tools/search-research/serperdevtool">
+    Integração com a API de busca do Google para capacidades abrangentes de pesquisa na web.
+  </Card>
+
+  <Card title="Brave Search Tool" icon="shield" href="/pt-BR/tools/search-research/bravesearchtool">
+    Pesquisa voltada para privacidade com o índice independente de busca do Brave.
+  </Card>
+
+  <Card title="Exa Search Tool" icon="magnifying-glass" href="/pt-BR/tools/search-research/exasearchtool">
+    Pesquisa impulsionada por IA para encontrar conteúdo específico e relevante.
+  </Card>
+
+  <Card title="LinkUp Search Tool" icon="link" href="/pt-BR/tools/search-research/linkupsearchtool">
+    Pesquisa em tempo real na web com indexação de conteúdo atualizado.
+  </Card>
+
+  <Card title="GitHub Search Tool" icon="github" href="/pt-BR/tools/search-research/githubsearchtool">
+    Pesquise repositórios do GitHub, códigos, issues e documentação.
+  </Card>
+
+  <Card title="Website Search Tool" icon="globe" href="/pt-BR/tools/search-research/websitesearchtool">
+    Pesquisa dentro de sites e domínios específicos.
+  </Card>
+
+  <Card title="Code Docs Search Tool" icon="code" href="/pt-BR/tools/search-research/codedocssearchtool">
+    Pesquise em documentação de código e recursos técnicos.
+  </Card>
+
+  <Card title="YouTube Channel Search" icon="youtube" href="/pt-BR/tools/search-research/youtubechannelsearchtool">
+    Pesquise canais do YouTube para encontrar conteúdos e criadores específicos.
+  </Card>
+
+  <Card title="YouTube Video Search" icon="play" href="/pt-BR/tools/search-research/youtubevideosearchtool">
+    Encontre e analise vídeos do YouTube por assunto, palavra-chave ou critério.
+  </Card>
+</CardGroup>
+
+## **Casos de Uso Comuns**
+
+- **Pesquisa de Mercado**: Pesquise tendências de mercado e análise de concorrentes
+- **Descoberta de Conteúdo**: Encontre artigos, vídeos e recursos relevantes
+- **Pesquisa de Código**: Pesquise repositórios e documentação em busca de soluções
+- **Geração de Leads**: Pesquise empresas e pessoas
+- **Pesquisa Acadêmica**: Encontre artigos científicos e trabalhos técnicos
+
+```python
+from crewai_tools import SerperDevTool, GitHubSearchTool, YoutubeVideoSearchTool
+
+# Create research tools
+web_search = SerperDevTool()
+code_search = GitHubSearchTool()
+video_research = YoutubeVideoSearchTool()
+
+# Add to your agent
+agent = Agent(
+    role="Research Analyst",
+    tools=[web_search, code_search, video_research],
+    goal="Gather comprehensive information on any topic"
+)
+```

docs/pt-BR/tools/search-research/serperdevtool.mdx

@@ -0,0 +1,112 @@
+---
+title: Pesquisa Serper Google
+description: O `SerperDevTool` é projetado para pesquisar na internet e retornar os resultados mais relevantes.
+icon: google
+---
+
+# `SerperDevTool`
+
+<Note>
+    Ainda estamos trabalhando na melhoria das ferramentas, portanto, pode haver comportamentos inesperados ou mudanças no futuro.
+</Note>
+
+## Descrição
+
+Esta ferramenta foi projetada para realizar buscas semânticas para uma consulta especificada a partir do conteúdo de um texto na internet. Ela utiliza a API do [serper.dev](https://serper.dev) 
+para buscar e exibir os resultados de pesquisa mais relevantes com base na consulta fornecida pelo usuário.
+
+## Instalação
+
+Para incorporar esta ferramenta em seu projeto, siga as instruções de instalação abaixo:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma busca com uma consulta fornecida:
+
+```python Code
+from crewai_tools import SerperDevTool
+
+# Inicializar a ferramenta para capacidades de busca na internet
+tool = SerperDevTool()
+```
+
+## Etapas para Começar
+
+Para utilizar o `SerperDevTool` de forma eficaz, siga estes passos:
+
+1. **Instalação do Pacote**: Confirme se o pacote `crewai[tools]` está instalado em seu ambiente Python.
+2. **Obtenção da Chave de API**: Adquira uma chave de API do `serper.dev` registrando-se para uma conta gratuita em `serper.dev`.
+3. **Configuração do Ambiente**: Armazene sua chave de API obtida em uma variável de ambiente chamada `SERPER_API_KEY` para facilitar o uso pela ferramenta.
+
+## Parâmetros
+
+O `SerperDevTool` possui vários parâmetros que serão passados para a API:
+
+- **search_url**: O endpoint da URL para a API de busca. (Padrão é `https://google.serper.dev/search`)
+
+- **country**: Opcional. Especifica o país para os resultados de busca.
+- **location**: Opcional. Especifica a localização para os resultados de busca.
+- **locale**: Opcional. Especifica o local para os resultados de busca.
+- **n_results**: Número de resultados de busca a serem retornados. O padrão é `10`.
+
+Os valores para `country`, `location`, `locale` e `search_url` podem ser encontrados no [Serper Playground](https://serper.dev/playground).
+
+## Exemplo com Parâmetros
+
+Aqui está um exemplo demonstrando como usar a ferramenta com parâmetros adicionais:
+
+```python Code
+from crewai_tools import SerperDevTool
+
+tool = SerperDevTool(
+    search_url="https://google.serper.dev/scholar",
+    n_results=2,
+)
+
+print(tool.run(search_query="ChatGPT"))
+
+# Using Tool: Search the internet
+
+# Search results: Title: Role of chat gpt in public health
+# Link: https://link.springer.com/article/10.1007/s10439-023-03172-7
+# Snippet: … ChatGPT in public health. In this overview, we will examine the potential uses of ChatGPT in
+# ---
+# Title: Potential use of chat gpt in global warming
+# Link: https://link.springer.com/article/10.1007/s10439-023-03171-8
+# Snippet: … as ChatGPT, have the potential to play a critical role in advancing our understanding of climate
+# ---
+
+```
+
+```python Code
+from crewai_tools import SerperDevTool
+
+tool = SerperDevTool(
+    country="fr",
+    locale="fr",
+    location="Paris, Paris, Ile-de-France, France",
+    n_results=2,
+)
+
+print(tool.run(search_query="Jeux Olympiques"))
+
+# Using Tool: Search the internet
+
+# Search results: Title: Jeux Olympiques de Paris 2024 - Actualités, calendriers, résultats
+# Link: https://olympics.com/fr/paris-2024
+# Snippet: Quels sont les sports présents aux Jeux Olympiques de Paris 2024 ? · Athlétisme · Aviron · Badminton · Basketball · Basketball 3x3 · Boxe · Breaking · Canoë ...
+# ---
+# Title: Billetterie Officielle de Paris 2024 - Jeux Olympiques et Paralympiques
+# Link: https://tickets.paris2024.org/
+# Snippet: Achetez vos billets exclusivement sur le site officiel de la billetterie de Paris 2024 pour participer au plus grand événement sportif au monde.
+# ---
+```
+
+## Conclusão
+
+Ao integrar o `SerperDevTool` em projetos Python, os usuários obtêm a capacidade de realizar buscas em tempo real e relevantes na internet diretamente de suas aplicações. 
+Os parâmetros atualizados permitem resultados de busca mais personalizados e localizados. Seguindo as diretrizes de configuração e uso fornecidas, a incorporação desta ferramenta nos projetos é simplificada e direta.

docs/pt-BR/tools/search-research/websitesearchtool.mdx

@@ -0,0 +1,77 @@
+---
+title: Pesquisa RAG em Sites
+description: O `WebsiteSearchTool` foi projetado para realizar uma busca RAG (Geração Aumentada por Recuperação) dentro do conteúdo de um site.
+icon: globe-stand
+---
+
+# `WebsiteSearchTool`
+
+<Note>
+    O WebsiteSearchTool está atualmente em fase experimental. Estamos trabalhando ativamente para incorporar esta ferramenta em nosso conjunto de ofertas e atualizaremos a documentação conforme necessário.
+</Note>
+
+## Descrição
+
+O WebsiteSearchTool foi concebido como um conceito para realizar buscas semânticas dentro do conteúdo de sites. 
+Ele visa aproveitar modelos avançados de aprendizado de máquina, como a Geração Aumentada por Recuperação (RAG), para navegar e extrair informações de URLs especificadas de forma eficiente. 
+Esta ferramenta pretende oferecer flexibilidade, permitindo que usuários realizem buscas em qualquer site ou foquem em sites específicos de seu interesse. 
+Por favor, note que os detalhes da implementação atual do WebsiteSearchTool estão em desenvolvimento, e as funcionalidades aqui descritas podem ainda não estar acessíveis.
+
+## Instalação
+
+Para preparar seu ambiente para quando o WebsiteSearchTool estiver disponível, você pode instalar o pacote fundamental com:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+Este comando instala as dependências necessárias para garantir que, assim que a ferramenta estiver totalmente integrada, os usuários possam começar a usá-la imediatamente.
+
+## Exemplo de Uso
+
+Abaixo estão exemplos de como o WebsiteSearchTool poderá ser utilizado em diferentes cenários. Por favor, observe que esses exemplos são ilustrativos e representam funcionalidades planejadas:
+
+```python Code
+from crewai_tools import WebsiteSearchTool
+
+# Exemplo de inicialização da ferramenta que agentes podem usar 
+# para pesquisar em quaisquer sites descobertos
+tool = WebsiteSearchTool()
+
+# Exemplo de limitação da busca ao conteúdo de um site específico, 
+# assim os agentes podem buscar somente dentro desse site
+tool = WebsiteSearchTool(website='https://example.com')
+```
+
+## Argumentos
+
+- `website`: Um argumento opcional destinado a especificar a URL do site para buscas direcionadas. Este argumento foi projetado para aumentar a flexibilidade da ferramenta, permitindo buscas mais focadas quando necessário.
+
+## Opções de Personalização
+
+Por padrão, a ferramenta utiliza a OpenAI tanto para embeddings quanto para sumarização. Para personalizar o modelo, você pode usar um dicionário de configuração, conforme o exemplo abaixo:
+
+
+```python Code
+tool = WebsiteSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/pt-BR/tools/search-research/youtubechannelsearchtool.mdx

@@ -0,0 +1,194 @@
+---
+title: Busca RAG em Canal do YouTube
+description: O `YoutubeChannelSearchTool` foi desenvolvido para realizar buscas RAG (Retrieval-Augmented Generation) no conteúdo de um canal do Youtube.
+icon: youtube
+---
+
+# `YoutubeChannelSearchTool`
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, então pode haver comportamentos inesperados ou alterações no futuro.
+</Note>
+
+## Descrição
+
+Esta ferramenta foi desenvolvida para realizar buscas semânticas dentro do conteúdo de um canal específico do Youtube.
+Aproveitando a metodologia RAG (Retrieval-Augmented Generation), ela fornece resultados de busca relevantes,
+tornando-se indispensável para extrair informações ou encontrar conteúdos específicos sem a necessidade de percorrer manualmente os vídeos.
+Ela otimiza o processo de busca em canais do Youtube, sendo ideal para pesquisadores, criadores de conteúdo e espectadores que buscam informações ou temas específicos.
+
+## Instalação
+
+Para utilizar o YoutubeChannelSearchTool, é necessário instalar o pacote `crewai_tools`. Execute o seguinte comando no seu terminal para instalar:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+O exemplo a seguir demonstra como utilizar o `YoutubeChannelSearchTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import YoutubeChannelSearchTool
+
+# Inicializa a ferramenta para buscas gerais em canais do YouTube
+youtube_channel_tool = YoutubeChannelSearchTool()
+
+# Define um agente que utiliza a ferramenta
+channel_researcher = Agent(
+    role="Channel Researcher",
+    goal="Extrair informações relevantes de canais do YouTube",
+    backstory="Um pesquisador especialista em analisar conteúdos de canais do YouTube.",
+    tools=[youtube_channel_tool],
+    verbose=True,
+)
+
+# Exemplo de tarefa para buscar informações em um canal específico
+research_task = Task(
+    description="Buscar informações sobre tutoriais de machine learning no canal do YouTube {youtube_channel_handle}",
+    expected_output="Um resumo dos principais tutoriais de machine learning disponíveis no canal.",
+    agent=channel_researcher,
+)
+
+# Cria e executa o crew
+crew = Crew(agents=[channel_researcher], tasks=[research_task])
+result = crew.kickoff(inputs={"youtube_channel_handle": "@exampleChannel"})
+```
+
+Você também pode inicializar a ferramenta com um handle específico de canal do YouTube:
+
+```python Code
+# Inicializa a ferramenta com o handle específico de um canal do YouTube
+youtube_channel_tool = YoutubeChannelSearchTool(
+    youtube_channel_handle='@exampleChannel'
+)
+
+# Define um agente que utiliza a ferramenta
+channel_researcher = Agent(
+    role="Channel Researcher",
+    goal="Extrair informações relevantes de um canal específico do YouTube",
+    backstory="Um pesquisador especialista em analisar conteúdos de canais do YouTube.",
+    tools=[youtube_channel_tool],
+    verbose=True,
+)
+```
+
+## Parâmetros
+
+O `YoutubeChannelSearchTool` aceita os seguintes parâmetros:
+
+- **youtube_channel_handle**: Opcional. O handle do canal do YouTube para realizar a busca. Se fornecido durante a inicialização, o agente não precisará informá-lo ao utilizar a ferramenta. Se o handle não começar com '@', será adicionado automaticamente.
+- **config**: Opcional. Configurações para o sistema RAG subjacente, incluindo parâmetros de LLM e embedder.
+- **summarize**: Opcional. Indica se o conteúdo recuperado deve ser resumido. O padrão é `False`.
+
+Ao utilizar a ferramenta com um agente, o agente deverá fornecer:
+
+- **search_query**: Obrigatório. A consulta de busca para encontrar informações relevantes no conteúdo do canal.
+- **youtube_channel_handle**: Obrigatório apenas se não for fornecido durante a inicialização. O handle do canal do YouTube onde realizar a busca.
+
+## Modelo Personalizado e Embeddings
+
+Por padrão, a ferramenta utiliza o OpenAI tanto para embeddings quanto para sumarização. Para personalizar o modelo, é possível usar um dicionário de configuração como no exemplo:
+
+```python Code  
+youtube_channel_tool = YoutubeChannelSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```
+
+## Exemplo de Integração com Agente
+
+Veja um exemplo mais detalhado de como integrar o `YoutubeChannelSearchTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import YoutubeChannelSearchTool
+
+# Inicializa a ferramenta
+youtube_channel_tool = YoutubeChannelSearchTool()
+
+# Define um agente que utiliza a ferramenta
+channel_researcher = Agent(
+    role="Channel Researcher",
+    goal="Extrair e analisar informações de canais do YouTube",
+    backstory="""Você é um pesquisador especialista em canais, com experiência
+    em extrair e analisar informações de canais do YouTube. Você possui olho clínico para detalhes
+    e pode rapidamente identificar pontos-chave e insights a partir do conteúdo em vídeo de todo o canal.""",
+    tools=[youtube_channel_tool],
+    verbose=True,
+)
+
+# Crie uma tarefa para o agente
+research_task = Task(
+    description="""
+    Buscar informações sobre projetos e tutoriais de ciência de dados
+    no canal do YouTube {youtube_channel_handle}.
+    
+    Foque em:
+    1. Principais técnicas de ciência de dados abordadas
+    2. Séries de tutoriais populares
+    3. Vídeos mais vistos ou recomendados
+    
+    Forneça um resumo abrangente sobre esses pontos.
+    """,
+    expected_output="Um resumo detalhado sobre o conteúdo de ciência de dados disponível no canal.",
+    agent=channel_researcher,
+)
+
+# Execute a tarefa
+crew = Crew(agents=[channel_researcher], tasks=[research_task])
+result = crew.kickoff(inputs={"youtube_channel_handle": "@exampleDataScienceChannel"})
+```
+
+## Detalhes da Implementação
+
+O `YoutubeChannelSearchTool` é implementado como uma subclasse de `RagTool`, que fornece a funcionalidade base para Retrieval-Augmented Generation:
+
+```python Code
+class YoutubeChannelSearchTool(RagTool):
+    name: str = "Search a Youtube Channels content"
+    description: str = "A tool that can be used to semantic search a query from a Youtube Channels content."
+    args_schema: Type[BaseModel] = YoutubeChannelSearchToolSchema
+
+    def __init__(self, youtube_channel_handle: Optional[str] = None, **kwargs):
+        super().__init__(**kwargs)
+        if youtube_channel_handle is not None:
+            kwargs["data_type"] = DataType.YOUTUBE_CHANNEL
+            self.add(youtube_channel_handle)
+            self.description = f"A tool that can be used to semantic search a query the {youtube_channel_handle} Youtube Channels content."
+            self.args_schema = FixedYoutubeChannelSearchToolSchema
+            self._generate_description()
+
+    def add(
+        self,
+        youtube_channel_handle: str,
+        **kwargs: Any,
+    ) -> None:
+        if not youtube_channel_handle.startswith("@"):
+            youtube_channel_handle = f"@{youtube_channel_handle}"
+        super().add(youtube_channel_handle, **kwargs)
+```
+
+## Conclusão
+
+O `YoutubeChannelSearchTool` oferece uma forma poderosa de buscar e extrair informações do conteúdo de canais do YouTube utilizando técnicas RAG. Ao possibilitar que agentes busquem entre todos os vídeos de um canal, facilita tarefas de extração e análise de informações que seriam difíceis de executar manualmente. Esta ferramenta é especialmente útil para pesquisa, análise de conteúdo e extração de conhecimento de canais do YouTube.

docs/pt-BR/tools/search-research/youtubevideosearchtool.mdx

@@ -0,0 +1,187 @@
+---
+title: Pesquisa RAG em Vídeos do YouTube
+description: O `YoutubeVideoSearchTool` foi projetado para realizar uma busca RAG (Geração Auxiliada por Recuperação) no conteúdo de um vídeo do Youtube.
+icon: youtube
+---
+
+# `YoutubeVideoSearchTool`
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, portanto podem ocorrer comportamentos inesperados ou mudanças no futuro.
+</Note>
+
+## Descrição
+
+Esta ferramenta faz parte do pacote `crewai_tools` e foi projetada para realizar buscas semânticas dentro do conteúdo de vídeos do Youtube, utilizando técnicas de Geração Auxiliada por Recuperação (RAG).
+É uma das diversas ferramentas de "Pesquisa" do pacote que aproveitam RAG para diferentes fontes.
+O YoutubeVideoSearchTool permite flexibilidade nas buscas: usuários podem pesquisar em qualquer conteúdo de vídeo do Youtube sem especificar uma URL,
+ou podem direcionar sua busca para um vídeo específico fornecendo sua URL.
+
+## Instalação
+
+Para utilizar o `YoutubeVideoSearchTool`, é necessário primeiro instalar o pacote `crewai_tools`.
+Esse pacote contém o `YoutubeVideoSearchTool` entre outras utilidades desenvolvidas para melhorar suas tarefas de análise e processamento de dados.
+Instale o pacote executando o seguinte comando em seu terminal:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar o `YoutubeVideoSearchTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import YoutubeVideoSearchTool
+
+# Inicialize a ferramenta para buscas gerais em vídeos do YouTube
+youtube_search_tool = YoutubeVideoSearchTool()
+
+# Defina um agente que usa a ferramenta
+video_researcher = Agent(
+    role="Video Researcher",
+    goal="Extract relevant information from YouTube videos",
+    backstory="An expert researcher who specializes in analyzing video content.",
+    tools=[youtube_search_tool],
+    verbose=True,
+)
+
+# Exemplo de tarefa para buscar informações em um vídeo específico
+research_task = Task(
+    description="Search for information about machine learning frameworks in the YouTube video at {youtube_video_url}",
+    expected_output="A summary of the key machine learning frameworks mentioned in the video.",
+    agent=video_researcher,
+)
+
+# Crie e execute a crew
+crew = Crew(agents=[video_researcher], tasks=[research_task])
+result = crew.kickoff(inputs={"youtube_video_url": "https://youtube.com/watch?v=example"})
+```
+
+Você também pode inicializar a ferramenta com a URL de um vídeo específico do YouTube:
+
+```python Code
+# Inicialize a ferramenta com a URL de um vídeo específico do YouTube
+youtube_search_tool = YoutubeVideoSearchTool(
+    youtube_video_url='https://youtube.com/watch?v=example'
+)
+
+# Defina um agente que usa a ferramenta
+video_researcher = Agent(
+    role="Video Researcher",
+    goal="Extract relevant information from a specific YouTube video",
+    backstory="An expert researcher who specializes in analyzing video content.",
+    tools=[youtube_search_tool],
+    verbose=True,
+)
+```
+
+## Parâmetros
+
+O `YoutubeVideoSearchTool` aceita os seguintes parâmetros:
+
+- **youtube_video_url**: Opcional. A URL do vídeo do YouTube para pesquisa. Se fornecida durante a inicialização, o agente não precisará especificar ao utilizar a ferramenta.
+- **config**: Opcional. Configuração para o sistema RAG subjacente, incluindo definições de LLM e embedder.
+- **summarize**: Opcional. Indica se o conteúdo recuperado deve ser resumido. O padrão é `False`.
+
+Ao usar a ferramenta com um agente, é necessário fornecer:
+
+- **search_query**: Obrigatório. A consulta de busca para encontrar informações relevantes no conteúdo do vídeo.
+- **youtube_video_url**: Obrigatório somente se não for fornecida na inicialização. A URL do vídeo do YouTube a ser pesquisado.
+
+## Modelo e Embeddings Personalizados
+
+Por padrão, a ferramenta utiliza OpenAI tanto para embeddings quanto para sumarização. Para personalizar o modelo, utilize um dicionário de configuração conforme exemplo:
+
+```python Code  
+youtube_search_tool = YoutubeVideoSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # ou google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # ou openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```
+
+## Exemplo de Integração com Agente
+
+Aqui está um exemplo mais detalhado de como integrar o `YoutubeVideoSearchTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import YoutubeVideoSearchTool
+
+# Inicialize a ferramenta
+youtube_search_tool = YoutubeVideoSearchTool()
+
+# Defina um agente que usa a ferramenta
+video_researcher = Agent(
+    role="Video Researcher",
+    goal="Extract and analyze information from YouTube videos",
+    backstory="""You are an expert video researcher who specializes in extracting 
+    and analyzing information from YouTube videos. You have a keen eye for detail 
+    and can quickly identify key points and insights from video content.""",
+    tools=[youtube_search_tool],
+    verbose=True,
+)
+
+# Crie uma tarefa para o agente
+research_task = Task(
+    description="""
+    Search for information about recent advancements in artificial intelligence 
+    in the YouTube video at {youtube_video_url}. 
+    
+    Focus on:
+    1. Key AI technologies mentioned
+    2. Real-world applications discussed
+    3. Future predictions made by the speaker
+    
+    Provide a comprehensive summary of these points.
+    """,
+    expected_output="A detailed summary of AI advancements, applications, and future predictions from the video.",
+    agent=video_researcher,
+)
+
+# Execute a tarefa
+crew = Crew(agents=[video_researcher], tasks=[research_task])
+result = crew.kickoff(inputs={"youtube_video_url": "https://youtube.com/watch?v=example"})
+```
+
+## Detalhes de Implementação
+
+O `YoutubeVideoSearchTool` é implementado como uma subclasse de `RagTool`, que fornece a funcionalidade base para Geração Auxiliada por Recuperação:
+
+```python Code
+class YoutubeVideoSearchTool(RagTool):
+    name: str = "Search a Youtube Video content"
+    description: str = "A tool that can be used to semantic search a query from a Youtube Video content."
+    args_schema: Type[BaseModel] = YoutubeVideoSearchToolSchema
+
+    def __init__(self, youtube_video_url: Optional[str] = None, **kwargs):
+        super().__init__(**kwargs)
+        if youtube_video_url is not None:
+            kwargs["data_type"] = DataType.YOUTUBE_VIDEO
+            self.add(youtube_video_url)
+            self.description = f"A tool that can be used to semantic search a query the {youtube_video_url} Youtube Video content."
+            self.args_schema = FixedYoutubeVideoSearchToolSchema
+            self._generate_description()
+```
+
+## Conclusão
+
+O `YoutubeVideoSearchTool` oferece uma maneira poderosa de pesquisar e extrair informações de conteúdos de vídeos do YouTube utilizando técnicas RAG. Ao possibilitar que agentes pesquisem dentro do conteúdo dos vídeos, facilita tarefas de extração e análise de informação que anteriormente seriam difíceis de realizar. Esta ferramenta é especialmente útil para pesquisas, análise de conteúdo e extração de conhecimento a partir de fontes em vídeo.

docs/pt-BR/tools/web-scraping/browserbaseloadtool.mdx

@@ -0,0 +1,50 @@
+---
+title: Carregador Web Browserbase
+description: O Browserbase é uma plataforma para desenvolvedores para executar, gerenciar e monitorar navegadores headless de forma confiável.
+icon: browser 
+---
+
+# `BrowserbaseLoadTool`
+
+## Descrição
+
+[Browserbase](https://browserbase.com) é uma plataforma para desenvolvedores que permite executar, gerenciar e monitorar navegadores headless de forma confiável.
+
+Potencialize suas buscas de dados para IA com:
+
+ - [Infraestrutura Serverless](https://docs.browserbase.com/under-the-hood) fornecendo navegadores confiáveis para extrair dados de interfaces complexas
+ - [Modo Stealth](https://docs.browserbase.com/features/stealth-mode) com táticas de fingerprinting e resolução automática de captcha incluídas
+ - [Depurador de Sessão](https://docs.browserbase.com/features/sessions) para inspecionar sua Sessão do Navegador com linha do tempo de rede e logs
+ - [Depuração Ao Vivo](https://docs.browserbase.com/guides/session-debug-connection/browser-remote-control) para depurar rapidamente sua automação
+
+## Instalação
+
+- Obtenha uma chave de API e o Project ID em [browserbase.com](https://browserbase.com) e defina-os nas variáveis de ambiente (`BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`).
+- Instale o [SDK do Browserbase](http://github.com/browserbase/python-sdk) juntamente com o pacote `crewai[tools]`:
+
+```shell
+pip install browserbase 'crewai[tools]'
+```
+
+## Exemplo
+
+Utilize o BrowserbaseLoadTool conforme abaixo para permitir que seu agente carregue sites:
+
+```python Code
+from crewai_tools import BrowserbaseLoadTool
+
+# Inicialize a ferramenta com a chave da API do Browserbase e o Project ID
+tool = BrowserbaseLoadTool()
+```
+
+## Argumentos
+
+Os parâmetros a seguir podem ser usados para customizar o comportamento do `BrowserbaseLoadTool`:
+
+| Argumento        | Tipo      | Descrição                                                                                                                         |
+|:-----------------|:----------|:----------------------------------------------------------------------------------------------------------------------------------|
+| **api_key**      | `string`  | _Opcional_. Chave de API do Browserbase. Padrão é a variável de ambiente `BROWSERBASE_API_KEY`.                                   |
+| **project_id**   | `string`  | _Opcional_. Project ID do Browserbase. Padrão é a variável de ambiente `BROWSERBASE_PROJECT_ID`.                                  |
+| **text_content** | `bool`    | _Opcional_. Recuperar somente o conteúdo em texto. O padrão é `False`.                                                            |
+| **session_id**   | `string`  | _Opcional_. Forneça um Session ID existente.                                                                                      |
+| **proxy**        | `bool`    | _Opcional_. Habilitar/Desabilitar proxies. O padrão é `False`.                                                                    |

docs/pt-BR/tools/web-scraping/firecrawlcrawlwebsitetool.mdx

@@ -0,0 +1,47 @@
+---
+title: Firecrawl Crawl Website
+description: O `FirecrawlCrawlWebsiteTool` foi projetado para rastrear e converter sites em markdown limpo ou dados estruturados.
+icon: fire-flame
+---
+
+# `FirecrawlCrawlWebsiteTool`
+
+## Descrição
+
+[Firecrawl](https://firecrawl.dev) é uma plataforma para rastrear e converter qualquer site em markdown limpo ou dados estruturados.
+
+## Instalação
+
+- Obtenha uma chave de API em [firecrawl.dev](https://firecrawl.dev) e defina-a nas variáveis de ambiente (`FIRECRAWL_API_KEY`).
+- Instale o [SDK do Firecrawl](https://github.com/mendableai/firecrawl) junto com o pacote `crewai[tools]`:
+
+```shell
+pip install firecrawl-py 'crewai[tools]'
+```
+
+## Exemplo
+
+Utilize o FirecrawlScrapeFromWebsiteTool como a seguir para permitir que seu agente carregue sites:
+
+```python Code
+from crewai_tools import FirecrawlCrawlWebsiteTool
+
+tool = FirecrawlCrawlWebsiteTool(url='firecrawl.dev')
+```
+
+## Argumentos
+
+- `api_key`: Opcional. Especifica a chave de API do Firecrawl. Por padrão, utiliza a variável de ambiente `FIRECRAWL_API_KEY`.
+- `url`: A URL base para iniciar o rastreamento.
+- `page_options`: Opcional.
+  - `onlyMainContent`: Opcional. Retorna apenas o conteúdo principal da página, excluindo cabeçalhos, navegações, rodapés, etc.
+  - `includeHtml`: Opcional. Inclui o conteúdo HTML bruto da página. Vai adicionar uma chave html na resposta.
+- `crawler_options`: Opcional. Opções para controlar o comportamento do rastreamento.
+  - `includes`: Opcional. Padrões de URL para incluir no rastreamento.
+  - `exclude`: Opcional. Padrões de URL para excluir do rastreamento.
+  - `generateImgAltText`: Opcional. Gera texto alternativo para imagens usando LLMs (requer um plano pago).
+  - `returnOnlyUrls`: Opcional. Se verdadeiro, retorna apenas as URLs como uma lista no status do rastreamento. Nota: a resposta será uma lista de URLs dentro do campo data, não uma lista de documentos.
+  - `maxDepth`: Opcional. Profundidade máxima de rastreamento. Profundidade 1 é a URL base, profundidade 2 inclui a URL base e seus filhos diretos, e assim por diante.
+  - `mode`: Opcional. O modo de rastreamento a ser utilizado. O modo rápido rastreia 4x mais rápido em sites sem sitemap, mas pode não ser tão preciso e não deve ser usado em sites fortemente renderizados com JavaScript.
+  - `limit`: Opcional. Número máximo de páginas a serem rastreadas.
+  - `timeout`: Opcional. Tempo limite em milissegundos para a operação de rastreamento.

docs/pt-BR/tools/web-scraping/firecrawlscrapewebsitetool.mdx

@@ -0,0 +1,43 @@
+---
+title: Firecrawl Scrape Website
+description: A ferramenta `FirecrawlScrapeWebsiteTool` foi projetada para fazer scraping de sites e convertê-los em markdown limpo ou dados estruturados.
+icon: fire-flame
+---
+
+# `FirecrawlScrapeWebsiteTool`
+
+## Descrição
+
+[Firecrawl](https://firecrawl.dev) é uma plataforma para rastrear e converter qualquer site em markdown limpo ou dados estruturados.
+
+## Instalação
+
+- Obtenha uma chave de API em [firecrawl.dev](https://firecrawl.dev) e defina-a nas variáveis de ambiente (`FIRECRAWL_API_KEY`).
+- Instale o [Firecrawl SDK](https://github.com/mendableai/firecrawl) junto com o pacote `crewai[tools]`:
+
+```shell
+pip install firecrawl-py 'crewai[tools]'
+```
+
+## Exemplo
+
+Utilize o FirecrawlScrapeWebsiteTool da seguinte forma para permitir que seu agente carregue sites:
+
+```python Code
+from crewai_tools import FirecrawlScrapeWebsiteTool
+
+tool = FirecrawlScrapeWebsiteTool(url='firecrawl.dev')
+```
+
+## Argumentos
+
+- `api_key`: Opcional. Especifica a chave de API do Firecrawl. O padrão é a variável de ambiente `FIRECRAWL_API_KEY`.
+- `url`: A URL a ser raspada.
+- `page_options`: Opcional.
+  - `onlyMainContent`: Opcional. Retorna apenas o conteúdo principal da página, excluindo cabeçalhos, navegações, rodapés, etc.
+  - `includeHtml`: Opcional. Inclui o conteúdo HTML bruto da página. Irá gerar uma chave html na resposta.
+- `extractor_options`: Opcional. Opções para extração baseada em LLM de informações estruturadas do conteúdo da página
+  - `mode`: O modo de extração a ser utilizado, atualmente suporta 'llm-extraction'
+  - `extractionPrompt`: Opcional. Um prompt descrevendo quais informações extrair da página
+  - `extractionSchema`: Opcional. O esquema para os dados a serem extraídos
+- `timeout`: Opcional. Timeout em milissegundos para a requisição

docs/pt-BR/tools/web-scraping/firecrawlsearchtool.mdx

@@ -0,0 +1,41 @@
+---
+title: Firecrawl Search
+description: O `FirecrawlSearchTool` foi projetado para pesquisar sites e convertê-los em markdown limpo ou dados estruturados.
+icon: fire-flame
+---
+
+# `FirecrawlSearchTool`
+
+## Descrição
+
+[Firecrawl](https://firecrawl.dev) é uma plataforma para rastrear e converter qualquer site em markdown limpo ou dados estruturados.
+
+## Instalação
+
+- Obtenha uma chave de API em [firecrawl.dev](https://firecrawl.dev) e defina-a nas variáveis de ambiente (`FIRECRAWL_API_KEY`).
+- Instale o [Firecrawl SDK](https://github.com/mendableai/firecrawl) junto com o pacote `crewai[tools]`:
+
+```shell
+pip install firecrawl-py 'crewai[tools]'
+```
+
+## Exemplo
+
+Utilize o FirecrawlSearchTool da seguinte forma para permitir que seu agente carregue sites:
+
+```python Code
+from crewai_tools import FirecrawlSearchTool
+
+tool = FirecrawlSearchTool(query='what is firecrawl?')
+```
+
+## Argumentos
+
+- `api_key`: Opcional. Especifica a chave de API do Firecrawl. O padrão é a variável de ambiente `FIRECRAWL_API_KEY`.
+- `query`: A string da consulta de busca a ser utilizada na pesquisa.
+- `page_options`: Opcional. Opções para formatação dos resultados.
+  - `onlyMainContent`: Opcional. Retorna somente o conteúdo principal da página, excluindo cabeçalhos, navegações, rodapés, etc.
+  - `includeHtml`: Opcional. Inclui o conteúdo HTML bruto da página. Vai gerar uma chave html na resposta.
+  - `fetchPageContent`: Opcional. Busca o conteúdo completo da página.
+- `search_options`: Opcional. Opções para controle do comportamento de rastreamento.
+  - `limit`: Opcional. Número máximo de páginas a rastrear.

docs/pt-BR/tools/web-scraping/hyperbrowserloadtool.mdx

@@ -0,0 +1,86 @@
+---
+title: Hyperbrowser Load Tool
+description: O `HyperbrowserLoadTool` permite realizar web scraping e crawling utilizando o Hyperbrowser.
+icon: globe
+---
+
+# `HyperbrowserLoadTool`
+
+## Descrição
+
+O `HyperbrowserLoadTool` permite realizar web scraping e crawling utilizando o [Hyperbrowser](https://hyperbrowser.ai), uma plataforma para executar e escalar browsers headless. Essa ferramenta possibilita extrair dados de uma única página ou rastrear um site inteiro, retornando o conteúdo em markdown ou HTML corretamente formatado.
+
+Principais Características:
+- Escalabilidade Instantânea – Inicie centenas de sessões de browser em segundos sem se preocupar com infraestrutura
+- Integração Simples – Funciona perfeitamente com ferramentas populares como Puppeteer e Playwright
+- APIs Poderosas – APIs fáceis de usar para scraping/crawling de qualquer site
+- Supera Medidas Anti-Bot – Inclui modo stealth, bloqueio de anúncios, resolução automática de CAPTCHA e proxies rotativos
+
+## Instalação
+
+Para utilizar esta ferramenta, você precisa instalar o SDK do Hyperbrowser:
+
+```shell
+uv add hyperbrowser
+```
+
+## Passos para Começar
+
+Para usar efetivamente o `HyperbrowserLoadTool`, siga estes passos:
+
+1. **Cadastre-se**: Vá até o [Hyperbrowser](https://app.hyperbrowser.ai/) para criar uma conta e gerar uma chave de API.
+2. **Chave de API**: Defina a variável de ambiente `HYPERBROWSER_API_KEY` ou passe-a diretamente no construtor da ferramenta.
+3. **Instale o SDK**: Instale o SDK do Hyperbrowser usando o comando acima.
+
+## Exemplo
+
+O exemplo a seguir demonstra como inicializar a ferramenta e utilizá-la para extrair dados de um site:
+
+```python Code
+from crewai_tools import HyperbrowserLoadTool
+from crewai import Agent
+
+# Initialize the tool with your API key
+tool = HyperbrowserLoadTool(api_key="your_api_key")  # Or use environment variable
+
+# Define an agent that uses the tool
+@agent
+def web_researcher(self) -> Agent:
+    '''
+    This agent uses the HyperbrowserLoadTool to scrape websites
+    and extract information.
+    '''
+    return Agent(
+        config=self.agents_config["web_researcher"],
+        tools=[tool]
+    )
+```
+
+## Parâmetros
+
+O `HyperbrowserLoadTool` aceita os seguintes parâmetros:
+
+### Parâmetros do Construtor
+- **api_key**: Opcional. Sua chave de API do Hyperbrowser. Se não fornecida, será lida da variável de ambiente `HYPERBROWSER_API_KEY`.
+
+### Parâmetros de Execução
+- **url**: Obrigatório. A URL do site a ser extraído ou rastreado.
+- **operation**: Opcional. A operação a ser realizada no site. Pode ser 'scrape' ou 'crawl'. O padrão é 'scrape'.
+- **params**: Opcional. Parâmetros adicionais para a operação de scraping ou crawling.
+
+## Parâmetros Suportados
+
+Para informações detalhadas sobre todos os parâmetros suportados, acesse:
+- [Parâmetros de Scrape](https://docs.hyperbrowser.ai/reference/sdks/python/scrape#start-scrape-job-and-wait)
+- [Parâmetros de Crawl](https://docs.hyperbrowser.ai/reference/sdks/python/crawl#start-crawl-job-and-wait)
+
+## Formato de Retorno
+
+A ferramenta retorna o conteúdo nos seguintes formatos:
+
+- Para operações **scrape**: O conteúdo da página no formato markdown ou HTML.
+- Para operações **crawl**: O conteúdo de cada página separado por divisores, incluindo a URL de cada página.
+
+## Conclusão
+
+O `HyperbrowserLoadTool` oferece uma maneira poderosa de realizar scraping e crawling em sites, lidando com cenários complexos como medidas anti-bot, CAPTCHAs e muito mais. Aproveitando a plataforma do Hyperbrowser, essa ferramenta permite que agentes acessem e extraiam conteúdo da web de forma eficiente.

docs/pt-BR/tools/web-scraping/overview.mdx

@@ -0,0 +1,107 @@
+---
+title: "Visão Geral"
+description: "Extraia dados de websites e automatize interações com o navegador utilizando poderosas ferramentas de scraping"
+icon: "face-smile"
+---
+
+Essas ferramentas permitem que seus agentes interajam com a web, extraiam dados de websites e automatizem tarefas baseadas em navegador. De raspagem simples a automação complexa de navegador, essas ferramentas cobrem todas as suas necessidades de interação com a web.
+
+## **Ferramentas Disponíveis**
+
+<CardGroup cols={2}>
+  <Card title="Ferramenta de Scrape de Website" icon="globe" href="/pt-BR/tools/web-scraping/scrapewebsitetool">
+    Ferramenta de raspagem de uso geral para extrair conteúdo de qualquer site.
+  </Card>
+
+  <Card title="Ferramenta de Scrape de Elemento" icon="crosshairs" href="/pt-BR/tools/web-scraping/scrapeelementfromwebsitetool">
+    Extraia elementos específicos de páginas web com capacidades de raspagem precisa.
+  </Card>
+
+  <Card title="Ferramenta Firecrawl Crawl" icon="spider" href="/pt-BR/tools/web-scraping/firecrawlcrawlwebsitetool">
+    Rastreie sites inteiros de forma sistemática com o poderoso mecanismo do Firecrawl.
+  </Card>
+
+  <Card title="Ferramenta Firecrawl Scrape" icon="fire" href="/pt-BR/tools/web-scraping/firecrawlscrapewebsitetool">
+    Raspagem web de alta performance com as capacidades avançadas do Firecrawl.
+  </Card>
+
+  <Card title="Ferramenta Firecrawl Search" icon="magnifying-glass" href="/pt-BR/tools/web-scraping/firecrawlsearchtool">
+    Pesquise e extraia conteúdos específicos utilizando os recursos de busca do Firecrawl.
+  </Card>
+
+  <Card title="Ferramenta Selenium Scraping" icon="robot" href="/pt-BR/tools/web-scraping/seleniumscrapingtool">
+    Automação de navegador e scraping com as capacidades do Selenium WebDriver.
+  </Card>
+
+  <Card title="Ferramenta ScrapFly" icon="plane" href="/pt-BR/tools/web-scraping/scrapflyscrapetool">
+    Raspagem profissional de web com o serviço premium do ScrapFly.
+  </Card>
+
+  <Card title="Ferramenta ScrapGraph" icon="network-wired" href="/pt-BR/tools/web-scraping/scrapegraphscrapetool">
+    Raspagem baseada em grafos para relacionamentos de dados complexos.
+  </Card>
+
+  <Card title="Ferramenta Spider" icon="spider" href="/pt-BR/tools/web-scraping/spidertool">
+    Rastreio abrangente de sites e capacidades de extração de dados.
+  </Card>
+
+  <Card title="Ferramenta BrowserBase" icon="browser" href="/pt-BR/tools/web-scraping/browserbaseloadtool">
+    Automação de navegador baseada em nuvem com a infraestrutura do BrowserBase.
+  </Card>
+
+  <Card title="Ferramenta HyperBrowser" icon="window-maximize" href="/pt-BR/tools/web-scraping/hyperbrowserloadtool">
+    Interações rápidas com o navegador através do engine otimizado do HyperBrowser.
+  </Card>
+
+  <Card title="Ferramenta Stagehand" icon="hand" href="/pt-BR/tools/web-scraping/stagehandtool">
+    Automação inteligente de navegador com comandos em linguagem natural.
+  </Card>
+
+  <Card title="Ferramenta Oxylabs Scraper" icon="globe" href="/pt-BR/tools/web-scraping/oxylabsscraperstool">
+    Acesse dados web em escala com o Oxylabs.
+  </Card>
+</CardGroup>
+
+## **Casos de Uso Comuns**
+
+- **Extração de Dados**: Raspagem de informações de produtos, preços e avaliações
+- **Monitoramento de Conteúdo**: Acompanhe mudanças em sites e fontes de notícias
+- **Geração de Leads**: Extraia informações de contato e dados de empresas
+- **Pesquisa de Mercado**: Coleta de inteligência competitiva e dados de mercado
+- **Testes & QA**: Automatize fluxos de teste e validação em navegadores
+- **Mídias Sociais**: Extraia posts, comentários e análises de redes sociais
+
+## **Exemplo de Início Rápido**
+
+```python
+from crewai_tools import ScrapeWebsiteTool, FirecrawlScrapeWebsiteTool, SeleniumScrapingTool
+
+# Create scraping tools
+simple_scraper = ScrapeWebsiteTool()
+advanced_scraper = FirecrawlScrapeWebsiteTool()
+browser_automation = SeleniumScrapingTool()
+
+# Add to your agent
+agent = Agent(
+    role="Web Research Specialist",
+    tools=[simple_scraper, advanced_scraper, browser_automation],
+    goal="Extract and analyze web data efficiently"
+)
+```
+
+## **Boas Práticas de Scraping**
+
+- **Respeite o robots.txt**: Sempre verifique e siga as políticas de scraping do website
+- **Controle de Taxa (Rate Limiting)**: Implemente atrasos entre as requisições para evitar sobrecarregar servidores
+- **User Agents**: Use strings de user agent apropriadas para identificar o seu bot
+- **Conformidade Legal**: Certifique-se de que suas atividades de scraping estejam em conformidade com os termos de serviço
+- **Tratamento de Erros**: Implemente um tratamento de erros robusto para problemas de rede e requisições bloqueadas
+- **Qualidade dos Dados**: Valide e limpe os dados extraídos antes de processar
+
+## **Guia de Seleção de Ferramentas**
+
+- **Tarefas Simples**: Use `ScrapeWebsiteTool` para extração básica de conteúdo
+- **Sites Dinâmicos com JavaScript**: Use `SeleniumScrapingTool` para conteúdo dinâmico
+- **Escala & Performance**: Use `FirecrawlScrapeWebsiteTool` para scraping em grande volume
+- **Infraestrutura em Nuvem**: Use `BrowserBaseLoadTool` para automação de navegador escalável
+- **Fluxos Complexos**: Use `StagehandTool` para interações inteligentes com o navegador

docs/pt-BR/tools/web-scraping/oxylabsscraperstool.mdx

@@ -0,0 +1,235 @@
+---
+title: Oxylabs Scrapers
+description: >
+  Os Scrapers da Oxylabs permitem acessar facilmente informações de fontes específicas. Veja abaixo a lista de fontes disponíveis:
+    - `Amazon Product`
+    - `Amazon Search`
+    - `Google Seach`
+    - `Universal`
+icon: globe
+---
+
+## Instalação
+
+Obtenha as credenciais criando uma conta na Oxylabs [aqui](https://oxylabs.io).
+```shell
+pip install 'crewai[tools]' oxylabs
+```
+Confira a [Documentação da Oxylabs](https://developers.oxylabs.io/scraping-solutions/web-scraper-api/targets) para mais informações sobre os parâmetros da API.
+
+# `OxylabsAmazonProductScraperTool`
+
+### Exemplo
+
+```python
+from crewai_tools import OxylabsAmazonProductScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsAmazonProductScraperTool()
+
+result = tool.run(query="AAAAABBBBCC")
+
+print(result)
+```
+
+### Parâmetros
+
+- `query` - código ASIN de 10 caracteres.
+- `domain` - domínio de localização da Amazon.
+- `geo_location` - local de entrega (_Deliver to_).
+- `user_agent_type` - tipo de dispositivo e navegador.
+- `render` - ativa o renderizador JavaScript ao definir como `html`.
+- `callback_url` - URL do seu endpoint de callback.
+- `context` - Configurações avançadas adicionais e controles para requisitos especializados.
+- `parse` - retorna os dados já processados quando definido como true.
+- `parsing_instructions` - defina sua própria lógica de parsing e transformação de dados que será executada no resultado de scraping HTML.
+
+### Exemplo avançado
+
+```python
+from crewai_tools import OxylabsAmazonProductScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsAmazonProductScraperTool(
+    config={
+        "domain": "com",
+        "parse": True,
+        "context": [
+            {
+                "key": "autoselect_variant",
+                "value": True
+            }
+        ]
+    }
+)
+
+result = tool.run(query="AAAAABBBBCC")
+
+print(result)
+```
+
+# `OxylabsAmazonSearchScraperTool`
+
+### Exemplo
+
+```python
+from crewai_tools import OxylabsAmazonSearchScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsAmazonSearchScraperTool()
+
+result = tool.run(query="headsets")
+
+print(result)
+```
+
+### Parâmetros
+
+- `query` - termo de busca da Amazon.
+- `domain` - Domínio de localização para Bestbuy.
+- `start_page` - número da página inicial.
+- `pages` - quantidade de páginas a ser recuperada.
+- `geo_location` - local de entrega (_Deliver to_).
+- `user_agent_type` - tipo de dispositivo e navegador.
+- `render` - ativa o renderizador JavaScript ao definir como `html`.
+- `callback_url` - URL do seu endpoint de callback.
+- `context` - Configurações avançadas adicionais e controles para requisitos especializados.
+- `parse` - retorna os dados já processados quando definido como true.
+- `parsing_instructions` - defina sua própria lógica de parsing e transformação de dados que será executada no resultado de scraping HTML.
+
+### Exemplo avançado
+
+```python
+from crewai_tools import OxylabsAmazonSearchScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsAmazonSearchScraperTool(
+    config={
+        "domain": 'nl',
+        "start_page": 2,
+        "pages": 2,
+        "parse": True,
+        "context": [
+            {'key': 'category_id', 'value': 16391693031}
+        ],
+    }
+)
+
+result = tool.run(query='nirvana tshirt')
+
+print(result)
+```
+
+# `OxylabsGoogleSearchScraperTool`
+
+### Exemplo
+
+```python
+from crewai_tools import OxylabsGoogleSearchScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsGoogleSearchScraperTool()
+
+result = tool.run(query="iPhone 16")
+
+print(result)
+```
+
+### Parâmetros
+
+- `query` - palavra-chave de busca.
+- `domain` - domínio de localização do Google.
+- `start_page` - número da página inicial.
+- `pages` - número de páginas a ser recuperado.
+- `limit` - quantidade de resultados a ser recuperada em cada página.
+- `locale` - valor do header `Accept-Language`, que altera o idioma da interface da página de pesquisa do Google.
+- `geo_location` - a localização geográfica para a qual o resultado deve ser adaptado. Usar este parâmetro corretamente é extremamente importante para obter os dados corretos.
+- `user_agent_type` - tipo de dispositivo e navegador.
+- `render` - ativa o renderizador JavaScript ao definir como `html`.
+- `callback_url` - URL do seu endpoint de callback.
+- `context` - Configurações avançadas adicionais e controles para requisitos especializados.
+- `parse` - retorna os dados já processados quando definido como true.
+- `parsing_instructions` - defina sua própria lógica de parsing e transformação de dados que será executada no resultado de scraping HTML.
+
+### Exemplo avançado
+
+```python
+from crewai_tools import OxylabsGoogleSearchScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsGoogleSearchScraperTool(
+    config={
+        "parse": True,
+        "geo_location": "Paris, France",
+        "user_agent_type": "tablet",
+    }
+)
+
+result = tool.run(query="iPhone 16")
+
+print(result)
+```
+
+# `OxylabsUniversalScraperTool`
+
+### Exemplo
+
+```python
+from crewai_tools import OxylabsUniversalScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsUniversalScraperTool()
+
+result = tool.run(url="https://ip.oxylabs.io")
+
+print(result)
+```
+
+### Parâmetros
+
+- `url` - URL do site a ser raspada.
+- `user_agent_type` - tipo de dispositivo e navegador.
+- `geo_location` - define a geolocalização do proxy para coletar os dados.
+- `render` - ativa o renderizador JavaScript ao definir como `html`.
+- `callback_url` - URL do seu endpoint de callback.
+- `context` - Configurações avançadas adicionais e controles para requisitos especializados.
+- `parse` - retorna os dados já processados quando definido como `true`, desde que exista um parser dedicado para o tipo de página da URL fornecida.
+- `parsing_instructions` - defina sua própria lógica de parsing e transformação de dados que será executada no resultado de scraping HTML.
+
+### Exemplo avançado
+
+```python
+from crewai_tools import OxylabsUniversalScraperTool
+
+# certifique-se de que as variáveis OXYLABS_USERNAME e OXYLABS_PASSWORD estejam definidas
+tool = OxylabsUniversalScraperTool(
+    config={
+        "render": "html",
+        "user_agent_type": "mobile",
+        "context": [
+            {"key": "force_headers", "value": True},
+            {"key": "force_cookies", "value": True},
+            {
+                "key": "headers",
+                "value": {
+                    "Custom-Header-Name": "custom header content",
+                },
+            },
+            {
+                "key": "cookies",
+                "value": [
+                    {"key": "NID", "value": "1234567890"},
+                    {"key": "1P JAR", "value": "0987654321"},
+                ],
+            },
+            {"key": "http_method", "value": "get"},
+            {"key": "follow_redirects", "value": True},
+            {"key": "successful_status_codes", "value": [808, 909]},
+        ],
+    }
+)
+
+result = tool.run(url="https://ip.oxylabs.io")
+
+print(result)
+```

docs/pt-BR/tools/web-scraping/scrapeelementfromwebsitetool.mdx

@@ -0,0 +1,139 @@
+---
+title: Ferramenta de Extração de Elementos de Website
+description: A `ScrapeElementFromWebsiteTool` permite que agentes CrewAI extraiam elementos específicos de websites usando seletores CSS.
+icon: code
+---
+
+# `ScrapeElementFromWebsiteTool`
+
+## Descrição
+
+A `ScrapeElementFromWebsiteTool` foi projetada para extrair elementos específicos de websites utilizando seletores CSS. Esta ferramenta permite que agentes CrewAI capturem conteúdos direcionados de páginas web, tornando-se útil para tarefas de extração de dados em que apenas partes específicas de uma página são necessárias.
+
+## Instalação
+
+Para utilizar esta ferramenta, você precisa instalar as dependências necessárias:
+
+```shell
+uv add requests beautifulsoup4
+```
+
+## Passos para Começar
+
+Para usar a `ScrapeElementFromWebsiteTool` de maneira eficaz, siga estes passos:
+
+1. **Instale as Dependências**: Instale os pacotes necessários com o comando acima.
+2. **Identifique os Seletores CSS**: Determine os seletores CSS dos elementos que deseja extrair do site.
+3. **Inicialize a Ferramenta**: Crie uma instância da ferramenta com os parâmetros necessários.
+
+## Exemplo
+
+O exemplo abaixo demonstra como usar a `ScrapeElementFromWebsiteTool` para extrair elementos específicos de um website:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import ScrapeElementFromWebsiteTool
+
+# Inicie a ferramenta
+scrape_tool = ScrapeElementFromWebsiteTool()
+
+# Defina um agente que utilizará a ferramenta
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extrair informações específicas de websites",
+    backstory="Um especialista em web scraping capaz de capturar conteúdos direcionados de páginas web.",
+    tools=[scrape_tool],
+    verbose=True,
+)
+
+# Exemplo de tarefa para extrair manchetes de um site de notícias
+scrape_task = Task(
+    description="Extraia as principais manchetes da página inicial da CNN. Use o seletor CSS '.headline' para atingir os elementos de manchete.",
+    expected_output="Uma lista das principais manchetes da CNN.",
+    agent=web_scraper_agent,
+)
+
+# Crie e execute o crew
+crew = Crew(agents=[web_scraper_agent], tasks=[scrape_task])
+result = crew.kickoff()
+```
+
+Você também pode inicializar a ferramenta com parâmetros pré-definidos:
+
+```python Code
+# Inicialize a ferramenta com parâmetros pré-definidos
+scrape_tool = ScrapeElementFromWebsiteTool(
+    website_url="https://www.example.com",
+    css_element=".main-content"
+)
+```
+
+## Parâmetros
+
+A `ScrapeElementFromWebsiteTool` aceita os seguintes parâmetros durante a inicialização:
+
+- **website_url**: Opcional. A URL do website a ser extraído. Se fornecido na inicialização, o agente não precisará especificá-lo ao utilizar a ferramenta.
+- **css_element**: Opcional. O seletor CSS para os elementos a serem extraídos. Se fornecido na inicialização, o agente não precisará especificá-lo ao utilizar a ferramenta.
+- **cookies**: Opcional. Um dicionário contendo cookies a serem enviados com a requisição. Isso pode ser útil para sites que requerem autenticação.
+
+## Uso
+
+Ao utilizar a `ScrapeElementFromWebsiteTool` com um agente, o agente precisará fornecer os seguintes parâmetros (a menos que já tenham sido especificados na inicialização):
+
+- **website_url**: A URL do website a ser extraído.
+- **css_element**: O seletor CSS dos elementos a serem extraídos.
+
+A ferramenta retornará o conteúdo de texto de todos os elementos que correspondam ao seletor CSS, separados por quebras de linha.
+
+```python Code
+# Exemplo de uso da ferramenta com um agente
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extrair elementos específicos de websites",
+    backstory="Um especialista em web scraping capaz de extrair conteúdo direcionado por meio de seletores CSS.",
+    tools=[scrape_tool],
+    verbose=True,
+)
+
+# Crie uma tarefa para o agente extrair elementos específicos
+extract_task = Task(
+    description="""
+    Extraia todos os títulos de produtos da seção de produtos em destaque no example.com.
+    Use o seletor CSS '.product-title' para atingir os elementos de título.
+    """,
+    expected_output="Uma lista de títulos de produtos do site",
+    agent=web_scraper_agent,
+)
+
+# Execute a tarefa utilizando um crew
+crew = Crew(agents=[web_scraper_agent], tasks=[extract_task])
+result = crew.kickoff()
+```
+
+## Detalhes de Implementação
+
+A `ScrapeElementFromWebsiteTool` utiliza a biblioteca `requests` para buscar a página web e `BeautifulSoup` para analisar o HTML e extrair os elementos especificados:
+
+```python Code
+class ScrapeElementFromWebsiteTool(BaseTool):
+    name: str = "Read a website content"
+    description: str = "A tool that can be used to read a website content."
+    
+    # Implementation details...
+    
+    def _run(self, **kwargs: Any) -> Any:
+        website_url = kwargs.get("website_url", self.website_url)
+        css_element = kwargs.get("css_element", self.css_element)
+        page = requests.get(
+            website_url,
+            headers=self.headers,
+            cookies=self.cookies if self.cookies else {},
+        )
+        parsed = BeautifulSoup(page.content, "html.parser")
+        elements = parsed.select(css_element)
+        return "\n".join([element.get_text() for element in elements])
+```
+
+## Conclusão
+
+A `ScrapeElementFromWebsiteTool` oferece uma maneira poderosa de extrair elementos específicos de websites utilizando seletores CSS. Ao possibilitar que agentes direcionem apenas o conteúdo que necessitam, ela torna as tarefas de web scraping mais eficientes e objetivas. Esta ferramenta é particularmente útil para extração de dados, monitoramento de conteúdos e tarefas de pesquisa em que informações específicas precisam ser extraídas de páginas web.

docs/pt-BR/tools/web-scraping/scrapegraphscrapetool.mdx

@@ -0,0 +1,196 @@
+---
+title: Ferramenta de Extração Scrapegraph
+description: A `ScrapegraphScrapeTool` utiliza a API SmartScraper da Scrapegraph AI para extrair conteúdo de sites de forma inteligente.
+icon: chart-area
+---
+
+# `ScrapegraphScrapeTool`
+
+## Descrição
+
+A `ScrapegraphScrapeTool` foi projetada para utilizar a API SmartScraper da Scrapegraph AI e extrair conteúdo de sites de maneira inteligente. Esta ferramenta oferece recursos avançados de web scraping com extração de conteúdo potencializada por IA, tornando-se ideal para coleta de dados direcionada e tarefas de análise de conteúdo. Diferente dos scrapers tradicionais, ela entende o contexto e a estrutura das páginas da web para extrair as informações mais relevantes, com base em instruções em linguagem natural.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar o cliente Python do Scrapegraph:
+
+```shell
+uv add scrapegraph-py
+```
+
+Você também precisa definir sua chave de API do Scrapegraph como uma variável de ambiente:
+
+```shell
+export SCRAPEGRAPH_API_KEY="your_api_key"
+```
+
+Você pode obter uma chave de API em [Scrapegraph AI](https://scrapegraphai.com).
+
+## Passos para Começar
+
+Para usar efetivamente a `ScrapegraphScrapeTool`, siga estes passos:
+
+1. **Instale as dependências**: Instale o pacote necessário usando o comando acima.
+2. **Configure a chave de API**: Defina sua chave de API do Scrapegraph como variável de ambiente ou forneça-a durante a inicialização.
+3. **Inicialize a ferramenta**: Crie uma instância da ferramenta com os parâmetros necessários.
+4. **Defina instruções de extração**: Crie prompts em linguagem natural para guiar a extração de conteúdos específicos.
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar a `ScrapegraphScrapeTool` para extrair conteúdo de um site:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import ScrapegraphScrapeTool
+
+# Initialize the tool
+scrape_tool = ScrapegraphScrapeTool(api_key="your_api_key")
+
+# Define an agent that uses the tool
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract specific information from websites",
+    backstory="An expert in web scraping who can extract targeted content from web pages.",
+    tools=[scrape_tool],
+    verbose=True,
+)
+
+# Example task to extract product information from an e-commerce site
+scrape_task = Task(
+    description="Extract product names, prices, and descriptions from the featured products section of example.com.",
+    expected_output="A structured list of product information including names, prices, and descriptions.",
+    agent=web_scraper_agent,
+)
+
+# Create and run the crew
+crew = Crew(agents=[web_scraper_agent], tasks=[scrape_task])
+result = crew.kickoff()
+```
+
+Você também pode inicializar a ferramenta com parâmetros pré-definidos:
+
+```python Code
+# Initialize the tool with predefined parameters
+scrape_tool = ScrapegraphScrapeTool(
+    website_url="https://www.example.com",
+    user_prompt="Extract all product prices and descriptions",
+    api_key="your_api_key"
+)
+```
+
+## Parâmetros
+
+A `ScrapegraphScrapeTool` aceita os seguintes parâmetros durante a inicialização:
+
+- **api_key**: Opcional. Sua chave de API do Scrapegraph. Se não for fornecida, será procurada a variável de ambiente `SCRAPEGRAPH_API_KEY`.
+- **website_url**: Opcional. A URL do site a ser extraído. Se fornecida na inicialização, o agente não precisa especificá-la ao usar a ferramenta.
+- **user_prompt**: Opcional. Instruções customizadas para extração de conteúdo. Se fornecida na inicialização, o agente não precisa especificá-la ao usar a ferramenta.
+- **enable_logging**: Opcional. Define se o registro (logging) na Scrapegraph deve ser ativado. O padrão é `False`.
+
+## Uso
+
+Ao usar a `ScrapegraphScrapeTool` com um agente, será necessário fornecer os seguintes parâmetros (a menos que tenham sido especificados durante a inicialização):
+
+- **website_url**: A URL do site a ser extraída.
+- **user_prompt**: Opcional. Instruções customizadas para extração de conteúdo. O padrão é "Extract the main content of the webpage".
+
+A ferramenta retornará o conteúdo extraído com base no prompt fornecido.
+
+```python Code
+# Example of using the tool with an agent
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract specific information from websites",
+    backstory="An expert in web scraping who can extract targeted content from web pages.",
+    tools=[scrape_tool],
+    verbose=True,
+)
+
+# Create a task for the agent to extract specific content
+extract_task = Task(
+    description="Extract the main heading and summary from example.com",
+    expected_output="The main heading and summary from the website",
+    agent=web_scraper_agent,
+)
+
+# Run the task
+crew = Crew(agents=[web_scraper_agent], tasks=[extract_task])
+result = crew.kickoff()
+```
+
+## Tratamento de Erros
+
+A `ScrapegraphScrapeTool` pode lançar as seguintes exceções:
+
+- **ValueError**: Quando a chave da API está ausente ou o formato da URL é inválido.
+- **RateLimitError**: Quando o limite de requisições da API é excedido.
+- **RuntimeError**: Quando a operação de extração falha (problemas de rede, erros da API).
+
+Recomenda-se instruir os agentes a lidarem com potenciais erros de forma apropriada:
+
+```python Code
+# Create a task that includes error handling instructions
+robust_extract_task = Task(
+    description="""
+    Extract the main heading from example.com.
+    Be aware that you might encounter errors such as:
+    - Invalid URL format
+    - Missing API key
+    - Rate limit exceeded
+    - Network or API errors
+    
+    If you encounter any errors, provide a clear explanation of what went wrong
+    and suggest possible solutions.
+    """,
+    expected_output="Either the extracted heading or a clear error explanation",
+    agent=web_scraper_agent,
+)
+```
+
+## Limitações de Taxa
+
+A API do Scrapegraph possui limites de requisição que variam conforme o seu plano de assinatura. Considere as seguintes boas práticas:
+
+- Implemente atrasos apropriados entre requisições ao processar múltiplas URLs.
+- Trate erros de limite de requisição de forma apropriada em sua aplicação.
+- Verifique os limites do seu plano de API no painel do Scrapegraph.
+
+## Detalhes de Implementação
+
+A `ScrapegraphScrapeTool` utiliza o cliente Python do Scrapegraph para se comunicar com a API SmartScraper:
+
+```python Code
+class ScrapegraphScrapeTool(BaseTool):
+    """
+    A tool that uses Scrapegraph AI to intelligently scrape website content.
+    """
+    
+    # Implementation details...
+    
+    def _run(self, **kwargs: Any) -> Any:
+        website_url = kwargs.get("website_url", self.website_url)
+        user_prompt = (
+            kwargs.get("user_prompt", self.user_prompt)
+            or "Extract the main content of the webpage"
+        )
+
+        if not website_url:
+            raise ValueError("website_url is required")
+
+        # Validate URL format
+        self._validate_url(website_url)
+
+        try:
+            # Make the SmartScraper request
+            response = self._client.smartscraper(
+                website_url=website_url,
+                user_prompt=user_prompt,
+            )
+
+            return response
+        # Error handling...
+```
+
+## Conclusão
+
+A `ScrapegraphScrapeTool` oferece uma maneira poderosa de extrair conteúdo de sites utilizando o entendimento do formato das páginas pela IA. Ao permitir que os agentes direcionem informações específicas por meio de prompts em linguagem natural, ela torna tarefas de web scraping mais eficientes e focadas. Esta ferramenta é especialmente útil para extração de dados, monitoramento de conteúdo e pesquisas em que informações específicas precisam ser extraídas de páginas web.

docs/pt-BR/tools/web-scraping/scrapewebsitetool.mdx

@@ -0,0 +1,47 @@
+---
+title: Raspar Site
+description: O `ScrapeWebsiteTool` foi desenvolvido para extrair e ler o conteúdo de um site especificado.
+icon: magnifying-glass-location
+---
+
+# `ScrapeWebsiteTool`
+
+<Note>
+    Ainda estamos trabalhando para melhorar as ferramentas, então pode haver comportamentos inesperados ou mudanças futuras.
+</Note>
+
+## Descrição
+
+Uma ferramenta desenvolvida para extrair e ler o conteúdo de um site especificado. Ela é capaz de lidar com diversos tipos de páginas web fazendo requisições HTTP e analisando o conteúdo HTML recebido.
+Esta ferramenta pode ser especialmente útil para tarefas de raspagem de dados, coleta de dados ou extração de informações específicas de sites.
+
+## Instalação
+
+Instale o pacote crewai_tools
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Exemplo
+
+```python
+from crewai_tools import ScrapeWebsiteTool
+
+# Para permitir a raspagem de qualquer site encontrado durante a execução
+tool = ScrapeWebsiteTool()
+
+# Inicialize a ferramenta com a URL do site,
+# assim o agente só poderá raspar o conteúdo do site especificado
+tool = ScrapeWebsiteTool(website_url='https://www.example.com')
+
+# Extraia o texto do site
+text = tool.run()
+print(text)
+```
+
+## Argumentos
+
+| Argumento       | Tipo     | Descrição                                                                                                                         |
+|:---------------|:---------|:-----------------------------------------------------------------------------------------------------------------------------------|
+| **website_url**  | `string`   | **Obrigatório** URL do site para leitura do arquivo. Esta é a entrada principal da ferramenta, especificando de qual site o conteúdo deve ser raspado e lido.                                                |

docs/pt-BR/tools/web-scraping/scrapflyscrapetool.mdx

@@ -0,0 +1,220 @@
+---
+title: Ferramenta de Raspagem de Sites Scrapfly
+description: A `ScrapflyScrapeWebsiteTool` aproveita a API de web scraping da Scrapfly para extrair conteúdo de sites em diversos formatos.
+icon: spider
+---
+
+# `ScrapflyScrapeWebsiteTool`
+
+## Descrição
+
+A `ScrapflyScrapeWebsiteTool` foi desenvolvida para aproveitar a API de web scraping da [Scrapfly](https://scrapfly.io/) para extrair conteúdo de sites. Esta ferramenta oferece recursos avançados de raspagem com suporte a navegador headless, proxies e recursos de bypass de anti-bot. Permite extrair dados de páginas web em vários formatos, incluindo HTML bruto, markdown e texto simples, sendo ideal para uma ampla variedade de tarefas de raspagem de sites.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar o Scrapfly SDK:
+
+```shell
+uv add scrapfly-sdk
+```
+
+Você também precisará obter uma chave de API da Scrapfly registrando-se em [scrapfly.io/register](https://www.scrapfly.io/register/).
+
+## Passos para Começar
+
+Para usar a `ScrapflyScrapeWebsiteTool` de forma eficaz, siga estas etapas:
+
+1. **Instale as Dependências**: Instale o Scrapfly SDK usando o comando acima.
+2. **Obtenha a Chave de API**: Cadastre-se na Scrapfly para obter sua chave de API.
+3. **Inicialize a Ferramenta**: Crie uma instância da ferramenta com sua chave de API.
+4. **Configure os Parâmetros de Raspagem**: Personalize os parâmetros de raspagem conforme suas necessidades.
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar a `ScrapflyScrapeWebsiteTool` para extrair conteúdo de um site:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai_tools import ScrapflyScrapeWebsiteTool
+
+# Initialize the tool
+scrape_tool = ScrapflyScrapeWebsiteTool(api_key="your_scrapfly_api_key")
+
+# Define an agent that uses the tool
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract information from websites",
+    backstory="An expert in web scraping who can extract content from any website.",
+    tools=[scrape_tool],
+    verbose=True,
+)
+
+# Example task to extract content from a website
+scrape_task = Task(
+    description="Extract the main content from the product page at https://web-scraping.dev/products and summarize the available products.",
+    expected_output="A summary of the products available on the website.",
+    agent=web_scraper_agent,
+)
+
+# Create and run the crew
+crew = Crew(agents=[web_scraper_agent], tasks=[scrape_task])
+result = crew.kickoff()
+```
+
+Você também pode personalizar os parâmetros de raspagem:
+
+```python Code
+# Example with custom scraping parameters
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract information from websites with custom parameters",
+    backstory="An expert in web scraping who can extract content from any website.",
+    tools=[scrape_tool],
+    verbose=True,
+)
+
+# The agent will use the tool with parameters like:
+# url="https://web-scraping.dev/products"
+# scrape_format="markdown"
+# ignore_scrape_failures=True
+# scrape_config={
+#     "asp": True,  # Bypass scraping blocking solutions, like Cloudflare
+#     "render_js": True,  # Enable JavaScript rendering with a cloud headless browser
+#     "proxy_pool": "public_residential_pool",  # Select a proxy pool
+#     "country": "us",  # Select a proxy location
+#     "auto_scroll": True,  # Auto scroll the page
+# }
+
+scrape_task = Task(
+    description="Extract the main content from the product page at https://web-scraping.dev/products using advanced scraping options including JavaScript rendering and proxy settings.",
+    expected_output="A detailed summary of the products with all available information.",
+    agent=web_scraper_agent,
+)
+```
+
+## Parâmetros
+
+A `ScrapflyScrapeWebsiteTool` aceita os seguintes parâmetros:
+
+### Parâmetros de Inicialização
+
+- **api_key**: Obrigatório. Sua chave de API da Scrapfly.
+
+### Parâmetros de Execução
+
+- **url**: Obrigatório. A URL do site a ser raspado.
+- **scrape_format**: Opcional. O formato em que o conteúdo da página será extraído. As opções são "raw" (HTML), "markdown" ou "text". O padrão é "markdown".
+- **scrape_config**: Opcional. Um dicionário contendo opções adicionais de configuração de raspagem da Scrapfly.
+- **ignore_scrape_failures**: Opcional. Determina se as falhas de raspagem devem ser ignoradas. Se definido como `True`, a ferramenta irá retornar `None` ao invés de lançar uma exceção caso ocorra uma falha na raspagem.
+
+## Opções de Configuração Scrapfly
+
+O parâmetro `scrape_config` permite personalizar o comportamento da raspagem com as seguintes opções:
+
+- **asp**: Ativa o bypass de proteção anti-scraping.
+- **render_js**: Ativa a renderização de JavaScript com um navegador headless na nuvem.
+- **proxy_pool**: Seleciona um pool de proxies (por exemplo, "public_residential_pool", "datacenter").
+- **country**: Seleciona a localização do proxy (por exemplo, "us", "uk").
+- **auto_scroll**: Rola automaticamente a página para carregar conteúdo lazy-loaded.
+- **js**: Executa código JavaScript personalizado via o navegador headless.
+
+Para uma lista completa de opções de configuração, consulte a [documentação da API Scrapfly](https://scrapfly.io/docs/scrape-api/getting-started).
+
+## Uso
+
+Ao usar a `ScrapflyScrapeWebsiteTool` com um agente, o agente deverá fornecer a URL do site a ser raspado e pode opcionalmente especificar o formato e opções adicionais de configuração:
+
+```python Code
+# Example of using the tool with an agent
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract information from websites",
+    backstory="An expert in web scraping who can extract content from any website.",
+    tools=[scrape_tool],
+    verbose=True,
+)
+
+# Create a task for the agent
+scrape_task = Task(
+    description="Extract the main content from example.com in markdown format.",
+    expected_output="The main content of example.com in markdown format.",
+    agent=web_scraper_agent,
+)
+
+# Run the task
+crew = Crew(agents=[web_scraper_agent], tasks=[scrape_task])
+result = crew.kickoff()
+```
+
+Para um uso mais avançado com configurações personalizadas:
+
+```python Code
+# Create a task with more specific instructions
+advanced_scrape_task = Task(
+    description="""
+    Extract content from example.com with the following requirements:
+    - Convert the content to plain text format
+    - Enable JavaScript rendering
+    - Use a US-based proxy
+    - Handle any scraping failures gracefully
+    """,
+    expected_output="The extracted content from example.com",
+    agent=web_scraper_agent,
+)
+```
+
+## Tratamento de Erros
+
+Por padrão, a `ScrapflyScrapeWebsiteTool` irá lançar uma exceção se a raspagem falhar. Os agentes podem ser instruídos a tratar falhas de forma mais flexível especificando o parâmetro `ignore_scrape_failures`:
+
+```python Code
+# Create a task that instructs the agent to handle errors
+error_handling_task = Task(
+    description="""
+    Extract content from a potentially problematic website and make sure to handle any 
+    scraping failures gracefully by setting ignore_scrape_failures to True.
+    """,
+    expected_output="Either the extracted content or a graceful error message",
+    agent=web_scraper_agent,
+)
+```
+
+## Detalhes de Implementação
+
+A `ScrapflyScrapeWebsiteTool` utiliza o Scrapfly SDK para interagir com a API Scrapfly:
+
+```python Code
+class ScrapflyScrapeWebsiteTool(BaseTool):
+    name: str = "Scrapfly web scraping API tool"
+    description: str = (
+        "Scrape a webpage url using Scrapfly and return its content as markdown or text"
+    )
+    
+    # Implementation details...
+    
+    def _run(
+        self,
+        url: str,
+        scrape_format: str = "markdown",
+        scrape_config: Optional[Dict[str, Any]] = None,
+        ignore_scrape_failures: Optional[bool] = None,
+    ):
+        from scrapfly import ScrapeApiResponse, ScrapeConfig
+
+        scrape_config = scrape_config if scrape_config is not None else {}
+        try:
+            response: ScrapeApiResponse = self.scrapfly.scrape(
+                ScrapeConfig(url, format=scrape_format, **scrape_config)
+            )
+            return response.scrape_result["content"]
+        except Exception as e:
+            if ignore_scrape_failures:
+                logger.error(f"Error fetching data from {url}, exception: {e}")
+                return None
+            else:
+                raise e
+```
+
+## Conclusão
+
+A `ScrapflyScrapeWebsiteTool` oferece uma forma poderosa de extrair conteúdo de sites usando as avançadas capacidades de web scraping da Scrapfly. Com recursos como suporte a navegador headless, proxies e bypass de anti-bot, ela consegue lidar com sites complexos e extrair conteúdo em diversos formatos. Esta ferramenta é especialmente útil em tarefas de extração de dados, monitoramento de conteúdo e pesquisa, onde a raspagem confiável de sites é necessária.

docs/pt-BR/tools/web-scraping/seleniumscrapingtool.mdx

@@ -0,0 +1,195 @@
+---
+title: Selenium Scraper
+description: O `SeleniumScrapingTool` foi desenvolvido para extrair e ler o conteúdo de um site específico utilizando o Selenium.
+icon: clipboard-user
+---
+
+# `SeleniumScrapingTool`
+
+<Note>
+    Esta ferramenta está atualmente em desenvolvimento. Conforme aprimoramos suas capacidades, os usuários podem encontrar comportamentos inesperados.
+    Seu feedback é inestimável para que possamos melhorar.
+</Note>
+
+## Descrição
+
+O `SeleniumScrapingTool` foi criado para tarefas de raspagem web de alta eficiência.
+Permite a extração precisa de conteúdo de páginas web utilizando seletores CSS para direcionar elementos específicos.
+Seu design atende a uma ampla gama de necessidades de scraping, oferecendo flexibilidade para trabalhar com qualquer URL de site fornecida.
+
+## Instalação
+
+Para utilizar esta ferramenta, é necessário instalar o pacote CrewAI tools e o Selenium:
+
+```shell
+pip install 'crewai[tools]'
+uv add selenium webdriver-manager
+```
+
+Você também precisará ter o Chrome instalado em seu sistema, pois a ferramenta utiliza o Chrome WebDriver para automação do navegador.
+
+## Exemplo
+
+O exemplo a seguir demonstra como usar o `SeleniumScrapingTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew, Process
+from crewai_tools import SeleniumScrapingTool
+
+# Inicializa a ferramenta
+selenium_tool = SeleniumScrapingTool()
+
+# Define um agente que utiliza a ferramenta
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract information from websites using Selenium",
+    backstory="An expert web scraper who can extract content from dynamic websites.",
+    tools=[selenium_tool],
+    verbose=True,
+)
+
+# Exemplo de tarefa para extrair conteúdo de um site
+scrape_task = Task(
+    description="Extract the main content from the homepage of example.com. Use the CSS selector 'main' to target the main content area.",
+    expected_output="The main content from example.com's homepage.",
+    agent=web_scraper_agent,
+)
+
+# Cria e executa o crew
+crew = Crew(
+    agents=[web_scraper_agent],
+    tasks=[scrape_task],
+    verbose=True,
+    process=Process.sequential,
+)
+result = crew.kickoff()
+```
+
+Você também pode inicializar a ferramenta com parâmetros predefinidos:
+
+```python Code
+# Inicializa a ferramenta com parâmetros predefinidos
+selenium_tool = SeleniumScrapingTool(
+    website_url='https://example.com',
+    css_element='.main-content',
+    wait_time=5
+)
+
+# Define um agente que utiliza a ferramenta
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract information from websites using Selenium",
+    backstory="An expert web scraper who can extract content from dynamic websites.",
+    tools=[selenium_tool],
+    verbose=True,
+)
+```
+
+## Parâmetros
+
+O `SeleniumScrapingTool` aceita os seguintes parâmetros durante a inicialização:
+
+- **website_url**: Opcional. A URL do site a ser raspado. Se fornecido durante a inicialização, o agente não precisará especificá-lo ao utilizar a ferramenta.
+- **css_element**: Opcional. O seletor CSS dos elementos a serem extraídos. Se fornecido durante a inicialização, o agente não precisará especificá-lo ao utilizar a ferramenta.
+- **cookie**: Opcional. Um dicionário contendo informações de cookies, útil para simular uma sessão logada e acessar conteúdo restrito.
+- **wait_time**: Opcional. Especifica o atraso (em segundos) antes da raspagem, permitindo que o site e qualquer conteúdo dinâmico carreguem totalmente. O padrão é `3` segundos.
+- **return_html**: Opcional. Indica se o conteúdo HTML deve ser retornado em vez do texto simples. O padrão é `False`.
+
+Ao usar a ferramenta com um agente, o agente precisará fornecer os seguintes parâmetros (a menos que tenham sido especificados durante a inicialização):
+
+- **website_url**: Obrigatório. A URL do site a ser raspado.
+- **css_element**: Obrigatório. O seletor CSS dos elementos a serem extraídos.
+
+## Exemplo de Integração com Agente
+
+Aqui está um exemplo mais detalhado de como integrar o `SeleniumScrapingTool` com um agente CrewAI:
+
+```python Code
+from crewai import Agent, Task, Crew, Process
+from crewai_tools import SeleniumScrapingTool
+
+# Inicializa a ferramenta
+selenium_tool = SeleniumScrapingTool()
+
+# Define um agente que utiliza a ferramenta
+web_scraper_agent = Agent(
+    role="Web Scraper",
+    goal="Extract and analyze information from dynamic websites",
+    backstory="""You are an expert web scraper who specializes in extracting 
+    content from dynamic websites that require browser automation. You have 
+    extensive knowledge of CSS selectors and can identify the right selectors 
+    to target specific content on any website.""",
+    tools=[selenium_tool],
+    verbose=True,
+)
+
+# Cria uma tarefa para o agente
+scrape_task = Task(
+    description="""
+    Extract the following information from the news website at {website_url}:
+    
+    1. The headlines of all featured articles (CSS selector: '.headline')
+    2. The publication dates of these articles (CSS selector: '.pub-date')
+    3. The author names where available (CSS selector: '.author')
+    
+    Compile this information into a structured format with each article's details grouped together.
+    """,
+    expected_output="A structured list of articles with their headlines, publication dates, and authors.",
+    agent=web_scraper_agent,
+)
+
+# Executa a tarefa
+crew = Crew(
+    agents=[web_scraper_agent],
+    tasks=[scrape_task],
+    verbose=True,
+    process=Process.sequential,
+)
+result = crew.kickoff(inputs={"website_url": "https://news-example.com"})
+```
+
+## Detalhes de Implementação
+
+O `SeleniumScrapingTool` utiliza o Selenium WebDriver para automatizar interações com o navegador:
+
+```python Code
+class SeleniumScrapingTool(BaseTool):
+    name: str = "Read a website content"
+    description: str = "A tool that can be used to read a website content."
+    args_schema: Type[BaseModel] = SeleniumScrapingToolSchema
+    
+    def _run(self, **kwargs: Any) -> Any:
+        website_url = kwargs.get("website_url", self.website_url)
+        css_element = kwargs.get("css_element", self.css_element)
+        return_html = kwargs.get("return_html", self.return_html)
+        driver = self._create_driver(website_url, self.cookie, self.wait_time)
+
+        content = self._get_content(driver, css_element, return_html)
+        driver.close()
+
+        return "\n".join(content)
+```
+
+A ferramenta executa as seguintes etapas:
+1. Cria uma instância do Chrome em modo headless
+2. Navega até a URL especificada
+3. Aguarda o tempo especificado para permitir o carregamento da página
+4. Adiciona cookies se fornecidos
+5. Extrai conteúdo baseado no seletor CSS
+6. Retorna o conteúdo extraído como texto ou HTML
+7. Encerra a instância do navegador
+
+## Tratamento de Conteúdo Dinâmico
+
+O `SeleniumScrapingTool` é especialmente útil para extrair sites com conteúdo dinâmico carregado via JavaScript. Usando uma instância real de navegador, ele pode:
+
+1. Executar JavaScript na página
+2. Aguardar o carregamento do conteúdo dinâmico
+3. Interagir com elementos se necessário
+4. Extrair conteúdo que não estaria disponível usando apenas requisições HTTP simples
+
+Você pode ajustar o parâmetro `wait_time` para garantir que todo o conteúdo dinâmico tenha sido carregado antes da extração.
+
+## Conclusão
+
+O `SeleniumScrapingTool` fornece uma maneira poderosa de extrair conteúdo de sites utilizando automação de navegador. Ao permitir que agentes interajam com sites como um usuário real, ele facilita a raspagem de conteúdo dinâmico que seria difícil ou impossível de extrair utilizando métodos mais simples. Esta ferramenta é especialmente útil para pesquisas, coleta de dados e tarefas de monitoramento que envolvem aplicações web modernas com conteúdo renderizado por JavaScript.

docs/pt-BR/tools/web-scraping/spidertool.mdx

@@ -0,0 +1,91 @@
+---
+title: Spider Scraper
+description: O `SpiderTool` foi projetado para extrair e ler o conteúdo de um site especificado usando o Spider.
+icon: spider-web
+---
+
+# `SpiderTool`
+
+## Descrição
+
+[Spider](https://spider.cloud/?ref=crewai) é o [scraper](https://github.com/spider-rs/spider/blob/main/benches/BENCHMARKS.md#benchmark-results) e crawler de código aberto mais rápido que retorna dados prontos para LLM.  
+Ele converte qualquer site em HTML puro, markdown, metadados ou texto e permite que você faça crawling com ações personalizadas utilizando IA.
+
+## Instalação
+
+Para usar o `SpiderTool` você precisa baixar o [Spider SDK](https://pypi.org/project/spider-client/)  
+e também o SDK `crewai[tools]`:
+
+```shell
+pip install spider-client 'crewai[tools]'
+```
+
+## Exemplo
+
+Este exemplo mostra como você pode usar o `SpiderTool` para permitir que seu agente faça scraping e crawling de websites.  
+Os dados retornados pela API do Spider já estão prontos para LLM, então não é necessário fazer nenhuma limpeza adicional.
+
+```python Code
+from crewai_tools import SpiderTool
+
+def main():
+    spider_tool = SpiderTool()
+
+    searcher = Agent(
+        role="Web Research Expert",
+        goal="Find related information from specific URL's",
+        backstory="An expert web researcher that uses the web extremely well",
+        tools=[spider_tool],
+        verbose=True,
+    )
+
+    return_metadata = Task(
+        description="Scrape https://spider.cloud with a limit of 1 and enable metadata",
+        expected_output="Metadata and 10 word summary of spider.cloud",
+        agent=searcher
+    )
+
+    crew = Crew(
+        agents=[searcher],
+        tasks=[
+            return_metadata,
+        ],
+        verbose=2
+    )
+
+    crew.kickoff()
+
+if __name__ == "__main__":
+    main()
+```
+
+## Argumentos
+| Argumento            | Tipo      | Descrição                                                                                                                                             |
+|:---------------------|:----------|:------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **api_key**          | `string`  | Especifica a chave da API do Spider. Se não for definida, procura por `SPIDER_API_KEY` nas variáveis de ambiente.                                     |
+| **params**           | `object`  | Parâmetros opcionais para a requisição. O padrão é `{"return_format": "markdown"}` para otimizar o conteúdo para LLMs.                                |
+| **request**          | `string`  | Tipo de requisição a ser realizada (`http`, `chrome`, `smart`). `smart` tem como padrão HTTP, alterando para renderização JavaScript se necessário.   |
+| **limit**            | `int`     | Máximo de páginas a serem rastreadas por site. Defina como `0` ou omita para ilimitado.                                                               |
+| **depth**            | `int`     | Profundidade máxima do crawl. Defina como `0` para sem limite.                                                                                        |
+| **cache**            | `bool`    | Habilita cache HTTP para acelerar execuções repetidas. O padrão é `true`.                                                                             |
+| **budget**           | `object`  | Define limites baseados em caminho para páginas rastreadas, ex.: `{"*":1}` apenas para a página raiz.                                                 |
+| **locale**           | `string`  | Localidade da requisição, ex.: `en-US`.                                                                                                               |
+| **cookies**          | `string`  | Cookies HTTP para a requisição.                                                                                                                       |
+| **stealth**          | `bool`    | Habilita modo furtivo para requisições Chrome para evitar detecção. O padrão é `true`.                                                                |
+| **headers**          | `object`  | Headers HTTP como um mapa de chave-valor para todas as requisições.                                                                                   |
+| **metadata**         | `bool`    | Armazena metadados sobre as páginas e conteúdos, auxiliando interoperabilidade com IA. O padrão é `false`.                                            |
+| **viewport**         | `object`  | Define as dimensões de viewport do Chrome. O padrão é `800x600`.                                                                                      |
+| **encoding**         | `string`  | Especifica o tipo de codificação, ex.: `UTF-8`, `SHIFT_JIS`.                                                                                          |
+| **subdomains**       | `bool`    | Inclui subdomínios no crawl. O padrão é `false`.                                                                                                      |
+| **user_agent**       | `string`  | User agent HTTP personalizado. Padrão é um agente aleatório.                                                                                          |
+| **store_data**       | `bool`    | Habilita o armazenamento dos dados para a requisição. Sobrescreve `storageless` quando definido. O padrão é `false`.                                  |
+| **gpt_config**       | `object`  | Permite à IA gerar ações de crawl, com encadeamento de etapas opcional via array para `"prompt"`.                                                     |
+| **fingerprint**      | `bool`    | Habilita fingerprint avançado para o Chrome.                                                                                                          |
+| **storageless**      | `bool`    | Impede todo o armazenamento de dados, incluindo embeddings de IA. O padrão é `false`.                                                                |
+| **readability**      | `bool`    | Pré-processa conteúdo para leitura via [Mozilla’s readability](https://github.com/mozilla/readability). Melhora o conteúdo para LLMs.                 |
+| **return_format**    | `string`  | Formato para retorno dos dados: `markdown`, `raw`, `text`, `html2text`. Use `raw` para formato padrão da página.                                     |
+| **proxy_enabled**    | `bool`    | Habilita proxies de alta performance para evitar bloqueios em nível de rede.                                                                          |
+| **query_selector**   | `string`  | CSS query selector para extração de conteúdo a partir do markup.                                                                                      |
+| **full_resources**   | `bool`    | Baixa todos os recursos vinculados ao site.                                                                                                           |
+| **request_timeout**  | `int`     | Timeout em segundos para as requisições (5-60). O padrão é `30`.                                                                                     |
+| **run_in_background**| `bool`    | Executa a requisição em segundo plano. Útil para armazenamento de dados e acionamento de crawls no dashboard. Não tem efeito se `storageless` estiver definido.

docs/pt-BR/tools/web-scraping/stagehandtool.mdx

@@ -0,0 +1,241 @@
+---
+title: Ferramenta Stagehand
+description: Ferramenta de automação web que integra o Stagehand ao CrewAI para interação e automação em navegadores
+icon: hand
+---
+
+# Visão Geral
+
+A `StagehandTool` integra o framework [Stagehand](https://docs.stagehand.dev/get_started/introduction) com o CrewAI, permitindo que agentes interajam com sites e automatizem tarefas no navegador utilizando instruções em linguagem natural.
+
+## Visão Geral
+
+O Stagehand é um poderoso framework de automação de navegador criado pela Browserbase que permite aos agentes de IA:
+
+- Navegar por sites
+- Clicar em botões, links e outros elementos
+- Preencher formulários
+- Extrair dados de páginas web
+- Observar e identificar elementos
+- Realizar fluxos de trabalho complexos
+
+A StagehandTool encapsula o SDK Python do Stagehand para fornecer aos agentes do CrewAI capacidades de controle do navegador através de três primitivas principais:
+
+1. **Act**: Executar ações como clicar, digitar ou navegar
+2. **Extract**: Extrair dados estruturados de páginas web
+3. **Observe**: Identificar e analisar elementos na página
+
+## Pré-requisitos
+
+Antes de utilizar esta ferramenta, certifique-se de que você possui:
+
+1. Uma conta [Browserbase](https://www.browserbase.com/) com chave API e ID de projeto
+2. Uma chave API para um LLM (OpenAI ou Anthropic Claude)
+3. O SDK Python do Stagehand instalado
+
+Instale a dependência necessária:
+
+```bash
+pip install stagehand-py
+```
+
+## Uso
+
+### Implementação Básica
+
+A StagehandTool pode ser implementada de duas maneiras:
+
+#### 1. Usando Context Manager (Recomendado)
+<Tip>
+  A abordagem de context manager é recomendada, pois garante o encerramento adequado dos recursos mesmo em caso de exceções.
+</Tip>
+
+```python
+from crewai import Agent, Task, Crew
+from crewai_tools import StagehandTool
+from stagehand.schemas import AvailableModel
+
+# Initialize the tool with your API keys using a context manager
+with StagehandTool(
+    api_key="your-browserbase-api-key",
+    project_id="your-browserbase-project-id",
+    model_api_key="your-llm-api-key",  # OpenAI or Anthropic API key
+    model_name=AvailableModel.CLAUDE_3_7_SONNET_LATEST,  # Optional: specify which model to use
+) as stagehand_tool:
+    # Create an agent with the tool
+    researcher = Agent(
+        role="Web Researcher",
+        goal="Find and summarize information from websites",
+        backstory="I'm an expert at finding information online.",
+        verbose=True,
+        tools=[stagehand_tool],
+    )
+
+    # Create a task that uses the tool
+    research_task = Task(
+        description="Go to https://www.example.com and tell me what you see on the homepage.",
+        agent=researcher,
+    )
+
+    # Run the crew
+    crew = Crew(
+        agents=[researcher],
+        tasks=[research_task],
+        verbose=True,
+    )
+
+    result = crew.kickoff()
+    print(result)
+```
+
+#### 2. Gerenciamento Manual de Recursos
+
+```python
+from crewai import Agent, Task, Crew
+from crewai_tools import StagehandTool
+from stagehand.schemas import AvailableModel
+
+# Initialize the tool with your API keys
+stagehand_tool = StagehandTool(
+    api_key="your-browserbase-api-key",
+    project_id="your-browserbase-project-id",
+    model_api_key="your-llm-api-key",
+    model_name=AvailableModel.CLAUDE_3_7_SONNET_LATEST,
+)
+
+try:
+    # Create an agent with the tool
+    researcher = Agent(
+        role="Web Researcher",
+        goal="Find and summarize information from websites",
+        backstory="I'm an expert at finding information online.",
+        verbose=True,
+        tools=[stagehand_tool],
+    )
+
+    # Create a task that uses the tool
+    research_task = Task(
+        description="Go to https://www.example.com and tell me what you see on the homepage.",
+        agent=researcher,
+    )
+
+    # Run the crew
+    crew = Crew(
+        agents=[researcher],
+        tasks=[research_task],
+        verbose=True,
+    )
+
+    result = crew.kickoff()
+    print(result)
+finally:
+    # Explicitly clean up resources
+    stagehand_tool.close()
+```
+
+## Tipos de Comando
+
+A StagehandTool suporta três tipos diferentes de comando para tarefas específicas de automação web:
+
+### 1. Comando Act
+
+O tipo de comando `act` (padrão) permite interações em páginas web como clicar em botões, preencher formulários e navegar.
+
+```python
+# Perform an action (default behavior)
+result = stagehand_tool.run(
+    instruction="Click the login button", 
+    url="https://example.com",
+    command_type="act"  # Default, so can be omitted
+)
+
+# Fill out a form
+result = stagehand_tool.run(
+    instruction="Fill the contact form with name 'John Doe', email 'john@example.com', and message 'Hello world'", 
+    url="https://example.com/contact"
+)
+```
+
+### 2. Comando Extract
+
+O tipo de comando `extract` recupera dados estruturados de páginas web.
+
+```python
+# Extract all product information
+result = stagehand_tool.run(
+    instruction="Extract all product names, prices, and descriptions", 
+    url="https://example.com/products",
+    command_type="extract"
+)
+
+# Extract specific information with a selector
+result = stagehand_tool.run(
+    instruction="Extract the main article title and content", 
+    url="https://example.com/blog/article",
+    command_type="extract",
+    selector=".article-container"  # Optional CSS selector
+)
+```
+
+### 3. Comando Observe
+
+O tipo de comando `observe` identifica e analisa elementos da página web.
+
+```python
+# Find interactive elements
+result = stagehand_tool.run(
+    instruction="Find all interactive elements in the navigation menu", 
+    url="https://example.com",
+    command_type="observe"
+)
+
+# Identify form fields
+result = stagehand_tool.run(
+    instruction="Identify all the input fields in the registration form", 
+    url="https://example.com/register",
+    command_type="observe",
+    selector="#registration-form"
+)
+```
+
+## Opções de Configuração
+
+Personalize o comportamento da StagehandTool com estes parâmetros:
+
+```python
+stagehand_tool = StagehandTool(
+    api_key="your-browserbase-api-key",
+    project_id="your-browserbase-project-id",
+    model_api_key="your-llm-api-key",
+    model_name=AvailableModel.CLAUDE_3_7_SONNET_LATEST,
+    dom_settle_timeout_ms=5000,  # Wait longer for DOM to settle
+    headless=True,  # Run browser in headless mode
+    self_heal=True,  # Attempt to recover from errors
+    wait_for_captcha_solves=True,  # Wait for CAPTCHA solving
+    verbose=1,  # Control logging verbosity (0-3)
+)
+```
+
+## Boas Práticas
+
+1. **Seja Específico**: Forneça instruções detalhadas para melhores resultados
+2. **Escolha o Tipo de Comando Apropriado**: Selecione o comando correto para sua tarefa
+3. **Use Selectors**: Utilize seletores CSS para aumentar a precisão
+4. **Divida Tarefas Complexas**: Separe fluxos de trabalho complexos em múltiplas chamadas da ferramenta
+5. **Implemente Tratamento de Erros**: Adicione tratamento de erros para possíveis problemas
+
+## Solução de Problemas
+
+Problemas comuns e soluções:
+
+- **Problemas de Sessão**: Verifique as chaves de API tanto da Browserbase quanto do provedor de LLM
+- **Elemento Não Encontrado**: Aumente o `dom_settle_timeout_ms` para páginas mais lentas
+- **Falhas em Ações**: Use o `observe` para identificar corretamente os elementos antes
+- **Dados Incompletos**: Refine as instruções ou forneça seletores específicos
+
+## Recursos Adicionais
+
+Para dúvidas sobre a integração com o CrewAI:
+- Participe da comunidade [Slack do Stagehand](https://stagehand.dev/slack)
+- Abra uma issue no [repositório Stagehand](https://github.com/browserbase/stagehand)
+- Visite a [documentação do Stagehand](https://docs.stagehand.dev/)