如何在Python项目中集成企业级智能搜索？Tavily API封装库实战指南

2026-04-16 08:19:44作者：贡沫苏Truman

The Tavily Python SDK allows for easy interaction with the Tavily API, offering the full range of our search, extract, crawl, map, and research functionalities directly from your Python programs. Easily integrate smart search, content extraction, and research capabilities into your applications, harnessing Tavily's powerful features.

项目地址：https://gitcode.com/gh_mirrors/ta/tavily-python

在当今数据驱动的开发环境中，高效整合智能搜索能力已成为提升应用价值的关键环节。Tavily Python SDK作为一款专为企业级应用设计的API封装库，为Python开发者提供了便捷接入智能搜索功能的解决方案。本文将从功能解析、场景落地、进阶技巧到生态拓展四个维度，全面介绍如何利用这一Python开发工具构建强大的搜索功能。

一、核心功能解析：从基础到高级检索能力

1.1 基础检索功能实现

Tavily Python SDK的核心价值在于将复杂的搜索API交互封装为简洁的Python接口。开发者只需通过简单的初始化和方法调用，即可获得专业级的搜索能力。

# 基础搜索功能实现
from tavily import TavilyClient

def initialize_search_client(api_key):
    """初始化Tavily搜索客户端
    
    Args:
        api_key (str): Tavily API密钥
        
    Returns:
        TavilyClient: 初始化后的搜索客户端实例
    """
    try:
        return TavilyClient(api_key=api_key)
    except Exception as e:
        print(f"客户端初始化失败: {str(e)}")
        raise

# 初始化客户端
search_client = initialize_search_client("tvly-YOUR_API_KEY")

# 执行基础搜索
def perform_basic_search(client, query):
    """执行基础搜索查询
    
    Args:
        client (TavilyClient): 搜索客户端实例
        query (str): 搜索关键词
        
    Returns:
        dict: 搜索结果字典
    """
    return client.search(query)

# 执行搜索并处理结果
search_result = perform_basic_search(search_client, "2024年人工智能发展趋势")
print(f"搜索完成，找到{len(search_result.get('results', []))}条结果")

💡 提示：API密钥应通过环境变量或配置文件管理，避免硬编码在源代码中。生产环境建议使用密钥轮换机制增强安全性。

1.2 高级筛选与参数配置

Tavily SDK提供丰富的搜索参数配置，支持按时间范围、内容类型、来源可靠性等维度进行精确筛选，满足不同业务场景需求。

# 高级搜索参数配置示例
def advanced_search_demo(client):
    """高级搜索功能演示
    
    展示如何使用各种筛选参数优化搜索结果
    """
    # 1. 时间范围筛选 - 获取近30天的科技新闻
    tech_news = client.search(
        "量子计算最新突破",
        topic="technology",  # 指定主题分类
        days=30,            # 时间范围限制
        max_results=10      # 结果数量控制
    )
    
    # 2. 结果类型筛选 - 仅返回学术文章
    academic_papers = client.search(
        "机器学习算法优化",
        type="academic",    # 内容类型筛选
        sort="relevance"    # 按相关性排序
    )
    
    # 3. 多参数组合查询
    hybrid_search = client.search(
        "新能源政策分析",
        topic="business",
        days=90,
        include_answer=True,  # 包含AI生成的总结答案
        include_raw_content=False  # 不包含原始内容
    )
    
    return {
        "tech_news_count": len(tech_news.get("results", [])),
        "academic_papers_count": len(academic_papers.get("results", [])),
        "hybrid_search_answer": hybrid_search.get("answer", "无可用答案")
    }

# 执行高级搜索
advanced_results = advanced_search_demo(search_client)
print(f"高级搜索结果: {advanced_results}")

⚠️ 注意：过度限制搜索参数可能导致结果数量不足，建议先进行宽泛搜索，再根据返回结果逐步优化筛选条件。

1.3 结果处理与数据提取

SDK返回的搜索结果包含丰富的结构化数据，开发者可以根据需求提取关键信息，如摘要、来源、相关链接等，并进行二次处理和分析。

# 搜索结果处理与信息提取
def process_search_results(results):
    """处理搜索结果，提取关键信息
    
    Args:
        results (dict): 原始搜索结果
        
    Returns:
        list: 结构化处理后的结果列表
    """
    processed = []
    
    # 检查结果是否有效
    if not results or "results" not in results:
        return processed
        
    for item in results["results"]:
        # 提取核心信息
        processed_item = {
            "title": item.get("title", "无标题"),
            "source": item.get("url", "未知来源"),
            "summary": item.get("summary", "无摘要"),
            "published_date": item.get("published_date", "未知日期"),
            "relevance_score": item.get("score", 0)
        }
        processed.append(processed_item)
        
    # 按相关度排序
    return sorted(processed, key=lambda x: x["relevance_score"], reverse=True)

# 处理搜索结果
processed_results = process_search_results(search_result)
for i, item in enumerate(processed_results[:3], 1):
    print(f"结果{i}: {item['title']}")
    print(f"来源: {item['source']}")
    print(f"摘要: {item['summary'][:100]}...\n")

二、场景落地：从原型到生产环境的实践路径

2.1 快速原型开发：5分钟实现智能问答功能

对于需要快速验证概念的场景，Tavily SDK提供了简洁的问答接口，可在几分钟内搭建起基本的智能问答系统。

# 快速问答功能实现
def build_quick_qa_system(api_key):
    """构建快速问答系统原型
    
    Args:
        api_key (str): Tavily API密钥
        
    Returns:
        function: 问答函数
    """
    client = TavilyClient(api_key=api_key)
    
    def qa_system(query):
        """问答系统主函数
        
        Args:
            query (str): 用户问题
            
        Returns:
            str: 回答内容
        """
        try:
            # 直接使用qna_search方法获取答案
            answer = client.qna_search(query)
            return answer
        except Exception as e:
            return f"抱歉，无法回答您的问题: {str(e)}"
    
    return qa_system

# 构建问答系统
qa = build_quick_qa_system("tvly-YOUR_API_KEY")

# 测试问答功能
questions = [
    "什么是RAG技术？",
    "Python 3.11有哪些新特性？",
    "如何优化数据库查询性能？"
]

for question in questions:
    print(f"问: {question}")
    print(f"答: {qa(question)}\n")

RAG：检索增强生成技术，通过检索外部知识增强模型回答能力，解决大语言模型知识时效性和准确性问题。

2.2 生产环境部署：错误处理与性能优化

将搜索功能部署到生产环境时，需要考虑错误处理、性能优化和资源管理等关键问题。

# 生产级搜索服务实现
import logging
import time
from contextlib import contextmanager
from tavily import TavilyClient, APIError, RateLimitError

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger("tavily-search-service")

class SearchService:
    """生产级搜索服务类"""
    
    def __init__(self, api_key, timeout=10, max_retries=3):
        self.client = TavilyClient(api_key=api_key)
        self.timeout = timeout
        self.max_retries = max_retries
        self.metrics = {
            "successful_searches": 0,
            "failed_searches": 0,
            "average_latency": 0.0
        }
    
    @contextmanager
    def measure_performance(self):
        """性能测量上下文管理器"""
        start_time = time.time()
        yield
        latency = time.time() - start_time
        
        # 更新平均延迟
        total = self.metrics["successful_searches"] + self.metrics["failed_searches"]
        if total == 0:
            self.metrics["average_latency"] = latency
        else:
            self.metrics["average_latency"] = (
                self.metrics["average_latency"] * total + latency
            ) / (total + 1)
    
    def search_with_retry(self, query, **kwargs):
        """带重试机制的搜索方法"""
        for attempt in range(self.max_retries):
            try:
                with self.measure_performance():
                    result = self.client.search(query, **kwargs)
                self.metrics["successful_searches"] += 1
                logger.info(f"搜索成功: {query[:50]}...")
                return result
            except RateLimitError:
                if attempt == self.max_retries - 1:
                    logger.error("达到API速率限制，所有重试均失败")
                    self.metrics["failed_searches"] += 1
                    raise
                # 指数退避策略
                sleep_time = (2 ** attempt) * 0.5
                logger.warning(f"速率限制，将在{sleep_time}秒后重试")
                time.sleep(sleep_time)
            except APIError as e:
                logger.error(f"API错误: {str(e)}")
                self.metrics["failed_searches"] += 1
                raise
            except Exception as e:
                logger.error(f"搜索失败: {str(e)}")
                self.metrics["failed_searches"] += 1
                raise
    
    def get_metrics(self):
        """获取服务指标"""
        return self.metrics

# 使用生产级搜索服务
try:
    search_service = SearchService("tvly-YOUR_API_KEY")
    result = search_service.search_with_retry(
        "人工智能在医疗领域的最新应用",
        topic="healthcare",
        days=90
    )
    print(f"搜索结果: {len(result.get('results', []))}条记录")
    print(f"服务指标: {search_service.get_metrics()}")
except Exception as e:
    print(f"搜索服务异常: {str(e)}")

2.3 分布式应用：会话池与异步处理

在高并发场景下，合理使用会话池和异步处理可以显著提升系统性能和资源利用率。

# 分布式搜索应用实现
import asyncio
from tavily.async_tavily import AsyncTavilyClient

class AsyncSearchService:
    """异步搜索服务"""
    
    def __init__(self, api_key, max_concurrent=10):
        self.client = AsyncTavilyClient(api_key=api_key)
        self.semaphore = asyncio.Semaphore(max_concurrent)
    
    async def async_search(self, query, **kwargs):
        """异步搜索方法"""
        async with self.semaphore:
            try:
                start_time = asyncio.get_event_loop().time()
                result = await self.client.search(query, **kwargs)
                latency = asyncio.get_event_loop().time() - start_time
                return {
                    "query": query,
                    "result": result,
                    "latency": latency,
                    "success": True
                }
            except Exception as e:
                return {
                    "query": query,
                    "error": str(e),
                    "success": False
                }
    
    async def batch_search(self, queries, **kwargs):
        """批量搜索处理"""
        tasks = [self.async_search(query, **kwargs) for query in queries]
        results = await asyncio.gather(*tasks)
        return results

# 使用异步搜索服务
async def run_batch_search():
    search_service = AsyncSearchService("tvly-YOUR_API_KEY")
    
    # 批量搜索查询
    queries = [
        "Python异步编程最佳实践",
        "分布式系统设计原则",
        "微服务架构优缺点",
        "数据湖 vs 数据仓库",
        "机器学习模型部署策略"
    ]
    
    # 执行批量搜索
    results = await search_service.batch_search(
        queries,
        topic="technology",
        max_results=5
    )
    
    # 处理结果
    for res in results:
        if res["success"]:
            print(f"查询: {res['query']}")
            print(f"耗时: {res['latency']:.2f}秒")
            print(f"结果数: {len(res['result'].get('results', []))}\n")
        else:
            print(f"查询失败: {res['query']}, 错误: {res['error']}\n")

# 运行异步搜索
asyncio.run(run_batch_search())

三、进阶技巧：优化搜索体验与性能

3.1 上下文搜索与RAG集成

Tavily SDK提供的get_search_context方法特别适合与RAG系统集成，为语言模型提供精准的外部知识支持。

# RAG系统集成示例
def build_rag_enhanced_qa(api_key):
    """构建基于RAG的增强问答系统
    
    Args:
        api_key (str): Tavily API密钥
        
    Returns:
        function: 增强问答函数
    """
    client = TavilyClient(api_key=api_key)
    
    def rag_qa(query, context_depth=3):
        """RAG增强问答
        
        Args:
            query (str): 用户问题
            context_depth (int): 上下文深度，控制返回结果数量
            
        Returns:
            str: 增强后的回答
        """
        # 获取搜索上下文
        context = client.get_search_context(
            query=query,
            max_results=context_depth
        )
        
        # 这里可以集成LLM进行回答生成
        # 简化示例：直接返回上下文信息
        return f"基于最新信息的回答:\n\n{context}"
    
    return rag_qa

# 构建RAG问答系统
rag_qa_system = build_rag_enhanced_qa("tvly-YOUR_API_KEY")

# 测试RAG问答
questions = [
    "什么是向量数据库？",
    "如何使用Python进行数据可视化？",
    "DevOps最佳实践有哪些？"
]

for question in questions:
    print(f"问: {question}")
    print(f"答: {rag_qa_system(question)}\n")

3.2 性能优化策略

针对不同规模的应用，Tavily SDK提供了多种性能优化策略，包括结果缓存、请求批处理和连接池管理等。

# 搜索性能优化示例
import hashlib
import json
from functools import lru_cache

class OptimizedSearchService:
    """优化的搜索服务，包含缓存和批处理功能"""
    
    def __init__(self, api_key, cache_size=100):
        self.client = TavilyClient(api_key=api_key)
        # 使用LRU缓存存储搜索结果
        self._search_cache = lru_cache(maxsize=cache_size)(self._raw_search)
    
    def _raw_search(self, query, **kwargs):
        """原始搜索方法，实际调用API"""
        return self.client.search(query, **kwargs)
    
    def cached_search(self, query, ttl=3600, **kwargs):
        """带缓存的搜索方法
        
        Args:
            query (str): 搜索查询
            ttl (int): 缓存过期时间(秒)，默认1小时
            **kwargs: 其他搜索参数
            
        Returns:
            dict: 搜索结果
        """
        # 生成缓存键，包含查询和参数
        cache_key = hashlib.md5(
            json.dumps({"query": query, "kwargs": kwargs}, sort_keys=True).encode()
        ).hexdigest()
        
        # 这里实际实现应包含缓存存储和TTL检查
        # 简化示例：直接调用带LRU缓存的搜索方法
        return self._search_cache(query, **kwargs)
    
    def batch_search_optimized(self, queries, **kwargs):
        """优化的批处理搜索
        
        对重复查询使用缓存，只对新查询发起API请求
        """
        results = {}
        unique_queries = list(set(queries))  # 去重
        
        # 处理每个唯一查询
        for query in unique_queries:
            results[query] = self.cached_search(query, **kwargs)
        
        # 按原始顺序返回结果
        return [results[query] for query in queries]

# 使用优化的搜索服务
optimized_service = OptimizedSearchService("tvly-YOUR_API_KEY")

# 包含重复查询的批处理请求
queries = [
    "Python性能优化技巧",
    "Python性能优化技巧",  # 重复查询，将命中缓存
    "机器学习模型评估指标"
]

results = optimized_service.batch_search_optimized(queries, max_results=3)
for i, result in enumerate(results):
    print(f"查询{i+1}结果数: {len(result.get('results', []))}")

3.3 问题排查与调试

在集成过程中，有效的问题排查和调试机制对于快速解决问题至关重要。以下是一些常见问题的诊断和解决方法。

# 搜索问题排查工具
def search_troubleshooter(api_key, query, **kwargs):
    """搜索问题排查工具
    
    帮助诊断搜索API调用失败的原因
    """
    diagnostic_info = {
        "timestamp": time.time(),
        "query": query,
        "parameters": kwargs,
        "success": False,
        "error": None,
        "debug_info": {}
    }
    
    try:
        # 尝试基本连接测试
        client = TavilyClient(api_key=api_key)
        
        # 添加调试信息
        diagnostic_info["debug_info"]["sdk_version"] = getattr(tavily, "__version__", "unknown")
        
        # 执行测试搜索
        start_time = time.time()
        response = client.search(query, **kwargs)
        diagnostic_info["latency"] = time.time() - start_time
        diagnostic_info["success"] = True
        diagnostic_info["result_summary"] = {
            "result_count": len(response.get("results", [])),
            "has_answer": "answer" in response,
            "sources": [r.get("url") for r in response.get("results", [])[:3]]
        }
        
        return {
            "status": "success",
            "message": "搜索请求成功完成",
            "diagnostics": diagnostic_info
        }
        
    except APIError as e:
        diagnostic_info["error"] = {
            "type": "APIError",
            "message": str(e),
            "code": getattr(e, "code", "unknown")
        }
    except RateLimitError:
        diagnostic_info["error"] = {
            "type": "RateLimitError",
            "message": "API调用频率超限，请稍后再试"
        }
    except Exception as e:
        diagnostic_info["error"] = {
            "type": type(e).__name__,
            "message": str(e)
        }
    
    return {
        "status": "error",
        "message": "搜索请求失败",
        "diagnostics": diagnostic_info,
        "suggestions": _generate_solutions(diagnostic_info["error"]["type"])
    }

def _generate_solutions(error_type):
    """根据错误类型生成解决方案建议"""
    solutions = {
        "APIError": [
            "检查API密钥是否有效",
            "验证请求参数是否符合API要求",
            "查阅API文档确认支持的功能"
        ],
        "RateLimitError": [
            "减少请求频率",
            "实现指数退避重试机制",
            "考虑升级API套餐以提高配额"
        ],
        "ConnectionError": [
            "检查网络连接",
            "验证防火墙设置是否阻止API请求",
            "确认API端点URL是否正确"
        ]
    }
    
    return solutions.get(error_type, ["请检查错误详情并查阅官方文档"])

# 使用排查工具诊断问题
diagnostics = search_troubleshooter(
    "tvly-YOUR_API_KEY",
    "排查测试查询",
    max_results=5
)

print(f"排查结果: {diagnostics['status']}")
if diagnostics["status"] == "error":
    print(f"错误信息: {diagnostics['diagnostics']['error']['message']}")
    print("建议解决方案:")
    for i, sol in enumerate(diagnostics["suggestions"], 1):
        print(f"{i}. {sol}")

四、生态拓展：与主流框架的集成方案

4.1 Web框架集成：Django/Flask应用案例

将Tavily搜索功能集成到Web应用中，可以为用户提供实时智能搜索体验。以下是与Flask框架的集成示例。

# Flask应用集成示例
from flask import Flask, request, jsonify
from tavily import TavilyClient
import os
import logging

# 初始化Flask应用
app = Flask(__name__)

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('tavily-flask-app')

# 从环境变量获取API密钥
TAVILY_API_KEY = os.environ.get('TAVILY_API_KEY')
if not TAVILY_API_KEY:
    logger.error("未设置TAVILY_API_KEY环境变量")
    raise RuntimeError("TAVILY_API_KEY环境变量未配置")

# 初始化Tavily客户端
tavily_client = TavilyClient(api_key=TAVILY_API_KEY)

@app.route('/api/search', methods=['POST'])
def search_endpoint():
    """搜索API端点"""
    try:
        data = request.get_json()
        if not data or 'query' not in data:
            return jsonify({
                'error': '缺少必要参数: query'
            }), 400
            
        query = data['query']
        params = {
            'max_results': data.get('max_results', 5),
            'topic': data.get('topic', None),
            'days': data.get('days', None)
        }
        
        # 过滤None值参数
        params = {k: v for k, v in params.items() if v is not None}
        
        # 执行搜索
        logger.info(f"处理搜索请求: {query}")
        result = tavily_client.search(query, **params)
        
        return jsonify({
            'success': True,
            'query': query,
            'results': result.get('results', []),
            'answer': result.get('answer', None)
        })
        
    except Exception as e:
        logger.error(f"搜索请求处理失败: {str(e)}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/qa', methods=['POST'])
def qa_endpoint():
    """问答API端点"""
    try:
        data = request.get_json()
        if not data or 'query' not in data:
            return jsonify({
                'error': '缺少必要参数: query'
            }), 400
            
        query = data['query']
        logger.info(f"处理问答请求: {query}")
        
        # 获取搜索上下文
        context = tavily_client.get_search_context(query)
        
        # 这里可以集成LLM生成回答
        # 简化示例：直接返回上下文
        return jsonify({
            'success': True,
            'query': query,
            'context': context
        })
        
    except Exception as e:
        logger.error(f"问答请求处理失败: {str(e)}")
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

if __name__ == '__main__':
    # 仅用于开发环境
    app.run(debug=True, host='0.0.0.0', port=5000)

4.2 容器化部署：Docker配置示例

为确保搜索服务的可靠部署和扩展，可以使用Docker容器化应用，简化环境配置和版本管理。

# Dockerfile - Tavily搜索服务容器配置
FROM python:3.9-slim

# 设置工作目录
WORKDIR /app

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    TAVILY_API_KEY=${TAVILY_API_KEY}

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件
COPY requirements.txt .

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 5000

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:5000/health || exit 1

# 启动命令
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app", "--workers", "4"]

# docker-compose.yml - 服务编排配置
version: '3.8'

services:
  tavily-search-service:
    build: .
    restart: always
    ports:
      - "5000:5000"
    environment:
      - TAVILY_API_KEY=${TAVILY_API_KEY}
      - LOG_LEVEL=INFO
    resources:
      limits:
        cpus: '1'
        memory: 1G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s

  # 可选：添加Redis用于缓存
  redis:
    image: redis:6-alpine
    restart: always
    volumes:
      - redis-data:/data
    ports:
      - "6379:6379"

volumes:
  redis-data:

4.3 混合检索增强生成（Hybrid RAG）

Tavily SDK提供了专门的Hybrid RAG模块，结合向量搜索和关键词搜索的优势，提升检索准确性和召回率。

# Hybrid RAG实现示例
from tavily.hybrid_rag import HybridRAG

def build_hybrid_rag_system(api_key):
    """构建混合检索增强生成系统
    
    Args:
        api_key (str): Tavily API密钥
        
    Returns:
        HybridRAG: 混合RAG系统实例
    """
    # 初始化Hybrid RAG系统
    rag_system = HybridRAG(
        api_key=api_key,
        # 配置向量存储
        vector_store_config={
            "type": "in_memory",  # 生产环境可使用pinecone、weaviate等
            "dimension": 768
        },
        # 配置检索参数
        retrieval_config={
            "search_depth": 5,
            "rerank": True,
            "similarity_threshold": 0.7
        }
    )
    
    return rag_system

def rag_pipeline_demo(rag_system):
    """RAG系统使用演示"""
    # 1. 添加文档到向量存储
    documents = [
        {
            "id": "doc1",
            "content": "Tavily API提供多种搜索模式，包括基础搜索、高级搜索和问答搜索。",
            "metadata": {"source": "tavily_docs", "category": "api"}
        },
        {
            "id": "doc2",
            "content": "Hybrid RAG结合了关键词搜索和向量搜索的优势，提供更准确的检索结果。",
            "metadata": {"source": "tavily_docs", "category": "rag"}
        }
    ]
    
    # 添加文档到向量存储
    rag_system.add_documents(documents)
    print("已添加示例文档到向量存储")
    
    # 2. 执行混合检索
    query = "什么是Hybrid RAG？它有什么优势？"
    print(f"\n查询: {query}")
    
    # 执行检索
    results = rag_system.retrieve(query, limit=3)
    print("\n检索结果:")
    for i, result in enumerate(results, 1):
        print(f"结果{i}:")
        print(f"内容: {result['content'][:100]}...")
        print(f"来源: {result['metadata']['source']}")
        print(f"相似度: {result['score']:.4f}\n")
    
    # 3. 生成回答（简化示例）
    context = "\n".join([r["content"] for r in results])
    print(f"生成回答:\n基于检索到的信息，{query}\n{context}")

# 构建并使用Hybrid RAG系统
hybrid_rag = build_hybrid_rag_system("tvly-YOUR_API_KEY")
rag_pipeline_demo(hybrid_rag)

附录：API参数速查表与常见问题

API参数速查表

方法	参数	描述	可选值	默认值
search	query	搜索关键词	字符串	必需
	topic	搜索主题分类	"news", "technology", "business", "healthcare", "science", "sports", "entertainment"	None
	type	内容类型	"web", "academic", "video", "image"	"web"
	days	时间范围（天）	整数	None
	max_results	最大结果数	1-50	5
	include_answer	是否包含AI回答	True/False	False
	include_raw_content	是否包含原始内容	True/False	False
	sort	排序方式	"relevance", "date"	"relevance"
qna_search	query	问题	字符串	必需
	context	是否返回上下文	True/False	False
get_search_context	query	搜索关键词	字符串	必需
	max_results	最大结果数	1-10	3
	context_depth	上下文深度	1-5	2