如果你正在使用大语言模型LLM进行开发很可能已经感受到了成本压力调用 API 的费用像流水一样尤其是在处理大量对话、长文本分析或复杂推理任务时。更让人头疼的是不同的模型提供商如 OpenAI、Anthropic、Google 等在价格、性能、上下文长度和特定任务能力上差异巨大。选择一个固定的模型往往意味着在成本、速度或质量上做出妥协。但有没有一种方法既能保证任务执行的质量又能动态选择最经济的模型从而显著降低开销这正是 Best-Execution for Intelligence智能最优执行策略要解决的核心问题。本文将深入探讨如何通过一套系统性的方法将 LLM 的应用成本降低 50% 甚至更多。这不仅仅是切换模型那么简单而是涉及路由策略、成本监控、回退机制和效果评估的完整工程实践。我们将从实际痛点出发逐步拆解 Best-Execution 的核心原理并提供从环境准备、策略配置、代码实现到效果验证的完整操作指南。无论你是个人开发者还是技术团队的负责人都能从中找到可落地的方案。1. 为什么单纯的模型降价无法解决根本问题许多团队的第一反应是寻找更便宜的模型替代品。例如从 GPT-4 切换到 GPT-3.5-Turbo或者尝试一些开源模型。这种做法确实能立即看到成本下降但往往伴随着质量损失更弱的推理能力、更差的指令跟随甚至更高的错误率导致需要人工复查或重试反而增加了综合成本。真正的瓶颈在于静态绑定。将一个应用或一个任务类型固定绑定到某个特定模型无法适应动态变化的需求和资源环境。Best-Execution 策略的核心思想是动态路由根据任务类型、实时价格、性能指标和历史表现智能地将请求分发到当前最优的模型上。这里的最优是一个多目标权衡包括成本、延迟、准确性和任务匹配度。2. Best-Execution 的核心概念与适用场景2.1 什么是 Best-ExecutionBest-Execution 源于金融交易领域指在执客户订单时经纪商有义务寻求最有利的执行条件如最佳价格、最快速度。将其类比到 LLM 应用领域意味着系统有责任为每个查询请求选择最能平衡成本、质量和延迟的模型执行端点。一个典型的 Best-Execution 系统包含以下组件路由决策器根据预设策略决定将请求发送到哪个模型。成本计算器实时或近实时计算不同模型处理当前请求的预估成本。性能监控器跟踪各模型的响应延迟、错误率等。质量评估器对模型输出进行质量评估可通过规则、简单模型或人工反馈。回退机制当首选模型失败或超时时自动切换到备用模型。2.2 哪些场景最适合采用 Best-Execution对话型应用用户问题难度差异大简单问题可用廉价模型复杂推理需要更强模型。内容生成与摘要对质量要求有弹性的任务可以优先选择性价比高的模型。批量数据处理处理大量文档时成本敏感度高适合动态选择模型。多租户SaaS服务需要为不同客户群体平衡成本与服务等级协议SLA。2.3 关键权衡成本 vs. 质量 vs. 延迟实施 Best-Execution 不是追求绝对的最低成本而是找到适合业务需求的最佳平衡点。以下是一个简单的决策框架业务优先级推荐策略潜在牺牲成本敏感型优先选择低成本模型设置质量阈值响应时间可能波动质量偶尔下降质量优先型以高质量模型为主低成本模型处理简单任务成本节约空间有限延迟敏感型选择低延迟模型忽略小幅成本差异成本较高模型能力可能受限3. 环境准备与工具选择3.1 基础环境要求在开始实现 Best-Execution 策略前需要准备以下环境Python 3.8本文示例以 Python 为主但概念适用于任何语言。API 密钥准备多个 LLM 提供商的 API 密钥如 OpenAI、AnthropicClaude、Google AIGemini等。简单的数据存储用于记录请求日志和性能指标可以是 SQLite、PostgreSQL 或简单的文件存储。3.2 推荐的工具库# requirements.txt 示例 openai1.0.0 anthropic0.7.0 google-generativeai0.3.0 litellm1.0.0 # 统一的LLM调用抽象层 pydantic2.0.0 # 数据验证 requests2.28.0 # HTTP请求 sqlalchemy2.0.0 # 数据库操作可选 pandas1.5.0 # 数据分析可选特别推荐litellm库它提供了统一的接口来调用多个 LLM 提供商简化了不同 API 的差异处理。4. 构建基础的成本监控系统在实现复杂的路由策略前首先需要建立成本追踪能力。这是优化决策的数据基础。4.1 定义统一请求记录格式from pydantic import BaseModel from datetime import datetime from enum import Enum from typing import Optional, Dict, Any class ModelProvider(str, Enum): OPENAI openai ANTHROPIC anthropic GOOGLE google # 可扩展其他提供商 class LLMRequestRecord(BaseModel): request_id: str timestamp: datetime model_used: str provider: ModelProvider prompt_tokens: int completion_tokens: int total_tokens: int cost_usd: float response_time_ms: int success: bool error_message: Optional[str] None user_id: Optional[str] None task_type: str # 如 chat, summarization, analysis4.2 实现成本计算器不同模型的计价方式不同需要统一换算class CostCalculator: 统一计算不同模型的调用成本 # 示例价格美元/百万tokens请以各提供商最新价格为准 MODEL_PRICES { openai:gpt-4: {input: 30.0, output: 60.0}, # $30/1M input, $60/1M output openai:gpt-3.5-turbo: {input: 1.5, output: 2.0}, anthropic:claude-3-sonnet: {input: 3.0, output: 15.0}, google:gemini-pro: {input: 0.5, output: 1.5}, # 示例价格 } classmethod def calculate_cost(cls, model: str, input_tokens: int, output_tokens: int) - float: 计算指定模型的调用成本 if model not in cls.MODEL_PRICES: # 默认使用较高价格避免低估 return (input_tokens * 30.0 / 1_000_000) (output_tokens * 60.0 / 1_000_000) prices cls.MODEL_PRICES[model] input_cost (input_tokens * prices[input]) / 1_000_000 output_cost (output_tokens * prices[output]) / 1_000_000 return input_cost output_cost classmethod def estimate_cost(cls, model: str, prompt: str, estimated_output_length: int 500) - float: 预估给定提示词和预期输出长度的成本 # 简化估算使用平均token长度 input_tokens_est len(prompt) // 4 # 粗略估算4字符/token output_tokens_est estimated_output_length // 4 return cls.calculate_cost(model, input_tokens_est, output_tokens_est)5. 核心路由策略实现5.1 基础路由器类设计from abc import ABC, abstractmethod import asyncio from typing import List, Dict, Any class BaseRouter(ABC): 路由策略基类 def __init__(self, available_models: List[Dict[str, Any]]): self.available_models available_models self.performance_stats {} # 存储各模型性能统计 abstractmethod async def select_model(self, prompt: str, task_type: str, **kwargs) - str: 选择最适合的模型 pass def update_performance(self, model: str, success: bool, response_time: float, cost: float): 更新模型性能统计 if model not in self.performance_stats: self.performance_stats[model] { total_requests: 0, successful_requests: 0, total_response_time: 0, total_cost: 0, last_updated: None } stats self.performance_stats[model] stats[total_requests] 1 if success: stats[successful_requests] 1 stats[total_response_time] response_time stats[total_cost] cost stats[last_updated] datetime.now()5.2 成本优先路由策略class CostFirstRouter(BaseRouter): 成本优先路由在满足质量要求的前提下选择最便宜的模型 def __init__(self, available_models: List[Dict[str, Any]], max_response_time: int 10000): super().__init__(available_models) self.max_response_time max_response_time # 最大可接受响应时间(ms) self.cost_calculator CostCalculator() async def select_model(self, prompt: str, task_type: str, **kwargs) - str: 基于成本预估选择模型 qualified_models [] for model_info in self.available_models: # 检查模型是否适用于当前任务类型 if task_type not in model_info.get(supported_tasks, [chat]): continue # 预估成本 estimated_cost self.cost_calculator.estimate_cost( model_info[model_id], prompt, kwargs.get(estimated_output_length, 500) ) # 检查性能历史如果有 model_stats self.performance_stats.get(model_info[model_id], {}) avg_response_time ( model_stats.get(total_response_time, 0) / max(1, model_stats.get(total_requests, 1)) ) if model_stats else model_info.get(avg_response_time, 5000) # 只有响应时间可接受的模型才考虑 if avg_response_time self.max_response_time: qualified_models.append({ model_id: model_info[model_id], estimated_cost: estimated_cost, avg_response_time: avg_response_time, success_rate: ( model_stats.get(successful_requests, 1) / max(1, model_stats.get(total_requests, 1)) ) if model_stats else model_info.get(success_rate, 0.95) }) if not qualified_models: # 没有合格模型返回默认模型 return self.available_models[0][model_id] # 按成本排序选择最便宜的合格模型 qualified_models.sort(keylambda x: x[estimated_cost]) return qualified_models[0][model_id]5.3 质量保证路由策略class QualityAwareRouter(BaseRouter): 质量感知路由对关键任务保证质量对简单任务优化成本 def __init__(self, available_models: List[Dict[str, Any]], quality_threshold: float 0.8): super().__init__(available_models) self.quality_threshold quality_threshold self.cost_calculator CostCalculator() async def select_model(self, prompt: str, task_type: str, **kwargs) - str: 基于任务关键性和复杂度选择模型 # 评估任务复杂度简化版基于提示词长度和内容 task_complexity self.assess_task_complexity(prompt, task_type) if task_complexity high: # 高复杂度任务选择最强模型保证质量 return self.select_best_model() elif task_complexity medium: # 中等复杂度平衡质量和成本 return self.select_balanced_model() else: # 低复杂度成本优先 return self.select_cost_effective_model() def assess_task_complexity(self, prompt: str, task_type: str) - str: 评估任务复杂度实际项目中可引入更复杂的评估逻辑 prompt_length len(prompt) # 基于提示词长度和内容的简单启发式评估 complex_keywords [分析, 推理, 比较, 评估, 解释原因, 为什么] has_complex_content any(keyword in prompt for keyword in complex_keywords) if prompt_length 1000 or has_complex_content or task_type in [analysis, reasoning]: return high elif prompt_length 300 or task_type in [summarization, classification]: return medium else: return low def select_best_model(self) - str: 选择能力最强的模型 # 通常是最贵但能力最强的模型 best_models [m for m in self.available_models if gpt-4 in m[model_id] or claude-3 in m[model_id]] return best_models[0][model_id] if best_models else self.available_models[0][model_id] def select_balanced_model(self) - str: 选择平衡型的模型 balanced_models [m for m in self.available_models if gpt-3.5 in m[model_id] or claude-3-haiku in m[model_id]] return balanced_models[0][model_id] if balanced_models else self.available_models[0][model_id] def select_cost_effective_model(self) - str: 选择成本最优的模型 cost_effective_models [m for m in self.available_models if turbo in m[model_id] or haiku in m[model_id] or gemini in m[model_id]] return cost_effective_models[0][model_id] if cost_effective_models else self.available_models[0][model_id]6. 完整的最佳执行系统实现6.1 统一执行器类import logging from typing import Optional, Callable class BestExecutionLLM: 智能最优执行LLM系统 def __init__(self, router: BaseRouter, fallback_models: List[str] None): self.router router self.fallback_models fallback_models or [] self.logger logging.getLogger(__name__) self.request_history [] async def execute( self, prompt: str, task_type: str chat, max_retries: int 2, quality_validator: Optional[Callable] None, **kwargs ) - Dict[str, Any]: 执行LLM请求自动选择最优模型 selected_model await self.router.select_model(prompt, task_type, **kwargs) self.logger.info(fSelected model: {selected_model} for task: {task_type}) # 尝试执行支持重试和回退 for attempt in range(max_retries 1): model_to_try selected_model if attempt 0 else self._get_fallback_model(attempt) if model_to_try is None: break # 没有更多可回退的模型 try: start_time datetime.now() response await self._call_model(model_to_try, prompt, **kwargs) response_time (datetime.now() - start_time).total_seconds() * 1000 # 计算成本 cost self._calculate_cost(model_to_try, prompt, response) # 质量验证如果提供了验证器 quality_score 1.0 if quality_validator: quality_score quality_validator(response, prompt) # 记录请求 self._record_request( model_to_try, prompt, response, response_time, cost, True, None, task_type, quality_score ) # 更新路由器性能统计 self.router.update_performance(model_to_try, True, response_time, cost) return { model_used: model_to_try, response: response, response_time_ms: response_time, cost_usd: cost, quality_score: quality_score, attempts: attempt 1, success: True } except Exception as e: self.logger.warning(fAttempt {attempt 1} failed with model {model_to_try}: {str(e)}) # 记录失败请求 self._record_request( model_to_try, prompt, None, 0, 0, False, str(e), task_type, 0 ) self.router.update_performance(model_to_try, False, 0, 0) if attempt max_retries: # 最后一次尝试也失败 return { model_used: model_to_try, response: None, error: str(e), attempts: attempt 1, success: False } def _get_fallback_model(self, attempt: int) - Optional[str]: 获取回退模型 if attempt - 1 len(self.fallback_models): return self.fallback_models[attempt - 1] return None async def _call_model(self, model: str, prompt: str, **kwargs) - str: 调用具体模型简化示例实际应使用litellm等库 # 这里使用伪代码实际实现需要集成具体模型的SDK if openai in model: return await self._call_openai(model, prompt, **kwargs) elif anthropic in model: return await self._call_anthropic(model, prompt, **kwargs) elif google in model: return await self._call_google(model, prompt, **kwargs) else: raise ValueError(fUnsupported model: {model}) def _calculate_cost(self, model: str, prompt: str, response: str) - float: 计算实际成本 # 简化计算实际应根据token数量精确计算 input_tokens len(prompt) // 4 output_tokens len(response) // 4 return CostCalculator.calculate_cost(model, input_tokens, output_tokens) def _record_request(self, model: str, prompt: str, response: Optional[str], response_time: float, cost: float, success: bool, error: Optional[str], task_type: str, quality_score: float): 记录请求历史 record { timestamp: datetime.now(), model: model, prompt_length: len(prompt), response_length: len(response) if response else 0, response_time_ms: response_time, cost_usd: cost, success: success, error: error, task_type: task_type, quality_score: quality_score } self.request_history.append(record)6.2 配置示例与系统初始化# 系统配置示例 def setup_best_execution_system(): 设置最佳执行系统 # 可用模型配置 available_models [ { model_id: openai:gpt-4, supported_tasks: [chat, analysis, reasoning, summarization], avg_response_time: 3000, success_rate: 0.98, description: 最强能力高成本 }, { model_id: openai:gpt-3.5-turbo, supported_tasks: [chat, summarization, classification], avg_response_time: 1500, success_rate: 0.99, description: 平衡型性价比高 }, { model_id: anthropic:claude-3-haiku, supported_tasks: [chat, summarization, analysis], avg_response_time: 2000, success_rate: 0.97, description: 快速响应成本较低 }, { model_id: google:gemini-pro, supported_tasks: [chat, summarization], avg_response_time: 1800, success_rate: 0.96, description: 谷歌模型特定任务表现好 } ] # 创建路由器 router QualityAwareRouter(available_models, quality_threshold0.85) # 回退模型顺序 fallback_models [openai:gpt-3.5-turbo, anthropic:claude-3-haiku, google:gemini-pro] # 创建最佳执行系统 llm_system BestExecutionLLM(router, fallback_models) return llm_system # 使用示例 async def demo_usage(): 演示如何使用最佳执行系统 system setup_best_execution_system() # 简单任务 - 期望系统选择低成本模型 simple_prompt 请将以下英文翻译成中文Hello, how are you today? result1 await system.execute(simple_prompt, task_typetranslation) print(f简单任务结果: {result1}) # 复杂任务 - 期望系统选择高质量模型 complex_prompt 请分析以下商业场景并给出建议 我们是一家SaaS公司主要产品是项目管理工具。最近发现用户流失率上升 特别是中小型企业客户。请分析可能的原因并提出改进策略。 result2 await system.execute(complex_prompt, task_typeanalysis) print(f复杂任务结果: {result2}) # 查看成本节约情况 total_cost sum(r[cost_usd] for r in system.request_history if r[success]) print(f总成本: ${total_cost:.4f})7. 效果验证与性能监控7.1 成本节约验证方法要验证 Best-Execution 策略的实际效果需要建立对比基准import matplotlib.pyplot as plt import pandas as pd from datetime import datetime, timedelta class PerformanceAnalyzer: 性能分析器验证成本节约效果 def __init__(self, llm_system: BestExecutionLLM): self.llm_system llm_system self.df_requests pd.DataFrame(llm_system.request_history) def analyze_cost_savings(self, baseline_model: str openai:gpt-4): 分析与固定使用基准模型相比的成本节约 if self.df_requests.empty: return {error: No request data available} # 计算实际总成本 actual_total_cost self.df_requests[cost_usd].sum() # 计算如果全部使用基准模型的成本 baseline_costs [] for _, row in self.df_requests.iterrows(): prompt_length row[prompt_length] response_length row[response_length] if row[success] else 0 baseline_cost CostCalculator.calculate_cost( baseline_model, prompt_length // 4, response_length // 4 ) baseline_costs.append(baseline_cost) baseline_total_cost sum(baseline_costs) # 计算节约 savings baseline_total_cost - actual_total_cost savings_percentage (savings / baseline_total_cost) * 100 if baseline_total_cost 0 else 0 return { actual_total_cost: actual_total_cost, baseline_total_cost: baseline_total_cost, cost_savings: savings, savings_percentage: savings_percentage, requests_processed: len(self.df_requests) } def visualize_performance(self): 可视化性能指标 if self.df_requests.empty: return # 创建子图 fig, ((ax1, ax2), (ax3, ax4)) plt.subplots(2, 2, figsize(12, 10)) # 1. 各模型使用分布 model_usage self.df_requests[model].value_counts() ax1.pie(model_usage.values, labelsmodel_usage.index, autopct%1.1f%%) ax1.set_title(模型使用分布) # 2. 成本随时间变化 self.df_requests[hour] self.df_requests[timestamp].dt.hour hourly_cost self.df_requests.groupby(hour)[cost_usd].sum() ax2.bar(hourly_cost.index, hourly_cost.values) ax2.set_title(每小时成本分布) ax2.set_xlabel(小时) ax2.set_ylabel(成本(USD)) # 3. 各任务类型成本对比 task_cost self.df_requests.groupby(task_type)[cost_usd].sum() ax3.bar(task_cost.index, task_cost.values) ax3.set_title(各任务类型成本) ax3.set_ylabel(成本(USD)) # 4. 质量分数分布 successful_requests self.df_requests[self.df_requests[success]] ax4.hist(successful_requests[quality_score], bins10, alpha0.7) ax4.set_title(质量分数分布) ax4.set_xlabel(质量分数) ax4.set_ylabel(请求数量) plt.tight_layout() plt.show()7.2 运行验证示例# 验证脚本 async def validate_system_performance(): 验证系统性能 system setup_best_execution_system() # 模拟一批测试请求 test_requests [ (简单问候, chat, Hello, how are you?), (文本摘要, summarization, 长文本摘要测试... * 50), # 长文本 (复杂分析, analysis, 请分析当前AI市场的竞争格局和未来趋势...), (代码生成, coding, 用Python实现快速排序算法), ] print(开始性能测试...) for i, (desc, task_type, prompt) in enumerate(test_requests): print(f处理请求 {i1}/{len(test_requests)}: {desc}) result await system.execute(prompt, task_typetask_type) if result[success]: print(f 成功 - 模型: {result[model_used]}, 成本: ${result[cost_usd]:.6f}, 耗时: {result[response_time_ms]:.0f}ms) else: print(f 失败 - 错误: {result.get(error, Unknown error)}) # 分析性能 analyzer PerformanceAnalyzer(system) savings_report analyzer.analyze_cost_savings() print(\n 成本节约分析 ) print(f处理请求数量: {savings_report[requests_processed]}) print(f实际总成本: ${savings_report[actual_total_cost]:.4f}) print(f基准模型总成本: ${savings_report[baseline_total_cost]:.4f}) print(f成本节约: ${savings_report[cost_savings]:.4f}) print(f节约比例: {savings_report[savings_percentage]:.1f}%) # 显示可视化图表 analyzer.visualize_performance() # 运行验证 if __name__ __main__: import asyncio asyncio.run(validate_system_performance())8. 常见问题与排查方法在实际实施 Best-Execution 策略时可能会遇到以下典型问题8.1 路由决策不准确问题现象系统频繁选择不合适的模型导致质量下降或成本过高。排查步骤检查任务复杂度评估逻辑是否合理验证模型支持的任务类型配置是否正确分析历史性能数据是否准确反映了模型能力解决方案# 优化任务评估函数 def improved_complexity_assessment(prompt: str, task_type: str) - str: 改进的任务复杂度评估 # 添加更多特征提问句式、关键词密度、语义复杂度等 features { length: len(prompt), question_marks: prompt.count(?), complex_verbs: count_complex_verbs(prompt), technical_terms: count_technical_terms(prompt) } # 使用加权评分 score (features[length] * 0.3 features[question_marks] * 0.2 features[complex_verbs] * 0.25 features[technical_terms] * 0.25) if score 0.7: return high elif score 0.3: return medium else: return low8.2 回退机制失效问题现象主模型失败时回退模型也失败导致服务不可用。排查步骤检查回退模型列表是否配置了真正可用的备用模型验证网络连接和API密钥有效性检查错误处理逻辑是否完整解决方案# 增强回退机制 class RobustBestExecutionLLM(BestExecutionLLM): 增强版的Best-Execution系统 async def execute_with_robust_fallback(self, prompt: str, **kwargs): 带健康检查的增强执行 # 先检查所有模型的健康状态 healthy_models await self._check_model_health() if not healthy_models: raise Exception(No healthy models available) # 只从健康模型中选择 original_models self.router.available_models self.router.available_models [m for m in original_models if m[model_id] in healthy_models] try: return await self.execute(prompt, **kwargs) finally: self.router.available_models original_models async def _check_model_health(self) - List[str]: 检查模型健康状态 healthy_models [] for model_info in self.router.available_models: try: # 发送简单测试请求验证模型可用性 test_result await self._call_model(model_info[model_id], Test, max_tokens5) healthy_models.append(model_info[model_id]) except Exception: self.logger.warning(fModel {model_info[model_id]} is unhealthy) return healthy_models8.3 成本计算不准确问题现象预估成本与实际账单差异较大。排查步骤验证token计数方法是否正确检查价格表是否及时更新确认是否有隐藏费用如API调用次数费解决方案# 精确token计数 def accurate_token_count(text: str, model: str) - int: 根据模型使用相应的tokenizer进行精确计数 if gpt in model: # 使用tiktoken库进行OpenAI模型token计数 import tiktoken encoding tiktoken.encoding_for_model(model.split(:)[-1]) return len(encoding.encode(text)) elif claude in model: # Anthropic模型的近似计数 return len(text) // 3.5 # 近似值 else: # 默认估算 return len(text) // 4 # 更新成本计算器 class AccurateCostCalculator(CostCalculator): 使用精确token计数的成本计算器 classmethod def calculate_cost(cls, model: str, input_text: str, output_text: str) - float: 基于精确token计数计算成本 input_tokens accurate_token_count(input_text, model) output_tokens accurate_token_count(output_text, model) return super().calculate_cost(model, input_tokens, output_tokens)9. 最佳实践与生产环境建议9.1 渐进式部署策略在生产环境实施 Best-Execution 时建议采用渐进式部署影子模式先运行但不实际使用路由结果只记录决策和对比数据小流量测试对少量流量启用路由验证效果逐步扩大根据验证结果逐步扩大流量比例持续监控建立实时监控告警机制9.2 性能优化建议# 缓存优化 import redis import json from hashlib import md5 class CachedBestExecutionLLM(BestExecutionLLM): 带缓存的最佳执行系统 def __init__(self, *args, redis_url: str redis://localhost:6379, **kwargs): super().__init__(*args, **kwargs) self.redis_client redis.from_url(redis_url) self.cache_ttl 3600 # 1小时缓存 async def execute(self, prompt: str, **kwargs) - Dict[str, Any]: 带缓存的执行方法 cache_key self._generate_cache_key(prompt, kwargs) cached_result self.redis_client.get(cache_key) if cached_result: return json.loads(cached_result) # 执行并缓存结果 result await super().execute(prompt, **kwargs) if result[success]: self.redis_client.setex(cache_key, self.cache_ttl, json.dumps(result)) return result def _generate_cache_key(self, prompt: str, kwargs: Dict) - str: 生成缓存键 content prompt json.dumps(kwargs, sort_keysTrue) return fllm_cache:{md5(content.encode()).hexdigest()}9.3 安全与合规考虑数据隐私敏感数据避免发送到第三方API或使用企业版API速率限制遵守各平台的速率限制实现适当的退避机制审计日志保留完整的请求日志用于合规审计预算控制实现硬性预算限制防止意外费用9.4 团队协作规范配置管理使用