多模型适配器模式:用 Rust Trait 统一接入 DeepSeek、Claude 与本地 Ollama

在我们的抓包分析器中,AI 诊断模块是核心亮点之一。然而,不同的用户和部署环境有着多样化的模型诉求:
- 在日常开发和公开云端测试时,用户倾向于使用高性价比的 DeepSeek API;
- 在涉及企业内网敏感报文诊断时,出于数据隐私与合规要求,用户希望直接连接本地通过 Ollama 部署的离线开源小模型;
- 在进行深度安全漏洞因果推断时,可能需要切换到 Claude 或其他高智力模型。
如果针对每个不同的模型厂商都写一套独立的调用逻辑,代码库很快就会变得臃肿混乱。
在 Rust 中,**基于 Trait 的适配器模式(Adapter Pattern)与依赖注入(Dependency Injection)**是实现多后端解耦的最佳范式。今天这篇文章,我们在 packet-ai 模块中设计一套统一、抽象、且支持动态多态与静态分发的多模型适配器体系。
1. 适配器架构设计与异步 Trait 契约
在 Rust 1.75+ 中,标准库已经原生支持了 async fn in traits(AFIT)。我们定义一个统一的 LlmProviderAdapter Trait:
┌───────────────────────────────┐
│ trait LlmProviderAdapter │
│ + diagnose_stream(...) │
│ + provider_name() │
└───────────────┬───────────────┘
│
┌───────────────────────┼───────────────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ DeepSeek │ │ Ollama │ │ Claude │
│ Adapter │ │ LocalAdapter │ │ Adapter │
└──────────────┘ └──────────────┘ └──────────────┘
2. 定义通用流式诊断 Trait
在 crates/packet-ai/src/adapter.rs 中:
// crates/packet-ai/src/adapter.rs
use crate::client::AiClientError;
use futures_util::Stream;
use std::pin::Pin;
pub type DiagnosticStream = Pin<Box<dyn Stream<Item = Result<String, AiClientError>> + Send>>;
/// 统一的 AI 模型服务提供商适配器特征
pub trait LlmProviderAdapter: Send + Sync {
/// 服务商名称标识(用于日志与 TUI 展现)
fn provider_name(&self) -> &'static str;
/// 发起流式诊断请求
fn stream_diagnose(
&self,
system_prompt: &str,
anomaly_context: &str,
) -> Pin<Box<dyn std::future::Future<Output = Result<DiagnosticStream, AiClientError>> + Send + '_>>;
}
3. 实现 DeepSeek / OpenAI 兼容适配器
在 crates/packet-ai/src/providers/openai_compatible.rs 中:
// crates/packet-ai/src/providers/openai_compatible.rs
use crate::adapter::{DiagnosticStream, LlmProviderAdapter};
use crate::client::AiClientError;
use crate::stream_client::stream_diagnose;
use reqwest::Client;
use std::pin::Pin;
pub struct OpenAiCompatibleAdapter {
client: Client,
provider_tag: &'static str,
base_url: String,
api_key: String,
model_name: String,
}
impl OpenAiCompatibleAdapter {
pub fn new(
provider_tag: &'static str,
base_url: impl Into<String>,
api_key: impl Into<String>,
model_name: impl Into<String>,
) -> Self {
Self {
client: Client::new(),
provider_tag,
base_url: base_url.into(),
api_key: api_key.into(),
model_name: model_name.into(),
}
}
}
impl LlmProviderAdapter for OpenAiCompatibleAdapter {
fn provider_name(&self) -> &'static str {
self.provider_tag
}
fn stream_diagnose(
&self,
system_prompt: &str,
anomaly_context: &str,
) -> Pin<Box<dyn std::future::Future<Output = Result<DiagnosticStream, AiClientError>> + Send + '_>> {
let full_prompt = format!("{}\n\n待分析异常报文:\n{}", system_prompt, anomaly_context);
Box::pin(async move {
stream_diagnose(
&self.client,
&self.base_url,
&self.api_key,
&self.model_name,
&full_prompt,
)
.await
})
}
}
4. 实现 Ollama 本地离线小模型适配器
本地部署的 Ollama 提供了极简的 /api/generate 原生端点(格式为 JSON 换行流):
在 crates/packet-ai/src/providers/ollama.rs 中:
// crates/packet-ai/src/providers/ollama.rs
use crate::adapter::{DiagnosticStream, LlmProviderAdapter};
use crate::client::AiClientError;
use futures_util::StreamExt;
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::pin::Pin;
#[derive(Serialize)]
struct OllamaGenerateRequest {
model: String,
prompt: String,
system: String,
stream: bool,
}
#[derive(Deserialize)]
struct OllamaGenerateChunk {
response: String,
done: bool,
}
pub struct OllamaAdapter {
client: Client,
endpoint: String,
model_name: String,
}
impl OllamaAdapter {
pub fn new(base_url: &str, model_name: &str) -> Self {
let endpoint = format!("{}/api/generate", base_url.trim_end_matches('/'));
Self {
client: Client::new(),
endpoint,
model_name: model_name.to_string(),
}
}
}
impl LlmProviderAdapter for OllamaAdapter {
fn provider_name(&self) -> &'static str {
"Ollama (Local Offline)"
}
fn stream_diagnose(
&self,
system_prompt: &str,
anomaly_context: &str,
) -> Pin<Box<dyn std::future::Future<Output = Result<DiagnosticStream, AiClientError>> + Send + '_>> {
let req_body = OllamaGenerateRequest {
model: self.model_name.clone(),
prompt: anomaly_context.to_string(),
system: system_prompt.to_string(),
stream: true,
};
Box::pin(async move {
let res = self
.client
.post(&self.endpoint)
.json(&req_body)
.send()
.await
.map_err(AiClientError::HttpError)?;
let byte_stream = res.bytes_stream();
let token_stream = async_stream::try_stream! {
let mut buffer = String::new();
for await chunk_result in byte_stream {
let bytes = chunk_result.map_err(AiClientError::HttpError)?;
buffer.push_str(&String::from_utf8_lossy(&bytes));
while let Some(pos) = buffer.find('\n') {
let line: String = buffer.drain(..=pos).collect();
if let Ok(chunk) = serde_json::from_str::<OllamaGenerateChunk>(line.trim()) {
yield chunk.response;
if chunk.done {
return;
}
}
}
}
};
Ok(Box::pin(token_stream) as DiagnosticStream)
})
}
}
5. 动态工厂与依赖注入实战
在主程序启动时,根据命令行参数一键创建对应的适配器实例(基于 Arc<dyn LlmProviderAdapter> 动态分发):
// crates/packet-ai/src/factory.rs
use crate::adapter::LlmProviderAdapter;
use crate::providers::ollama::OllamaAdapter;
use crate::providers::openai_compatible::OpenAiCompatibleAdapter;
use std::sync::Arc;
pub struct AdapterFactory;
impl AdapterFactory {
pub fn create_adapter(
provider_type: &str,
base_url: &str,
api_key: &str,
model: &str,
) -> Arc<dyn LlmProviderAdapter> {
match provider_type.to_lowercase().as_str() {
"ollama" | "local" => {
Arc::new(OllamaAdapter::new(base_url, model))
}
"claude" => {
Arc::new(OpenAiCompatibleAdapter::new("Anthropic Claude", base_url, api_key, model))
}
_ => {
// 默认使用 DeepSeek / OpenAI 标准
Arc::new(OpenAiCompatibleAdapter::new("DeepSeek Cloud", base_url, api_key, model))
}
}
}
}
总结
通过引入 Trait 适配器模式:
- 上层业务零感知:TUI 看板和诊断流水线只依赖
dyn LlmProviderAdapter,不与任何具体厂商 API 强绑定; - 支持一键平滑切换:用户通过命令行
--provider ollama --base-url http://localhost:11434即可瞬间切换为纯本地离线推理,兼顾数据隐私与公网可用性。
533



被折叠的 条评论
为什么被折叠?



