Como Construir Sistemas RAG de Grau de Produção e Reduzir os Custos de Tokens de LLM em 70%

Principais Conclusões:

• Markdown limpo é o formato que os LLMs realmente desejam. HTML bruto é, na maior parte, navegação, scripts, slots de anúncios e estilos inline — ruído que desperdiça a janela de contexto e degrada a qualidade da recuperação. O scrape_markdown do Scrapeless retorna o corpo legível de uma página como Markdown limpo, para que o texto que chega ao seu modelo de embedding seja o texto do qual a página trata.
• O pipeline é composto por quatro etapas: Descobrir → Extrair → Chunk → Embed. Encontre os URLs relevantes, renderize cada um para Markdown limpo com o navegador em nuvem, divida o Markdown em chunks sobrepostos do tamanho adequado para o seu modelo e, em seguida, faça o embed e persista em um banco de dados vetorial para geração aumentada pela recuperação.
• Páginas pesadas em JavaScript e paredes anti-bot são tratadas na plataforma. Muitas fontes de alto valor hidratam seu conteúdo por meio de renderização do lado do cliente ou estão atrás de desafios de bot. O Scrapeless Scraping Browser renderiza a página em um verdadeiro navegador em nuvem anti-detectação com saída residencial, então o Markdown que você recebe de volta é a página totalmente hidratada, não uma casca vazia.
• Duas superfícies, um primitivo. Chame scrape_markdown a partir do servidor MCP do Scrapeless quando um agente de IA dirige o pipeline ou inicie uma sessão de navegador em nuvem com o SDK Python quando um script controla o loop. Ambos utilizam o mesmo navegador em nuvem anti-detectação.
• Ferramentas MCP sem estado prefixam sua carga com Response:\n\n. Quando você lê a saída de scrape_markdown através do servidor MCP, remova esse prefixo antes de chunking — uma correção de uma linha que impede que um cabeçalho desnecessário entre em seu corpus.
• Navegador em nuvem anti-detectação, proxies residenciais em 195+ países. O Scrapeless Scraping Browser lida com renderização em JavaScript, saída por proxies residenciais e randomização de impressões digitais (UA, fuso horário, WebGL, canvas) em cada sessão, para que o script de construção de corpus permaneça focado na qualidade do texto em vez de encanamentos de evasão.
• Grátis para começar. Novas contas do Scrapeless incluem tempo de execução gratuito do Scraping Browser — inscreva-se em Scrapeless.

Introdução: alimente seu modelo com o texto, não com a formatação da página

Um modelo de linguagem é tão bom quanto o texto que lê. Se você está montando um corpus de ajuste fino, construindo uma base de conhecimento (RAG) aumentada por recuperação sobre sua própria documentação ou fundamentando um agente em dados de mercado ao vivo, a fase de entrada define o teto em tudo o que vem a seguir. Entradas ruins não produzem apenas saídas ruins — são tokens desperdiçados, embeddings poluídos e recuperação que apresenta uma faixa de cookies em vez de uma resposta.

O problema é que a web moderna é construída para navegadores e humanos, não para modelos de embedding. Uma página típica de artigo contém alguns milhares de palavras de conteúdo real envoltas em dezenas de milhares de caracteres de menus de navegação, botões de compartilhamento, grades de posts relacionados, widgets de comentários, avisos de cookies, scripts de rastreamento e CSS inline. Alimente esse HTML bruto a um incorporador e o sinal se afoga na marcação. Além do ruído, uma parte crescente das páginas renderiza seu conteúdo principal com JavaScript após o carregamento inicial, então uma simples busca HTTP retorna um contêiner vazio. Outras estão atrás de desafios anti-bot que bloqueiam completamente a coleta automatizada.

Este post explica um fluxo de trabalho em Python em cima do Scrapeless Scraping Browser que transforma páginas web públicas desordenadas em texto limpo, segmentado e pronto para embedding. O pipeline possui quatro etapas — descobrir os URLs, extrair Markdown limpo, segmentar para RAG, fazer o embed em um banco de dados vetorial — e scrape_markdown realiza a maior parte do trabalho na etapa de extração ao retornar o corpo legível de qualquer página como Markdown limpo. Para uma versão da mesma primitiva em um framework de agente, consulte o post de integração com LangChain.

O Que Você Pode Construir

A extração de texto limpo é a base para uma ampla gama de sistemas LLM e RAG:

• RAG sobre sua própria documentação. Navegue em um site de documentação ou uma base de conhecimento para Markdown limpo, segmente-o e faça o embed para que um agente de suporte responda a partir da documentação atual em vez de um corte de treinamento obsoleto.
• Corpora de ajuste fino e pré-treinamento contínuo. Monte grandes conjuntos de dados de texto deduplicados a partir de artigos e referências públicas, com os elementos de formatação já removidos no momento da coleta.
• Fundamentação da web ao vivo para agentes. Renderize as páginas que um agente precisa no momento da consulta e forneça Markdown limpo, para que a resposta cite a página como ela é lida hoje.
• Inteligência competitiva e de mercado. Transforme páginas de produtos públicas, posts de blog e notas de lançamento em um índice vetorial pesquisável que um analista ou LLM pode consultar.
• Monitoramento de notícias e pesquisas. Ingestão de páginas de editores e revistas em um cronograma, normalize para Markdown e faça o embed para busca semântica em um corpo de fontes em movimento.
• Busca semântica interna. Construa uma camada de recuperação privada sobre material de referência pública em que sua equipe confia, mantida atualizada em um cronograma.

Por Que Scrapeless Scraping Browser

O Navegador de Scraping Sem Resíduos é um navegador em nuvem personalizável e anti-detectação projetado para crawlers da web e agentes de IA. Para pipelines de texto LLM e RAG especificamente, ele traz:

• Extração limpa de Markdown. scrape_markdown renderiza uma URL e retorna o corpo legível em Markdown — cabeçalhos, parágrafos, listas, tabelas e links preservados; navegação, scripts, espaços para anúncios e estilos em linha removidos. Esse é o formato que um modelo de embedding lê melhor.
• Renderização de JavaScript do lado da nuvem. O Chromium completo hidrata a página antes da extração, portanto, aplicativos de página única, seções carregadas de forma preguiçosa e conteúdo injetado após a solicitação inicial são capturados em vez de perdidos.
• Proxies residenciais em mais de 195 países. Páginas geograficamente limitadas retornam o conteúdo que um leitor local veria, e a rotação é automática em cada sessão — a diferença entre um artigo real e uma página de bloqueio regional.
• Impressão digital anti-detectação em cada sessão — UA, fuso horário, idioma, resolução de tela, WebGL e canvas são randomizados por sessão, para que fontes de alto valor permaneçam acessíveis sem ajuste de impressão digital por solicitação.
• Uma primitiva, duas superfícies. O mesmo navegador em nuvem é acessível como uma ferramenta MCP para pipelines dirigidos por agentes e como uma sessão SDK Python para pipelines dirigidos por script, portanto, o mesmo passo de extração se compõe em qualquer uma das arquiteturas.

Obtenha sua chave de API no plano gratuito em Scrapeless.

Pré-requisitos

• Python 3.10 ou mais recente.
• Uma conta Scrapeless e chave de API — inscreva-se em app.scrapeless.com e copie a chave de Configurações → Gerenciamento de Chave de API.
• Uma chave de API do modelo de embedding se planejar embutir (os exemplos abaixo usam OpenAI; qualquer provedor de embedding funciona trocando uma linha).
• Familiaridade básica com pip e venv.

A referência completa do SDK e ferramentas está em docs.scrapeless.com.

Instalação

Existem duas maneiras de acessar o mesmo navegador em nuvem. Escolha a que se adequa a quem dirige o pipeline — um agente ou um script.

Opção A — SDK Python (dirigido por script)

Para um script que possui o loop descobrir → extrair → dividir → embutir, instale o SDK Python Scrapeless mais as bibliotecas de embedding e de armazenamento vetorial que pretende usar:

python -m venv .venv
source .venv/bin/activate          # Windows: .venv\Scripts\activate
pip install scrapeless openai chromadb tiktoken

Exporte sua chave de API para o shell atual. O SDK lê SCRAPELESS_API_KEY do ambiente automaticamente:

export SCRAPELESS_API_KEY="sua_chave_api_aqui"
export OPENAI_API_KEY="sua_chave_openai_aqui"

Opção B — servidor MCP (dirigido por agente)

Para um agente de IA que chama ferramentas, execute o servidor MCP Scrapeless. Ele expõe scrape_markdown, scrape_html, google_search e um conjunto de ferramentas de navegador para qualquer cliente compatível com MCP:

npx -y scrapeless-mcp-server

Aponte seu cliente MCP para o comando e passe a chave de API como a variável de ambiente SCRAPELESS_KEY na configuração do servidor. O agente pode então chamar scrape_markdown diretamente.

O pipeline em um relance

Descobrir URLs            Extrair texto limpo         Dividir para RAG            Embutir + armazenar
┌──────────────┐         ┌──────────────────┐       ┌──────────────┐        ┌──────────────┐
│ google_search│         │ scrape_markdown   │       │ dividir em    │        │ embutir cada  │
│ ou sitemap   │  ────►   │ (navegador em nuvem│ ────► │ ~500–1000-tok │ ────►  │_chunk, upsert │
│ ou lista de sementes │         │  renderiza + limpa)│       │ pedaços        │        └──────────────┘
└──────────────┘         └──────────────────┘       └──────────────┘

Quatro estágios, separação limpa. A descoberta decide quais páginas entram no corpus; a extração decide quão limpo o texto é; a divisão decide quão recuperável é; a inserção torna-o pesquisável. Scrapeless controla os primeiros dois estágios — aqueles em que a web ao vivo responde — e bibliotecas padrão controlam os últimos dois.

Etapa 1 — Descobrir as URLs

Um corpus começa com uma lista de URLs. Três fontes comuns cobrem quase todos os casos:

• Uma lista de sementes ou sitemap que você já possui — o caso mais simples; pule direto para a Etapa 2.
• Uma rastreio de site — comece de uma raiz de seção e siga links do domínio até uma profundidade limitada.
• Descoberta por busca — quando as páginas relevantes não são conhecidas antecipadamente, busque por elas.

O servidor MCP Scrapeless oferece uma ferramenta google_search que retorna resultados orgânicos como linhas estruturadas, que é uma maneira limpa de descobrir URLs de origem para um tópico. Cada linha contém posição, título, link, snippet e fonte:

# discover.py — coletar URLs candidatas de uma consulta de busca
# (os argumentos da ferramenta MCP são camelCase; isso ilustra a forma retornada)
resultados = [

{"position": 1, "title": "Geração Aumentada por Recuperação, explicada",
     "link": "https://example.com/guides/rag-explained", "source": "example.com"},
    {"position": 2, "title": "Estratégias de Chunking para RAG",
     "link": "https://example.com/blog/chunking-strategies", "source": "example.com"},
    # ...
]

urls = [row["link"] for row in results]

Mantenha a fase de descoberta honesta: deduplica URLs, elimina domínios fora do tópico e limita a contagem antes de gastar qualquer orçamento de renderização por página. Um corpus focado de 200 URLs recupera melhor do que um barulhento de 2.000 URLs.

Passo 2 — Extrair Markdown limpo com scrape_markdown

Esta é a fase que decide a qualidade do corpus. scrape_markdown renderiza a URL no navegador da nuvem anti-detecção — JavaScript é executado, a página é hidratada, a saída residencial mantém o conteúdo acessível — e retorna o corpo legível como Markdown limpo. Títulos permanecem títulos, listas permanecem listas, tabelas permanecem tabelas, e tudo que não é conteúdo é removido.

Dirigido por agente (MCP)

Quando um agente chama a ferramenta, ele recebe o Markdown como resultado da ferramenta. Um detalhe é importante para a higiene do corpus: ferramentas MCP sem estado prefixam sua carga de texto com Response:\n\n. Remova esse cabeçalho antes do texto entrar no seu corpus, ou ele ficará no topo do seu primeiro chunk:

# clean_mcp_payload.py — normalize um resultado de ferramenta MCP antes do chunking
PREFIX = "Response:\n\n"

def clean_markdown(tool_result: str) -> str:
    """Remove o prefixo 'Response:' da ferramenta sem estado de um resultado de scrape_markdown de um MCP."""
    if tool_result.startswith(PREFIX):
        tool_result = tool_result[len(PREFIX):]
    return tool_result.strip()

Dirigido por script (SDK Python)

Quando um script controla o loop, crie uma sessão de navegador em nuvem com o SDK e renderize cada URL. O SDK lê SCRAPELESS_API_KEY do ambiente; proxy_country fixa a saída residencial (snake_case no SDK):

# extract.py — renderiza cada URL descoberta para Markdown limpo
from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser

client = Scrapeless()  # lê SCRAPELESS_API_KEY
session = client.browser.create(
    ICreateBrowser(proxy_country="US", session_ttl=240)
)

def fetch_markdown(url: str) -> str:
    """Renderiza uma URL no navegador da nuvem e retorna o texto do corpo Markdown limpo."""
    # A sessão expõe um ponto de extremidade CDP em session.browser_ws_endpoint;
    # dirija-o para navegar até `url`, deixe a página hidratar, então leia o
    # corpo Markdown limpo para o corpus.
    # `render_to_markdown` é seu próprio auxiliar: dirija o ponto de extremidade CDP para navegar,
    # espere pela hidratação, então converta o HTML limpo para Markdown. Para um resultado completo
    # sem auxiliar a escrever, use a ferramenta MCP `scrape_markdown` mostrada
    # acima, que retorna Markdown diretamente.
    markdown = render_to_markdown(session, url)
    return markdown.strip()

documents = []
for url in urls:
    text = fetch_markdown(url)
    if len(text) > 200:                # pula páginas quase vazias / bloqueadas
        documents.append({"url": url, "text": text})

Um guardião de comprimento curto no final é útil: uma página que retorna apenas algumas dezenas de caracteres de Markdown é geralmente um muro de consentimento ou um recipiente vazio, não um artigo, e não deve poluir o corpus.

Obtenha sua chave de API no plano gratuito: Scrapeless

Markdown ou HTML?

scrape_markdown e scrape_html apresentam a mesma renderização. A diferença é o que vem de volta e o que você faz com isso:

Para um corpus de LLM ou RAG, Markdown é o padrão. Ele entrega ao modelo de embedding o conteúdo e nada mais, sobrevive melhor à rotação de DOM do que seletores CSS e custa muito menos tokens em cada etapa a montante. Use scrape_html apenas quando precisar executar seus próprios seletores contra um layout específico.

Passo 3 — Chunk para RAG

Um modelo de embedding tem um tamanho de entrada finito, e a recuperação funciona melhor quando cada unidade armazenada é um trecho coerente em vez de um documento inteiro. O chunking divide o Markdown limpo em janelas sobrepostas. Um padrão prático é 500–1000 tokens por chunk com 10–15% de sobreposição — grande o suficiente para conter uma ideia completa, pequena o suficiente para manter a recuperação precisa, com sobreposição para que uma frase dividida através de um limite ainda apareça inteira em pelo menos um chunk.

# chunk.py — divide Markdown limpo em chunks sobrepostos, com tamanho em tokens
import tiktoken

enc = tiktoken.get_encoding("cl100k_base")

def chunk_text(text: str, max_tokens: int = 800, overlap: int = 100):
    """Gere janelas de tokens sobrepostas sobre o Markdown limpo."""
    tokens = enc.encode(text)
    step = max_tokens - overlap
    for start in range(0, len(tokens), step):
        window = tokens[start:start + max_tokens]
        if not window:
            break
        yield enc.decode(window)

chunks = []
for doc in documents:
    for i, piece in enumerate(chunk_text(doc["text"])):
        chunks.append({
            "id": f"{doc['url']}#chunk-{i}",
            "url": doc["url"],
            "chunk_index": i,
            "text": piece,
        })

Como a entrada já é um Markdown limpo, o fragmentador nunca precisa enfrentar banners de cookies ou blocos <script> dividindo um parágrafo em dois. Dividir em cabeçalhos Markdown antes da janelação de tokens mantém o conteúdo relacionado ainda melhor junto — fragmentando dentro de uma seção, e não entre duas — quando os documentos de origem têm uma estrutura de cabeçalho clara.

Um único registro de fragmento se parece com isto:

{
  "id": "https://example.com/guides/rag-explained#chunk-0",
  "url": "https://example.com/guides/rag-explained",
  "chunk_index": 0,
  "token_count": 800,
  "text": "## Geração Aumentada por Recuperação\n\nRAG fundamenta um modelo de linguagem em um corpus externo, recuperando as passagens mais relevantes no momento da consulta e passando-as para o modelo como contexto. A qualidade da recuperação depende diretamente de quão limpo o texto de origem foi extraído e fragmentado ..."
}

Passo 4 — Embutir e persistir em um banco de dados vetorial

A etapa final transforma cada fragmento em um vetor e o armazena para recuperação. O exemplo abaixo usa um armazenamento Chroma local e embeddings da OpenAI; a forma é idêntica para pgvector, Pinecone ou qualquer outro banco de dados vetorial — troque o cliente e mantenha os registros os mesmos:

# embed.py — embutir cada fragmento e inserir em um armazenamento vetorial
import chromadb
from openai import OpenAI

oai = OpenAI()
db = chromadb.PersistentClient(path=".chroma")
collection = db.get_or_create_collection("web_corpus")

def embed(texts: list[str]) -> list[list[float]]:
    resp = oai.embeddings.create(model="text-embedding-3-small", input=texts)
    return [d.embedding for d in resp.data]

batch = chunks[:64]                                   # embutir em lotes
collection.upsert(
    ids=[c["id"] for c in batch],
    documents=[c["text"] for c in batch],
    embeddings=embed([c["text"] for c in batch]),
    metadatas=[{"url": c["url"], "chunk_index": c["chunk_index"]} for c in batch],
)

Os metadados url e chunk_index acompanham cada vetor, para que, quando a recuperação traga um fragmento, você possa citar a página de origem e reassemblar fragmentos vizinhos para um contexto mais completo. Esses metadados também permitem que você insira por id — atualizar uma página substitui seus fragmentos no lugar, em vez de duplicá-los.

O que você recebe de volta

O corpus que chega ao armazenamento vetorial é uma lista de fragmentos limpos, embutidos e vinculados à fonte. Um registro recuperado se parece com isto:

{
  "id": "https://example.com/blog/chunking-strategies#chunk-2",
  "document": "### Sobreposição\n\nUma sobreposição de 10–15% entre fragmentos adjacentes mantém uma sentença que cai em um limite intacta em pelo menos uma janela, o que aumenta a recuperação em consultas que visam a junção entre duas ideias ...",
  "metadata": {
    "url": "https://example.com/blog/chunking-strategies",
    "chunk_index": 2
  },
  "distance": 0.18
}
// O esquema reflete exatamente o que a inserção do Passo 4 emite. Os valores dos campos são amostras ilustrativas.

Algumas observações honestas sobre o que esperar quando isso rodar contra a web ao vivo:

• A qualidade do Markdown acompanha a estrutura da página. Páginas com HTML semântico limpo se convertem em Markdown excelente; páginas construídas a partir de sopa genérica de <div> se convertem de forma aceitável, mas podem mesclar uma legenda de barra lateral ao corpo. Verifique uma amostra de páginas convertidas antes de confiar em um grande corpus.
• O tempo de hidratação varia por site. A maioria das páginas está totalmente renderizada quando o Markdown é lido, mas algumas hidratam seu conteúdo principal por meio de uma solicitação atrasada; para essas, permita que a página se estabilize um momento antes de ler.
• Desduplicar em dois níveis. Elimine URLs duplicadas na descoberta e fragmentos quase duplicados antes de embutir (um hash ou um limiar de similaridade) — artigos sindicados e rodapés padronizados, de outra forma, inflacionam o corpus e enviesam a recuperação.
• Fixe a região de saída para conteúdo com variação geográfica. Sites que localizam conteúdo retornam diferentes textos por região; configure proxy_country para a região cuja versão você deseja no corpus, para que o conjunto de dados permaneça consistente.
• Mantenha o limite de comprimento. Uma página que retorna apenas algumas dezenas de caracteres geralmente é uma parede de consentimento ou um contêiner vazio, não conteúdo — filtre antes de fragmentar.

Conclusão: crie um pipeline de texto limpo que escale

O formato Descobrir → Extrair → Fragmentar → Incorporar colapsa para cerca de sessenta linhas de Python. A etapa que suporta a carga é a extração, e scrape_markdown é responsável por isso: o navegador anti-detecção renderiza a página, a saída residencial a mantém acessível, e o que retorna é o corpo legível como Markdown limpo — o formato que um modelo de incorporação lê melhor. Fragmentar e incorporar são, então, trabalho de biblioteca padrão em texto que já está limpo.

Para o mesmo primitivo do Navegador de Scraping Sem Scrapeless conectado a uma estrutura de agente com saída tipada e um armazenamento vetorial, consulte o post de integração do LangChain. Para mais padrões de ponta a ponta que compostem busca, renderização e extração em sistemas funcionais, veja o post de casos de uso de agentes de IA. O padrão que se mantém em todos eles: fixe uma região, retorne Markdown, não HTML, fraccione com sobreposição e deduplice antes de incorporar.

Pronto para Construir Seu Pipeline de Dados Potencializado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores que estão construindo pipelines de dados LLM e RAG no Scrapeless: Discord · Telegram.

Inscreva-se em Scrapeless para um tempo de execução gratuito do Navegador de Scraping e adapte os padrões acima às fontes, regiões e tamanhos de fragmentos que seu pipeline necessita. Os planos e limites estão em scrapeless.com/en/pricing.

FAQ

Q: É legal raspar texto de sites para um corpus de LLM ou RAG?

Raspar dados visíveis publicamente é amplamente permitido na maioria das jurisdições, mas as regras variam por país e pelos termos de serviço do site. Reveja os ToS do site alvo, respeite robots.txt quando aplicável, não colete dados pessoais sem uma base legal e consulte um advogado para corpora em escala comercial. Construir um conjunto de dados de treinamento ou RAG não altera a obrigação subjacente de acessar apenas dados públicos de forma legal.

Q: Por que Markdown em vez de HTML bruto para entrada de LLM?

HTML bruto é principalmente marcação — navegação, scripts, slots de anúncios, estilos inline — que dilui o sinal de conteúdo, infla o custo de tokens e polui as incorporações. Markdown limpo do scrape_markdown mantém os títulos, parágrafos, listas, tabelas e links sobre os quais a página realmente se trata e descarta o restante, de forma que o modelo de incorporação lê o conteúdo e nada mais. O Markdown também sobrevive melhor a mudanças no DOM do que a extração por seletor CSS.

Q: Qual tamanho de fragmento devo usar para RAG?

Um padrão prático é de 500 a 1000 tokens por fragmento com 10 a 15% de sobreposição. Fragmentos menores aumentam a precisão de recuperação, mas podem dividir uma ideia; fragmentos maiores mantêm mais contexto, mas diluem a relevância. Ajuste ao tamanho de entrada do seu modelo de incorporação e suas consultas — pesquisas fatuais curtas favorecem fragmentos menores, perguntas de síntese favorecem os maiores. Fragmentar em títulos Markdown antes da janela de tokens mantém o conteúdo relacionado junto.

Q: Eu preciso de um proxy?

Sim, para a maioria das fontes públicas que valem a pena coletar. A saída residencial é o que mantém páginas geolocalizadas e protegidas contra bots acessíveis, e é o que faz uma página pesada em JavaScript renderizar conteúdo real em vez de uma página bloqueada. O Navegador de Scraping Sem Scrapeless roteia através de proxies residenciais em mais de 195 países; defina proxy_country para fixar a região cuja versão do conteúdo você deseja.

Q: Como faço para deduplicar e limpar o corpus?

Deduplica em dois níveis: elimine URLs duplicadas na descoberta e elimine fragmentos quase duplicados antes da incorporação usando um hash de conteúdo ou um limiar de similaridade. Como o scrape_markdown já remove o boilerplate, a limpeza restante é leve — um guardião de comprimento para descartar páginas quase vazias e uma fragmentação ciente de cabeçalhos são geralmente suficientes.

Q: Por que o resultado do MCP scrape_markdown começa com Response:?

Ferramentas sem estado no servidor MCP do Scrapeless prefixam sua carga útil de texto com Response:\n\n. É um cabeçalho de camada de transporte, não parte do conteúdo da página. Remova-o antes de fragmentar — o helper de uma linha clean_markdown no Passo 2 cuida disso — para que o prefixo não apareça no topo do seu primeiro fragmento.

Q: Posso executar isso sem um agente de IA?

Sim. O caminho do SDK Python no Passo 2 possui o loop descobrir → extrair → fragmentar → incorporar de ponta a ponta sem envolvimento de agente. O servidor MCP é o caminho recomendado quando um agente decide quais páginas coletar; o SDK é o caminho recomendado quando um script faz isso.