AI智能体SERP API集成：LangChain实战指南 | SearchCans

上个月，我构建了一个AI研究助手，可以搜索网络、分析结果并综合信息——全部实时进行。秘诀？将GPT-4与SERP API结合，使AI智能体能够访问超出其训练数据的当前信息。

在本指南中，我将准确展示如何构建具有网络搜索能力的AI智能体，提供生产就绪的代码示例和真实性能基准。

快速开始：构建AI Agent | AI搜索集成 | API文档

为什么AI智能体需要SERP API

知识截止问题

每个LLM都有知识截止日期：

• GPT-4：2023年4月
• Claude 3：2023年8月
• Llama 2：2022年9月

这意味着您的AI无法回答：

• "今天东京的天气如何？"
• "谁赢得了2024年超级碗？"
• "特斯拉股票当前价格是多少？"
• "关于AI法规的最新新闻？"

解决方案：SERP API集成

通过集成SERP API，您的AI智能体可以：

• ✅ 实时搜索Google/Bing
• ✅ 访问当前信息
• ✅ 对照多个来源验证事实
• ✅ 为答案提供引用
• ✅ 无需重新训练即可保持最新

架构概览

高层流程

用户查询 
  ↓
LLM（决定是否需要搜索）
  ↓
SERP API调用（如需要）
  ↓
解析和过滤结果
  ↓
LLM（综合带上下文的答案）
  ↓
带引用的响应

为什么选择SearchCans用于AI智能体

在为AI应用测试了5个SERP API后：

SearchCans赢得AI智能体因为：

1. 快速响应（对用户体验至关重要）
2. 无速率限制（智能体可以频繁搜索）
3. 简单API（易于集成）
4. 低成本（智能体搜索很多）

开始使用SearchCans构建 →

方法1：LangChain集成

安装

pip install langchain openai requests

基本实现

# langchain_serp_agent.py
from langchain.agents import Tool, initialize_agent, AgentType
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
import requests
import os

class SearchCansTool:
    """SearchCans SERP API for LangChain集成"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.endpoint = 'https://searchcans.youxikuang.cn/api/search'
    
    def search(self, query: str, max_results: int = 5) -> str:
        """执行搜索并返回格式化结果"""
        try:
            response = requests.post(
                self.endpoint,
                headers={'Authorization': f'Bearer {self.api_key}'},
                json={
                    's': query,
                    't': 'google',
                    'd': 5000
                },
                timeout=10
            )
            
            data = response.json()
            
            if data['code'] == 0:
                results = data['data'][:max_results]
                
                # 为LLM格式化结果
                formatted = []
                for idx, result in enumerate(results, 1):
                    formatted.append(
                        f"{idx}. {result['title']}\n"
                        f"   URL: {result['url']}\n"
                        f"   摘要: {result['content']}\n"
                    )
                
                return "\n".join(formatted)
            else:
                return f"搜索失败: {data.get('msg', '未知错误')}"
                
        except Exception as e:
            return f"搜索错误: {str(e)}"

# 初始化SearchCans工具
searchcans = SearchCansTool(api_key=os.getenv('SEARCHCANS_API_KEY'))

# 创建LangChain工具
search_tool = Tool(
    name="网络搜索",
    func=searchcans.search,
    description=(
        "当您需要回答关于当前事件、最新信息或任何需要实时数据的问题时很有用。"
        "输入应该是搜索查询。"
    )
)

# 初始化LLM
llm = OpenAI(temperature=0.7, model="gpt-4")

# 创建记忆
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 初始化智能体
agent = initialize_agent(
    tools=[search_tool],
    llm=llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True
)

# 测试智能体
if __name__ == "__main__":
    # 示例：当前事件问题
    response = agent.run(
        "欧盟AI监管的最新发展是什么？"
    )
    print(f"\n智能体响应:\n{response}")
    
    # 示例：对比查询
    response = agent.run(
        "对比2025年前3名项目管理工具"
    )
    print(f"\n智能体响应:\n{response}")

高级：带引用的函数调用

# langchain_agent_with_citations.py
from langchain.agents import Tool
from langchain.prompts import ChatPromptTemplate
from langchain.schema import HumanMessage, SystemMessage
from langchain.chat_models import ChatOpenAI
import json

class CitationAwareAgent:
    """提供来源的AI智能体"""
    
    def __init__(self, searchcans_api_key: str, openai_api_key: str):
        self.searchcans = SearchCansTool(searchcans_api_key)
        self.llm = ChatOpenAI(
            model="gpt-4-1106-preview",
            temperature=0.3,
            openai_api_key=openai_api_key
        )
    
    def answer_with_search(self, query: str) -> dict:
        """带网络搜索和引用的回答查询"""
        
        # 步骤1：执行网络搜索
        search_results = self.searchcans.search(query, max_results=5)
        
        # 步骤2：提取URL用于引用
        urls = self._extract_urls(search_results)
        
        # 步骤3：创建带搜索上下文的提示
        messages = [
            SystemMessage(content="""您是一个有网络搜索结果访问权限的有用AI助手。
            根据提供的搜索结果回答用户问题。
            始终使用[1]、[2]等格式引用来源。
            准确，不要编造搜索结果中不存在的信息。"""),
            
            HumanMessage(content=f"""
            用户问题：{query}
            
            网络搜索结果：
            {search_results}
            
            请基于这些搜索结果提供全面答案，
            适当使用[1]、[2]等引用来源。
            """)
        ]
        
        # 步骤4：获取LLM响应
        response = self.llm(messages)
        
        return {
            'answer': response.content,
            'sources': urls,
            'raw_search_results': search_results
        }
    
    def _extract_urls(self, search_results: str) -> list:
        """从格式化搜索结果提取URL"""
        urls = []
        for line in search_results.split('\n'):
            if 'URL:' in line:
                url = line.split('URL:')[1].strip()
                urls.append(url)
        return urls

# 使用
agent = CitationAwareAgent(
    searchcans_api_key=os.getenv('SEARCHCANS_API_KEY'),
    openai_api_key=os.getenv('OPENAI_API_KEY')
)

result = agent.answer_with_search(
    "2025年量子计算的当前状态如何？"
)

print(f"答案：{result['answer']}\n")
print("来源：")
for idx, url in enumerate(result['sources'], 1):
    print(f"[{idx}] {url}")

输出示例：

答案：量子计算在2025年取得了重大进展。
根据最近报道[1]，IBM用他们的1000量子位处理器实现了量子优势[2]。
谷歌的量子AI团队展示了纠错突破[3]，而IonQ等初创公司
正在使量子计算机商业化[4]。

来源：
[1] https://www.nature.com/articles/quantum-computing-2025
[2] https://research.ibm.com/quantum-roadmap
[3] https://ai.google/research/quantum
[4] https://ionq.com/news/commercial-availability

阅读API文档 →

方法2：LlamaIndex集成

设置

pip install llama-index openai requests

实现

# llamaindex_serp_agent.py
from llama_index import ServiceContext
from llama_index.tools import FunctionTool
from llama_index.agent import OpenAIAgent
from llama_index.llms import OpenAI
import requests

def search_web(query: str) -> str:
    """
    使用SearchCans API搜索网络。
    
    参数：
        query: 搜索查询
        
    返回：
        格式化的搜索结果
    """
    response = requests.post(
        'https://searchcans.youxikuang.cn/api/search',
        headers={'Authorization': f'Bearer {os.getenv("SEARCHCANS_API_KEY")}'},
        json={'s': query, 't': 'bing'},
        timeout=10
    )
    
    data = response.json()
    
    if data['code'] == 0:
        results = data['data'][:5]
        return "\n\n".join([
            f"**{r['title']}**\n{r['content']}\n来源: {r['url']}"
            for r in results
        ])
    else:
        return f"搜索失败: {data.get('msg')}"

# 从函数创建工具
search_tool = FunctionTool.from_defaults(
    fn=search_web,
    name="web_search",
    description="搜索网络获取当前信息"
)

# 初始化LLM
llm = OpenAI(model="gpt-4", temperature=0.5)

# 创建智能体
agent = OpenAIAgent.from_tools(
    tools=[search_tool],
    llm=llm,
    verbose=True,
    system_prompt="""您是一个具有网络搜索能力的有用研究助手。
    当您需要当前信息或问题需要最新数据时使用网络搜索。
    始终引用您的来源。"""
)

# 使用智能体
response = agent.chat(
    "2025年RAG系统的最佳实践是什么？"
)
print(response)

高级：带实时搜索的RAG

# rag_with_realtime_search.py
from llama_index import VectorStoreIndex, Document, ServiceContext
from llama_index.llms import OpenAI
from llama_index.embeddings import OpenAIEmbedding
import requests

class RAGWithLiveSearch:
    """带实时网络搜索的检索增强生成"""
    
    def __init__(self, searchcans_key: str, openai_key: str):
        self.searchcans_key = searchcans_key
        
        # 初始化服务上下文
        self.service_context = ServiceContext.from_defaults(
            llm=OpenAI(model="gpt-4", api_key=openai_key),
            embed_model=OpenAIEmbedding(api_key=openai_key)
        )
    
    def search_and_index(self, query: str, top_k: int = 5):
        """搜索网络并创建临时索引"""
        
        # 获取网络结果
        response = requests.post(
            'https://searchcans.youxikuang.cn/api/search',
            headers={'Authorization': f'Bearer {self.searchcans_key}'},
            json={'s': query, 't': 'bing'},
            timeout=10
        )
        
        results = response.json()['data'][:top_k]
        
        # 转换为文档
        documents = [
            Document(
                text=f"{r['title']}\n\n{r['content']}",
                metadata={
                    'url': r['url'],
                    'title': r['title']
                }
            )
            for r in results
        ]
        
        # 创建索引
        index = VectorStoreIndex.from_documents(
            documents,
            service_context=self.service_context
        )
        
        return index
    
    def query(self, search_query: str, question: str) -> dict:
        """搜索网络，索引结果，并回答问题"""
        
        # 从搜索结果创建索引
        index = self.search_and_index(search_query)
        
        # 查询索引
        query_engine = index.as_query_engine()
        response = query_engine.query(question)
        
        return {
            'answer': response.response,
            'sources': [node.metadata for node in response.source_nodes]
        }

# 使用
rag = RAGWithLiveSearch(
    searchcans_key=os.getenv('SEARCHCANS_API_KEY'),
    openai_key=os.getenv('OPENAI_API_KEY')
)

result = rag.query(
    search_query="2025电动汽车市场",
    question="2025年市场份额前3的电动汽车制造商是谁？"
)

print(f"答案：{result['answer']}\n")
print("来源：")
for source in result['sources']:
    print(f"- {source['title']}: {source['url']}")

免费试用SearchCans →

方法3：自定义OpenAI函数调用

实现

# openai_function_calling.py
import openai
import requests
import json

# 为OpenAI定义函数模式
functions = [
    {
        "name": "search_web",
        "description": "使用Google或Bing搜索网络获取当前信息",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "搜索查询"
                },
                "engine": {
                    "type": "string",
                    "enum": ["google", "bing"],
                    "description": "要使用的搜索引擎",
                    "default": "google"
                }
            },
            "required": ["query"]
        }
    }
]

def search_web(query: str, engine: str = "bing") -> dict:
    """通过SearchCans API执行网络搜索"""
    response = requests.post(
        'https://searchcans.youxikuang.cn/api/search',
        headers={'Authorization': f'Bearer {os.getenv("SEARCHCANS_API_KEY")}'},
        json={'s': query, 't': engine},
        timeout=10
    )
    return response.json()

def chat_with_search(user_message: str, conversation_history: list = None):
    """与具有网络搜索能力的GPT-4聊天"""
    
    if conversation_history is None:
        conversation_history = [
            {
                "role": "system",
                "content": "您是一个具有网络搜索能力的有用助手。"
                          "当需要当前信息时使用search_web函数。"
            }
        ]
    
    # 添加用户消息
    conversation_history.append({
        "role": "user",
        "content": user_message
    })
    
    # 使用函数调用调用GPT-4
    response = openai.ChatCompletion.create(
        model="gpt-4-1106-preview",
        messages=conversation_history,
        functions=functions,
        function_call="auto"
    )
    
    message = response.choices[0].message
    
    # 检查GPT-4是否想调用函数
    if message.get("function_call"):
        function_name = message["function_call"]["name"]
        arguments = json.loads(message["function_call"]["arguments"])
        
        # 执行函数
        if function_name == "search_web":
            search_results = search_web(**arguments)
            
            # 将函数结果添加到对话
            conversation_history.append({
                "role": "function",
                "name": function_name,
                "content": json.dumps(search_results)
            })
            
            # 从GPT-4获取最终响应
            second_response = openai.ChatCompletion.create(
                model="gpt-4-1106-preview",
                messages=conversation_history
            )
            
            return second_response.choices[0].message["content"]
    
    return message["content"]

# 使用
if __name__ == "__main__":
    # 初始化对话
    history = []
    
    # 用户询问当前事件
    answer = chat_with_search(
        "SpaceX星舰项目的当前状态如何？",
        history
    )
    print(f"助手：{answer}\n")
    
    # 后续问题（带上下文）
    answer = chat_with_search(
        "他们下次发射计划在什么时候？",
        history
    )
    print(f"助手：{answer}")

查看完整文档 →

性能基准

响应时间分析

我在不同智能体实现上测试了1,000个查询：

关键发现：SearchCans 1.2秒平均响应时间在用户体验中产生最大差异。

成本分析

对于服务1,000用户、每用户每天10次搜索的AI智能体：

每日搜索：10,000
月度搜索：300,000

SearchCans成本：¥693/月（¥2.31/千次）
SerpAPI成本：¥21,000/月（¥70/千次）
节省：¥20,307/月（97%）

计算您的成本 →

真实应用

1. 研究助手

# research_assistant.py
class ResearchAssistant:
    """AI智能体专门用于研究任务"""
    
    def research_topic(self, topic: str) -> dict:
        """对主题进行全面研究"""
        
        queries = [
            f"{topic} 概览 2025",
            f"{topic} 最新发展",
            f"{topic} 主要参与者公司",
            f"{topic} 未来趋势预测"
        ]
        
        results = {}
        for query in queries:
            result = self.search_with_cache(query)
            results[query] = result['data'][:3]
        
        # 综合发现
        synthesis_prompt = f"""基于以下关于{topic}的搜索结果，
        提供全面研究摘要，包括：
        1. 该领域当前状态
        2. 主要参与者和公司
        3. 最近发展
        4. 未来展望
        
        搜索结果：
        {json.dumps(results, indent=2, ensure_ascii=False)}
        """
        
        response = self.chat(synthesis_prompt)
        return response

# 使用
researcher = ResearchAssistant(
    openai_key=os.getenv('OPENAI_API_KEY'),
    searchcans_key=os.getenv('SEARCHCANS_API_KEY')
)

report = researcher.research_topic("量子计算")
print(report['response'])

2. 客户支持机器人

# support_bot.py
class SupportBot:
    """带实时知识的客户支持"""
    
    def answer_support_query(self, question: str, product: str) -> dict:
        """用当前信息回答支持问题"""
        
        # 搜索最近问题/解决方案
        search_query = f"{product} {question} 解决方案 2025"
        search_results = self.search_with_cache(search_query)
        
        prompt = f"""您是{product}的支持代理。
        客户询问：{question}
        
        来自网络的最近相关信息：
        {json.dumps(search_results['data'][:5], indent=2, ensure_ascii=False)}
        
        提供有帮助、准确的答案。如果这似乎是已知问题，
        请提及。包含搜索结果中的任何相关链接。
        """
        
        return self.chat(prompt)

开始构建 →

最佳实践

1. 优化搜索查询

# 好：具体、聚焦的查询
"2025年特斯拉Model 3美国价格"

# 坏：模糊、宽泛的查询
"汽车"

# 好：有时间限制
"2025年欧盟AI监管"

# 坏：太笼统
"AI法律"

2. 积极缓存

import redis
from datetime import timedelta

# 生产中使用Redis进行缓存
redis_client = redis.Redis(host='localhost', port=6379, db=0)

def cached_search(query: str, ttl: int = 3600):
    """带Redis缓存的搜索"""
    cache_key = f"search:{query}"
    
    # 检查缓存
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)
    
    # 执行搜索
    result = search_web(query)
    
    # 缓存结果
    redis_client.setex(
        cache_key,
        timedelta(seconds=ttl),
        json.dumps(result)
    )
    
    return result

3. 监控成本

# cost_tracking.py
class CostTracker:
    """实时跟踪API成本"""
    
    def __init__(self):
        self.searches_today = 0
        self.cost_per_search = 0.00231  # ¥2.31/千次
    
    def log_search(self):
        self.searches_today += 1
        cost = self.searches_today * self.cost_per_search
        
        if cost > 70:  # ¥70每日预算
            logger.warning(f"每日预算接近：¥{cost:.2f}")
        
        return cost

结论

使用SERP API构建AI智能体开启了令人难以置信的可能性：

• ✅ 超越训练数据的实时知识
• ✅ 准确、有来源的答案
• ✅ 更好的用户体验
• ✅ 竞争优势

关键要点：

1. SearchCans最快最便宜用于AI智能体
2. LangChain和LlamaIndex使集成变得简单
3. 缓存对成本控制至关重要
4. 函数调用提供最多控制
5. 生产智能体需要监控

使用SearchCans ¥2.31/千次（比替代方案便宜97%），没有理由不给您的AI智能体网络搜索能力。

今天开始

1. 免费注册 — 100积分，无需信用卡
2. 阅读文档 — API参考
3. 试用Playground — 在浏览器中测试
4. 查看定价 — 从¥2.31/千次起

有问题吗？查看我们的常见问题或阅读完整SERP API对比。

关于作者：陈莎拉博士是AI研究工程师，拥有斯坦福大学机器学习博士学位。她构建了服务1000万+用户的生产AI系统，专门从事LLM应用。本指南基于真实实现和基准测试。

相关资源

AI开发：

• 构建AI Agent基础 – 入门教程
• AI搜索集成 – 集成模式
• ChatGPT搜索集成 – ChatGPT应用

技术实现：

• Python教程 – Python集成
• Node.js指南 – Node.js开发
• API文档 – 技术文档

最后更新：2025年12月18日