OpenClaw 联网搜索完全指南：从基础到高级实战

在 AI Agent 开发中，联网搜索能力是区分”聊天机器人”和”真正智能代理”的关键分水岭。OpenClaw 作为一个强大的 AI Agent 框架，提供了四种不同层级的联网工具，每种工具都有其独特的使用场景和优势。

本文将深入探讨 OpenClaw 的完整联网搜索生态系统，帮助你为不同任务选择最合适的工具，并提供大量实战案例和优化技巧。

为什么 OpenClaw 需要多种联网工具？

不同的任务需要不同层级的网络访问能力：

理解这些工具的差异，是构建高效 AI Agent 的第一步。

工具 1：web_search —— 快速信息检索

什么是 web_search？

web_search 是 OpenClaw 的原生搜索工具，基于 Brave Search API。它提供了类似于 Google 搜索的能力，但专为 AI Agent 设计。

核心特性

1. 搜索结果结构化：返回标题、URL 和摘要
2. 地域和语言支持：可指定国家和语言
3. 时间过滤：支持按日期范围筛选结果
4. 轻量级：直接 JSON 响应，无需 HTML 解析

配置 Brave Search API

# 1. 获取 API Key
访问 https://api.search.brave.com/app/keys
注册并创建免费 API Key（每月 2000 次免费查询）

# 2. 配置 OpenClaw
编辑 ~/.openclaw/openclaw.json：

{
  "tools": {
    "web_search": {
      "enabled": true,
      "provider": "brave",
      "apiKey": "YOUR_BRAVE_API_KEY"
    }
  }
}

基础用法

# 在 Agent 中使用
def quick_search(query):
    """快速搜索查询"""
    results = web_search(
        query="OpenClaw AI Agent tutorial",
        count=5,              # 返回结果数量
        country="CN",         # 中国地区结果
        search_lang="zh",     # 中文内容
        freshness="pw"        # 过去一周（pd/pw/pm/py）
    )
    
    return {
        "results": results,
        "count": len(results),
        "top_result": results[0] if results else None
    }

高级技巧

1. 分阶段搜索策略

def progressive_search(initial_query, max_rounds=3):
    """渐进式深度搜索"""
    
    current_query = initial_query
    all_results = []
    
    for round_num in range(max_rounds):
        # 搜索当前查询
        results = web_search(current_query, count=5)
        all_results.extend(results)
        
        if not results:
            break
        
        # 基于结果生成下一轮查询
        top_keywords = extract_keywords(results[:3])
        current_query = f"{initial_query} {top_keywords}"
    
    return deduplicate(all_results)

2. 多语言交叉验证

def multilingual_search(query, languages=['zh', 'en', 'ja']):
    """多语言搜索交叉验证"""
    
    results_by_lang = {}
    
    for lang in languages:
        results = web_search(
            query=query,
            search_lang=lang,
            count=5
        )
        results_by_lang[lang] = results
    
    # 使用 AI 模型综合不同语言的结果
    synthesis = ai_generate(
        prompt=f"""
        综合以下多语言搜索结果：
        
        中文：{results_by_lang['zh']}
        英文：{results_by_lang['en']}
        日文：{results_by_lang['ja']}
        
        提取关键信息，标注每个信息点的来源语言。
        """
    )
    
    return synthesis

3. 时间序列分析

def temporal_search(topic, time_ranges=['pd', 'pw', 'pm', 'py']):
    """时间序列搜索分析"""
    
    timeline = {}
    
    for time_range in time_ranges:
        results = web_search(
            query=topic,
            freshness=time_range,
            count=10
        )
        
        # 统计关键词频率
        keywords_freq = analyze_keywords(results)
        timeline[time_range] = keywords_freq
    
    # 识别趋势
    trends = identify_trends(timeline)
    
    return {
        "timeline": timeline,
        "trends": trends,
        "insights": generate_insights(trends)
    }

实战案例 1：实时新闻监控 Agent

class NewsMonitorAgent:
    """实时新闻监控 Agent"""
    
    def __init__(self, topics):
        self.topics = topics
        self.last_check = {}
    
    def check_updates(self):
        """检查各主题的最新新闻"""
        
        updates = {}
        
        for topic in self.topics:
            # 搜索过去 24 小时的新闻
            results = web_search(
                query=f"{topic} news",
                freshness="pd",  # past day
                count=10
            )
            
            # 过滤新内容
            new_items = filter_new(
                results, 
                self.last_check.get(topic, [])
            )
            
            if new_items:
                updates[topic] = new_items
                self.last_check[topic] = results
        
        return updates
    
    def generate_digest(self, updates):
        """生成新闻摘要"""
        
        for topic, items in updates.items():
            digest = ai_generate(
                prompt=f"""
                将以下新闻整理成摘要：
                
                主题：{topic}
                新闻：{items}
                
                格式：
                1. 要点标题（3-5 条）
                2. 每条一句话摘要
                3. 重要度评级（高/中/低）
                """
            )
            
            print(f"\n【{topic}】\n{digest}\n")

工具 2：web_fetch —— 轻量级页面抓取

什么是 web_fetch？

web_fetch 是一个 HTTP 客户端 + HTML 解析器，用于快速获取单个网页的内容并转换为 Markdown/纯文本。

核心特性

1. 自动解析：HTML → Markdown 转换
2. 轻量快速：直接 HTTP 请求，无浏览器开销
3. 可控性：支持自定义请求头和超时
4. 限制智能：自动截断大文件（50KB 或 2000 行）

基础用法

def fetch_article(url):
    """获取文章内容"""
    
    content = web_fetch(
        url=url,
        extractMode="markdown",  # 或 "text"
        maxChars=10000           # 最大字符数
    )
    
    return {
        "url": url,
        "content": content,
        "length": len(content),
        "preview": content[:200]
    }

高级技巧

1. 批量抓取

def batch_fetch(urls, max_concurrent=5):
    """批量抓取多个 URL"""
    
    from concurrent.futures import ThreadPoolExecutor
    
    def safe_fetch(url):
        try:
            return {"url": url, "content": web_fetch(url)}
        except Exception as e:
            return {"url": url, "error": str(e)}
    
    with ThreadPoolExecutor(max_workers=max_concurrent) as executor:
        results = list(executor.map(safe_fetch, urls))
    
    # 过滤成功的结果
    successful = [r for r in results if "content" in r]
    
    return {
        "total": len(urls),
        "success": len(successful),
        "failed": len(urls) - len(successful),
        "results": successful
    }

2. 链式抓取

def recursive_fetch(start_url, max_depth=2, visited=None):
    """递归抓取相关链接"""
    
    if visited is None:
        visited = set()
    
    if start_url in visited or max_depth == 0:
        return []
    
    visited.add(start_url)
    
    # 获取页面内容
    content = web_fetch(start_url, extractMode="markdown")
    
    # 提取相关链接
    links = extract_links(content)
    
    results = [{"url": start_url, "content": content}]
    
    # 递归抓取相关链接（限制数量）
    for link in links[:3]:
        results.extend(
            recursive_fetch(link, max_depth - 1, visited)
        )
    
    return results

实战案例 2：文档聚合器

class DocAggregator:
    """技术文档聚合器"""
    
    def aggregate_topic(self, topic, max_pages=10):
        """聚合某个主题的文档"""
        
        # 第一步：搜索相关文档
        search_results = web_search(
            query=f"{topic} official documentation guide",
            count=10
        )
        
        # 第二步：批量抓取
        urls = [r['url'] for r in search_results[:max_pages]]
        pages = batch_fetch(urls)
        
        # 第三步：提取关键信息
        key_info = []
        for page in pages['results']:
            info = extract_key_info(page['content'])
            key_info.append({
                "url": page['url'],
                "info": info
            })
        
        # 第四步：生成综合指南
        guide = ai_generate(
            prompt=f"""
            基于 {len(key_info)} 个文档来源，生成 {topic} 完整指南：
            
            {key_info}
            
            包含：
            1. 快速开始
            2. 核心概念
            3. 实战示例
            4. 最佳实践
            5. 常见问题
            """
        )
        
        return guide

限制和注意事项

⚠️ web_fetch 的局限性：

• 无法执行 JavaScript（对 SPA 站点无效）
• 可能被 Cloudflare 等反爬虫系统拦截
• 不支持交互式操作

替代方案：遇到这些情况时，使用 firecrawl 或 browser。

工具 3：firecrawl —— 企业级爬虫

什么是 firecrawl？

firecrawl 是一个强大的网页爬取工具，专门设计用于处理复杂站点和反爬虫系统。它是 Firecrawl CLI 的集成版本。

核心特性

1. 反爬虫绕过：自动处理 Cloudflare、验证码等
2. 智能爬取：自动发现和跟踪链接
3. 高质量输出：优化的 Markdown，适合 LLM 消费
4. 大规模支持：可爬取整个站点或指定路径

配置

# 安装 Firecrawl CLI
cd /home/admin/clawd/skills/firecrawl-skills
npm install

# 配置 API Key（如果需要）
# Firecrawl 有免费层级，但可能需要注册

基础用法

# 在 Skill 中使用
def firecrawl_search(url_or_query):
    """使用 Firecrawl 爬取内容"""
    
    # 如果是 URL，直接爬取
    if url_or_query.startswith('http'):
        result = firecrawl_crawl(url=url_or_query)
    else:
        # 如果是查询，先搜索再爬取
        search_results = web_search(url_or_query, count=5)
        urls = [r['url'] for r in search_results[:3]]
        
        results = []
        for url in urls:
            result = firecrawl_crawl(url=url)
            results.append(result)
        
        return merge_results(results)
    
    return result

高级技巧

1. 站点地图爬取

def crawl_sitemap(base_url, max_pages=50):
    """爬取站点地图"""
    
    # 获取站点地图
    sitemap = firecrawl_crawl(
        url=f"{base_url}/sitemap.xml",
        options={
            "formats": ["markdown"],
            "onlyMainContent": True
        }
    )
    
    # 提取所有 URL
    urls = extract_urls_from_sitemap(sitemap)
    
    # 批量爬取（限制数量）
    results = []
    for url in urls[:max_pages]:
        page = firecrawl_crawl(url, options={"includeTags": ["article", "main"]})
        results.append(page)
    
    return results

2. 竞争对手分析

def competitor_analysis(target_site, query):
    """竞争对手内容分析"""
    
    # 1. 爬取目标站点
    site_content = firecrawl_crawl(
        url=target_site,
        options={
            "includePaths": ["/blog/*", "/docs/*"],
            "limit": 20
        }
    )
    
    # 2. 搜索同类内容
    search_results = web_search(query, count=10)
    
    # 3. 爬取竞争对手内容
    competitor_urls = [r['url'] for r in search_results[:5] 
                       if r['url'] != target_site]
    
    competitor_content = []
    for url in competitor_urls:
        content = firecrawl_crawl(url)
        competitor_content.append(content)
    
    # 4. 对比分析
    analysis = ai_generate(
        prompt=f"""
        对比分析以下内容：
        
        目标站点：
        {site_content}
        
        竞争对手：
        {competitor_content}
        
        分析维度：
        1. 内容深度和完整性
        2. 技术准确性
        3. 更新频率
        4. 用户体验
        5. SEO 优化
        """
    )
    
    return analysis

实战案例 3：产品文档迁移

def migrate_docs(source_site, output_dir):
    """迁移产品文档到新平台"""
    
    # 1. 爬取完整文档树
    docs = firecrawl_crawl(
        url=source_site,
        options={
            "includePaths": ["/docs/**"],
            "formats": ["markdown"],
            "onlyMainContent": True
        }
    )
    
    # 2. 转换和优化
    for doc in docs:
        # 清理 Markdown
        cleaned = clean_markdown(doc['content'])
        
        # 添加 frontmatter
        frontmatter = generate_frontmatter(doc)
        
        # 写入文件
        filename = slugify(doc['title']) + ".md"
        filepath = f"{output_dir}/{filename}"
        
        with open(filepath, 'w') as f:
            f.write(frontmatter + "\n\n" + cleaned)
    
    return {
        "total_docs": len(docs),
        "output_dir": output_dir,
        "files_created": len(docs)
    }

工具 4：browser —— 完整浏览器控制

什么是 browser？

browser 工具提供了对真实浏览器的完整控制能力，基于 OpenClaw 的 Browser Control Server。它可以处理需要 JavaScript 执行、用户交互或截图的场景。

核心特性

1. 完整浏览器环境：支持 JavaScript、Cookie、Session
2. 交互能力：点击、填表、滚动、上传
3. 多标签页管理：可同时控制多个标签
4. 截图和 PDF：可视化输出
5. 两种模式：
   • openclaw：隔离浏览器
   • chrome：接管现有 Chrome 标签（需要扩展）

基础用法

def browser_automation_example():
    """浏览器自动化示例"""
    
    # 启动浏览器
    browser_start(profile="openclaw")
    
    # 打开页面
    browser_open("https://example.com")
    
    # 获取快照（分析页面结构）
    snapshot = browser_snapshot(refs="aria")
    
    # 点击元素
    browser_act(
        request={
            "kind": "click",
            "ref": "login-button"  # aria-ref
        }
    )
    
    # 填写表单
    browser_act(
        request={
            "kind": "type",
            "ref": "email-input",
            "text": "[email protected]"
        }
    )
    
    # 截图
    screenshot = browser_screenshot()
    
    # 关闭浏览器
    browser_stop()
    
    return screenshot

高级技巧

1. 动态内容抓取

def scrape_dynamic_content(url):
    """抓取需要 JS 渲染的内容"""
    
    browser_start(profile="openclaw")
    browser_open(url)
    
    # 等待内容加载
    import time
    time.sleep(3)
    
    # 滚动到底部触发懒加载
    browser_act(request={"kind": "press", "key": "End"})
    time.sleep(2)
    
    # 获取最终内容
    snapshot = browser_snapshot()
    
    browser_stop()
    
    return extract_content(snapshot)

2. 多步骤流程自动化

def automate_form_filling(form_url, data):
    """自动填写复杂表单"""
    
    browser_start(profile="openclaw")
    browser_open(form_url)
    
    # 获取初始快照
    snapshot = browser_snapshot(refs="aria")
    
    # 逐步填写字段
    for field, value in data.items():
        # 找到输入框
        input_ref = find_element_by_label(snapshot, field)
        
        # 填写内容
        browser_act(
            request={
                "kind": "type",
                "ref": input_ref,
                "text": str(value)
            }
        )
        
        # 等待响应
        time.sleep(0.5)
    
    # 提交表单
    browser_act(
        request={
            "kind": "click",
            "ref": "submit-button"
        }
    )
    
    # 等待结果
    time.sleep(2)
    
    # 截图结果
    result = browser_screenshot()
    
    browser_stop()
    
    return result

3. Chrome 扩展模式

def use_existing_chrome_tab():
    """使用现有的 Chrome 标签页"""
    
    # 注意：需要用户先点击 OpenClaw Browser Relay 扩展图标
    
    # 获取已连接的标签
    tabs = browser_tabs(profile="chrome")
    
    if not tabs:
        return {"error": "No Chrome tab connected"}
    
    # 使用第一个标签
    target_tab = tabs[0]
    
    # 在该标签中执行操作
    browser_snapshot(targetId=target_tab['id'])
    browser_act(
        request={"kind": "click", "ref": "some-button"},
        targetId=target_tab['id']
    )
    
    return {"success": True}

实战案例 4：价格监控 Agent

class PriceMonitorAgent:
    """电商价格监控 Agent"""
    
    def __init__(self, product_urls):
        self.product_urls = product_urls
        self.price_history = {}
    
    def check_prices(self):
        """检查所有产品价格"""
        
        browser_start(profile="openclaw")
        
        for url in self.product_urls:
            browser_open(url)
            time.sleep(2)  # 等待页面加载
            
            # 获取页面快照
            snapshot = browser_snapshot()
            
            # 提取价格
            price = extract_price(snapshot)
            
            # 记录历史
            if url not in self.price_history:
                self.price_history[url] = []
            
            self.price_history[url].append({
                "timestamp": datetime.now(),
                "price": price
            })
            
            # 检查是否降价
            if self.is_price_drop(url, price):
                self.alert_price_drop(url, price)
        
        browser_stop()
        
        return self.generate_report()
    
    def is_price_drop(self, url, current_price):
        """检查是否降价"""
        
        history = self.price_history[url]
        if len(history) < 2:
            return False
        
        last_price = history[-2]['price']
        return current_price < last_price

工具选择决策树

如何为你的任务选择合适的工具？

开始
  │
  ├─ 需要快速搜索查询？
  │   └─ YES → web_search
  │   └─ NO  → 继续
  │
  ├─ 是单个已知 URL，内容简单？
  │   └─ YES → web_fetch
  │   └─ NO  → 继续
  │
  ├─ 需要绕过反爬虫 / 大规模爬取？
  │   └─ YES → firecrawl
  │   └─ NO  → 继续
  │
  ├─ 需要 JavaScript / 用户交互 / 截图？
  │   └─ YES → browser
  │   └─ NO  → 回到 web_fetch

场景对比表

性能优化和成本控制

1. 缓存策略

from functools import lru_cache
import hashlib
import json

def cache_key(url_or_query):
    """生成缓存键"""
    return hashlib.md5(url_or_query.encode()).hexdigest()

@lru_cache(maxsize=100)
def cached_web_search(query, **kwargs):
    """带缓存的搜索"""
    return web_search(query, **kwargs)

def cached_fetch(url):
    """带缓存的抓取"""
    cache_file = f"/tmp/fetch_{cache_key(url)}.json"
    
    if os.path.exists(cache_file):
        with open(cache_file) as f:
            return json.load(f)
    
    content = web_fetch(url)
    
    with open(cache_file, 'w') as f:
        json.dump(content, f)
    
    return content

2. 并发控制

from concurrent.futures import ThreadPoolExecutor, as_completed

def parallel_search(queries, max_workers=3):
    """并行搜索多个查询"""
    
    results = {}
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {
            executor.submit(web_search, q): q 
            for q in queries
        }
        
        for future in as_completed(futures):
            query = futures[future]
            try:
                results[query] = future.result()
            except Exception as e:
                results[query] = {"error": str(e)}
    
    return results

3. 成本优化

优化建议：

• 优先使用 web_search 进行初步筛选
• 使用缓存避免重复查询
• 批量操作时控制并发数
• 定期清理缓存文件

常见问题和解决方案

Q1: web_fetch 返回空内容

原因：目标站点使用 JavaScript 渲染或有反爬虫保护

解决方案：

# 尝试 firecrawl
content = firecrawl_crawl(url)

# 或使用 browser
browser_start()
browser_open(url)
snapshot = browser_snapshot()
browser_stop()

Q2: browser 操作不稳定

原因：元素加载延迟或选择器变化

解决方案：

def robust_click(ref, max_wait=10):
    """稳定的点击操作"""
    
    for attempt in range(max_wait):
        try:
            browser_act(request={"kind": "click", "ref": ref})
            return True
        except Exception as e:
            if "Element not found" in str(e):
                time.sleep(1)
            else:
                raise
    
    raise TimeoutError(f"Element {ref} not found after {max_wait}s")

Q3: firecrawl 爬取太慢

原因：默认爬取整个站点

解决方案：

# 限制爬取范围
result = firecrawl_crawl(
    url=url,
    options={
        "includePaths": ["/blog/*"],
        "limit": 10,
        "maxDepth": 2
    }
)

Q4: web_search 结果不相关

原因：查询词太泛或搜索策略不当

解决方案：

def adaptive_search(query):
    """自适应搜索"""
    
    # 策略 1：精确匹配
    exact = web_search(f'"{query}"')
    
    # 策略 2：添加关键词
    with_keywords = web_search(f'{query} guide tutorial')
    
    # 策略 3：站点限定
    site_specific = web_search(f'{query} site:stackoverflow.com')
    
    # 使用 AI 评估最佳结果
    best = ai_generate(
        prompt=f"""
        评估这三组搜索结果，选择最相关的：
        
        1. 精确匹配：{len(exact)} 条
        2. 关键词：{len(with_keywords)} 条
        3. 站点限定：{len(site_specific)} 条
        
        返回策略编号（1/2/3）和理由。
        """
    )
    
    strategies = {
        "1": exact,
        "2": with_keywords,
        "3": site_specific
    }
    
    return strategies[best[0]]

综合实战案例：智能研究助手

结合所有工具，构建一个完整的研究助手：

class IntelligentResearchAssistant:
    """智能研究助手"""
    
    def __init__(self, topic):
        self.topic = topic
        self.findings = {
            "overview": None,
            "sources": [],
            "deep_dives": [],
            "visuals": []
        }
    
    def research(self):
        """完整研究流程"""
        
        # 第 1 步：快速概览（web_search）
        print("[1/5] 搜索概览...")
        overview = self.get_overview()
        
        # 第 2 步：收集高质量来源（web_search + web_fetch）
        print("[2/5] 收集来源...")
        sources = self.collect_sources()
        
        # 第 3 步：深度研究关键点（firecrawl）
        print("[3/5] 深度研究...")
        deep_dives = self.deep_dive()
        
        # 第 4 步：可视化数据（browser）
        print("[4/5] 采集可视化...")
        visuals = self.collect_visuals()
        
        # 第 5 步：生成报告
        print("[5/5] 生成报告...")
        report = self.generate_report()
        
        return report
    
    def get_overview(self):
        """获取主题概览"""
        
        results = web_search(
            query=self.topic,
            count=10
        )
        
        overview = ai_generate(
            prompt=f"""
            基于搜索结果，生成"{self.topic}"的概览：
            
            {results}
            
            包含：
            1. 定义和核心概念
            2. 主要应用场景
            3. 关键技术/方法
            4. 当前趋势
            """
        )
        
        self.findings["overview"] = overview
        return overview
    
    def collect_sources(self):
        """收集高质量来源"""
        
        # 搜索官方文档和权威来源
        authority_results = web_search(
            query=f'{self.topic} official documentation',
            count=5
        )
        
        sources = []
        for result in authority_results:
            # 使用 web_fetch 快速抓取
            content = web_fetch(result['url'], maxChars=5000)
            
            sources.append({
                "url": result['url'],
                "title": result['title'],
                "content": content
            })
        
        self.findings["sources"] = sources
        return sources
    
    def deep_dive(self):
        """深度研究关键点"""
        
        # 识别 3 个关键子主题
        key_points = ai_generate(
            prompt=f"""
            从"{self.topic}"中提取 3 个最重要的子主题：
            
            概览：{self.findings['overview']}
            
            只返回主题名称，用逗号分隔。
            """
        ).split(',')
        
        deep_dives = []
        
        for point in key_points[:3]:
            # 为每个子主题进行深度搜索
            search_results = web_search(
                query=f"{self.topic} {point.strip()}",
                count=5
            )
            
            # 使用 firecrawl 爬取最佳来源
            best_url = search_results[0]['url']
            detailed_content = firecrawl_crawl(best_url)
            
            deep_dives.append({
                "topic": point.strip(),
                "url": best_url,
                "content": detailed_content
            })
        
        self.findings["deep_dives"] = deep_dives
        return deep_dives
    
    def collect_visuals(self):
        """收集可视化内容"""
        
        # 搜索图表和截图
        visual_results = web_search(
            query=f"{self.topic} diagram chart infographic",
            count=5
        )
        
        visuals = []
        
        browser_start(profile="openclaw")
        
        for result in visual_results[:3]:
            browser_open(result['url'])
            time.sleep(2)
            
            # 截图
            screenshot = browser_screenshot()
            
            visuals.append({
                "url": result['url'],
                "screenshot": screenshot
            })
        
        browser_stop()
        
        self.findings["visuals"] = visuals
        return visuals
    
    def generate_report(self):
        """生成完整研究报告"""
        
        report = ai_generate(
            prompt=f"""
            基于 {len(self.findings['sources'])} 个来源和 
            {len(self.findings['deep_dives'])} 个深度分析，
            生成"{self.topic}"的完整研究报告：
            
            概览：{self.findings['overview']}
            
            深度分析：
            {self.findings['deep_dives']}
            
            报告结构：
            1. 执行摘要
            2. 背景和定义
            3. 核心概念（3-5 个）
            4. 实际应用
            5. 最新趋势
            6. 推荐资源（带链接）
            7. 未来展望
            
            使用 Markdown 格式，包含来源引用。
            """
        )
        
        return report


# 使用示例
assistant = IntelligentResearchAssistant("OpenClaw AI Agent")
report = assistant.research()

# 保存报告
with open("research_report.md", "w") as f:
    f.write(report)

print("✅ 研究报告已生成")

最佳实践总结

✅ 推荐做法

1. 从轻量级工具开始：web_search → web_fetch → firecrawl → browser
2. 合理使用缓存：避免重复查询和抓取
3. 错误处理：每个工具调用都应有超时和重试机制
4. 并发控制：批量操作时限制并发数，避免被反爬虫检测
5. 成本监控：跟踪 API 使用量，设置预算提醒
6. 来源验证：交叉验证多个来源的信息
7. 尊重 robots.txt：爬取时遵守站点规则

❌ 避免陷阱

1. 过度依赖浏览器：browser 最慢最贵，能不用就不用
2. 忽略反爬虫：大规模抓取前先测试限制
3. 重复抓取：相同内容用缓存，不要重复请求
4. 超时不设置：网络请求永远要设置超时
5. 单一来源：关键信息要从多个来源验证
6. 忽略版权：抓取的内容要注意使用许可

与 Gemini 集成（补充）

虽然本文重点介绍 OpenClaw 的原生工具，但与 Gemini 的结合能进一步提升能力：

def gemini_enhanced_search(topic):
    """Gemini 增强的搜索流程"""
    
    # 第 1 步：使用 web_search 快速获取信息
    initial_results = web_search(topic, count=10)
    
    # 第 2 步：Gemini 分析并生成子查询
    sub_queries = gemini_generate(
        prompt=f"""
        基于搜索结果，生成 5 个深度搜索方向：
        
        {initial_results}
        
        只返回查询语句，每行一个。
        """
    ).split('\n')
    
    # 第 3 步：对每个子查询进行深度搜索
    deep_results = []
    for query in sub_queries:
        results = web_search(query, count=3)
        deep_results.extend(results)
    
    # 第 4 步：Gemini 综合生成报告
    report = gemini_generate(
        prompt=f"""
        综合所有搜索结果，生成完整报告：
        
        初始结果：{initial_results}
        深度结果：{deep_results}
        
        包含：概述、关键点、来源链接、建议。
        """
    )
    
    return report

详细的 Gemini 集成指南，请参考：Gemini + OpenClaw 网络搜索完整指南

未来展望

OpenClaw 的联网搜索能力仍在快速发展：

1. 更多集成：未来可能支持更多搜索 API（Bing、DuckDuckGo）
2. 智能路由：自动选择最合适的工具
3. 学习优化：基于历史数据优化搜索策略
4. 多模态：图片和视频搜索能力
5. 协作爬取：多个 Agent 并行处理大规模任务

结语

OpenClaw 提供的四层联网工具，为 AI Agent 提供了从快速查询到深度爬取的完整能力栈。理解每种工具的特点和适用场景，是构建高效、低成本 AI Agent 的关键。

记住：

• web_search：快速搜索，实时信息
• web_fetch：轻量抓取，简单页面
• firecrawl：企业爬虫，复杂站点
• browser：完整控制，交互操作

从简单任务开始，逐步升级到更强大的工具。大多数情况下，web_search 和 web_fetch 已经足够；只有遇到反爬虫或需要交互时，才考虑 firecrawl 或 browser。

开始构建你的第一个联网增强型 AI Agent 吧！

相关资源：

• OpenClaw 官方文档
• Brave Search API
• Firecrawl 文档
• Gemini 集成指南

更新日期：2026 年 2 月 15 日
作者：基于 OpenClaw v1.x 编写