DeepSeek Integration Skill
Expert guidance for integrating DeepSeek API with reqwest HTTP client, streaming responses, and error handling.
Overview
WeReply uses DeepSeek API to generate reply suggestions:
- HTTP Client: reqwest with connection pooling
- API Endpoint:
https://api.deepseek.com/v1/chat/completions - Authentication: API key via Bearer token
- Response Format: JSON (non-streaming) or Server-Sent Events (streaming)
- Configuration: API key stored in system keychain
HTTP Client Configuration
Reqwest Client Setup
use reqwest::{Client, ClientBuilder};
use std::time::Duration;
use std::sync::Arc;
pub struct DeepSeekClient {
client: Arc<Client>,
api_key: String,
api_endpoint: String,
}
impl DeepSeekClient {
pub fn new(api_key: String) -> anyhow::Result<Self> {
let client = ClientBuilder::new()
.pool_max_idle_per_host(10) // 连接池最大空闲连接数
.timeout(Duration::from_secs(30)) // 请求超时30秒
.connect_timeout(Duration::from_secs(10)) // 连接超时10秒
.build()?;
Ok(Self {
client: Arc::new(client),
api_key,
api_endpoint: "https://api.deepseek.com/v1/chat/completions".to_string(),
})
}
pub fn with_custom_endpoint(mut self, endpoint: String) -> Self {
self.api_endpoint = endpoint;
self
}
}Connection Pooling Best Practices
// ✓ 共享 Client 实例（连接池复用）
pub struct AppState {
deepseek_client: Arc<DeepSeekClient>,
}
// ✗ 每次创建新 Client（无连接池复用）
pub async fn bad_example() {
let client = DeepSeekClient::new(api_key).unwrap(); // 不要这样做
}API Request Pattern
Basic Request/Response
use serde::{Deserialize, Serialize};
#[derive(Serialize)]
pub struct ChatCompletionRequest {
model: String,
messages: Vec<ChatMessage>,
#[serde(skip_serializing_if = "Option::is_none")]
temperature: Option<f32>,
#[serde(skip_serializing_if = "Option::is_none")]
max_tokens: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
stream: Option<bool>,
}
#[derive(Serialize, Deserialize)]
pub struct ChatMessage {
role: String, // "system", "user", "assistant"
content: String,
}
#[derive(Deserialize)]
pub struct ChatCompletionResponse {
id: String,
model: String,
choices: Vec<ChatChoice>,
usage: Usage,
}
#[derive(Deserialize)]
pub struct ChatChoice {
index: u32,
message: ChatMessage,
finish_reason: String,
}
#[derive(Deserialize)]
pub struct Usage {
prompt_tokens: u32,
completion_tokens: u32,
total_tokens: u32,
}Making API Requests
impl DeepSeekClient {
pub async fn generate_completion(
&self,
messages: Vec<ChatMessage>,
) -> anyhow::Result<ChatCompletionResponse> {
let request = ChatCompletionRequest {
model: "deepseek-chat".to_string(),
messages,
temperature: Some(0.7),
max_tokens: Some(1000),
stream: Some(false),
};
let response = self.client
.post(&self.api_endpoint)
.header("Authorization", format!("Bearer {}", self.api_key))
.header("Content-Type", "application/json")
.json(&request)
.send()
.await?;
// 检查 HTTP 状态码
if !response.status().is_success() {
let status = response.status();
let error_text = response.text().await.unwrap_or_default();
return Err(anyhow!(
"DeepSeek API 请求失败: {} - {}",
status,
error_text
));
}
// 解析响应
let completion = response.json::<ChatCompletionResponse>().await?;
Ok(completion)
}
}Streaming Response Pattern
Event Stream Processing
use futures::stream::StreamExt;
use serde_json;
impl DeepSeekClient {
pub async fn generate_completion_stream(
&self,
messages: Vec<ChatMessage>,
on_chunk: impl Fn(String) + Send + 'static,
) -> anyhow::Result<String> {
let request = ChatCompletionRequest {
model: "deepseek-chat".to_string(),
messages,
temperature: Some(0.7),
max_tokens: Some(1000),
stream: Some(true), // 启用流式响应
};
let response = self.client
.post(&self.api_endpoint)
.header("Authorization", format!("Bearer {}", self.api_key))
.header("Content-Type", "application/json")
.json(&request)
.send()
.await?;
if !response.status().is_success() {
let status = response.status();
let error_text = response.text().await.unwrap_or_default();
return Err(anyhow!(
"DeepSeek API 请求失败: {} - {}",
status,
error_text
));
}
let mut stream = response.bytes_stream();
let mut full_content = String::new();
let mut buffer = String::new();
while let Some(chunk_result) = stream.next().await {
let chunk = chunk_result?;
let chunk_str = String::from_utf8_lossy(&chunk);
buffer.push_str(&chunk_str);
// 处理 SSE 格式：data: {...}\n\ndata: {...}\n\n
for line in buffer.lines() {
if line.starts_with("data: ") {
let json_str = &line[6..]; // 去掉 "data: " 前缀
if json_str == "[DONE]" {
break;
}
if let Ok(chunk_data) = serde_json::from_str::<StreamChunk>(json_str) {
if let Some(choice) = chunk_data.choices.first() {
if let Some(content) = &choice.delta.content {
full_content.push_str(content);
on_chunk(content.clone());
}
}
}
}
}
buffer.clear();
}
Ok(full_content)
}
}
#[derive(Deserialize)]
struct StreamChunk {
choices: Vec<StreamChoice>,
}
#[derive(Deserialize)]
struct StreamChoice {
delta: Delta,
finish_reason: Option<String>,
}
#[derive(Deserialize)]
struct Delta {
#[serde(skip_serializing_if = "Option::is_none")]
content: Option<String>,
}Tauri Event Integration
use tauri::Manager;
#[tauri::command]
#[specta::specta]
pub async fn generate_suggestions_stream(
context_messages: Vec<String>,
style: String,
state: State<'_, AppState>,
app_handle: tauri::AppHandle,
) -> ApiResponse<String> {
let client = state.deepseek_client.clone();
// 构建消息
let messages = build_chat_messages(context_messages, style);
// 流式生成，实时发送到前端
match client.generate_completion_stream(messages, move |chunk| {
// 发送 chunk 到前端
app_handle.emit_all("suggestion-chunk", chunk).ok();
}).await {
Ok(full_text) => api_ok(full_text),
Err(e) => api_err(format!("生成建议失败: {}", e)),
}
}Error Handling and Retry
Exponential Backoff Retry
use tokio::time::{sleep, Duration};
impl DeepSeekClient {
pub async fn generate_completion_with_retry(
&self,
messages: Vec<ChatMessage>,
max_retries: u32,
) -> anyhow::Result<ChatCompletionResponse> {
let mut retry_count = 0;
let mut backoff_ms = 1000; // 初始退避时间 1 秒
loop {
match self.generate_completion(messages.clone()).await {
Ok(response) => return Ok(response),
Err(e) => {
retry_count += 1;
if retry_count > max_retries {
return Err(anyhow!(
"DeepSeek API 调用失败，已重试 {} 次: {}",
max_retries,
e
));
}
// 判断是否可重试的错误
if !is_retryable_error(&e) {
return Err(e);
}
tracing::warn!(
error = %e,
retry_count = retry_count,
backoff_ms = backoff_ms,
"DeepSeek API 调用失败，等待重试"
);
// 指数退避
sleep(Duration::from_millis(backoff_ms)).await;
backoff_ms = (backoff_ms * 2).min(30000); // 最大退避 30 秒
}
}
}
}
}
fn is_retryable_error(error: &anyhow::Error) -> bool {
let error_msg = error.to_string().to_lowercase();
// 网络错误、超时、429 (Rate Limit)、5xx 服务器错误可重试
error_msg.contains("timeout")
|| error_msg.contains("network")
|| error_msg.contains("429")
|| error_msg.contains("500")
|| error_msg.contains("502")
|| error_msg.contains("503")
|| error_msg.contains("504")
}Error Classification
#[derive(Debug, thiserror::Error)]
pub enum DeepSeekError {
#[error("API 密钥无效")]
InvalidApiKey,
#[error("请求超时")]
Timeout,
#[error("请求频率超限")]
RateLimitExceeded,
#[error("服务不可用")]
ServiceUnavailable,
#[error("网络错误: {0}")]
NetworkError(String),
#[error("响应解析错误: {0}")]
ParseError(String),
#[error("未知错误: {0}")]
Unknown(String),
}
impl DeepSeekClient {
fn classify_error(status_code: u16, body: &str) -> DeepSeekError {
match status_code {
401 => DeepSeekError::InvalidApiKey,
408 | 504 => DeepSeekError::Timeout,
429 => DeepSeekError::RateLimitExceeded,
500 | 502 | 503 => DeepSeekError::ServiceUnavailable,
_ => DeepSeekError::Unknown(body.to_string()),
}
}
}Message Construction Pattern
Building Chat Messages
pub fn build_chat_messages(
context_messages: Vec<String>,
style: &str,
) -> Vec<ChatMessage> {
let mut messages = Vec::new();
// 系统提示词
let system_prompt = format!(
"你是一个微信回复建议助手。请根据聊天上下文，用{}风格生成3条简短的回复建议。\
每条建议不超过50字，自然流畅，符合微信聊天习惯。",
get_style_description(style)
);
messages.push(ChatMessage {
role: "system".to_string(),
content: system_prompt,
});
// 聊天上下文
let context = context_messages.join("\n");
messages.push(ChatMessage {
role: "user".to_string(),
content: format!("聊天记录：\n{}\n\n请生成3条回复建议：", context),
});
messages
}
fn get_style_description(style: &str) -> &str {
match style {
"formal" => "正式、礼貌",
"friendly" => "亲切、友好",
"humorous" => "幽默、轻松",
_ => "自然、随和",
}
}Response Parsing
pub fn parse_suggestions(response_text: &str) -> Vec<String> {
// DeepSeek 可能返回带编号的列表，如：
// 1. 建议1
// 2. 建议2
// 3. 建议3
let mut suggestions = Vec::new();
for line in response_text.lines() {
let trimmed = line.trim();
// 匹配带编号的建议（如 "1. xxx" 或 "1) xxx"）
if let Some(content) = trimmed.strip_prefix(|c: char| c.is_numeric()) {
if let Some(content) = content.strip_prefix(". ").or(content.strip_prefix(") ")) {
suggestions.push(content.trim().to_string());
}
}
}
// 如果没找到带编号的建议，尝试按换行分割
if suggestions.is_empty() {
suggestions = response_text
.lines()
.map(|l| l.trim().to_string())
.filter(|l| !l.is_empty())
.collect();
}
suggestions
}Configuration Management
API Key from System Keychain
use keyring::Entry;
pub fn get_deepseek_api_key() -> anyhow::Result<String> {
let entry = Entry::new("wereply", "deepseek_api_key")?;
entry.get_password()
.context("未找到 DeepSeek API 密钥，请在设置中配置")
}
pub fn set_deepseek_api_key(api_key: &str) -> anyhow::Result<()> {
let entry = Entry::new("wereply", "deepseek_api_key")?;
entry.set_password(api_key)?;
Ok(())
}Environment Variable Fallback
use std::env;
pub fn get_api_endpoint() -> String {
env::var("DEEPSEEK_API_ENDPOINT")
.unwrap_or_else(|_| "https://api.deepseek.com/v1/chat/completions".to_string())
}
pub fn get_model_name() -> String {
env::var("DEEPSEEK_MODEL")
.unwrap_or_else(|_| "deepseek-chat".to_string())
}Testing
Mock HTTP Client
#[cfg(test)]
mod tests {
use super::*;
use mockito::{mock, server_url};
#[tokio::test]
async fn test_generate_completion() {
// 模拟 DeepSeek API 响应
let _m = mock("POST", "/v1/chat/completions")
.with_status(200)
.with_header("content-type", "application/json")
.with_body(r#"{
"id": "chatcmpl-123",
"model": "deepseek-chat",
"choices": [{
"index": 0,
"message": {
"role": "assistant",
"content": "1. 好的，谢谢！\n2. 收到，马上处理。\n3. 了解，没问题。"
},
"finish_reason": "stop"
}],
"usage": {
"prompt_tokens": 20,
"completion_tokens": 30,
"total_tokens": 50
}
}"#)
.create();
let client = DeepSeekClient::new("test_api_key".to_string())
.unwrap()
.with_custom_endpoint(server_url());
let messages = vec![
ChatMessage {
role: "user".to_string(),
content: "测试消息".to_string(),
},
];
let response = client.generate_completion(messages).await.unwrap();
assert_eq!(response.model, "deepseek-chat");
assert_eq!(response.choices.len(), 1);
assert!(response.choices[0].message.content.contains("好的"));
}
#[tokio::test]
async fn test_retry_on_error() {
// 模拟失败后成功的情况
let _m1 = mock("POST", "/v1/chat/completions")
.with_status(503)
.with_body("Service Unavailable")
.create();
let _m2 = mock("POST", "/v1/chat/completions")
.with_status(200)
.with_body(r#"{"id": "test", "choices": []}"#)
.create();
let client = DeepSeekClient::new("test_key".to_string())
.unwrap()
.with_custom_endpoint(server_url());
let messages = vec![];
let result = client.generate_completion_with_retry(messages, 3).await;
assert!(result.is_ok());
}
}Performance Optimization
Request Timeout Configuration
pub struct DeepSeekConfig {
pub connect_timeout_secs: u64,
pub request_timeout_secs: u64,
pub max_retries: u32,
}
impl Default for DeepSeekConfig {
fn default() -> Self {
Self {
connect_timeout_secs: 10,
request_timeout_secs: 30,
max_retries: 3,
}
}
}Batch Request Processing
use futures::future::join_all;
pub async fn generate_multiple_suggestions(
&self,
requests: Vec<Vec<ChatMessage>>,
) -> Vec<anyhow::Result<ChatCompletionResponse>> {
// 并发处理多个请求
let futures = requests.into_iter().map(|messages| {
let client = self.clone();
async move {
client.generate_completion(messages).await
}
});
join_all(futures).await
}Security Best Practices
API Key Validation
pub fn validate_api_key(api_key: &str) -> anyhow::Result<()> {
if api_key.is_empty() {
return Err(anyhow!("API 密钥不能为空"));
}
if !api_key.starts_with("sk-") {
return Err(anyhow!("API 密钥格式错误"));
}
if api_key.len() < 20 {
return Err(anyhow!("API 密钥长度不足"));
}
Ok(())
}Logging Without Sensitive Data
use tracing::info;
pub async fn log_api_call(
&self,
message_count: usize,
response_length: usize,
) {
info!(
message_count = message_count,
response_length = response_length,
"DeepSeek API 调用成功"
);
// ❌ 不要记录 API 密钥或消息内容
}When to Use This Skill
Activate this skill when:
- Integrating DeepSeek API
- Implementing AI-powered features
- Working with HTTP clients (reqwest)
- Handling streaming responses
- Implementing retry logic
- Managing API keys securely
- Optimizing API performance
- Testing API integrations