告别重复劳动：用LaVague实现全球招聘信息自动化聚合

告别重复劳动：用LaVague实现全球招聘信息自动化聚合

【免费下载链接】LaVague 项目地址: https://gitcode.com/GitHub_Trending/la/LaVague

你是否还在为寻找理想职位而在各大招聘网站间切换？每天重复填写相同的个人信息？错失最佳申请时机？本文将带你构建一个基于LaVague的智能招聘信息聚合系统，实现跨平台职位搜索、自动筛选和一键申请，彻底解放你的双手。读完本文，你将掌握Web智能体（Web Agent）的核心开发技术，能够定制专属的职位搜索逻辑，并通过实例代码快速部署属于自己的招聘自动化工具。

招聘信息聚合的痛点与解决方案

招聘信息获取的三大痛点

痛点	传统解决方案	LaVague解决方案	效率提升
多平台信息分散	人工访问10+网站	统一Agent调度多平台	80%时间节省
职位描述非结构化	手动筛选关键信息	视觉-文本联合解析	65%准确率提升
申请流程重复繁琐	重复填写表单	记忆化自动填充	90%操作简化

LaVague的技术优势

LaVague作为开源Web智能体框架，通过世界模型（World Model） 和行动引擎（Action Engine） 的协同工作，实现了对网页内容的理解和交互。其核心优势在于：

1. 多模态理解能力：结合视觉信息和文本内容，准确识别职位描述、申请按钮等关键元素
2. 灵活的驱动支持：同时兼容Selenium和Playwright两种主流Web自动化工具
3. 大模型适配性：支持Anthropic、OpenAI、Gemini等多种LLM后端，满足不同算力需求
4. 可扩展架构：通过上下文（Context）机制，轻松扩展新的网站解析逻辑

系统架构与核心组件

招聘信息聚合系统架构

核心组件解析

1. Web Agent（Web智能体）：系统的核心协调者，连接世界模型和行动引擎

   from lavague.core.agents import WebAgent
   agent = WebAgent(world_model, action_engine)
   

2. World Model（世界模型）：理解网页内容，判断当前状态与目标差距

   • 视觉解析：处理网页截图，识别UI元素
   • 文本理解：提取职位描述、要求、薪资等关键信息

3. Action Engine（行动引擎）：执行具体的网页操作

   • 导航控制：页面跳转、滚动、点击等
   • 表单处理：输入文本、选择选项、提交表单

4. Driver（驱动）：与浏览器交互的底层接口

   from lavague.drivers.selenium import SeleniumDriver
   driver = SeleniumDriver(headless=True)  # 无头模式运行，适合服务器部署
   

5. Context（上下文）：配置大模型参数和解析逻辑

   from lavague.contexts.anthropic import AnthropicContext
   context = AnthropicContext(model_name="claude-3-opus-20240229")
   

实战开发：构建招聘信息聚合器

环境准备与安装

首先，克隆项目仓库并安装依赖：

git clone https://gitcode.com/GitHub_Trending/la/LaVague
cd LaVague
poetry install
# 安装Selenium驱动支持
poetry add lavague-drivers-selenium
# 安装Anthropic上下文支持（用于Claude模型）
poetry add lavague-contexts-anthropic

基础架构搭建

创建job_aggregator.py文件，搭建基础框架：

from lavague.core import WorldModel, ActionEngine
from lavague.core.agents import WebAgent
from lavague.drivers.selenium import SeleniumDriver
from lavague.contexts.anthropic import AnthropicContext
from dotenv import load_dotenv
import os
import time

# 加载环境变量（存储API密钥等敏感信息）
load_dotenv()

class JobAggregator:
    def __init__(self, headless=True):
        # 初始化上下文（配置LLM）
        self.context = AnthropicContext(
            model_name="claude-3-opus-20240229",
            api_key=os.getenv("ANTHROPIC_API_KEY")
        )
        
        # 初始化浏览器驱动
        self.driver = SeleniumDriver(headless=headless)
        
        # 创建世界模型和行动引擎
        self.world_model = WorldModel.from_context(context=self.context)
        self.action_engine = ActionEngine.from_context(
            context=self.context, 
            driver=self.driver
        )
        
        # 创建Web智能体
        self.agent = WebAgent(self.world_model, self.action_engine)
        
        # 职位数据库
        self.jobs_database = []
        
    def search_jobs(self, query, sites=["linkedin", "indeed", "glassdoor"]):
        """在指定网站搜索职位"""
        results = []
        
        for site in sites:
            print(f"搜索 {site} 职位: {query}")
            results.extend(self._search_site(site, query))
            time.sleep(2)  # 避免请求过于频繁
            
        # 去重并按相关性排序
        unique_results = self._deduplicate(results)
        return sorted(unique_results, key=lambda x: x["relevance"], reverse=True)
    
    def _search_site(self, site, query):
        """搜索单个网站"""
        # 根据不同网站实现不同的搜索逻辑
        search_methods = {
            "linkedin": self._linkedin_search,
            "indeed": self._indeed_search,
            "glassdoor": self._glassdoor_search
        }
        
        if site in search_methods:
            return search_methods[site](query)
        else:
            print(f"不支持的网站: {site}")
            return []
    
    # 其他方法实现...

网站特定搜索逻辑实现

以LinkedIn为例，实现职位搜索逻辑：

def _linkedin_search(self, query):
    """LinkedIn职位搜索"""
    # 导航到LinkedIn职位搜索页面
    self.agent.get("https://www.linkedin.com/jobs/")
    
    # 输入搜索关键词
    self.agent.run(f"搜索职位 '{query}'")
    
    # 等待搜索结果加载
    time.sleep(3)
    
    # 提取职位信息
    jobs = self.agent.run("提取当前页面所有职位的标题、公司、位置和发布时间")
    
    # 解析结果并添加相关性评分
    results = []
    for job in jobs:
        # 简单的相关性评分逻辑
        relevance = self._calculate_relevance(job["title"], query)
        results.append({
            "title": job["title"],
            "company": job["company"],
            "location": job["location"],
            "posted_time": job["posted_time"],
            "url": job["url"],
            "site": "linkedin",
            "relevance": relevance
        })
    
    return results

def _calculate_relevance(self, title, query):
    """计算职位与查询的相关性"""
    keywords = query.lower().split()
    title_words = title.lower().split()
    return sum(1 for keyword in keywords if keyword in title_words)

职位信息提取与处理

利用LaVague的世界模型能力，我们可以准确提取职位描述中的关键信息：

def extract_job_details(self, job_url):
    """提取职位详细信息"""
    self.agent.get(job_url)
    
    # 使用LaVague的世界模型解析页面内容
    details = self.agent.run("""
    提取以下职位信息：
    1. 职位名称
    2. 公司名称
    3. 工作地点
    4. 职位描述
    5. 任职要求
    6. 薪资范围（如果有）
    7. 申请链接
    """)
    
    # 结构化处理结果
    structured_details = {
        "title": details.get("职位名称", ""),
        "company": details.get("公司名称", ""),
        "location": details.get("工作地点", ""),
        "description": details.get("职位描述", ""),
        "requirements": self._parse_requirements(details.get("任职要求", "")),
        "salary": details.get("薪资范围", "未公开"),
        "application_url": details.get("申请链接", job_url),
        "extracted_at": time.strftime("%Y-%m-%d %H:%M:%S")
    }
    
    return structured_details

def _parse_requirements(self, requirements_text):
    """解析任职要求为结构化列表"""
    if not requirements_text:
        return []
    
    # 使用LLM将文本要求转换为列表
    return self.world_model.analyze(
        f"将以下任职要求转换为项目符号列表: {requirements_text}"
    )

自动申请功能实现

LaVague的行动引擎可以模拟用户填写申请表单的过程：

def auto_apply(self, job_details, resume_path):
    """自动申请职位"""
    try:
        self.agent.get(job_details["application_url"])
        
        # 填写基本信息
        self.agent.run("点击'申请'按钮")
        self.agent.run("填写姓名为'张三'")
        self.agent.run("填写邮箱为'zhangsan@example.com'")
        self.agent.run(f"上传简历文件 '{resume_path}'")
        
        # 填写工作经验（示例）
        experience = self._extract_experience(resume_path)
        for i, exp in enumerate(experience[:2]):  # 只填写最近两份工作
            self.agent.run(f"在工作经验第{i+1}项填写公司'{exp['company']}'")
            self.agent.run(f"在工作经验第{i+1}项填写职位'{exp['title']}'")
        
        # 提交申请
        self.agent.run("点击'提交申请'按钮")
        
        # 验证申请状态
        status = self.agent.run("检查申请是否成功提交")
        return {
            "success": "成功" in status,
            "message": status,
            "job_id": job_details.get("id", ""),
            "applied_at": time.strftime("%Y-%m-%d %H:%M:%S")
        }
        
    except Exception as e:
        return {
            "success": False,
            "message": str(e),
            "job_id": job_details.get("id", ""),
            "applied_at": time.strftime("%Y-%m-%d %H:%M:%S")
        }

高级功能：智能筛选与优先级排序

基于规则的职位筛选

def filter_jobs(self, jobs, filters):
    """根据筛选条件过滤职位"""
    filtered = []
    
    for job in jobs:
        # 位置筛选
        if "location" in filters and filters["location"]:
            if not any(loc in job["location"].lower() for loc in filters["location"].lower().split(",")):
                continue
        
        # 薪资筛选
        if "min_salary" in filters and filters["min_salary"]:
            try:
                # 提取薪资数字（简化处理）
                salary_num = float(''.join(filter(str.isdigit, job["salary"])))
                if salary_num < filters["min_salary"]:
                    continue
            except:
                # 无法解析薪资，跳过筛选
                pass
        
        # 经验要求筛选
        if "experience" in filters and filters["experience"]:
            exp_required = self._extract_experience_required(job["description"])
            if exp_required > filters["experience"]:
                continue
                
        filtered.append(job)
    
    return filtered

def _extract_experience_required(self, description):
    """从职位描述中提取所需经验年限"""
    # 使用正则表达式查找经验要求
    import re
    pattern = r'(\d+)\s*年经验|\d+\s*years?\s*experience'
    match = re.search(pattern, description)
    
    if match:
        return int(match.group(1))
    return 0  # 默认无经验要求

基于嵌入向量的相似性匹配

对于更精确的职位匹配，可以使用嵌入向量（Embedding）技术：

def semantic_search_jobs(self, jobs, resume_text, top_n=5):
    """基于简历内容的语义搜索"""
    from sentence_transformers import SentenceTransformer, util
    
    # 加载预训练模型（使用国内可访问的模型）
    model = SentenceTransformer("shibing624/text2vec-base-chinese")
    
    # 生成简历嵌入向量
    resume_embedding = model.encode(resume_text, convert_to_tensor=True)
    
    # 为每个职位生成嵌入向量并计算相似度
    job_embeddings = []
    for job in jobs:
        # 合并职位标题和描述生成嵌入
        text = f"{job['title']} {job['company']} {job['description']}"
        embedding = model.encode(text, convert_to_tensor=True)
        similarity = util.cos_sim(resume_embedding, embedding).item()
        job_embeddings.append((job, similarity))
    
    # 按相似度排序并返回前N个结果
    job_embeddings.sort(key=lambda x: x[1], reverse=True)
    return [item[0] for item in job_embeddings[:top_n]]

部署与扩展

命令行接口实现

为了方便使用，可以添加命令行接口：

def main():
    import argparse
    
    parser = argparse.ArgumentParser(description="LaVague招聘信息聚合器")
    parser.add_argument("--query", required=True, help="职位搜索关键词")
    parser.add_argument("--sites", default="linkedin,indeed", help="要搜索的网站，用逗号分隔")
    parser.add_argument("--output", default="jobs.csv", help="输出文件路径")
    parser.add_argument("--resume", help="简历文件路径，用于智能匹配")
    
    args = parser.parse_args()
    
    # 初始化聚合器
    aggregator = JobAggregator(headless=False)  # 调试时使用非无头模式
    
    # 搜索职位
    sites = args.sites.split(",")
    jobs = aggregator.search_jobs(args.query, sites)
    
    # 如果提供了简历，进行智能匹配
    if args.resume:
        with open(args.resume, "r", encoding="utf-8") as f:
            resume_text = f.read()
        jobs = aggregator.semantic_search_jobs(jobs, resume_text)
    
    # 保存结果
    aggregator.save_results(jobs, args.output)
    print(f"已找到 {len(jobs)} 个相关职位，结果已保存至 {args.output}")

if __name__ == "__main__":
    main()

定时任务与通知系统

为了不错过最新职位，可以添加定时任务和邮件通知功能：

def schedule_search(self, query, interval=3600, sites=["linkedin", "indeed"]):
    """定时搜索职位"""
    import schedule
    import time
    
    def job():
        print(f"定时搜索: {query}")
        new_jobs = self.search_jobs(query, sites)
        if new_jobs:
            # 检查新职位
            self._check_new_jobs(new_jobs)
    
    # 设置定时任务
    schedule.every(interval).seconds.do(job)
    
    # 立即执行一次
    job()
    
    # 持续运行
    while True:
        schedule.run_pending()
        time.sleep(60)

def _check_new_jobs(self, new_jobs):
    """检查新职位并发送通知"""
    # 实现检查逻辑...
    
    if new_positions:
        self._send_notification(new_positions)
        # 更新数据库...

def _send_notification(self, jobs):
    """发送新职位通知"""
    import smtplib
    from email.mime.text import MIMEText
    
    # 构建邮件内容
    content = "发现新的匹配职位：\n\n"
    for job in jobs:
        content += f"- {job['title']} @ {job['company']}\n"
        content += f"  地点: {job['location']}\n"
        content += f"  链接: {job['url']}\n\n"
    
    # 发送邮件（使用国内邮箱服务）
    msg = MIMEText(content, "plain", "utf-8")
    msg["Subject"] = "LaVague招聘聚合器 - 新职位通知"
    msg["From"] = "job aggregator <aggregator@example.com>"
    msg["To"] = "your@email.com"
    
    with smtplib.SMTP_SSL("smtp.qq.com", 465) as server:
        server.login("your@email.com", "your_password")
        server.send_message(msg)
    
    print(f"已发送 {len(jobs)} 个新职位通知")

性能优化与最佳实践

反爬机制应对策略

为了确保系统稳定运行，需要采取一系列反爬措施：

1. 随机请求间隔：避免固定时间间隔的请求

   import random
   time.sleep(random.uniform(1.5, 3.5))  # 随机间隔1.5-3.5秒
   

2. User-Agent轮换：模拟不同浏览器的请求

   from fake_useragent import UserAgent
   ua = UserAgent()
   driver.set_user_agent(ua.random)
   

3. 分布式部署：通过多IP地址分散请求压力

4. 智能等待：根据页面加载状态动态调整等待时间

   # 使用显式等待而非固定延迟
   from selenium.webdriver.support.ui import WebDriverWait
   from selenium.webdriver.support import expected_conditions as EC
   
   WebDriverWait(driver, 10).until(
       EC.presence_of_element_located(("xpath", "//div[@class='job-card']"))
   )
   

资源占用优化

1. 无头模式运行：减少图形界面资源占用

   driver = SeleniumDriver(headless=True)
   

2. 页面缓存：缓存已访问页面，避免重复加载

3. 选择性截图：只在必要时进行全页面截图

4. 批处理操作：合并多个相似操作，减少API调用

总结与未来展望

本文介绍了如何使用LaVague构建招聘信息聚合系统，通过Web智能体技术实现了跨平台职位搜索、信息提取和自动申请。该系统不仅解决了招聘信息分散的问题，还通过智能筛选和匹配算法提高了职位搜索的精准度。

项目扩展方向

1. 多语言支持：扩展系统以支持中英文等多语言职位搜索
2. 高级自然语言查询：支持复杂的查询条件，如"远程工作且提供股票期权的Python开发职位"
3. 简历优化建议：根据职位要求自动生成简历修改建议
4. 面试准备助手：基于职位描述生成可能的面试问题和答案

学习资源与社区

• 官方文档：项目docs目录下提供了详细的使用指南和API参考
• 示例代码：examples目录包含各种场景的使用示例
• 贡献指南：docs/contributing目录下提供了参与项目开发的详细说明

要开始使用LaVague构建你的招聘信息聚合系统，只需执行以下命令：

git clone https://gitcode.com/GitHub_Trending/la/LaVague
cd LaVague
poetry install
cd examples
python job_aggregator.py --query "人工智能工程师" --sites "linkedin,indeed"

现在，你已经掌握了使用LaVague构建Web智能体的核心技术。无论是招聘信息聚合，还是其他Web自动化任务，LaVague都能为你提供强大的支持。立即开始探索，释放Web智能体的潜力！

如果觉得本文对你有帮助，请点赞、收藏并关注，以便获取更多关于LaVague的高级应用技巧。下期我们将介绍如何使用LaVague构建自动化测试系统，敬请期待！

【免费下载链接】LaVague 项目地址: https://gitcode.com/GitHub_Trending/la/LaVague