andre/crewAI
1
0
Fork 0
mirror of https://github.com/crewAIInc/crewAI.git synced 2026-01-10 08:38:30 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Add pt-BR docs translation (#3039)

Browse Source 
* 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
This commit is contained in:
Daniel Barreto
2025-06-25 12:52:33 -03:00
committed by GitHub
parent f6dfec61d6
commit a50fae3a4b
339 changed files with 33822 additions and 517 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
docs/pt-BR/tools/ai-ml/aimindtool.mdx Normal file
View File

@@ -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.

209
docs/pt-BR/tools/ai-ml/codeinterpretertool.mdx Normal file
View File

@@ -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.

51
docs/pt-BR/tools/ai-ml/dalletool.mdx Normal file
View File

@@ -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).

57
docs/pt-BR/tools/ai-ml/langchaintool.mdx Normal file
View File

@@ -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.

146
docs/pt-BR/tools/ai-ml/llamaindextool.mdx Normal file
View File

@@ -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.

65
docs/pt-BR/tools/ai-ml/overview.mdx Normal file
View File

@@ -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"
)
```

172
docs/pt-BR/tools/ai-ml/ragtool.mdx Normal file
View File

@@ -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.

49
docs/pt-BR/tools/ai-ml/visiontool.mdx Normal file
View File

@@ -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. |