95%性能 + 85%成本节省？RouteLLM让AI推理聪明又省钱！ 原创

# 安装
pip install semantic-router

# 如果要完全本地化（不依赖API）
pip install "semantic-router[local]"

from semantic_router import Route
from semantic_router.encoders import OpenAIEncoder
from semantic_router.routers import SemanticRouter
import os

# 设置API密钥
os.environ["OPENAI_API_KEY"] = "your-api-key"

# 1. 定义路由规则 - 简单直观
order_route = Route(
    name="order",
    utterances=[
        "我的订单在哪里",
        "订单什么时候发货",
        "查询订单状态",
        "物流信息",
        "快递到哪了",
        "为什么还没发货",
        "订单号12345的状态",
        "配送需要多久",
        "可以改地址吗",
        "取消订单"
    ]
)

payment_route = Route(
    name="payment",
    utterances=[
        "支付失败了",
        "可以用信用卡吗",
        "支持哪些支付方式",
        "退款要多久",
        "发票怎么开",
        "可以分期吗",
        "支付安全吗",
        "怎么绑定银行卡"
    ]
)

product_route = Route(
    name="product",
    utterances=[
        "这个产品有什么功能",
        "产品参数",
        "有哪些颜色",
        "保修期多长",
        "使用说明",
        "产品对比",
        "推荐产品",
        "价格多少"
    ]
)

complaint_route = Route(
    name="complaint",
    utterances=[
        "我要投诉",
        "太差劲了",
        "服务态度不好",
        "产品有问题",
        "要求赔偿",
        "找你们经理",
        "这是欺诈"
    ]
)

# 2. 创建路由器
routes = [order_route, payment_route, product_route, complaint_route]
encoder = OpenAIEncoder()  # 也可以用 CohereEncoder() 或 HuggingFaceEncoder()
router = SemanticRouter(encoder=encoder, routes=routes)

# 3. 使用路由器
def handle_query(user_input: str):
    """处理用户查询"""
    decision = router(user_input)
    
    if decision.name == "order":
        return handle_order(user_input)
    elif decision.name == "payment":
        return handle_payment(user_input)
    elif decision.name == "product":
        return handle_product(user_input)
    elif decision.name == "complaint":
        return escalate_to_human(user_input)
    else:
        return handle_general(user_input)

# 测试
print(router("我昨天买的东西怎么还没发货"))  # -> Route(name='order')
print(router("可以用花呗支付吗"))           # -> Route(name='payment')
print(router("这个手机防水吗"))             # -> Route(name='product')

from semantic_router.encoders import HuggingFaceEncoder
from semantic_router.llms import LlamaCppLLM

# 使用本地嵌入模型
encoder = HuggingFaceEncoder(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

# 使用本地LLM（可选，用于动态路由）
llm = LlamaCppLLM(
    model_path="./models/llama-2-7b-chat.gguf",
    n_ctx=2048,
    n_gpu_layers=32# 如果有GPU
)

# 创建完全本地化的路由器
router = SemanticRouter(
    encoder=encoder,
    routes=routes,
    llm=llm  # 可选：当无法匹配时使用LLM判断
)

from semantic_router import Route

# 创建动态路由 - 可以执行函数
def get_order_status(order_id: str):
    # 查询订单系统
    returnf"订单 {order_id} 正在配送中"

def process_payment(amount: float, method: str):
    # 处理支付
    returnf"正在处理 {amount} 元的 {method} 支付"

# 动态路由可以提取参数并调用函数
dynamic_order_route = Route(
    name="order_status",
    utterances=[
        "订单[ORDER_ID]的状态",
        "查询订单[ORDER_ID]",
        "[ORDER_ID]到哪了"
    ],
    function=get_order_status,
    function_schema={
        "type": "object",
        "properties": {
            "order_id": {"type": "string"}
        }
    }
)

from semantic_router.index import QdrantIndex
from semantic_router.routers import SemanticRouter

# 使用Qdrant向量数据库存储路由
qdrant_index = QdrantIndex(
    url="http://localhost:6333",  # Qdrant服务地址
    collection_name="routes"
)

# 创建支持向量数据库的路由器
router = SemanticRouter(
    encoder=encoder,
    routes=routes,
    index=qdrant_index,  # 使用向量数据库索引
    auto_sync="local"     # 自动同步到本地
)

# 现在可以处理成千上万个路由规则

pip install routellm

from routellm.controller import Controller
import os

# 设置API密钥
os.environ["OPENAI_API_KEY"] = "your-openai-key"
os.environ["ANYSCALE_API_KEY"] = "your-anyscale-key"# 用于Mixtral

# 创建智能路由控制器
client = Controller(
    routers=["mf"],  # 使用matrix factorization路由器
    strong_model="gpt-4",  # 强模型（贵但效果好）
    weak_model="anyscale/mistralai/Mixtral-8x7B-Instruct-v0.1",  # 弱模型（便宜）
)

# 使用示例
def smart_query(question: str, importance: str = "normal"):
    """
    智能查询，根据重要性选择路由阈值
    importance: "low", "normal", "high"
    """
    
    # 根据重要性设置阈值
    thresholds = {
        "low": 0.3,     # 更多使用便宜模型
        "normal": 0.5,  # 平衡
        "high": 0.8     # 更多使用贵模型
    }
    
    threshold = thresholds.get(importance, 0.5)
    
    response = client.chat.completions.create(
        model=f"router-mf-{threshold}",
        messages=[
            {"role": "user", "content": question}
        ],
        temperature=0.7
    )
    
    return response.choices[0].message.content

# 测试不同复杂度的问题
simple_q = "今天星期几？"# 简单问题 -> 路由到Mixtral
complex_q = "解释量子计算的原理，并给出实际应用案例"# 复杂问题 -> 路由到GPT-4

print(smart_query(simple_q, "low"))     # 用便宜模型
print(smart_query(complex_q, "high"))   # 用贵模型

# config.yaml
model_providers:
  - provider: openai
    api_key: ${OPENAI_API_KEY}
    models:
      - gpt-4
      - gpt-3.5-turbo

  - provider: anyscale
    api_key: ${ANYSCALE_API_KEY}
    models:
      - mistralai/Mixtral-8x7B-Instruct-v0.1

routers:
  mf:
    checkpoint_path: "routellm/mf_gpt4_augmented"
    strong_model: "gpt-4"
    weak_model: "anyscale/mistralai/Mixtral-8x7B-Instruct-v0.1"

python -m routellm.openai_server --routers mf --config config.yaml --port 8000

import openai

openai.api_base = "http://localhost:8000/v1"
openai.api_key = "PLACEHOLDER"

response = openai.ChatCompletion.create(
    model="router-mf-0.5",  # 使用路由器
    messages=[{"role": "user", "content": "你好"}]
)

from llama_index.core import VectorStoreIndex, SummaryIndex, Document
from llama_index.core.tools import QueryEngineTool
from llama_index.core.query_engine.router_query_engine import RouterQueryEngine
from llama_index.core.selectors import LLMSingleSelector

# 创建不同类型的索引
documents = [
    Document(text="公司2024年营收100亿..."),
    Document(text="产品使用说明..."),
    Document(text="技术文档...")
]

# 向量索引 - 用于语义搜索
vector_index = VectorStoreIndex.from_documents(
    documents[:2]
)

# 摘要索引 - 用于总结
summary_index = SummaryIndex.from_documents(
    documents[2:]
)

# 创建查询工具
vector_tool = QueryEngineTool.from_defaults(
    query_engine=vector_index.as_query_engine(),
    description="用于查找具体信息和事实"
)

summary_tool = QueryEngineTool.from_defaults(
    query_engine=summary_index.as_query_engine(),
    description="用于获取总结和概览"
)

# 创建路由查询引擎
router_query_engine = RouterQueryEngine(
    selector=LLMSingleSelector.from_defaults(),
    query_engine_tools=[vector_tool, summary_tool]
)

# 使用路由器
response = router_query_engine.query("公司去年的营收是多少？")  # -> 路由到vector_tool
response = router_query_engine.query("总结一下技术文档")      # -> 路由到summary_tool

from llama_index.core.query_engine import SimpleMultiModalQueryEngine
from llama_index.core.indices import MultiModalVectorStoreIndex

class MultiModalRouter:
    """多模态路由器"""
    
    def __init__(self):
        # 文本查询引擎
        self.text_engine = self._create_text_engine()
        
        # 图像查询引擎
        self.image_engine = self._create_image_engine()
        
        # 混合查询引擎
        self.hybrid_engine = self._create_hybrid_engine()
    
    def route(self, query: str, has_image: bool = False):
        """根据查询类型路由"""
        
        # 检测查询意图
        if any(word in query.lower() for word in ["图片", "图像", "照片", "看"]):
            return self.image_engine.query(query)
        elif has_image:
            return self.hybrid_engine.query(query)
        else:
            return self.text_engine.query(query)
    
    def _create_text_engine(self):
        # 创建文本查询引擎
        pass
    
    def _create_image_engine(self):
        # 创建图像查询引擎
        pass
    
    def _create_hybrid_engine(self):
        # 创建混合查询引擎
        pass

from llama_index.core.tools import FunctionTool
from llama_index.core.agent import ReActAgent

# 定义工具函数
def search_product(product_name: str) -> str:
    """搜索产品信息"""
    # 实现产品搜索逻辑
    returnf"找到产品: {product_name}"

def calculate_price(quantity: int, unit_price: float) -> float:
    """计算总价"""
    return quantity * unit_price

def check_inventory(product_id: str) -> int:
    """检查库存"""
    # 实现库存查询
    return100# 示例返回值

# 创建工具
tools = [
    FunctionTool.from_defaults(
        fn=search_product,
        description="搜索产品信息"
    ),
    FunctionTool.from_defaults(
        fn=calculate_price,
        description="计算价格"
    ),
    FunctionTool.from_defaults(
        fn=check_inventory,
        description="检查库存数量"
    )
]

# 创建智能代理（自动路由到合适的工具）
agent = ReActAgent.from_tools(
    tools,
    verbose=True
)

# 使用代理
response = agent.chat("iPhone 15 Pro有货吗？")  # 自动路由到check_inventory
response = agent.chat("10个单价99元的商品总价是多少？")  # 自动路由到calculate_price

你的主要需求是什么？
│
├─ 需要极快的响应速度？(<50ms)
│  └─ 选择 Semantic Router
│
├─ 需要控制API成本？
│  └─ 选择 RouteLLM
│
├─ 需要复杂的查询能力？
│  ├─ 需要多模态？
│  │  └─ 选择 LlamaIndex
│  └─ 只需要文本？
│     └─ 选择 Semantic Router + LlamaIndex 组合
│
└─ 需要简单快速上线？
   └─ 选择 Semantic Router

class HybridRouter:
    """混合路由器 - 结合多个开源方案的优势"""
    
    def __init__(self):
        # 第一层：Semantic Router处理常见查询（最快）
        self.semantic_router = self._init_semantic_router()
        
        # 第二层：RouteLLM处理复杂查询（成本优化）
        self.cost_router = self._init_routellm()
        
        # 第三层：LlamaIndex处理专业查询（功能强大）
        self.index_router = self._init_llamaindex()
    
    asyncdef route(self, query: str, context: dict = None):
        """三层路由策略"""
        
        # 1. 尝试快速语义路由
        semantic_result = self.semantic_router(query)
        if semantic_result.confidence > 0.8:
            return self.handle_semantic_result(semantic_result)
        
        # 2. 评估查询复杂度，决定是否需要贵模型
        if self.is_complex_query(query):
            returnawait self.cost_router.route_complex(query)
        
        # 3. 对于需要检索的查询，使用LlamaIndex
        if self.needs_retrieval(query):
            return self.index_router.query(query)
        
        # 默认处理
        return self.default_handler(query)

import time
from prometheus_client import Counter, Histogram, Gauge

# Prometheus指标
route_counter = Counter('routing_total', 'Total routing requests', ['router', 'route'])
route_latency = Histogram('routing_latency_seconds', 'Routing latency', ['router'])
route_errors = Counter('routing_errors_total', 'Routing errors', ['router', 'error_type'])

def monitor_routing(router_name: str):
    """路由监控装饰器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            start = time.time()
            try:
                result = func(*args, **kwargs)
                route_counter.labels(router=router_name, route=result.get('route', 'unknown')).inc()
                return result
            except Exception as e:
                route_errors.labels(router=router_name, error_type=type(e).__name__).inc()
                raise
            finally:
                route_latency.labels(router=router_name).observe(time.time() - start)
        return wrapper
    return decorator

# 使用监控
@monitor_routing("semantic_router")
def semantic_route(query):
    return router(query)