Dando dados frescos da web para um LLM: SERP APIs para RAG e grounding

Todo modelo tem um corte de treinamento, e a distância entre essa data e hoje só cresce. Grounding resolve isso do mesmo jeito que resolve desde que retrieval-augmented generation virou um padrão estabelecido: buscar primeiro, ler o que volta, depois responder a partir disso.

A mecânica é simples. A parte que vale a pena pensar direito é quanto custa rodar isso, porque esse número se comporta de forma bem diferente dependendo de quem controla a etapa de busca.

A etapa de retrieval, na prática

Busca entra, resultados orgânicos saem, busque as páginas que valem a pena ler, entregue ao modelo uma janela de contexto em vez de um corte de treinamento:

import requests

API_KEY = "faf_live_..."

def ground(query, top_n=3):
    serp = requests.get(
        "https://api.fastaf.co/v1/serp",
        params={"query": query, "results": top_n},
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=60,
    )
    serp.raise_for_status()
    links = [r["link"] for r in serp.json().get("organic_results", [])[:top_n]]

    context = []
    for link in links:
        page = requests.get(
            "https://api.fastaf.co/v1/scrape",
            params={"url": link},
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=60,
        )
        if page.status_code == 200:
            context.append({"url": link, "text": page.json().get("text", "")[:4000]})

    return context


sources = ground("latest changes to the EU AI Act")
prompt = "\n\n".join(f"Source: {s['url']}\n{s['text']}" for s in sources)
# passe `prompt` para sua chamada de LLM como contexto, junto com a pergunta original

/serp custa 5 créditos, /scrape custa 1 crédito para uma página estática (5 com dynamic=true se uma fonte precisar de renderização JS). Uma resposta fundamentada com três fontes é 5 + 3 = 8 créditos, fixos, sempre, independente do que o modelo faça com o resultado.

Por que as ferramentas de busca embutidas custam algo que você não consegue prever

Os dois grandes provedores agora oferecem uma ferramenta de busca que o modelo pode chamar por conta própria. A documentação da ferramenta de busca web da Anthropic, verificada em agosto de 2026, precifica isso em “$10 por 1.000 buscas, mais os custos padrão de tokens para conteúdo gerado pela busca”. A página de preços da OpenAI, verificada no mesmo mês, lista sua ferramenta padrão de busca web a “$10,00 / 1k chamadas + tokens de conteúdo de busca cobrados nas taxas do modelo”.

Nenhum dos dois números é o problema por si só. O problema é que o modelo decide quantas buscas rodar por requisição, e quanto de cada resultado ler. Um modelo com uma ferramenta de busca e uma pergunta difícil pode rodar uma busca ou dez, dependendo de como ele raciocina sobre a tarefa naquela vez. A documentação da Anthropic diz isso diretamente: “consultas factuais simples costumam usar de 1 a 3 buscas; pesquisas comparativas ou multientidade podem usar 10 ou mais.” Multiplique essa variação pelo conteúdo de página cobrado nas taxas de token do modelo, e a resposta honesta para “quanto isso vai custar por consulta” é uma faixa, não um número, até a conta chegar.

Você pode limitar o número de buscas por requisição (os dois provedores expõem um parâmetro tipo max-uses), o que limita o raio de impacto de uma única chamada. Isso não torna o custo por consulta previsível, porque o custo em tokens ainda escala conforme quanto de cada página o modelo decide ler.

Rodando o retrieval você mesmo

Chamar /serp e /scrape diretamente do seu próprio código contorna essa variação de um jeito específico: você decide top_n, você decide quanto de cada página guardar antes que chegue ao modelo, e o custo em créditos por chamada fundamentada fica fixo no momento em que você escreve a pipeline, não decidido por requisição pelo próprio julgamento do modelo.

A outra alavanca é a própria chave. Créditos são finitos em uma chave FastAF e reservados quando uma requisição começa, então um agente que entra em loop (tenta de novo em um resultado ruim, quebra uma pergunta em várias buscas, trava replanejando) esbarra em um limite rígido no saldo daquela chave, não em uma conta sem limite. Para um agente de IA chamando essa pipeline como uma ferramenta, esse saldo finito é o teto de gasto: dimensione uma chave para o orçamento daquele agente, e o teto é aplicado pela API, não por torcer para que o prompt dizendo para “buscar com moderação” seja respeitado.

def ground_with_budget(query, budget, top_n=3, cost_per_page=1):
    call_cost = 5 + top_n * cost_per_page  # /serp + /scrape por fonte
    if budget["spent"] + call_cost > budget["max_credits"]:
        return {"error": "grounding budget exhausted for this run"}

    budget["spent"] += call_cost
    return ground(query, top_n=top_n)

Resumindo

Fundamentar um LLM em busca ao vivo é uma chamada de busca, um punhado de buscas de página, e uma string de contexto, nada mais exótico que isso. A parte que decide se isso é barato e previsível ou um item de linha desagradável no fim do mês é quem escolhe quantas buscas e buscas de página acontecem: um modelo raciocinando turno a turno, ou uma pipeline que você escreveu com um top_n fixo e uma chave com um saldo finito por trás. Veja preços para o custo em créditos por endpoint, e a documentação para a lista completa de parâmetros de /serp e /scrape.