feat: 集成 LLM 客户端，支持与大语言模型交互；更新依赖项并优化配置

Author: ExquisiteCore

backend/Cargo.lock

@@ -46,3 +46,6 @@ anyhow = "1"
 jsonwebtoken = "9.3.1"
 bcrypt = "0.17.0"
 wechat-oa-sdk = "1.0.3"
+
+# HTTP 客户端（LLM API 调用）
+reqwest = { version = "0.12", features = ["json"] }

backend/Cargo.toml

@@ -19,6 +19,7 @@ use wechat_oa_sdk::{
 };
 
 use crate::error::{AppError, AppErrorType};
+use crate::llm::LlmClient;
 use crate::state::AppState;
 
 // ============================================================================
@@ -164,7 +165,7 @@ pub async fn receive_message(
     };
 
     // 处理消息并生成回复
-    let reply_xml = handle_message(message).await;
+    let reply_xml = handle_message(message, state.llm_client.as_ref()).await;
 
     // 如果是加密模式，加密回复
     if is_encrypted && reply_xml != "success" {
@@ -181,23 +182,45 @@ pub async fn receive_message(
 }
 
 /// 处理接收到的消息/事件
-async fn handle_message(message: IncomingMessage) -> String {
+async fn handle_message(message: IncomingMessage, llm_client: Option<&Arc<LlmClient>>) -> String {
     match message {
         IncomingMessage::Text(msg) => {
             info!("收到文本消息: {} from {}", msg.content, msg.from_user_name);
-            let reply_content = match msg.content.as_str() {
-                "你好" | "hello" | "hi" => "你好！欢迎关注我的博客！".to_string(),
-                "帮助" | "help" => {
-                    "可用命令：\n- 博客：获取博客链接\n- 最新：获取最新文章".to_string()
+
+            // 先处理特殊命令
+            let reply_content = match msg.content.trim().to_lowercase().as_str() {
+                "帮助" | "help" | "?" => {
+                    "可用命令：\n- 博客：获取博客链接\n- 清除：清除对话历史\n\n其他消息我会用 AI 回复你！".to_string()
+                }
+                "博客" | "blog" => "访问我的博客：https://blog.exquisitecore.xyz".to_string(),
+                "清除" | "clear" | "reset" => {
+                    // 清除对话历史
+                    if let Some(client) = llm_client {
+                        client.clear_history(&msg.from_user_name).await;
+                    }
+                    "对话历史已清除！".to_string()
+                }
+                _ => {
+                    // 使用 LLM 回复
+                    if let Some(client) = llm_client {
+                        match client.chat(&msg.from_user_name, &msg.content).await {
+                            Ok(response) => response,
+                            Err(e) => {
+                                error!("LLM 调用失败: {}", e);
+                                format!("抱歉，AI 服务暂时不可用：{}", e)
+                            }
+                        }
+                    } else {
+                        // 没有配置 LLM，使用简单回复
+                        format!("收到：{}", msg.content)
+                    }
                 }
-                "博客" => "访问我的博客：https://blog.exquisitecore.xyz".to_string(),
-                _ => format!("收到：{}", msg.content),
             };
             TextReply::new(&msg.from_user_name, &msg.to_user_name, reply_content).to_xml()
         }
         IncomingMessage::SubscribeEvent(event) => {
             info!("用户关注: {}", event.from_user_name);
-            let welcome = "感谢关注！\n\n这里是我的个人博客公众号，会不定期分享技术文章。\n\n回复「博客」获取博客链接";
+            let welcome = "感谢关注！\n\n这里是我的个人博客公众号，会不定期分享技术文章。\n\n💡 你可以直接向我发消息，我会用 AI 回复你！\n\n回复「帮助」查看更多命令";
             TextReply::new(&event.from_user_name, &event.to_user_name, welcome).to_xml()
         }
         IncomingMessage::UnsubscribeEvent(event) => {

backend/src/api/wechatapi.rs

@@ -27,6 +27,18 @@ pub struct Config {
     pub cors: CorsConfig,
     #[serde(default)]
     pub wechat: Option<WeChatConfig>,
+    #[serde(default)]
+    pub llm: Option<LlmConfig>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct LlmConfig {
+    pub provider: String,      // "deepseek", "openai", etc.
+    pub api_key: String,
+    pub base_url: Option<String>,
+    pub model: Option<String>,
+    pub max_tokens: Option<u32>,
+    pub timeout_secs: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -106,6 +118,7 @@ impl Default for Config {
                 allow_credentials: true,
             },
             wechat: None,
+            llm: None,
         }
     }
 }

backend/src/config.rs

@@ -1,6 +1,7 @@
 pub mod api;
 pub mod config;
 pub mod error;
+pub mod llm;
 pub mod logger;
 pub mod middleware;
 pub mod model;

backend/src/lib.rs

@@ -0,0 +1,172 @@
+//! LLM 集成模块
+//!
+//! 支持 DeepSeek 等大语言模型 API
+
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::RwLock;
+use std::collections::HashMap;
+use tracing::{error, info};
+
+use crate::config::LlmConfig;
+
+/// LLM 客户端
+pub struct LlmClient {
+    config: LlmConfig,
+    http: Client,
+    /// 用户对话历史缓存 (openid -> messages)
+    conversations: Arc<RwLock<HashMap<String, Vec<ChatMessage>>>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ChatMessage {
+    pub role: String,      // "system", "user", "assistant"
+    pub content: String,
+}
+
+#[derive(Debug, Serialize)]
+struct ChatRequest {
+    model: String,
+    messages: Vec<ChatMessage>,
+    max_tokens: Option<u32>,
+    temperature: Option<f32>,
+    stream: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct ChatResponse {
+    choices: Vec<Choice>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Choice {
+    message: ChatMessage,
+}
+
+#[derive(Debug, Deserialize)]
+struct ErrorResponse {
+    error: ApiError,
+}
+
+#[derive(Debug, Deserialize)]
+struct ApiError {
+    message: String,
+}
+
+impl LlmClient {
+    pub fn new(config: LlmConfig) -> Self {
+        let timeout = config.timeout_secs.unwrap_or(30);
+        let http = Client::builder()
+            .timeout(Duration::from_secs(timeout))
+            .build()
+            .expect("Failed to create HTTP client");
+
+        Self {
+            config,
+            http,
+            conversations: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    /// 与 LLM 聊天
+    ///
+    /// `user_id`: 用户标识（微信 openid），用于维护对话上下文
+    /// `message`: 用户消息
+    pub async fn chat(&self, user_id: &str, message: &str) -> Result<String, String> {
+        // 获取或创建对话历史
+        let mut conversations = self.conversations.write().await;
+        let history = conversations.entry(user_id.to_string()).or_insert_with(|| {
+            vec![ChatMessage {
+                role: "system".to_string(),
+                content: "你是一个友好的助手，用简洁的中文回复用户问题。回复尽量控制在100字以内。".to_string(),
+            }]
+        });
+
+        // 添加用户消息
+        history.push(ChatMessage {
+            role: "user".to_string(),
+            content: message.to_string(),
+        });
+
+        // 限制历史长度（保留最近10轮对话）
+        if history.len() > 21 {  // 1 system + 20 user/assistant
+            let system_msg = history[0].clone();
+            let recent: Vec<_> = history.iter().skip(history.len() - 20).cloned().collect();
+            history.clear();
+            history.push(system_msg);
+            history.extend(recent);
+        }
+
+        // 构建请求
+        let base_url = self.config.base_url.as_deref()
+            .unwrap_or("https://api.deepseek.com");
+        let model = self.config.model.as_deref()
+            .unwrap_or("deepseek-chat");
+
+        let request = ChatRequest {
+            model: model.to_string(),
+            messages: history.clone(),
+            max_tokens: self.config.max_tokens.or(Some(500)),
+            temperature: Some(0.7),
+            stream: false,
+        };
+
+        info!("Calling LLM API for user {}", user_id);
+
+        // 发送请求
+        let response = self.http
+            .post(format!("{}/v1/chat/completions", base_url))
+            .header("Authorization", format!("Bearer {}", self.config.api_key))
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| {
+                error!("LLM API request failed: {}", e);
+                format!("请求失败: {}", e)
+            })?;
+
+        let status = response.status();
+        let body = response.text().await.map_err(|e| format!("读取响应失败: {}", e))?;
+
+        if !status.is_success() {
+            error!("LLM API error: {} - {}", status, body);
+            // 尝试解析错误信息
+            if let Ok(err) = serde_json::from_str::<ErrorResponse>(&body) {
+                return Err(format!("API错误: {}", err.error.message));
+            }
+            return Err(format!("API错误: {}", status));
+        }
+
+        // 解析响应
+        let chat_response: ChatResponse = serde_json::from_str(&body)
+            .map_err(|e| {
+                error!("Failed to parse LLM response: {} - {}", e, body);
+                format!("解析响应失败: {}", e)
+            })?;
+
+        let assistant_message = chat_response.choices
+            .first()
+            .map(|c| c.message.content.clone())
+            .unwrap_or_else(|| "抱歉，我没有生成回复。".to_string());
+
+        // 保存助手回复到历史
+        history.push(ChatMessage {
+            role: "assistant".to_string(),
+            content: assistant_message.clone(),
+        });
+
+        info!("LLM response for user {}: {} chars", user_id, assistant_message.len());
+
+        Ok(assistant_message)
+    }
+
+    /// 清除用户对话历史
+    pub async fn clear_history(&self, user_id: &str) {
+        let mut conversations = self.conversations.write().await;
+        conversations.remove(user_id);
+        info!("Cleared conversation history for user {}", user_id);
+    }
+}

backend/src/llm.rs

@@ -1,4 +1,4 @@
-use backend::{config, logger, model, routes, state::AppState};
+use backend::{config, llm::LlmClient, logger, model, routes, state::AppState};
 use std::net::SocketAddr;
 use std::path::Path;
 use std::sync::Arc;
@@ -40,8 +40,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         WeChatClient::new(sdk_config)
     });
 
+    // 初始化 LLM 客户端（如果配置了）
+    let llm_client = config.llm.map(|lc| {
+        info!("初始化 LLM 客户端，provider: {}", lc.provider);
+        LlmClient::new(lc)
+    });
+
     // 创建应用状态
-    let app_state = AppState::new(pool, wechat_client);
+    let app_state = AppState::new(pool, wechat_client, llm_client);
 
     // 创建应用路由
     let app = routes::create_routes(app_state);

backend/src/main.rs

@@ -6,21 +6,30 @@ use sqlx::{Pool, Postgres};
 use std::sync::Arc;
 use wechat_oa_sdk::WeChatClient;
 
+use crate::llm::LlmClient;
+
 /// 应用状态
 #[derive(Clone)]
 pub struct AppState {
     /// 数据库连接池
     pub pool: Arc<Pool<Postgres>>,
     /// 微信客户端（可选）
     pub wechat_client: Option<Arc<WeChatClient>>,
+    /// LLM 客户端（可选）
+    pub llm_client: Option<Arc<LlmClient>>,
 }
 
 impl AppState {
     /// 创建新的应用状态
-    pub fn new(pool: Arc<Pool<Postgres>>, wechat_client: Option<WeChatClient>) -> Self {
+    pub fn new(
+        pool: Arc<Pool<Postgres>>,
+        wechat_client: Option<WeChatClient>,
+        llm_client: Option<LlmClient>,
+    ) -> Self {
         Self {
             pool,
             wechat_client: wechat_client.map(Arc::new),
+            llm_client: llm_client.map(Arc::new),
         }
     }
 }