mirror of
https://github.com/crewAIInc/crewAI.git
synced 2026-01-11 00:58:30 +00:00
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
This commit is contained in:
Daniel Barreto
50
docs/pt-BR/tools/web-scraping/browserbaseloadtool.mdx
Normal file
50
docs/pt-BR/tools/web-scraping/browserbaseloadtool.mdx
Normal file
@@ -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`. |
|
||||
47
docs/pt-BR/tools/web-scraping/firecrawlcrawlwebsitetool.mdx
Normal file
47
docs/pt-BR/tools/web-scraping/firecrawlcrawlwebsitetool.mdx
Normal file
@@ -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.
|
||||
43
docs/pt-BR/tools/web-scraping/firecrawlscrapewebsitetool.mdx
Normal file
43
docs/pt-BR/tools/web-scraping/firecrawlscrapewebsitetool.mdx
Normal file
@@ -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
|
||||
41
docs/pt-BR/tools/web-scraping/firecrawlsearchtool.mdx
Normal file
41
docs/pt-BR/tools/web-scraping/firecrawlsearchtool.mdx
Normal file
@@ -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.
|
||||
86
docs/pt-BR/tools/web-scraping/hyperbrowserloadtool.mdx
Normal file
86
docs/pt-BR/tools/web-scraping/hyperbrowserloadtool.mdx
Normal file
@@ -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.
|
||||
107
docs/pt-BR/tools/web-scraping/overview.mdx
Normal file
107
docs/pt-BR/tools/web-scraping/overview.mdx
Normal file
@@ -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
|
||||
235
docs/pt-BR/tools/web-scraping/oxylabsscraperstool.mdx
Normal file
235
docs/pt-BR/tools/web-scraping/oxylabsscraperstool.mdx
Normal file
@@ -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)
|
||||
```
|
||||
139
docs/pt-BR/tools/web-scraping/scrapeelementfromwebsitetool.mdx
Normal file
139
docs/pt-BR/tools/web-scraping/scrapeelementfromwebsitetool.mdx
Normal file
@@ -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.
|
||||
196
docs/pt-BR/tools/web-scraping/scrapegraphscrapetool.mdx
Normal file
196
docs/pt-BR/tools/web-scraping/scrapegraphscrapetool.mdx
Normal file
@@ -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.
|
||||
47
docs/pt-BR/tools/web-scraping/scrapewebsitetool.mdx
Normal file
47
docs/pt-BR/tools/web-scraping/scrapewebsitetool.mdx
Normal file
@@ -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. |
|
||||
220
docs/pt-BR/tools/web-scraping/scrapflyscrapetool.mdx
Normal file
220
docs/pt-BR/tools/web-scraping/scrapflyscrapetool.mdx
Normal file
@@ -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.
|
||||
195
docs/pt-BR/tools/web-scraping/seleniumscrapingtool.mdx
Normal file
195
docs/pt-BR/tools/web-scraping/seleniumscrapingtool.mdx
Normal file
@@ -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.
|
||||
91
docs/pt-BR/tools/web-scraping/spidertool.mdx
Normal file
91
docs/pt-BR/tools/web-scraping/spidertool.mdx
Normal file
@@ -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.
|
||||
241
docs/pt-BR/tools/web-scraping/stagehandtool.mdx
Normal file
241
docs/pt-BR/tools/web-scraping/stagehandtool.mdx
Normal file
@@ -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/)
|
||||
Reference in New Issue
Block a user