Posso usar isso para sites além do LinkedIn?

Sim. A Biblioteca de Web Scrapers da Bright Data cobre centenas de sites (Amazon, Zillow, Yelp e mais), cada um com seu próprio dataset_id. Troque o DATASET_ID em scrape.py e o mapeamento to_row() em index.py pelo novo formato JSON. A lógica de busca e indexação é agnóstica em relação aos dados e se mantém.

Preciso de uma conta paga do Cohere para isso?

Não, uma chave de teste executa toda a demonstração. O endpoint Rerank de teste do Cohere está atualmente limitado a 10 chamadas/min, então o eval.py recebe um 429 e recua automaticamente (~90s em vez de ~15s). Scraping, indexação e busca ad-hoc ficam bem dentro dos limites. Faça upgrade apenas se você iterar na avaliação com frequência.

Por que LanceDB e não Pinecone, Weaviate ou pgvector?

O LanceDB é uma biblioteca embarcada sem servidor, sem banco de dados separado e sem cobrança de serviço gerenciado. Ele suporta busca híbrida e reranking do Cohere nativamente, e cada escrita é um snapshot de versão. Para um pipeline de máquina única sem operações, é a menor sobrecarga. Os outros são capazes, mas adicionam mais infraestrutura.

Com que frequência devo reexecutar o scraper?

Uma vez por dia é adequado para um quadro de empregos ativo. A Bright Data pode executar coleta agendada pelo dashboard, e o upsert merge_insert desduplicata no lado do LanceDB, então as reexecuções são baratas. Anúncios com mais de ~30 dias geralmente estão fechados, então snapshots antigos se tornam históricos, e o versions.py os mantém consultáveis.

Busca Semântica de Empregos com Bright Data, LanceDB e Cohere

Os quadros de empregos pesquisam apenas por palavras exatas, então a vaga certa fica oculta quando sua formulação não corresponde ao anúncio. A busca semântica combina por significado. Construímos do início ao fim e medimos qual modo de busca vence, em vez de assumir que o mais complexo é o melhor.

TL;DR

Este guia cria um motor de busca de empregos semântico com 200 vagas reais do LinkedIn usando Bright Data (scraping), Cohere (embeddings + rerank) e LanceDB (armazenamento local de vetores).

A busca por palavras-chave combina palavras exatas. A busca vetorial combina significado. Uma consulta como “engenheiro que trabalha com LLMs” encontra uma vaga de “Desenvolvedor GenAI” que a busca por palavras-chave não encontra.
A API Web Scraper da Bright Data retorna vagas estruturadas do LinkedIn em JSON por $0,0015 por registro, sem parsing de HTML nem manutenção de Scraper.
O LanceDB roda localmente e combina busca vetorial com filtros SQL (salário, senioridade) em 1 consulta, além de busca em texto completo e reranking com Cohere.
Em 10 consultas de teste, a busca vetorial obteve 70% de precisão@3 contra 43% da busca por palavras-chave. Híbrido + rerank não acrescentou ganho mensurável nessa escala, então abaixo de ~10k linhas o vetor sozinho é um padrão razoável.
O projeto completo tem 9 arquivos pequenos, incluindo um harness de avaliação, e o código completo está no GitHub. A execução completa custa ~$0,34.

O problema com a busca por palavras-chave

A busca por palavras-chave em um quadro de empregos faz exatamente o que você pede. Ela retorna anúncios cujo título ou descrição contém os tokens literais da sua consulta. Pesquise por “engenheiro que trabalha com LLMs e engenharia de prompt” e você perderá vagas como “Desenvolvedor GenAI”, mesmo que sejam um ajuste perfeito. A busca lexical combina palavras exatas, não significado.

A busca vetorial combina por significado. Cada descrição de vaga é convertida em um embedding (um vetor de alta dimensão que captura seu conteúdo semântico), assim como sua consulta. Uma vaga cujo vetor está próximo ao da sua consulta é uma boa correspondência em significado, mesmo quando não compartilha nenhuma palavra em comum.

Transformar isso em um motor de busca funcional requer 3 componentes:

Bright Data faz o scraping de 200 vagas reais do LinkedIn em JSON estruturado e limpo.
Cohere transforma as descrições em embeddings e reordena os resultados finais.
LanceDB armazena os embeddings localmente e serve consultas híbridas (vetor + texto completo) com filtros no estilo SQL.

A stack em resumo

O que cada camada faz e por que a usamos:

Camada	Ferramenta	Por que esta
Dados web	Bright Data Web Scraper API	O Scraper pré-construído do LinkedIn retorna JSON estruturado com salário, senioridade e localização, sem parsing de HTML nem manutenção de Scraper.
Embeddings	Cohere `embed-english-v3.0`	Codificação assimétrica (tipos de entrada diferentes para documentos vs consultas). O Cohere também oferece `embed-v4.0`, que é multimodal. Usamos a v3 aqui pelo seu perfil de preço/latência apenas para inglês (planejamos re-embedar antes do fim de vida da v3).
Reranker	Cohere `rerank-v3.5`	Fixamos a v3.5 pelo seu perfil de preço/latência. O Cohere também oferece `rerank-v4.0` (`-pro` para qualidade, `-fast` para latência).
Armazenamento vetorial	LanceDB	Local, embarcado, sem servidores. Suporta busca híbrida (vetor + BM25) e pré-filtros SQL.
UI (opcional)	Streamlit	Interface web com código mínimo para um app de dados Python.

Esta stack roda a partir de um único venv Python no seu computador. Bright Data e Cohere são os únicos serviços gerenciados envolvidos.

Configuração

O projeto completo e executável está no GitHub. Clone-o e instale as dependências (Python 3.10 ou mais recente):

git clone https://github.com/triposat/semantic-job-search.git
cd semantic-job-search
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

Copie o arquivo env de exemplo e adicione suas duas chaves de API, um token da Bright Data e uma chave do Cohere em dashboard.cohere.com (uma chave de teste funciona para todo o guia):

cp .env.example .env
# then edit .env with your keys:
#   BRIGHTDATA_API_TOKEN=...
#   COHERE_API_KEY=...

Com ambas as chaves configuradas, execute python scrape.py para obter os dados e python index.py para construir o índice.

Arquitetura

O sistema tem dois fluxos, não um. Ingestão constrói o índice (executado uma vez ou em agendamento). Consulta é executada em cada busca. Ambos usam Cohere e LanceDB, mas para trabalhos diferentes.

Os dois fluxos lado a lado. A ingestão embeda documentos e os armazena. A consulta embeda o texto de busca, executa busca vetorial + texto completo com pré-filtro SQL e depois reordena. Cohere e LanceDB aparecem em ambos os fluxos, mas fazem trabalhos diferentes em cada um, por isso o rerank nunca toca no caminho de ingestão.

3 scripts executam o pipeline: scrape.py, index.py, search.py. Mais 6 auxiliares: lib.py (backend de busca compartilhado), compare.py (comparação de modos), eval.py (precisão@3), stats.py (resumo do conjunto de dados), versions.py (navegador de snapshots) e app.py (UI Streamlit).

Faça Scraping do LinkedIn com a Bright Data

O LinkedIn é uma fonte importante de dados de vagas, mas é difícil de fazer scraping de forma confiável: limites de taxa, marcação dinâmica e HTML que muda sem aviso. A Web Scraper API retorna JSON estruturado e limpo a partir de endpoints pré-construídos, para que você não precise manter parsers.

Escolha o endpoint correto

A Bright Data expõe vários Scrapers do LinkedIn:

Perfis de pessoas → perfis individuais de membros
Informações de empresas → páginas de empresas
Vagas → Coletar por URL → URLs específicas de vagas que você já possui
Vagas → Descobrir por palavra-chave ← queremos este
Vagas → Descobrir por URL → vagas a partir de uma URL de resultados de busca
Posts do LinkedIn e Busca de pessoas → outros tipos de entidade

Descobrir por palavra-chave é a opção certa porque queremos descoberta em massa de vagas a partir de uma consulta de busca. Uma única chamada de API retorna até 1.000 vagas estruturadas por palavra-chave, incluindo título, empresa, localização, nível de senioridade, tipo de emprego, faixa salarial quando listada e a descrição completa da vaga.

Cada Scraper tem seu próprio dataset_id. Para encontrar um, abra a Biblioteca de Scrapers da Bright Data, pesquise pelo site (aqui, linkedin.com) e abra-o. Escolha o endpoint Vagas → Descobrir por palavra-chave, e seu dataset_id (gd_lpfll7v5hcqtkxl6l) e uma solicitação pronta para uso aparecem no painel de exemplos de código. Um token válido é tudo que o scrape.py precisa para chamá-lo.

Dashboard da Bright Data mostrando o menu da Biblioteca de Web Scrapers, com o endpoint de vagas do LinkedIn → 'Descobrir por palavra-chave' selecionado na barra lateral esquerda. O painel central mostra a aba de Configuração com entradas de exemplo (paris/gerente de produto, Nova York/desenvolvedor python). O painel direito mostra a visualização de exemplos de código com uma solicitação curl autenticada contendo `dataset_id=gd_lpfll7v5hcqtkxl6l`.

A página do Scraper ‘Descobrir por palavra-chave’. O painel de exemplos de código à direita é onde você encontrará o dataset_id.

Síncrono vs assíncrono

A Bright Data oferece 2 modos de entrega:

Síncrono (POST /datasets/v3/scrape) retorna os dados inline, ideal para lotes pequenos.
Assíncrono (POST /datasets/v3/trigger) retorna um ID de snapshot. Você verifica o status até a conclusão e baixa o resultado, ideal para volumes maiores.

Em nossas execuções, o tempo de resposta foi em média ~6 segundos por entrada. Para 2 palavras-chave com limit_per_input=100 (200 vagas no total), uma chamada síncrona precisa manter a conexão aberta durante todo o lote, o que pode causar timeout. O assíncrono é o padrão seguro.

Controle o custo com limites por entrada

O parâmetro de consulta limit_per_input=N limita quantos resultados cada busca de entrada retorna, que é exatamente o controle que você precisa para gastos previsíveis:

2 keywords × 100 jobs × $0.0015 = $0.30 per run

Aumente para execuções maiores, até 1.000 vagas por palavra-chave.

O código

O Scraper aciona um snapshot, verifica o status até estar pronto e baixa o JSON. O núcleo está abaixo (uma versão de produção adicionaria retry/backoff e tratamento de erros mais robusto):

# scrape.py
import json, time, sys
from pathlib import Path
import requests
from lib import require_env

BD_TOKEN = require_env("BRIGHTDATA_API_TOKEN")
DATASET_ID = "gd_lpfll7v5hcqtkxl6l"  # LinkedIn jobs - discover by keyword
LIMIT_PER_INPUT = 100

SEARCHES = [
    {"location": "San Francisco", "keyword": "machine learning engineer",
     "country": "US", "time_range": "Past month", "job_type": "Full-time",
     "experience_level": "", "remote": "", "company": "", "location_radius": ""},
    {"location": "New York", "keyword": "python developer",
     "country": "US", "time_range": "Past month", "job_type": "Full-time",
     "experience_level": "", "remote": "", "company": "", "location_radius": ""},
]

API = "https://api.brightdata.com/datasets/v3"
HEADERS = {"Authorization": f"Bearer {BD_TOKEN}", "Content-Type": "application/json"}

def trigger_snapshot() -> str:
    r = requests.post(f"{API}/trigger", headers=HEADERS, json={"input": SEARCHES},
        params={"dataset_id": DATASET_ID, "type": "discover_new",
                "discover_by": "keyword", "include_errors": "true",
                "limit_per_input": str(LIMIT_PER_INPUT)})
    r.raise_for_status()
    return r.json()["snapshot_id"]

def wait_until_ready(snapshot_id: str) -> None:
    while True:
        status = requests.get(f"{API}/progress/{snapshot_id}", headers=HEADERS).json()["status"]
        if status == "ready": return
        if status == "failed": raise RuntimeError("snapshot failed")
        time.sleep(10)

def download(snapshot_id: str) -> list[dict]:
    return requests.get(f"{API}/snapshot/{snapshot_id}",
                        headers=HEADERS, params={"format": "json"}).json()

Executando:

$ python scrape.py
→ scraping 2 keyword searches, max 100 jobs each
  estimated max cost: $0.30 (at $0.0015/record × 200 max records)
  triggered snapshot: sd_mojicp6g39xwbwqn2
  status: ready
✓ saved 204 jobs → data/raw_jobs.json
  actual cost: $0.31

O que você recebe de volta

Cada vaga no JSON tem mais de 25 campos. Aqui estão os que importam:

{
  "job_posting_id": "<id>",
  "job_title": "Associate Machine Learning Engineer",
  "company_name": "ExampleCo",
  "job_location": "San Francisco, CA",
  "job_seniority_level": "Entry level",
  "job_employment_type": "Full-time",
  "job_industries": "Software Development",
  "job_summary": "About ExampleCo. ExampleCo is the career network for the AI economy...",
  "base_salary": {
    "min_amount": 115000,
    "max_amount": 144000,
    "currency": "$",
    "payment_period": "yr"
  },
  "job_posted_date": "2026-04-25T03:41:21.072Z",
  "url": "https://www.linkedin.com/jobs/view/<id>"
}

O campo estruturado base_salary é o que torna possíveis as consultas com filtro de salário na próxima etapa.

Indexe com Cohere e LanceDB

Temos 204 registros brutos de vagas, sendo 4 linhas de erro que filtramos no carregamento. Agora tornamos os 200 restantes pesquisáveis semanticamente.

Por que Cohere

Escolhemos o Cohere em vez das alternativas (modelos de embedding da OpenAI, Voyage AI ou sentence-transformers locais):

Codificação assimétrica. O Cohere permite marcar a entrada como search_document ao indexar ou search_query ao pesquisar. O modelo codifica cada lado de forma diferente, o que funciona melhor do que tratar ambos da mesma forma.
Embedding declarativo. O registro do LanceDB suporta Cohere nativamente (assim como OpenAI e sentence-transformers), então o embedding acontece na inserção e na consulta sem chamadas manuais de embed().
A API Rerank. É um modelo separado que recebe uma consulta mais uma lista de candidatos e reordena os candidatos por relevância real. É o segundo estágio que pode aprimorar o ranking de um pipeline híbrido, e adicionamos esse estágio com uma chamada .rerank().

O registro de embeddings do LanceDB

Os embeddings no LanceDB passam pelo seu registro de embeddings. Você declara seu schema uma vez e os embeddings acontecem automaticamente em cada inserção e consulta, cada um com o input_type correto.

# index.py
import lancedb
from lancedb.embeddings import get_registry
from lancedb.pydantic import LanceModel, Vector

cohere = get_registry().get("cohere").create(
    name="embed-english-v3.0",
    api_key=COHERE_API_KEY,
)

class Job(LanceModel):
    text: str = cohere.SourceField()              # ← o que embedar
    vector: Vector(cohere.ndims()) = cohere.VectorField()  # ← embedding armazenado
    job_id: str
    title: str
    company: str
    location: str
    country_code: str
    seniority: str
    employment_type: str
    job_function: str
    industry: str
    posted_date: str
    apply_url: str
    search_keyword: str
    salary_min_annual: float
    salary_max_annual: float
    salary_currency: str
    salary_display: str
    description_snippet: str

Tudo após vector é uma coluna armazenada simples, usada para filtragem e exibição.

O truque da normalização de salário

A maioria das vagas tem salários cotados por ano, mas alguns são por hora. Para que salary_min_annual >= 200000 funcione de forma consistente, normalizamos na ingestão:

HOURS_PER_YEAR = 2080

def _normalize_salary(base):
    if not base:
        return 0.0, 0.0, "", ""
    lo = float(base.get("min_amount") or 0)
    hi = float(base.get("max_amount") or 0)
    if (base.get("payment_period") or "").lower() == "hr":
        lo *= HOURS_PER_YEAR
        hi *= HOURS_PER_YEAR
    currency = base.get("currency") or ""
    display = f"{currency}{int(lo):,}–{currency}{int(hi):,}/yr" if (lo and hi) else ""
    return lo, hi, currency, display

Armazenamos tanto os valores numéricos brutos (para filtros) quanto uma string de exibição legível por humanos (para a UI).

Atualizações incrementais com upserts

Na primeira execução do index.py, ele cria a tabela. Cada execução subsequente é um upsert com chave em job_id:

result = (
    table.merge_insert("job_id")
         .when_matched_update_all()       # atualiza vagas existentes
         .when_not_matched_insert_all()   # adiciona novas descobertas
         .execute(rows)
)
print(f"inserted={result.num_inserted_rows}, updated={result.num_updated_rows}")

Novas vagas de um novo scraping da Bright Data são inseridas, e vagas repostadas (mesmo job_id) têm seus salários, descrições e timestamps atualizados. Para remover completamente anúncios obsoletos, encadeie .when_not_matched_by_source_delete().

Todo o upsert é uma única transação atômica. Como o Lance armazena dados de forma colunar com copy-on-write, a reingestão é uma escrita incremental em vez de uma reconstrução completa da tabela.

Índices escalares para filtros SQL rápidos

Quando search.py, where "salary_min_annual >= 200000" é executado, o LanceDB aplica o filtro antes da varredura vetorial (prefilter=True). Com 200 linhas, isso é instantâneo de qualquer forma. Com 200.000 linhas, o filtro percorreria a coluna inteira a menos que digamos ao LanceDB como indexá-la:

table.create_scalar_index("salary_min_annual", index_type="BTREE",  replace=True)
table.create_scalar_index("seniority",         index_type="BITMAP", replace=True)
table.create_scalar_index("search_keyword",    index_type="BITMAP", replace=True)
table.create_scalar_index("employment_type",   index_type="BITMAP", replace=True)

2 tipos de índice cobrem o que precisamos:

BTREE para colunas ordenáveis de maior cardinalidade. salary_min_annual se beneficia porque queremos consultas de intervalo (>=, BETWEEN).
BITMAP para enums de baixa cardinalidade. seniority tem ~6 valores distintos, employment_type é quase todo Full-time, e search_keyword é uma das 2 entradas de scraping. Cada valor distinto recebe seu próprio bitmap. Um filtro = se torna um único AND bit a bit.

Ambos executam com replace=True, então reexecutar o index.py os reconstrói de forma idempotente. Após a chamada, table.list_indices() reporta todos os 5 (os 4 escalares + o índice FTS):

text_idx               type=FTS      columns=['text']
salary_min_annual_idx  type=BTree    columns=['salary_min_annual']
seniority_idx          type=Bitmap   columns=['seniority']
search_keyword_idx     type=Bitmap   columns=['search_keyword']
employment_type_idx    type=Bitmap   columns=['employment_type']

Inspecione os dados indexados

Após executar o python index.py, nosso script auxiliar stats.py resume o que está no banco de dados:

$ python stats.py

📊 LanceDB · table 'jobs'  ·  200 rows

by source keyword
  machine learning engineer  ████████████████████ 100
  python developer           ████████████████████ 100

by seniority
  Mid-Senior level  ████████████████████ 99
  Entry level       ████████████ 62
  Not Applicable    ████ 20
  Internship        ██ 14
  Associate          4
  Director           1

salary coverage: 43/200 jobs (22%)
  min  $   65,000
  med  $  150,000
  max  $1,000,000

  highest-paying jobs:
    • Quantitative Developer (Python)                  Fintal Partners       $400,000–$1,000,000/yr
    • Machine Learning Engineer                        Mercor                $130,000–$500,000/yr
    • Data Scientist                                   Triumph               $200,000–$400,000/yr
    • Senior Python Developer (Middle Office Tech)     Quantitative Systems  $200,000–$400,000/yr
    • ML Engineer (Infra & Distributed training)       techire ai            $250,000–$400,000/yr

top hiring companies (top 10)
  Turing          ████████████████████ 7
  Handshake       █████████████████ 6
  OpenAI          █████████████████ 6
  Meta            █████████████████ 6
  Jack & Jill     ██████████████ 5
  DataAnnotation  ██████████████ 5
  Catalyst Labs   ███████████ 4
  Notion          ███████████ 4
  LangChain       ███████████ 4
  Uber            ████████ 3

Execute busca híbrida com reranking

O LanceDB suporta 3 modos de busca, e nosso lib.py expõe todos os 3 por trás de uma única função:

# lib.py
from lancedb.rerankers import CohereReranker

reranker = CohereReranker(model_name="rerank-v3.5")  # fixado; o modelo mais recente do Cohere é rerank-v4.0

def search(query: str, mode: str = "hybrid", limit: int = 10, where: str | None = None):
    table = _table()
    if mode == "vector":
        q = table.search(query, query_type="vector")
    elif mode == "keyword":
        q = table.search(query, query_type="fts")
    elif mode == "hybrid":
        q = table.search(query, query_type="hybrid").rerank(reranker=reranker)
    if where:
        q = q.where(where, prefilter=True)
    return q.limit(limit).to_pandas()

Três partes do search() merecem explicação:

query_type="hybrid" combina similaridade vetorial e pontuações BM25 do índice de texto completo que construímos no momento da indexação (FTS nativo do LanceDB). A união de candidatos é então reordenada.
.rerank(reranker) envia a lista de candidatos para a API Rerank do Cohere e retorna sua ordenação. Passamos model_name="rerank-v3.5" explicitamente porque o padrão do LanceDB é mais antigo.
prefilter=True aplica a cláusula SQL WHERE antes da varredura vetorial, não depois. Isso é mais rápido (espaço de busca menor) e mais preciso (você não perde resultados por truncamento).

Uma consulta real

Aqui estão os 2 principais resultados para uma consulta que não compartilha muitas palavras literais com nenhum título de vaga no conjunto de dados:

$ python search.py "deep learning model training with GPUs"

  ▸ Training: ML Framework Engineer  ·  score 0.275
    OpenAI — San Francisco, CA
    Entry level · Full-time · 2026-04-22
    "About The Team Training Runtime designs the core distributed
     machine-learning training runtime that powers everything from early
     research experiments to frontier-scale model runs..."

  ▸ Machine Learning Engineer  ·  score 0.138
    Skild AI — San Mateo, CA
    Entry level · Full-time · 2026-04-15
    "Company Overview At Skild AI, we are building the world's first
     general purpose robotic intelligence that is robust and adapts to
     unseen scenarios without failing. We believe massive scale through
     data-driven machine learning..."

Nenhum título de vaga contém “GPUs”, mas ambas as descrições são sobre treinamento distribuído de ML, que é exatamente o que a consulta pergunta. A busca pura por palavras-chave provavelmente perderia ambas.

Cada modo retorna um tipo diferente de pontuação. O modo vetorial retorna distância cosseno (menor = mais próximo), híbrido+rerank retorna a pontuação de relevância do Cohere (0 a 1, maior = melhor), e o modo por palavras-chave retorna BM25 bruto (ilimitado, maior = mais sobreposição de palavras). Os números não são comparáveis entre modos, apenas dentro de um único modo.

Combine semântica com restrições rígidas

Similaridade semântica e filtros SQL se combinam em uma única consulta no LanceDB:

$ python search.py "fintech python role with equity" \
    --where "salary_min_annual >= 250000"

  ▸ Quantitative Developer (Python)  ·  score 0.374
    Fintal Partners — New York, United States
    Mid-Senior level · Full-time · $400,000–$1,000,000/yr · 2026-04-22

  ▸ Senior Software Engineer (Python)  ·  score 0.272
    Fintal Partners — New York, NY
    Mid-Senior level · Full-time · $250,000–$400,000/yr · 2026-04-23

A parte vetorial combina o componente descritivo (“fintech python com equity”). O filtro SQL aplica a restrição numérica (>= $250k). Ambos os resultados são vagas da Fintal Partners na faixa salarial correta.

O mesmo padrão híbrido + filtro é executado na UI Streamlit, em um scraping posterior (os anúncios ao vivo diferem da execução CLI acima):

Interface de busca Streamlit com a consulta 'fintech python role with equity' e o slider de salário mínimo na barra lateral arrastado para $250.000. O cabeçalho de resultados mostra '3 resultados · modo: híbrido · filtro: salary_min_annual >= 250000′. O card do resultado principal mostra Senior Software Engineer (Python) na Fintal Partners em Nova York, NY, com badges de nível Sênior/Pleno, tempo integral e um badge verde de salário mostrando $300.000,$500.000/ano, pontuação de relevância 0,272 e um trecho sobre uma empresa de trading quantitativo. Um segundo resultado, Data Scientist na OpenArt AI em São Francisco, pontuação 0,165, começa abaixo.”/></figure>
<p class=

Gráfico de barras de precisão@3 em 10 consultas de teste: palavras-chave 43%, vetor 70%, híbrido + rerank 67%.

Item	Custo
Scraping da Bright Data (204 registros @ $0,0015/registro)	$0,31
Embeddings Cohere (~228k tokens no total @ $0,10/1M)	~$0,02
Rerank Cohere (~$0,002/consulta, Rerank v3.5 a $2 / 1k buscas)	~$0,01 para 5 consultas
LanceDB	gratuito

Domínio	Produto Bright Data	O que você consultaria
Acesso web agêntico	The Web MCP (nível gratuito atualmente 5.000 solicitações/mês)	“dê a um agente de IA ferramentas de busca + scraping ao vivo, depois fundamente suas respostas em um cache de resultados anteriores com suporte do LanceDB”
Corpora de sites completos	Crawl API	“indexe um site de documentação inteiro ou base de conhecimento para recuperação híbrida”
E-commerce	Web Scraper API (produtos da Amazon)	“tênis de corrida confortáveis abaixo de $100 com 4+ estrelas”
Imóveis	Web Scraper API (Zillow / Redfin)	“casa familiar tranquila perto de boas escolas, 3+ quartos”
Inteligência de notícias	SERP API + Web Unlocker	“artigos sobre segurança de IA desta semana, classificados por relevância para alinhamento”
Prospecção de vendas	Informações de empresas do LinkedIn	“startups Série A em IA para saúde baseadas na Europa”
Restaurantes	Conjunto de dados do Yelp	“lugar italiano aconchegante com área ao ar livre”

Contate-nos Teste grátis

Crie um Motor de Busca de Empregos Semântico com Bright Data, LanceDB e Cohere

TL;DR

O problema com a busca por palavras-chave

A stack em resumo

Configuração

Arquitetura

Faça Scraping do LinkedIn com a Bright Data

Escolha o endpoint correto

Síncrono vs assíncrono

Controle o custo com limites por entrada

O código

O que você recebe de volta

Indexe com Cohere e LanceDB

Por que Cohere

O registro de embeddings do LanceDB

O truque da normalização de salário

Atualizações incrementais com upserts

Índices escalares para filtros SQL rápidos

Inspecione os dados indexados

Execute busca híbrida com reranking

Uma consulta real

Combine semântica com restrições rígidas

Onde palavras-chave, vetor e híbrido discordam

Meça qualidade com precisão@3

O que os números dizem

Quando habilitar híbrido + rerank

Adicione uma UI web com Streamlit

Viagem no tempo gratuita com LanceDB

Custo e escala

Escale para mais

8 bugs e armadilhas que encontramos

O que você pode construir a seguir

Próximos passos

FAQ

Posso usar isso para sites além do LinkedIn?

Preciso de uma conta paga do Cohere para isso?

Por que LanceDB e não Pinecone, Weaviate ou pgvector?

Com que frequência devo reexecutar o scraper?

Você também pode estar interessado em

Hermes Agent + Bright Data: Construindo o Assistente de IA Web-Consciente Definitivo

Melhores Ferramentas CLI para Claude Code em 2026

Serviços Gerenciados vs. Scraping de Dados DIY: O Guia Completo de 2026