AI

使用 Bright Data、LanceDB 和 Cohere 构建语义职位搜索引擎

构建一个语义职位搜索引擎。Bright Data 的网页爬虫工具返回结构化 LinkedIn 职位;Cohere 提供用于基于含义匹配的嵌入。
11 分钟阅读
使用 Bright Data、LanceDB 和 Cohere 构建语义职位搜索引擎

招聘网站只按精确词语搜索,所以当你的措辞与职位发布不匹配时,合适的岗位仍会被隐藏。语义搜索则按含义匹配。我们端到端地构建它,然后衡量哪种搜索模式胜出,而不是假设最复杂的那种一定胜出。

TL;DR

本指南使用 Bright Data(爬虫)、Cohere(嵌入 + 重排)和 LanceDB(本地向量存储),在 200 条真实 LinkedIn 职位发布上构建一个语义职位搜索引擎。

  • 关键词搜索匹配精确词语。向量搜索匹配含义。像“engineer who works on LLMs”这样的查询可以找到关键词搜索会错过的“GenAI Developer”岗位。
  • Bright Data 的 Web 爬虫工具 API 以 JSON 形式返回结构化 LinkedIn 职位,每条记录 $0.0015,无需 HTML 解析或爬虫工具维护。
  • LanceDB 在本地运行,并在 1 个查询中将向量搜索与 SQL 过滤器(薪资、资历级别)结合起来,同时支持全文搜索和 Cohere 重排。
  • 在 10 个测试查询上,向量搜索的 precision@3 得分为 70%,而关键词为 43%。Hybrid + rerank 在这个规模下没有带来可衡量的提升,因此在约 10k 行以下,单独使用向量是一个合理的默认选择。
  • 完整项目由 9 个小文件组成,包括一个评估工具,并且完整代码在 GitHub 上。整次运行成本约为 ~$0.34。

关键词搜索的问题

招聘网站上的关键词搜索会精确执行你的要求。它返回标题或描述中包含你查询里字面 token 的职位发布。搜索 “engineer who works on LLMs and prompt engineering”,你会错过像 “GenAI Developer” 这样的岗位,即使它们非常匹配。词法搜索匹配精确词语,而不是含义。

向量搜索按含义匹配。每个职位描述都会被转换为一个嵌入(一个捕捉其语义内容的高维向量),你的查询也是如此。即使某个职位没有共享任何相同词语,只要它的向量接近你的查询向量,在含义上就是一个好匹配。

把它变成一个可工作的搜索引擎需要 3 个部分:

  1. Bright Data 将 200 条真实 LinkedIn 职位发布爬虫成干净的结构化 JSON。
  2. Cohere 将描述转换为嵌入,并对最终结果重新排序。
  3. LanceDB 在本地存储嵌入,并提供带 SQL 风格过滤器的混合(向量 + 全文)查询。

技术栈一览

每一层做什么,以及我们为什么使用它:

Layer Tool Why this one
Web data Bright Data Web 爬虫工具 API 预构建的 LinkedIn 爬虫工具返回包含薪资、资历级别和地点的结构化 JSON,无需 HTML 解析或爬虫工具维护。
Embeddings Cohere embed-english-v3.0 非对称编码(文档与查询使用不同输入类型)。Cohere 还提供 embed-v4.0,它是多模态的。这里我们使用 v3,是因为其仅英语场景下的价格/延迟特性(计划在 v3 生命周期结束前重新嵌入)。
Reranker Cohere rerank-v3.5 我们固定使用 v3.5,因为其价格/延迟特性。Cohere 还提供 rerank-v4.0(-pro 用于质量,-fast 用于延迟)。
Vector store LanceDB 本地、嵌入式、无服务器。它支持混合(向量 + BM25)搜索和 SQL 预过滤。
UI (optional) Streamlit 用于 Python 数据应用的低代码 Web UI。

这个技术栈从你笔记本上的单个 Python venv 运行。Bright Data 和 Cohere 是唯一涉及的托管服务。

设置

完整、可运行的项目在 GitHub 上。克隆它并安装依赖项(Python 3.10 或更新版本):

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

复制示例 env 文件并添加你的两个 API 密钥,一个 Bright Data 令牌 和一个来自 控制面板.cohere.com 的 Cohere 密钥(试用密钥可用于整个指南):

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

两个密钥都就位后,运行 python scrape.py 拉取数据,并运行 python index.py 构建索引。

架构

系统是两个流程,而不是一个。Ingest 构建索引(运行一次,或按计划运行)。Query 在每次搜索时运行。两者都使用 Cohere 和 LanceDB,但用于不同的工作。

双流程架构图。INGEST(运行一次,或按计划运行):一个“keyword”箭头进入 Bright Data(“Discover jobs by keyword (async)”),它将“jobs (JSON)”发送到 Cohere(“embed (document)”),Cohere 将“vectors”发送到 LanceDB(“vector + FTS + scalar indexes, versioned”)。QUERY(每次搜索,默认 hybrid 模式):一个“query”箭头进入 Cohere(“embed (query)”),Cohere 将“query vector”发送到 LanceDB(“vector + FTS search + SQL prefilter”),LanceDB 将“candidates”发送到 Cohere(“rerank”),Cohere 返回“ranked results”。Cohere 和 LanceDB 被着色以显示它们在两个流程中被复用,并且 rerank 仅在 hybrid 模式中运行。

并排显示的两个流程。Ingest 嵌入文档并存储它们。Query 嵌入搜索文本,运行带 SQL 预过滤的向量 + 全文搜索,然后重排。Cohere 和 LanceDB 出现在两个流程中,但在每个流程中执行不同工作,这就是为什么 rerank 永远不会触碰 ingest 路径。

3 个脚本运行该管道:scrape.py、index.py、search.py。还有 6 个辅助文件:lib.py(共享搜索后端)、compare.py(模式比较)、eval.py(precision@3)、stats.py(数据集摘要)、versions.py(快照浏览器)和 app.py(Streamlit UI)。

使用 Bright Data 爬虫 LinkedIn

LinkedIn 是职位数据的主要来源,但很难可靠地爬虫:速率限制、动态标记,以及会在不通知的情况下变化的 HTML。Web 爬虫工具 API 从预构建端点返回干净的结构化 JSON,因此你无需维护解析器。

选择正确的端点

Bright Data 暴露了几个 LinkedIn 爬虫工具:

  • People profiles → 个人会员资料
  • Company information → 公司页面
  • Job listings → Collect by URL → 你已有的特定职位 URL
  • Job listings → 按关键词发现 ← 我们需要这个
  • Job listings → Discover by URL → 来自搜索结果 URL 的职位
  • LinkedIn posts 和 People search → 其他实体类型

Discover by keyword 很适合,因为我们希望从搜索查询中批量发现职位。单个 API 调用每个关键词最多返回 1,000 条结构化职位发布,包括标题、公司、地点、资历级别、雇佣类型、列出的薪资范围以及完整职位描述。

每个抓取工具都有自己的 dataset_id。要找到一个,打开 Bright Data 的爬虫工具库,搜索站点(这里是 linkedin.com),并打开它。选择 Job listings → Discover by keyword 端点,其 dataset_id(gd_lpfll7v5hcqtkxl6l)以及一个可直接运行的请求会出现在 Code examples 面板中。scrape.py 调用它所需的只是一个有效 token。

Bright Data 控制面板显示 Web 爬虫工具 Library 菜单,左侧边栏中选中了 LinkedIn job listings → “Discover by keyword”端点。中间面板显示 Configuration 选项卡,其中有示例输入(paris/product manager、New York/python developer)。右侧面板显示 Code examples 视图,其中包含一个带身份验证的 curl 请求,含有 <code>dataset_id=gd_lpfll7v5hcqtkxl6l</code>。

Discover by keyword 爬虫页面。右侧的 Code examples 面板是你可以找到 dataset_id 的地方。

同步 vs 异步

Bright Data 提供 2 种交付模式:

  • Synchronous(POST /datasets/v3/scrape)以内联方式返回数据,最适合极小批量。
  • Asynchronous(POST /datasets/v3/trigger)返回一个 snapshot ID。你轮询完成状态并下载结果,最适合更大的任何任务。

在我们的运行中,响应时间平均约为每个输入 ~6 秒。对于 2 个关键词且 limit_per_input=100(总计 200 个职位),同步调用必须在整个批次期间保持连接打开,这有超时风险。异步是安全的默认选择。

使用每输入限制控制成本

查询参数 limit_per_input=N 限制每个输入搜索返回多少结果,这正是你用于可预测支出的旋钮:

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

对于更大的运行可以提高它,每个关键词最多 1,000 个职位。

代码

该爬虫工具触发一个快照,轮询直到就绪,然后下载 JSON。核心如下(生产版本会添加 retry/backoff 和更丰富的错误处理):

# 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()

运行它:

$ 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

你会得到什么

JSON 中的每个职位都有 25+ 个字段。以下是重要的字段:

{
  "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>"
}

结构化的 base_salary 字段让下一步中的薪资过滤查询成为可能。

使用 Cohere 和 LanceDB 建立索引

我们有 204 条原始职位记录,其中 4 条是加载时过滤掉的错误行。现在我们让剩下的 200 条可进行语义搜索。

为什么选择 Cohere

我们选择 Cohere 而不是其他替代方案(OpenAI 的嵌入模型、Voyage AI 或本地 sentence-transformers):

  1. 非对称编码。 Cohere 允许你在索引时将输入标记为 search_document,或在搜索时标记为 search_query。模型会以不同方式编码两侧,这比将两者视为相同更有效。
  2. 声明式嵌入。 LanceDB 的注册表原生支持 Cohere(也支持 OpenAI 和 sentence-transformers),因此嵌入会在插入和查询时发生,无需手动 embed() 调用。
  3. Rerank API。 它是一个单独的模型,接受一个查询和候选列表,并按实际相关性重新排序候选。它是可以强化混合管道排序的第二阶段,我们用一个 .rerank() 调用添加该阶段。

LanceDB 嵌入注册表

LanceDB 中的嵌入通过其嵌入注册表处理。你声明一次 schema,随后每次插入和每次查询都会自动发生嵌入,并使用正确的 input_type。

# 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()              # ← what to embed
    vector: Vector(cohere.ndims()) = cohere.VectorField()  # ← stored embedding
    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

vector 之后的所有内容都是普通存储列,用于过滤和显示。

薪资标准化技巧

大多数职位的薪资按年报价,但少数按小时报价。为了让 salary_min_annual >= 200000 始终有效,我们在 ingest 时进行标准化:

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

我们同时存储原始数值(用于过滤器)和人类可读的显示字符串(用于 UI)。

使用 upsert 进行增量更新

index.py 第一次运行时会创建表。之后每次运行都是一个以 job_id 为键的 upsert:

result = (
    table.merge_insert("job_id")
         .when_matched_update_all()       # refresh existing job postings
         .when_not_matched_insert_all()   # add newly-discovered ones
         .execute(rows)
)
print(f"inserted={result.num_inserted_rows}, updated={result.num_updated_rows}")

来自一次新 Bright Data 抓取的新职位发布会被插入,而重新发布的职位(相同 job_id)会刷新其薪资、描述和时间戳。要完全清理过期发布,链式调用 .when_not_matched_by_source_delete()。

整个 upsert 是一个单一原子事务。因为 Lance 以写时复制方式按列存储数据,重新 ingest 是增量写入,而不是全表重建。

用于快速 SQL 过滤器的标量索引

当 search.py, where "salary_min_annual >= 200000" 运行时,LanceDB 会在向量扫描之前应用过滤器(prefilter=True)。在 200 行时无论如何都是即时的。在 200,000 行时,除非我们告诉 LanceDB 如何索引它,否则过滤器会遍历整个列:

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 种索引类型覆盖了我们的需求:

  • BTREE 用于可排序、高基数列。salary_min_annual 会受益,因为我们想要范围查询(>=、BETWEEN)。
  • BITMAP 用于低基数枚举。seniority 有约 6 个不同值,employment_type 几乎全是 Full-time,而 search_keyword 是我们 2 个抓取输入之一。每个不同值都有自己的位图。= 过滤器会变成一次单一按位 AND。

两者都使用 replace=True 运行,因此重新运行 index.py 会幂等地重建它们。调用后,table.list_indices() 会报告全部 5 个(4 个标量 + 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']

检查已索引数据

运行 python index.py 后,我们的配套脚本 stats.py 会汇总数据库中的内容:

$ 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

使用重排运行混合搜索

LanceDB 支持 3 种搜索模式,而我们的 lib.py 通过一个函数暴露所有 3 种:

# lib.py
from lancedb.rerankers import CohereReranker

reranker = CohereReranker(model_name="rerank-v3.5")  # pinned; Cohere's newer model is 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()

search() 中有三部分值得解释:

  • query_type="hybrid" 将向量相似度和我们在索引时构建的全文索引(LanceDB 原生 FTS)中的 BM25 分数结合起来。候选集合的并集随后会被重排。
  • .rerank(reranker) 将候选列表发送到 Cohere 的 Rerank API,并返回它的排序。我们显式传入 model_name="rerank-v3.5",因为 LanceDB 默认值较旧。
  • prefilter=True 在向量扫描之前应用 SQL WHERE 子句,而不是之后。这样更快(搜索空间更小)且更准确(不会因截断而丢失结果)。

一个真实查询

下面是一个查询的前 2 个结果,该查询与数据集中任何职位标题都没有共享很多字面词语:

$ 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..."

两个职位标题都不包含“GPUs”,但两者的描述都关于分布式 ML 训练,这正是查询想要的。纯关键词搜索很可能会错过两者。

每种模式返回不同类型的分数。向量模式返回余弦距离(越低 = 越接近),hybrid+rerank 返回 Cohere 的相关性分数(0 到 1,越高 = 越好),关键词模式返回原始 BM25(无界,越高 = 关键词重叠越多)。这些数字不能跨模式比较,只能在单一模式内比较。

将语义与硬约束结合起来

语义相似度和 SQL 过滤器在 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

向量部分匹配描述性部分(“fintech python with equity”)。SQL 过滤器强制执行数值约束(>= $250k)。两个结果都是薪资区间合适的 Fintal Partners 岗位。

同样的 hybrid + filter 模式运行在 Streamlit UI 中,使用的是后续一次抓取(实时列表与上面的 CLI 运行不同):

Streamlit 搜索界面,查询为“fintech python role with equity”,侧边栏中的 Min salary 滑块拖到 $250,000。结果标题显示“3 results · mode: hybrid · filter: salary_min_annual >= 250000”。顶部结果卡片显示 Fintal Partners 在 New York, NY 的 Senior Software Engineer (Python),带有 Mid-Senior level、Full-time 徽章,以及一个绿色薪资徽章,显示 $300,000,$500,000/yr,相关性分数 0.272,并有关于一家量化交易公司的片段。第二个结果是 OpenArt AI 在 San Francisco 的 Data Scientist,分数 0.165,显示在下方。

设置了薪资滑块的混合查询,由 app.py 提供服务。滑块生成绿色黑底过滤横幅中显示的 salary_min_annual >= 250000 预过滤器。

关键词、向量和混合何处产生分歧

compare.py 通过所有 3 种模式运行同一个查询,并打印并排报告:

$ python compare.py "engineer working on LLMs and prompt engineering" --top 3

══════════════════════════════════════════════════════════════════════════
  query: engineer working on LLMs and prompt engineering
══════════════════════════════════════════════════════════════════════════

  ── keyword (BM25) ───────────────────────────────────────────────────────
  1. AI/ML Engineer                                          — Careerswift
  2. AI/ML Engineer                                          — Careerswift
  3. Applied AI Engineer                                     — Serval

  ── vector (Cohere) ──────────────────────────────────────────────────────
  1. Senior Software Engineer (Prompt Engineer Python/GenAI)        — Genpact
  2. 15+ Years exp/ Need f2f/ AI/ML Engineer or Python AI Engi...   — Jobs via Dice
  3. ML Engineer (Infra & Distributed training)                     — techire ai

  ── hybrid + rerank ──────────────────────────────────────────────────────
  1. Applied AI Engineer                                     — Serval
  2. Senior Software Engineer (Prompt Engineer Python/GenAI) — Genpact
  3. AI/ML Engineer                                          — Careerswift

  overlap: keyword∩vector=0/3 · hybrid∩vector=1/3 · hybrid∩keyword=2/3

在重叠行中,关键词和向量在前 3 个结果中找到了 0 个相同职位。 它们在搜索不同的概念空间。

  • 关键词(BM25)会找到字面 token “LLMs”和“prompt”出现最频繁的发布。它返回通用 AI/ML 标题。
  • 向量(Cohere)将 Senior Software Engineer (Prompt Engineer Python/GenAI) 发布排在 #1,即使用户查询说的是“prompt engineering”(动名词),而标题说的是“Prompt Engineer”(名词)。它还返回一个来自 Jobs via Dice 的 LLM 相关职位,该职位是强语义匹配,但在词法上与查询距离较远。
  • Hybrid + rerank 取并集、去重,并通过 Cohere Rerank 运行。Serval 的 Applied AI Engineer 岗位($200k 到 $325k)移动到 #1。它的描述中密集包含 prompt-engineering 和 LLM-智能体 工作,但其标题或其最高 BM25 权重词项都不会把该岗位排得这么高。

对于这个特定查询,向量和混合都比关键词做得更好。原始 token 重叠把 Genpact 和 Serval 结果排在了低于其语义相关性应有的位置。但单个查询只是轶事,不是证据。该模式是否总体成立,是只有真实评估才能回答的问题。

使用 precision@3 衡量质量

为了正确衡量这一点,eval.py 会用 10 个手写查询 对所有 3 种模式评分,并计算 precision@3,即前 3 个结果中匹配透明 ground-truth 谓词的比例。

每个查询的 ground truth 是一个 Python 谓词,而不是一个神秘数字,因此读者可以判断自己是否会用同样方式给结果打分。

对于 “machine learning engineer at OpenAI”,只有当结果的 company 字段包含“OpenAI”时,该结果才算相关。对于 “quantitative developer at trading firm”,规则更宽。若标题包含“Quant”或“Trading”,或公司是已知交易公司(Fintal Partners、DRW、Hudson River Trading、Tower Research、Mondrian Alpha),则结果算相关。这些谓词针对样本数据集调优,因此你的分数会随新职位变化。请根据自己的数据重新调优它们。即使精确百分比不同,各模式之间的差距也会延续。

运行它:

$ python eval.py

precision@3 per query (hits/3)
────────────────────────────────────────────────────────────────────────
  query                                          keyword    vector     hybrid
────────────────────────────────────────────────────────────────────────
  machine learning engineer at OpenAI            1.00 (3/3)  1.00 (3/3)  1.00 (3/3)
  founding engineer at AI startup with equity    0.33 (1/3)  0.67 (2/3)  0.67 (2/3)
  prompt engineer working with LLMs              0.00 (0/3)  0.67 (2/3)  0.33 (1/3)
  quantitative developer at trading firm         0.67 (2/3)  1.00 (3/3)  1.00 (3/3)
  computer vision and robotics engineer          1.00 (3/3)  0.67 (2/3)  1.00 (3/3)
  data scientist role                            0.67 (2/3)  1.00 (3/3)  1.00 (3/3)
  distributed training infrastructure for ML     0.33 (1/3)  0.67 (2/3)  0.67 (2/3)
  backend engineer at AI company                 0.33 (1/3)  0.33 (1/3)  0.33 (1/3)
  python developer at fintech                    0.00 (0/3)  0.67 (2/3)  0.33 (1/3)
  high-paying machine learning role with equity  0.00 (0/3)  0.33 (1/3)  0.33 (1/3)
────────────────────────────────────────────────────────────────────────
  AVERAGE (10 queries)                           0.433       0.700       0.667

同样数字的图表:

10 个测试查询上的 precision@3 条形图:keyword 43%,vector 70%,hybrid + rerank 67%。

在 10 个 eval 查询上平均的 Precision@3。向量得分远高于关键词,而混合与向量相差只有几个百分点。

数字说明了什么

从表中可以看出:

  • 向量搜索得分远高于关键词搜索,平均 precision@3 为 70% vs 43%。 所有 3 个关键词得分为 0 的查询(“prompt engineer”、“python developer at fintech”、“high-paying ML with equity”)在向量下至少有 1 个相关命中。
  • Hybrid + rerank 在这个规模下没有击败向量。 67% vs 70% 的差距在噪声范围内:重排器每个查询增加一次 Cohere 调用,而 FTS 部分会向它提供词法近似但不匹配的结果,然后它必须再过滤回去。
  • 没有任何模式被严格支配。 “Computer vision and robotics” 是关键词(1.00)得分高于向量(0.67)的一个查询,因为相关公司的描述中都包含字面 robotics 词项。

何时启用 hybrid + rerank

这取决于几个因素:

  • 候选池大小。 在几百行时,单独向量通常足够。混合的 2 阶段检索需要更大的池(10k+),rerank 步骤才值得其成本。
  • 查询类型。 同时具有语义意图和独特关键词(品牌名、特定技术)的查询会受益于混合。纯语义查询通常不会。
  • 重排器质量。 Cohere 的 rerank-v3.5 在我们的评估中表现良好。如果你换用不同的重排器,在信任它之前重新运行 eval.py,因为较弱的重排器可能会在小候选池上把好的向量结果向下重排。

在你自己的数据上运行 eval.py 来决定。添加一个查询就是一个字符串加一个 ground-truth 谓词。

Note: hybrid eval 在免费 Cohere 密钥上运行正常。试用速率限制会让它退避,并在约 ~90s 内完成,而不是 ~15。

使用 Streamlit 添加 Web UI

Streamlit 将同一个搜索后端变成一个可点击的 Web 应用。搜索和渲染核心如下:

# app.py
import streamlit as st
from lib import search

mode = st.sidebar.radio("Mode", ["hybrid", "vector", "keyword"])
seniority = st.sidebar.selectbox("Seniority", ["any", "Entry level", "Associate", "Mid-Senior level", "Director", "Internship", "Not Applicable"])
min_salary = st.sidebar.slider("Min salary ($/yr)", 0, 500_000, 0, step=10_000)

query = st.text_input("Search jobs", placeholder="e.g. remote ML engineer...")

if query:
    where_clauses = []
    if seniority != "any":
        where_clauses.append(f"seniority = '{seniority}'")
    if min_salary > 0:
        where_clauses.append(f"salary_min_annual >= {min_salary}")
    where = " AND ".join(where_clauses) or None

    df = search(query, mode=mode, where=where, limit=10)
    for _, row in df.iterrows():
        with st.container(border=True):
            st.markdown(f"### [{row['title']}]({row['apply_url']})")
            st.markdown(f"**{row['company']}** — {row['location']}")
            st.caption(row["description_snippet"] + "…")

运行它:

streamlit run app.py

你会在 localhost:8501 获得一个完整搜索页面,包含搜索框、模式切换、用于资历级别、来源关键词和薪资的侧边栏过滤器,以及带徽章、分数和片段预览的结果卡片。

Streamlit 搜索界面,查询为“founding ML engineer at AI startup with computer vision”,显示 hybrid 结果列表。侧边栏包含搜索模式、资历级别、来源搜索关键词、最低薪资和结果数量的过滤器。顶部结果卡片是 CoffeeSpace 在 San Francisco Bay Area 的“Founding ML Engineer | Frontier Medical AI | $150k,$200k | SF”,带有 Mid-Senior level + Full-time 徽章、Cohere 相关性分数 0.720 和描述片段。第二个结果“AI/ML Engineer - AI Design Software Leader”及分数 0.711 显示在下方。

运行混合搜索的 Streamlit 应用。每张卡片上的分数徽章是 Cohere 的相关性分数,徽章下方的片段展示了为什么每个结果进入前 3。

使用 LanceDB 免费时间旅行

这涵盖了搜索和 UI。LanceDB 还有一个值得展示的功能。每次写入 LanceDB 都会自动创建一个新版本,无需额外成本或基础设施。这是底层 Lance 列式格式的工作方式。为了让版本之后容易找到,index.py 在每次 ingest 后给它打标签:

table.tags.create(f"ingest-{datetime.now():%Y-%m-%d-%H%M}", table.version)

我们的配套 versions.py 脚本随后让你浏览并打开历史快照。运行一次 python index.py 后,你会看到 1 个标签。第二次 ingest 后(比如一周后重新爬虫),你会看到 2 个:

$ python versions.py

📊 table 'jobs'  ·  current version: 13  ·  200 rows

🏷  tags (2):
  • ingest-2026-05-20-0905           → version 7
  • ingest-2026-05-20-0906           → version 13  ← current

  travel back with: `python versions.py --tag <name>`

$ python versions.py --tag ingest-2026-05-20-0905

📌 snapshot 'ingest-2026-05-20-0905'  ·  version 7  ·  200 rows
  • Associate Machine Learning Engineer  — Handshake
  • Machine Learning Engineer            — RZR
  • Machine Learning Engineer            — ChatGPT Jobs

时间旅行就是一次 table.checkout(tag_or_version) 调用。对于职位搜索产品,它可以回答诸如 “what roles were posted last quarter?” 或 “is the salary distribution shifting over time?” 这样的问题,而无需单独的时间序列数据库。这是我们在这里选择 LanceDB 的原因之一。

成本和规模

对于演示(200 个职位,约 5 个示例查询):

Item Cost
Bright Data 爬虫(204 条记录 @ $0.0015/record) $0.31
Cohere 嵌入(总计约 ~228k tokens @ $0.10/1M) ~$0.02
Cohere rerank(约 ~$0.002/query,Rerank v3.5 为 $2 / 1k searches) 5 个查询约 ~$0.01
LanceDB 免费

端到端演示总成本为 ~$0.34。这些价格来自 2026 年的一次运行,因此请查看提供商的当前费率。

扩展规模

本地演示处理 200 个职位。从这里到生产规模数据集有几个杠杆:

  • 更多职位。 更改 LIMIT_PER_INPUT(每个关键词最大 1,000)或添加更多关键词搜索。10,000 个职位在 Bright Data credits 中约花费 ~$15。
  • 更多关键词 / 地点。 向 scrape.py 中的 SEARCHES 列表添加条目。
  • 计划刷新。 我们构建的 merge_insert upsert 意味着重新运行管道会刷新发生变化的内容。Bright Data 支持从控制面板进行计划采集和交付。将其与 upsert 配对,你就有了一个自更新数据集。
  • 向量索引。 超过约 ~10k 行后,通过 table.create_index(vector_column_name="vector") 将暴力搜索换成 HNSW 或 IVF_PQ 索引。它默认在 CPU 上构建。对于 GPU 构建,使用 PyTorch>2.0 传入 accelerator="cuda"(或在 Apple Silicon 上传入 "mps")。自动 GPU 索引目前是 LanceDB Enterprise 功能。
  • 生产向量存储。 LanceDB OSS 可在单节点上扩展到数百万向量。超过数亿向量或 TB 级数据后,LanceDB Cloud 和 Enterprise 会增加分布式索引和查询执行(其文档目标约为 ~10 到 50B 行 / ~10 到 30 TB)。

不过,在进行任何这些扩展动作之前,演示本身还有一些棘手之处。

我们遇到的 8 个 bug 和注意事项

以防能为你省下它们耗费我们的时间:

  1. list_tables() 不返回列表。 在 LanceDB 0.30 中,它返回一个 ListTablesResponse 对象,该对象在 REPL 中看起来可迭代,但 if TABLE in db.list_tables() 会静默失败。改用 try: db.open_table(TABLE) 并捕获异常,或使用响应上的 .tables。
  2. table.checkout(tag) 返回 None,并就地改变表句柄。它看起来像 bug,但不是。要写 t = db.open_table(...); t.checkout(tag); use(t),而不是 t = db.open_table(...).checkout(tag)。
  3. 默认的 CohereReranker() 使用旧模型(在我们测试的版本中是 rerank-english-v3.0)。显式传入一个模型,可以是 rerank-v3.5(我们在这里固定的),或更高质量的 rerank-v4.0-pro。默认值不会警告你。
  4. 对于真实批次,使用 /trigger + 轮询,而不是 /scrape。 同步(/scrape)是为小规模拉取构建的。为 limit_per_input=100 × 2 个关键词(约 200 个职位)保持连接打开可能会遇到超时,因此对于约 ~50 条记录以上的任何任务都使用 /trigger + 轮询。
  5. 少数爬虫记录是错误行。 在 204 个职位中,4 个设置了 error 字段而不是 job_title(例如,"Crawl aborted on job cancel")。它们表面上看起来像正常记录,因此请在 index.py 中过滤它们,否则 merge_insert 会因空 job_id 失败。
  6. 薪资有 2 个周期(yr 和 hr),但 schema 字段相同。如果不标准化为年薪(小时薪乘以 2080),像 salary_min_annual >= 200000 这样的过滤器会静默漏掉高薪小时合同,并包含不合理的低薪年薪岗位。
  7. 带原始 % 的 argparse 帮助字符串会在 Python 3.14 上崩溃。 在帮助文本中写 --where "salary > 200000 AND location LIKE '%SF%'" 会引发 ValueError: badly formed help string,因为 argparse 会尝试格式化它。转义为 %% 或改写示例。
  8. Streamlit 会将 $ 符号之间的文本渲染为 LaTeX 数学。 像 $150k,$200k 这样的薪资如果用 st.markdown 或 st.caption 显示,会变成乱码数学。转义显示字符串中的每个 $(仓库的 app.py 用一行 replace 做到),否则薪资徽章会渲染成乱码。

下一步你可以构建什么

这种模式,Bright Data ⟶ 嵌入 ⟶ 向量数据库 ⟶ 混合搜索,可以推广到几乎任何领域:

Domain Bright Data product What you’d query
智能体 Web 访问 The Web MCP(免费层目前 5,000 requests/mo) “给 AI 智能体实时搜索 + 爬虫工具,然后用 LanceDB 支持的过往结果缓存来锚定其答案”
整站语料库 Crawl API “索引整个文档站点或知识库以进行混合检索”
电子商务 Web 爬虫工具 API(Amazon products) “100 美元以下且 4+ 星的舒适跑鞋”
房地产 Web 爬虫工具 API(Zillow / Redfin) “靠近好学校的安静家庭住宅,3+ 张床”
新闻情报 搜索引擎 API + 网络解锁器 “本周的 AI safety 文章,按与 alignment 的相关性排序”
销售拓客 LinkedIn company info “总部在欧洲的医疗 AI Series A 初创公司”
餐厅 Yelp 数据集 “有户外座位的舒适意大利餐厅”

这个确切项目的一些自然扩展:

  • 多模态搜索。 切换到 Cohere embed-v4.0(原生多模态),并将公司 logo 与职位描述一起嵌入。
  • LLM 提取的过滤器。 让用户输入 “remote ML jobs paying $200k+”,并让 LLM 自动提取 remote=true, salary_min_annual >= 200000。
  • 带邮件提醒的保存搜索。 针对最新爬虫重新运行查询,并在有新匹配时通知。
  • 简历匹配。 嵌入一份简历,并按与候选人的相似度搜索职位。Bright Data 的 LinkedIn 求职 AI 助手是一个更完整的示例。
  • 自维护爬虫工具。 给智能体访问 Bright Data MCP 的权限,它可以检查页面、编写爬虫工具,并在布局变化时尝试修复,而不是你手动修补 scrape.py。Bright Data 的 爬虫工具 Studio 将其打包为托管产品,把普通英语提示变成自愈爬虫工具。

下一步

关键词搜索错过了合适的岗位,而向量搜索即使在标题从未匹配查询时也找到了它们。在评估中,向量相对于关键词的 43% 得到 70% precision@3,混合在这个规模下没有带来提升。

GitHub 上的完整项目是 9 个小文件。要在你自己的数据上使用它,先运行 python eval.py,因为最佳模式取决于数据,而不是哪一种最复杂。然后决定刷新节奏,其中 merge_insert 只 upsert 发生变化的内容,而 versions.py 为每次 ingest 创建快照。在任何内容上线之前,规划密钥轮换流程,因为 BD 和 Cohere 密钥都放在 .env 中。

同样的模式适用于 Bright Data 可以爬虫的任何内容,而不仅仅是职位。从那里开始,你就拥有了一个可复用于任何所爬虫数据集的语义搜索引擎。

FAQ

我可以将它用于 LinkedIn 以外的网站吗?

可以。Bright Data 的 Web 爬虫工具 Library 覆盖数百个站点(Amazon、Zillow、Yelp 等),每个都有自己的 dataset_id。将 scrape.py 中的 DATASET_ID 和 index.py 中的 to_row() 映射替换为新的 JSON 形状。搜索和索引逻辑与数据无关,并且可以沿用。

我需要付费 Cohere 账户来完成这个吗?

不需要,试用密钥可以运行整个演示。Cohere 的试用 Rerank 端点目前限制为 10 calls/min,因此 eval.py 会遇到 429 并自动退避(约 ~90s 而不是 ~15s)。抓取、索引和临时搜索都远低于限制。只有当你经常迭代评估时才需要升级。

为什么是 LanceDB,而不是 Pinecone、Weaviate 或 pgvector?

LanceDB 是一个嵌入式库,没有服务器、没有单独数据库,也没有托管服务账单。它原生支持混合搜索和 Cohere 重排,并且每次写入都是一个版本快照。对于无运维的单机管道,这是最小的开销。其他方案也有能力,但会增加更多基础设施。

我应该多久重新运行一次爬虫工具?

对于活跃招聘网站,每天一次比较合适。Bright Data 可以从控制面板运行计划采集,而 merge_insert upsert 会在 LanceDB 侧去重,因此重新运行成本很低。超过约 ~30 天的发布通常已经关闭,因此旧快照会成为历史,而 versions.py 会让它们保持可查询。

支持支付宝等多种支付方式

Satyam Tripathi

技术写作者

5 years experience

Satyam Tripathi 帮助 SaaS 和数据初创公司将复杂技术转化为可执行的内容,提升开发者采用度并增强用户理解。

Expertise
Python 开发者教育 技术写作