diff --git a/apps/desktop/src-tauri/src/infrastructure/gemini_service.rs b/apps/desktop/src-tauri/src/infrastructure/gemini_service.rs
index 4278783..38f56cb 100644
--- a/apps/desktop/src-tauri/src/infrastructure/gemini_service.rs
+++ b/apps/desktop/src-tauri/src/infrastructure/gemini_service.rs
@@ -148,6 +148,82 @@ struct ResponsePart {
     text: String,
 }
 
+/// RAG Grounding 配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RagGroundingConfig {
+    pub project_id: String,
+    pub location: String,
+    pub data_store_id: String,
+    pub model_id: String,
+    pub temperature: f32,
+    pub max_output_tokens: u32,
+    pub system_prompt: Option<String>,
+}
+
+impl Default for RagGroundingConfig {
+    fn default() -> Self {
+        Self {
+            project_id: "gen-lang-client-0413414134".to_string(),
+            location: "global".to_string(),
+            data_store_id: "default_data_store".to_string(),
+            model_id: "gemini-2.5-flash".to_string(),
+            temperature: 1.0,
+            max_output_tokens: 8192,
+            system_prompt: None,
+        }
+    }
+}
+
+/// RAG Grounding 请求
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RagGroundingRequest {
+    pub user_input: String,
+    pub config: Option<RagGroundingConfig>,
+    pub session_id: Option<String>,
+}
+
+/// RAG Grounding 响应
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RagGroundingResponse {
+    pub answer: String,
+    pub grounding_metadata: Option<GroundingMetadata>,
+    pub response_time_ms: u64,
+    pub model_used: String,
+}
+
+/// Grounding 元数据
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GroundingMetadata {
+    pub sources: Vec<GroundingSource>,
+    pub search_queries: Vec<String>,
+}
+
+/// Grounding 来源
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GroundingSource {
+    pub title: String,
+    pub uri: Option<String>,
+    pub snippet: String,
+    pub relevance_score: Option<f32>,
+}
+
+/// Vertex AI Search 工具配置
+#[derive(Debug, Serialize)]
+struct VertexAISearchTool {
+    retrieval: VertexAIRetrieval,
+}
+
+#[derive(Debug, Serialize)]
+struct VertexAIRetrieval {
+    #[serde(rename = "vertexAiSearch")]
+    vertex_ai_search: VertexAISearchConfig,
+}
+
+#[derive(Debug, Serialize)]
+struct VertexAISearchConfig {
+    datastore: String,
+}
+
 /// Gemini API服务
 /// 遵循 Tauri 开发规范的基础设施层设计模式
 #[derive(Clone)]
@@ -825,4 +901,203 @@ impl GeminiService {
             }
         }
     }
+
+    /// RAG Grounding 查询 (参考 RAGUtils.py 中的 query_llm_with_grounding)
+    pub async fn query_llm_with_grounding(&mut self, request: RagGroundingRequest) -> Result<RagGroundingResponse> {
+        let start_time = std::time::Instant::now();
+        println!("🔍 开始RAG Grounding查询: {}", request.user_input);
+
+        // 获取配置
+        let rag_config = request.config.unwrap_or_default();
+
+        // 获取访问令牌
+        let access_token = self.get_access_token().await?;
+
+        // 创建客户端配置
+        let client_config = self.create_gemini_client(&access_token);
+
+        // 构建数据存储路径
+        let datastore_path = format!(
+            "projects/{}/locations/{}/collections/default_collection/dataStores/{}",
+            rag_config.project_id,
+            rag_config.location,
+            rag_config.data_store_id
+        );
+
+        // 构建工具配置 (Vertex AI Search)
+        let tools = vec![VertexAISearchTool {
+            retrieval: VertexAIRetrieval {
+                vertex_ai_search: VertexAISearchConfig {
+                    datastore: datastore_path,
+                },
+            },
+        }];
+
+        // 构建请求内容
+        let contents = vec![ContentPart {
+            role: "user".to_string(),
+            parts: vec![Part::Text { text: request.user_input.clone() }],
+        }];
+
+        // 构建生成配置
+        let generation_config = GenerationConfig {
+            temperature: rag_config.temperature,
+            top_k: 32,
+            top_p: 1.0,
+            max_output_tokens: rag_config.max_output_tokens,
+        };
+
+        // 准备请求数据
+        let request_data = serde_json::json!({
+            "contents": contents,
+            "tools": tools,
+            "generationConfig": generation_config,
+            "systemInstruction": rag_config.system_prompt.map(|prompt| {
+                serde_json::json!({
+                    "role": "system",
+                    "parts": [{"text": prompt}]
+                })
+            })
+        });
+
+        // 发送请求到Cloudflare Gateway (使用beta API)
+        let generate_url = format!("{}/{}:generateContent", client_config.gateway_url, rag_config.model_id);
+
+        // 重试机制
+        let mut last_error = None;
+        for attempt in 0..self.config.max_retries {
+            match self.send_rag_grounding_request(&generate_url, &client_config, &request_data).await {
+                Ok(response) => {
+                    let elapsed = start_time.elapsed();
+                    println!("✅ RAG Grounding查询完成，耗时: {:?}", elapsed);
+
+                    return Ok(RagGroundingResponse {
+                        answer: response.answer,
+                        grounding_metadata: response.grounding_metadata,
+                        response_time_ms: elapsed.as_millis() as u64,
+                        model_used: rag_config.model_id,
+                    });
+                }
+                Err(e) => {
+                    last_error = Some(e);
+                    if attempt < self.config.max_retries - 1 {
+                        tokio::time::sleep(tokio::time::Duration::from_secs(self.config.retry_delay)).await;
+                    }
+                }
+            }
+        }
+
+        Err(anyhow!("RAG Grounding查询失败，已重试{}次: {}", self.config.max_retries, last_error.unwrap()))
+    }
+
+    /// 发送RAG Grounding请求
+    async fn send_rag_grounding_request(
+        &self,
+        url: &str,
+        client_config: &ClientConfig,
+        request_data: &serde_json::Value,
+    ) -> Result<RagGroundingResponse> {
+        let mut request_builder = self.client
+            .post(url)
+            .json(request_data);
+
+        // 添加请求头
+        for (key, value) in &client_config.headers {
+            request_builder = request_builder.header(key, value);
+        }
+
+        let response = request_builder
+            .send()
+            .await
+            .map_err(|e| anyhow!("发送RAG请求失败: {}", e))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| anyhow!("读取RAG响应失败: {}", e))?;
+
+        if !status.is_success() {
+            return Err(anyhow!("RAG请求失败 ({}): {}", status, response_text));
+        }
+
+        // 解析响应
+        self.parse_rag_grounding_response(&response_text)
+    }
+
+    /// 解析RAG Grounding响应
+    fn parse_rag_grounding_response(&self, response_text: &str) -> Result<RagGroundingResponse> {
+        let response_json: serde_json::Value = serde_json::from_str(response_text)
+            .map_err(|e| anyhow!("解析RAG响应JSON失败: {}", e))?;
+
+        // 提取主要回答内容
+        let answer = response_json
+            .get("candidates")
+            .and_then(|c| c.as_array())
+            .and_then(|arr| arr.first())
+            .and_then(|candidate| candidate.get("content"))
+            .and_then(|content| content.get("parts"))
+            .and_then(|parts| parts.as_array())
+            .and_then(|arr| arr.first())
+            .and_then(|part| part.get("text"))
+            .and_then(|text| text.as_str())
+            .unwrap_or("无法解析响应内容")
+            .to_string();
+
+        // 提取Grounding元数据
+        let grounding_metadata = self.extract_grounding_metadata(&response_json);
+
+        Ok(RagGroundingResponse {
+            answer,
+            grounding_metadata,
+            response_time_ms: 0, // 将在调用方设置
+            model_used: "gemini-2.5-flash".to_string(),
+        })
+    }
+
+    /// 提取Grounding元数据
+    fn extract_grounding_metadata(&self, response_json: &serde_json::Value) -> Option<GroundingMetadata> {
+        let grounding_metadata = response_json
+            .get("candidates")
+            .and_then(|c| c.as_array())
+            .and_then(|arr| arr.first())
+            .and_then(|candidate| candidate.get("groundingMetadata"))?;
+
+        let sources = grounding_metadata
+            .get("groundingSources")
+            .and_then(|sources| sources.as_array())
+            .map(|sources_array| {
+                sources_array
+                    .iter()
+                    .filter_map(|source| {
+                        Some(GroundingSource {
+                            title: source.get("title")?.as_str()?.to_string(),
+                            uri: source.get("uri").and_then(|u| u.as_str()).map(|s| s.to_string()),
+                            snippet: source.get("snippet")?.as_str()?.to_string(),
+                            relevance_score: source.get("relevanceScore").and_then(|s| s.as_f64()).map(|f| f as f32),
+                        })
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        let search_queries = grounding_metadata
+            .get("searchQueries")
+            .and_then(|queries| queries.as_array())
+            .map(|queries_array| {
+                queries_array
+                    .iter()
+                    .filter_map(|q| q.as_str().map(|s| s.to_string()))
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        Some(GroundingMetadata {
+            sources,
+            search_queries,
+        })
+    }
 }
+
+// 导入测试文件
+#[cfg(test)]
+#[path = "gemini_service_tests.rs"]
+mod gemini_service_tests;
diff --git a/apps/desktop/src-tauri/src/infrastructure/gemini_service_tests.rs b/apps/desktop/src-tauri/src/infrastructure/gemini_service_tests.rs
new file mode 100644
index 0000000..1e8f412
--- /dev/null
+++ b/apps/desktop/src-tauri/src/infrastructure/gemini_service_tests.rs
@@ -0,0 +1,226 @@
+#[cfg(test)]
+mod rag_grounding_tests {
+    use crate::infrastructure::gemini_service::{
+        GeminiService, GeminiConfig, RagGroundingRequest, RagGroundingConfig, RagGroundingResponse,
+        GroundingMetadata, GroundingSource,
+    };
+
+    /// 创建测试用的 GeminiService 实例
+    fn create_test_service() -> GeminiService {
+        let config = GeminiConfig::default();
+        GeminiService::new(Some(config)).expect("Failed to create test service")
+    }
+
+    /// 创建测试用的 RAG Grounding 请求
+    fn create_test_request() -> RagGroundingRequest {
+        RagGroundingRequest {
+            user_input: "测试查询".to_string(),
+            config: Some(RagGroundingConfig::default()),
+            session_id: Some("test-session".to_string()),
+        }
+    }
+
+    #[test]
+    fn test_rag_grounding_config_default() {
+        let config = RagGroundingConfig::default();
+        
+        assert_eq!(config.project_id, "gen-lang-client-0413414134");
+        assert_eq!(config.location, "global");
+        assert_eq!(config.data_store_id, "default_data_store");
+        assert_eq!(config.model_id, "gemini-2.5-flash");
+        assert_eq!(config.temperature, 1.0);
+        assert_eq!(config.max_output_tokens, 8192);
+        assert!(config.system_prompt.is_none());
+    }
+
+    #[test]
+    fn test_rag_grounding_request_creation() {
+        let request = create_test_request();
+        
+        assert_eq!(request.user_input, "测试查询");
+        assert!(request.config.is_some());
+        assert_eq!(request.session_id, Some("test-session".to_string()));
+    }
+
+    #[test]
+    fn test_rag_grounding_request_serialization() {
+        let request = create_test_request();
+        
+        // 测试序列化
+        let serialized = serde_json::to_string(&request).expect("Failed to serialize request");
+        assert!(serialized.contains("测试查询"));
+        assert!(serialized.contains("test-session"));
+        
+        // 测试反序列化
+        let deserialized: RagGroundingRequest = serde_json::from_str(&serialized)
+            .expect("Failed to deserialize request");
+        assert_eq!(deserialized.user_input, request.user_input);
+        assert_eq!(deserialized.session_id, request.session_id);
+    }
+
+    #[test]
+    fn test_rag_grounding_response_creation() {
+        let response = RagGroundingResponse {
+            answer: "测试回答".to_string(),
+            grounding_metadata: Some(GroundingMetadata {
+                sources: vec![GroundingSource {
+                    title: "测试来源".to_string(),
+                    uri: Some("https://example.com".to_string()),
+                    snippet: "测试片段".to_string(),
+                    relevance_score: Some(0.95),
+                }],
+                search_queries: vec!["测试查询".to_string()],
+            }),
+            response_time_ms: 1500,
+            model_used: "gemini-2.5-flash".to_string(),
+        };
+
+        assert_eq!(response.answer, "测试回答");
+        assert!(response.grounding_metadata.is_some());
+        assert_eq!(response.response_time_ms, 1500);
+        assert_eq!(response.model_used, "gemini-2.5-flash");
+
+        let metadata = response.grounding_metadata.unwrap();
+        assert_eq!(metadata.sources.len(), 1);
+        assert_eq!(metadata.search_queries.len(), 1);
+
+        let source = &metadata.sources[0];
+        assert_eq!(source.title, "测试来源");
+        assert_eq!(source.uri, Some("https://example.com".to_string()));
+        assert_eq!(source.snippet, "测试片段");
+        assert_eq!(source.relevance_score, Some(0.95));
+    }
+
+    #[test]
+    fn test_grounding_metadata_empty() {
+        let metadata = GroundingMetadata {
+            sources: vec![],
+            search_queries: vec![],
+        };
+
+        assert!(metadata.sources.is_empty());
+        assert!(metadata.search_queries.is_empty());
+    }
+
+    #[test]
+    fn test_grounding_source_without_optional_fields() {
+        let source = GroundingSource {
+            title: "测试来源".to_string(),
+            uri: None,
+            snippet: "测试片段".to_string(),
+            relevance_score: None,
+        };
+
+        assert_eq!(source.title, "测试来源");
+        assert!(source.uri.is_none());
+        assert_eq!(source.snippet, "测试片段");
+        assert!(source.relevance_score.is_none());
+    }
+
+    #[test]
+    fn test_rag_grounding_config_with_system_prompt() {
+        let mut config = RagGroundingConfig::default();
+        config.system_prompt = Some("你是一个专业的助手".to_string());
+
+        assert!(config.system_prompt.is_some());
+        assert_eq!(config.system_prompt.unwrap(), "你是一个专业的助手");
+    }
+
+    #[test]
+    fn test_rag_grounding_config_custom_values() {
+        let config = RagGroundingConfig {
+            project_id: "custom-project".to_string(),
+            location: "us-central1".to_string(),
+            data_store_id: "custom-datastore".to_string(),
+            model_id: "gemini-pro".to_string(),
+            temperature: 0.5,
+            max_output_tokens: 4096,
+            system_prompt: Some("自定义系统提示".to_string()),
+        };
+
+        assert_eq!(config.project_id, "custom-project");
+        assert_eq!(config.location, "us-central1");
+        assert_eq!(config.data_store_id, "custom-datastore");
+        assert_eq!(config.model_id, "gemini-pro");
+        assert_eq!(config.temperature, 0.5);
+        assert_eq!(config.max_output_tokens, 4096);
+        assert_eq!(config.system_prompt, Some("自定义系统提示".to_string()));
+    }
+
+    #[test]
+    fn test_gemini_service_creation() {
+        let service = create_test_service();
+        // 基本的服务创建测试，确保没有panic
+        assert!(true); // 如果能到这里说明服务创建成功
+    }
+
+    /// 测试 JSON 响应解析
+    #[test]
+    fn test_parse_rag_grounding_response_json() {
+        let service = create_test_service();
+        
+        // 模拟一个典型的 Gemini API 响应
+        let mock_response = r#"{
+            "candidates": [{
+                "content": {
+                    "parts": [{
+                        "text": "这是一个测试回答"
+                    }]
+                },
+                "groundingMetadata": {
+                    "groundingSources": [{
+                        "title": "测试文档",
+                        "uri": "https://example.com/doc",
+                        "snippet": "这是一个测试片段",
+                        "relevanceScore": 0.85
+                    }],
+                    "searchQueries": ["测试查询"]
+                }
+            }]
+        }"#;
+
+        let result = service.parse_rag_grounding_response(mock_response);
+        assert!(result.is_ok());
+
+        let response = result.unwrap();
+        assert_eq!(response.answer, "这是一个测试回答");
+        assert!(response.grounding_metadata.is_some());
+
+        let metadata = response.grounding_metadata.unwrap();
+        assert_eq!(metadata.sources.len(), 1);
+        assert_eq!(metadata.search_queries.len(), 1);
+
+        let source = &metadata.sources[0];
+        assert_eq!(source.title, "测试文档");
+        assert_eq!(source.uri, Some("https://example.com/doc".to_string()));
+        assert_eq!(source.snippet, "这是一个测试片段");
+        assert_eq!(source.relevance_score, Some(0.85));
+    }
+
+    /// 测试无效 JSON 响应处理
+    #[test]
+    fn test_parse_invalid_json_response() {
+        let service = create_test_service();
+        
+        let invalid_json = "这不是有效的JSON";
+        let result = service.parse_rag_grounding_response(invalid_json);
+        assert!(result.is_err());
+    }
+
+    /// 测试缺少必要字段的响应
+    #[test]
+    fn test_parse_incomplete_response() {
+        let service = create_test_service();
+        
+        let incomplete_response = r#"{
+            "candidates": []
+        }"#;
+
+        let result = service.parse_rag_grounding_response(incomplete_response);
+        assert!(result.is_ok());
+
+        let response = result.unwrap();
+        assert_eq!(response.answer, "无法解析响应内容");
+        assert!(response.grounding_metadata.is_none());
+    }
+}
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 4dd5d8a..dee2be5 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -306,7 +306,11 @@ pub fn run() {
             commands::tolerant_json_commands::validate_json_format,
             commands::tolerant_json_commands::format_json_text,
             commands::tolerant_json_commands::get_recovery_strategies,
-            commands::tolerant_json_commands::get_default_parser_config
+            commands::tolerant_json_commands::get_default_parser_config,
+            // RAG Grounding命令
+            commands::rag_grounding_commands::query_rag_grounding,
+            commands::rag_grounding_commands::test_rag_grounding_connection,
+            commands::rag_grounding_commands::get_rag_grounding_config
         ])
         .setup(|app| {
             // 初始化日志系统
diff --git a/apps/desktop/src-tauri/src/presentation/commands/mod.rs b/apps/desktop/src-tauri/src/presentation/commands/mod.rs
index eb93261..abab292 100644
--- a/apps/desktop/src-tauri/src/presentation/commands/mod.rs
+++ b/apps/desktop/src-tauri/src/presentation/commands/mod.rs
@@ -21,3 +21,4 @@ pub mod tools_commands;
 pub mod outfit_search_commands;
 pub mod custom_tag_commands;
 pub mod tolerant_json_commands;
+pub mod rag_grounding_commands;
diff --git a/apps/desktop/src-tauri/src/presentation/commands/rag_grounding_commands.rs b/apps/desktop/src-tauri/src/presentation/commands/rag_grounding_commands.rs
new file mode 100644
index 0000000..ae7a3b9
--- /dev/null
+++ b/apps/desktop/src-tauri/src/presentation/commands/rag_grounding_commands.rs
@@ -0,0 +1,123 @@
+use tauri::{command, State};
+use crate::infrastructure::gemini_service::{GeminiService, GeminiConfig, RagGroundingRequest, RagGroundingResponse};
+use crate::app_state::AppState;
+
+/// RAG Grounding 查询命令
+/// 基于数据存储的检索增强生成，参考 RAGUtils.py 中的 query_llm_with_grounding 实现
+#[command]
+pub async fn query_rag_grounding(
+    _state: State<'_, AppState>,
+    request: RagGroundingRequest,
+) -> Result<RagGroundingResponse, String> {
+    println!("🔍 收到RAG Grounding查询请求: {}", request.user_input);
+
+    // 创建Gemini服务实例
+    let config = GeminiConfig::default();
+    let mut gemini_service = GeminiService::new(Some(config))
+        .map_err(|e| format!("创建GeminiService失败: {}", e))?;
+
+    // 执行RAG Grounding查询
+    let response = gemini_service
+        .query_llm_with_grounding(request)
+        .await
+        .map_err(|e| {
+            eprintln!("RAG Grounding查询失败: {}", e);
+            format!("RAG Grounding查询失败: {}", e)
+        })?;
+
+    println!("✅ RAG Grounding查询成功，响应时间: {}ms", response.response_time_ms);
+    Ok(response)
+}
+
+/// 测试RAG Grounding连接
+#[command]
+pub async fn test_rag_grounding_connection(
+    _state: State<'_, AppState>,
+) -> Result<String, String> {
+    println!("🔧 测试RAG Grounding连接");
+
+    // 创建Gemini服务实例
+    let config = GeminiConfig::default();
+    let mut gemini_service = GeminiService::new(Some(config))
+        .map_err(|e| format!("创建GeminiService失败: {}", e))?;
+
+    // 创建测试请求
+    let test_request = RagGroundingRequest {
+        user_input: "测试连接".to_string(),
+        config: None,
+        session_id: Some("test-session".to_string()),
+    };
+
+    // 执行测试查询
+    match gemini_service.query_llm_with_grounding(test_request).await {
+        Ok(response) => {
+            println!("✅ RAG Grounding连接测试成功");
+            Ok(format!("连接测试成功，响应时间: {}ms", response.response_time_ms))
+        }
+        Err(e) => {
+            eprintln!("❌ RAG Grounding连接测试失败: {}", e);
+            Err(format!("连接测试失败: {}", e))
+        }
+    }
+}
+
+/// 获取RAG Grounding配置信息
+#[command]
+pub async fn get_rag_grounding_config(
+    _state: State<'_, AppState>,
+) -> Result<serde_json::Value, String> {
+    println!("📋 获取RAG Grounding配置信息");
+
+    let config = GeminiConfig::default();
+    
+    let config_info = serde_json::json!({
+        "base_url": config.base_url,
+        "model_name": config.model_name,
+        "timeout": config.timeout,
+        "max_retries": config.max_retries,
+        "retry_delay": config.retry_delay,
+        "temperature": config.temperature,
+        "max_tokens": config.max_tokens,
+        "cloudflare_project_id": config.cloudflare_project_id,
+        "cloudflare_gateway_id": config.cloudflare_gateway_id,
+        "google_project_id": config.google_project_id,
+        "regions": config.regions
+    });
+
+    Ok(config_info)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::infrastructure::gemini_service::RagGroundingConfig;
+
+    #[tokio::test]
+    async fn test_rag_grounding_request_creation() {
+        let request = RagGroundingRequest {
+            user_input: "测试查询".to_string(),
+            config: Some(RagGroundingConfig::default()),
+            session_id: Some("test-session".to_string()),
+        };
+
+        assert_eq!(request.user_input, "测试查询");
+        assert!(request.config.is_some());
+        assert_eq!(request.session_id, Some("test-session".to_string()));
+    }
+
+    #[test]
+    fn test_rag_grounding_config_default() {
+        let config = RagGroundingConfig::default();
+        
+        assert_eq!(config.project_id, "gen-lang-client-0413414134");
+        assert_eq!(config.location, "global");
+        assert_eq!(config.model_id, "gemini-2.5-flash");
+        assert_eq!(config.temperature, 1.0);
+        assert_eq!(config.max_output_tokens, 8192);
+    }
+}
+
+// 导入测试文件
+#[cfg(test)]
+#[path = "rag_grounding_commands_tests.rs"]
+mod rag_grounding_commands_tests;
diff --git a/apps/desktop/src-tauri/src/presentation/commands/rag_grounding_commands_tests.rs b/apps/desktop/src-tauri/src/presentation/commands/rag_grounding_commands_tests.rs
new file mode 100644
index 0000000..53e5701
--- /dev/null
+++ b/apps/desktop/src-tauri/src/presentation/commands/rag_grounding_commands_tests.rs
@@ -0,0 +1,189 @@
+#[cfg(test)]
+mod rag_grounding_commands_tests {
+    use super::*;
+    use crate::app_state::AppState;
+    use crate::infrastructure::gemini_service::{RagGroundingRequest, RagGroundingConfig};
+    use tauri::State;
+    use std::sync::Arc;
+
+    /// 创建测试用的 AppState
+    fn create_test_app_state() -> AppState {
+        AppState::new()
+    }
+
+    #[test]
+    fn test_rag_grounding_request_validation() {
+        let request = RagGroundingRequest {
+            user_input: "测试查询".to_string(),
+            config: Some(RagGroundingConfig::default()),
+            session_id: Some("test-session".to_string()),
+        };
+
+        // 验证请求结构
+        assert!(!request.user_input.is_empty());
+        assert!(request.config.is_some());
+        assert!(request.session_id.is_some());
+    }
+
+    #[test]
+    fn test_rag_grounding_config_serialization() {
+        let config = RagGroundingConfig::default();
+        
+        // 测试序列化
+        let serialized = serde_json::to_string(&config).expect("Failed to serialize config");
+        assert!(serialized.contains("gen-lang-client-0413414134"));
+        assert!(serialized.contains("gemini-2.5-flash"));
+        
+        // 测试反序列化
+        let deserialized: RagGroundingConfig = serde_json::from_str(&serialized)
+            .expect("Failed to deserialize config");
+        assert_eq!(deserialized.project_id, config.project_id);
+        assert_eq!(deserialized.model_id, config.model_id);
+    }
+
+    #[test]
+    fn test_empty_user_input_handling() {
+        let request = RagGroundingRequest {
+            user_input: "".to_string(),
+            config: None,
+            session_id: None,
+        };
+
+        // 空输入应该被正确处理
+        assert!(request.user_input.is_empty());
+        assert!(request.config.is_none());
+        assert!(request.session_id.is_none());
+    }
+
+    #[test]
+    fn test_custom_config_override() {
+        let custom_config = RagGroundingConfig {
+            project_id: "custom-project".to_string(),
+            location: "us-central1".to_string(),
+            data_store_id: "custom-datastore".to_string(),
+            model_id: "gemini-pro".to_string(),
+            temperature: 0.5,
+            max_output_tokens: 4096,
+            system_prompt: Some("自定义提示".to_string()),
+        };
+
+        let request = RagGroundingRequest {
+            user_input: "测试查询".to_string(),
+            config: Some(custom_config.clone()),
+            session_id: Some("custom-session".to_string()),
+        };
+
+        assert_eq!(request.config.as_ref().unwrap().project_id, "custom-project");
+        assert_eq!(request.config.as_ref().unwrap().temperature, 0.5);
+        assert_eq!(request.config.as_ref().unwrap().system_prompt, Some("自定义提示".to_string()));
+    }
+
+    #[test]
+    fn test_session_id_generation() {
+        let session_id = format!("session-{}", chrono::Utc::now().timestamp());
+        
+        let request = RagGroundingRequest {
+            user_input: "测试查询".to_string(),
+            config: None,
+            session_id: Some(session_id.clone()),
+        };
+
+        assert_eq!(request.session_id, Some(session_id));
+        assert!(request.session_id.as_ref().unwrap().starts_with("session-"));
+    }
+
+    #[test]
+    fn test_config_json_structure() {
+        let config = RagGroundingConfig::default();
+        let json_value = serde_json::to_value(&config).expect("Failed to convert to JSON");
+
+        // 验证必要字段存在
+        assert!(json_value.get("project_id").is_some());
+        assert!(json_value.get("location").is_some());
+        assert!(json_value.get("data_store_id").is_some());
+        assert!(json_value.get("model_id").is_some());
+        assert!(json_value.get("temperature").is_some());
+        assert!(json_value.get("max_output_tokens").is_some());
+
+        // 验证字段类型
+        assert!(json_value["project_id"].is_string());
+        assert!(json_value["temperature"].is_number());
+        assert!(json_value["max_output_tokens"].is_number());
+    }
+
+    #[test]
+    fn test_request_with_minimal_data() {
+        let request = RagGroundingRequest {
+            user_input: "简单查询".to_string(),
+            config: None,
+            session_id: None,
+        };
+
+        // 最小数据请求应该有效
+        assert_eq!(request.user_input, "简单查询");
+        assert!(request.config.is_none());
+        assert!(request.session_id.is_none());
+    }
+
+    #[test]
+    fn test_unicode_input_handling() {
+        let unicode_input = "测试中文输入 🔍 emoji 和特殊字符 @#$%";
+        
+        let request = RagGroundingRequest {
+            user_input: unicode_input.to_string(),
+            config: None,
+            session_id: None,
+        };
+
+        assert_eq!(request.user_input, unicode_input);
+        
+        // 测试序列化包含Unicode字符的请求
+        let serialized = serde_json::to_string(&request).expect("Failed to serialize Unicode request");
+        assert!(serialized.contains("测试中文输入"));
+        assert!(serialized.contains("🔍"));
+    }
+
+    #[test]
+    fn test_long_input_handling() {
+        let long_input = "这是一个很长的输入".repeat(100);
+        
+        let request = RagGroundingRequest {
+            user_input: long_input.clone(),
+            config: None,
+            session_id: None,
+        };
+
+        assert_eq!(request.user_input.len(), long_input.len());
+        assert!(request.user_input.len() > 1000); // 确保输入确实很长
+    }
+
+    #[test]
+    fn test_config_temperature_bounds() {
+        let mut config = RagGroundingConfig::default();
+        
+        // 测试不同的温度值
+        config.temperature = 0.0;
+        assert_eq!(config.temperature, 0.0);
+        
+        config.temperature = 1.0;
+        assert_eq!(config.temperature, 1.0);
+        
+        config.temperature = 2.0;
+        assert_eq!(config.temperature, 2.0);
+    }
+
+    #[test]
+    fn test_config_token_limits() {
+        let mut config = RagGroundingConfig::default();
+        
+        // 测试不同的令牌限制
+        config.max_output_tokens = 1024;
+        assert_eq!(config.max_output_tokens, 1024);
+        
+        config.max_output_tokens = 8192;
+        assert_eq!(config.max_output_tokens, 8192);
+        
+        config.max_output_tokens = 32768;
+        assert_eq!(config.max_output_tokens, 32768);
+    }
+}
diff --git a/apps/desktop/src/services/ragGroundingService.ts b/apps/desktop/src/services/ragGroundingService.ts
new file mode 100644
index 0000000..f7f0acd
--- /dev/null
+++ b/apps/desktop/src/services/ragGroundingService.ts
@@ -0,0 +1,263 @@
+import { invoke } from '@tauri-apps/api/core';
+import {
+  RagGroundingRequest,
+  RagGroundingResponse,
+  RagGroundingConfig,
+  RagGroundingConfigInfo,
+  RagGroundingQueryOptions,
+  RagGroundingQueryResult,
+  RagGroundingServiceStatus,
+  RagGroundingError,
+  RagGroundingErrorType,
+  RagGroundingStats,
+  DEFAULT_RAG_GROUNDING_CONFIG,
+} from '../types/ragGrounding';
+
+/**
+ * RAG Grounding 服务
+ * 提供基于检索增强生成的智能问答功能
+ */
+export class RagGroundingService {
+  private static instance: RagGroundingService;
+  private stats: RagGroundingStats = {
+    totalQueries: 0,
+    successfulQueries: 0,
+    failedQueries: 0,
+    averageResponseTime: 0,
+    fastestResponseTime: Infinity,
+    slowestResponseTime: 0,
+  };
+
+  private constructor() {}
+
+  /**
+   * 获取服务单例实例
+   */
+  public static getInstance(): RagGroundingService {
+    if (!RagGroundingService.instance) {
+      RagGroundingService.instance = new RagGroundingService();
+    }
+    return RagGroundingService.instance;
+  }
+
+  /**
+   * 执行 RAG Grounding 查询
+   */
+  public async queryRagGrounding(
+    userInput: string,
+    options: RagGroundingQueryOptions = {}
+  ): Promise<RagGroundingQueryResult> {
+    const startTime = new Date();
+    this.stats.totalQueries++;
+
+    try {
+      // 构建请求配置
+      const config: RagGroundingConfig = {
+        ...DEFAULT_RAG_GROUNDING_CONFIG,
+        ...options.customConfig,
+      };
+
+      // 构建请求
+      const request: RagGroundingRequest = {
+        user_input: userInput,
+        config,
+        session_id: options.sessionId,
+      };
+
+      console.log('🔍 发起RAG Grounding查询:', { userInput, options });
+
+      // 调用后端命令
+      const response = await invoke<RagGroundingResponse>('query_rag_grounding', {
+        request,
+      });
+
+      const endTime = new Date();
+      const totalTime = endTime.getTime() - startTime.getTime();
+
+      // 更新统计信息
+      this.updateStats(true, totalTime);
+
+      console.log('✅ RAG Grounding查询成功:', response);
+
+      return {
+        success: true,
+        data: response,
+        startTime,
+        endTime,
+        totalTime,
+      };
+    } catch (error) {
+      const endTime = new Date();
+      const totalTime = endTime.getTime() - startTime.getTime();
+
+      // 更新统计信息
+      this.updateStats(false, totalTime);
+
+      console.error('❌ RAG Grounding查询失败:', error);
+
+      return {
+        success: false,
+        error: this.formatError(error),
+        startTime,
+        endTime,
+        totalTime,
+      };
+    }
+  }
+
+  /**
+   * 测试 RAG Grounding 连接
+   */
+  public async testConnection(): Promise<RagGroundingServiceStatus> {
+    const lastChecked = new Date();
+
+    try {
+      console.log('🔧 测试RAG Grounding连接');
+
+      const connectionTest = await invoke<string>('test_rag_grounding_connection');
+      const config = await this.getConfig();
+
+      console.log('✅ RAG Grounding连接测试成功:', connectionTest);
+
+      return {
+        available: true,
+        lastChecked,
+        connectionTest,
+        config,
+      };
+    } catch (error) {
+      console.error('❌ RAG Grounding连接测试失败:', error);
+
+      return {
+        available: false,
+        lastChecked,
+        connectionTest: this.formatError(error),
+      };
+    }
+  }
+
+  /**
+   * 获取 RAG Grounding 配置信息
+   */
+  public async getConfig(): Promise<RagGroundingConfigInfo> {
+    try {
+      console.log('📋 获取RAG Grounding配置信息');
+
+      const config = await invoke<RagGroundingConfigInfo>('get_rag_grounding_config');
+
+      console.log('✅ 获取RAG Grounding配置成功:', config);
+
+      return config;
+    } catch (error) {
+      console.error('❌ 获取RAG Grounding配置失败:', error);
+      throw new Error(`获取配置失败: ${this.formatError(error)}`);
+    }
+  }
+
+  /**
+   * 获取服务统计信息
+   */
+  public getStats(): RagGroundingStats {
+    return { ...this.stats };
+  }
+
+  /**
+   * 重置统计信息
+   */
+  public resetStats(): void {
+    this.stats = {
+      totalQueries: 0,
+      successfulQueries: 0,
+      failedQueries: 0,
+      averageResponseTime: 0,
+      fastestResponseTime: Infinity,
+      slowestResponseTime: 0,
+    };
+  }
+
+  /**
+   * 更新统计信息
+   */
+  private updateStats(success: boolean, responseTime: number): void {
+    if (success) {
+      this.stats.successfulQueries++;
+    } else {
+      this.stats.failedQueries++;
+    }
+
+    // 更新响应时间统计
+    if (responseTime < this.stats.fastestResponseTime) {
+      this.stats.fastestResponseTime = responseTime;
+    }
+    if (responseTime > this.stats.slowestResponseTime) {
+      this.stats.slowestResponseTime = responseTime;
+    }
+
+    // 计算平均响应时间
+    const totalResponseTime = this.stats.averageResponseTime * (this.stats.totalQueries - 1) + responseTime;
+    this.stats.averageResponseTime = totalResponseTime / this.stats.totalQueries;
+
+    this.stats.lastQueryTime = new Date();
+  }
+
+  /**
+   * 格式化错误信息
+   */
+  private formatError(error: any): string {
+    if (typeof error === 'string') {
+      return error;
+    }
+    if (error?.message) {
+      return error.message;
+    }
+    return JSON.stringify(error);
+  }
+
+  /**
+   * 创建 RAG Grounding 错误
+   */
+  private createError(type: RagGroundingErrorType, message: string, details?: any): RagGroundingError {
+    return {
+      type,
+      message,
+      details,
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * 导出服务实例
+ */
+export const ragGroundingService = RagGroundingService.getInstance();
+
+/**
+ * 便捷方法：执行 RAG Grounding 查询
+ */
+export async function queryRagGrounding(
+  userInput: string,
+  options?: RagGroundingQueryOptions
+): Promise<RagGroundingQueryResult> {
+  return ragGroundingService.queryRagGrounding(userInput, options);
+}
+
+/**
+ * 便捷方法：测试 RAG Grounding 连接
+ */
+export async function testRagGroundingConnection(): Promise<RagGroundingServiceStatus> {
+  return ragGroundingService.testConnection();
+}
+
+/**
+ * 便捷方法：获取 RAG Grounding 配置
+ */
+export async function getRagGroundingConfig(): Promise<RagGroundingConfigInfo> {
+  return ragGroundingService.getConfig();
+}
+
+/**
+ * 便捷方法：获取 RAG Grounding 统计信息
+ */
+export function getRagGroundingStats(): RagGroundingStats {
+  return ragGroundingService.getStats();
+}
diff --git a/apps/desktop/src/types/ragGrounding.ts b/apps/desktop/src/types/ragGrounding.ts
new file mode 100644
index 0000000..b3cbc8a
--- /dev/null
+++ b/apps/desktop/src/types/ragGrounding.ts
@@ -0,0 +1,171 @@
+/**
+ * RAG Grounding 相关类型定义
+ * 基于 Rust 后端的数据结构，提供类型安全的前端接口
+ */
+
+/**
+ * RAG Grounding 配置
+ */
+export interface RagGroundingConfig {
+  project_id: string;
+  location: string;
+  data_store_id: string;
+  model_id: string;
+  temperature: number;
+  max_output_tokens: number;
+  system_prompt?: string;
+}
+
+/**
+ * RAG Grounding 请求
+ */
+export interface RagGroundingRequest {
+  user_input: string;
+  config?: RagGroundingConfig;
+  session_id?: string;
+}
+
+/**
+ * RAG Grounding 响应
+ */
+export interface RagGroundingResponse {
+  answer: string;
+  grounding_metadata?: GroundingMetadata;
+  response_time_ms: number;
+  model_used: string;
+}
+
+/**
+ * Grounding 元数据
+ */
+export interface GroundingMetadata {
+  sources: GroundingSource[];
+  search_queries: string[];
+}
+
+/**
+ * Grounding 来源
+ */
+export interface GroundingSource {
+  title: string;
+  uri?: string;
+  snippet: string;
+  relevance_score?: number;
+}
+
+/**
+ * RAG Grounding 配置信息
+ */
+export interface RagGroundingConfigInfo {
+  base_url: string;
+  model_name: string;
+  timeout: number;
+  max_retries: number;
+  retry_delay: number;
+  temperature: number;
+  max_tokens: number;
+  cloudflare_project_id: string;
+  cloudflare_gateway_id: string;
+  google_project_id: string;
+  regions: string[];
+}
+
+/**
+ * RAG Grounding 默认配置
+ */
+export const DEFAULT_RAG_GROUNDING_CONFIG: RagGroundingConfig = {
+  project_id: "gen-lang-client-0413414134",
+  location: "global",
+  data_store_id: "default_data_store",
+  model_id: "gemini-2.5-flash",
+  temperature: 1.0,
+  max_output_tokens: 8192,
+};
+
+/**
+ * RAG Grounding 查询选项
+ */
+export interface RagGroundingQueryOptions {
+  /** 是否包含 grounding 元数据 */
+  includeMetadata?: boolean;
+  /** 会话ID，用于上下文保持 */
+  sessionId?: string;
+  /** 自定义配置 */
+  customConfig?: Partial<RagGroundingConfig>;
+  /** 超时时间（毫秒） */
+  timeout?: number;
+}
+
+/**
+ * RAG Grounding 查询结果
+ */
+export interface RagGroundingQueryResult {
+  /** 查询是否成功 */
+  success: boolean;
+  /** 响应数据 */
+  data?: RagGroundingResponse;
+  /** 错误信息 */
+  error?: string;
+  /** 查询开始时间 */
+  startTime: Date;
+  /** 查询结束时间 */
+  endTime: Date;
+  /** 总耗时（毫秒） */
+  totalTime: number;
+}
+
+/**
+ * RAG Grounding 服务状态
+ */
+export interface RagGroundingServiceStatus {
+  /** 服务是否可用 */
+  available: boolean;
+  /** 最后检查时间 */
+  lastChecked: Date;
+  /** 连接测试结果 */
+  connectionTest?: string;
+  /** 配置信息 */
+  config?: RagGroundingConfigInfo;
+}
+
+/**
+ * RAG Grounding 错误类型
+ */
+export enum RagGroundingErrorType {
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  AUTHENTICATION_ERROR = 'AUTHENTICATION_ERROR',
+  CONFIGURATION_ERROR = 'CONFIGURATION_ERROR',
+  TIMEOUT_ERROR = 'TIMEOUT_ERROR',
+  PARSING_ERROR = 'PARSING_ERROR',
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',
+}
+
+/**
+ * RAG Grounding 错误
+ */
+export interface RagGroundingError {
+  type: RagGroundingErrorType;
+  message: string;
+  details?: any;
+  timestamp: Date;
+}
+
+/**
+ * RAG Grounding 统计信息
+ */
+export interface RagGroundingStats {
+  /** 总查询次数 */
+  totalQueries: number;
+  /** 成功查询次数 */
+  successfulQueries: number;
+  /** 失败查询次数 */
+  failedQueries: number;
+  /** 平均响应时间（毫秒） */
+  averageResponseTime: number;
+  /** 最快响应时间（毫秒） */
+  fastestResponseTime: number;
+  /** 最慢响应时间（毫秒） */
+  slowestResponseTime: number;
+  /** 最后查询时间 */
+  lastQueryTime?: Date;
+}
diff --git a/docs/rag-grounding-api.md b/docs/rag-grounding-api.md
new file mode 100644
index 0000000..f351b8d
--- /dev/null
+++ b/docs/rag-grounding-api.md
@@ -0,0 +1,264 @@
+# RAG Grounding API 文档
+
+## 概述
+
+RAG Grounding 服务基于 Google Vertex AI Search 和 Gemini 模型，提供检索增强生成（Retrieval-Augmented Generation）功能。该服务参考了 `promptx/outfit-match` 项目中的 `query_llm_with_grounding` 实现，遵循 Tauri 桌面应用开发规范。
+
+## 核心特性
+
+- **检索增强生成**：基于数据存储的智能检索和内容生成
+- **Cloudflare Gateway 集成**：通过 Cloudflare Gateway 访问 Google Vertex AI
+- **容错机制**：内置重试机制和错误处理
+- **类型安全**：完整的 TypeScript 类型定义
+- **性能监控**：响应时间统计和性能指标
+
+## API 接口
+
+### 1. 查询 RAG Grounding
+
+**命令**: `query_rag_grounding`
+
+**请求参数**:
+```typescript
+interface RagGroundingRequest {
+  user_input: string;           // 用户查询内容
+  config?: RagGroundingConfig;  // 可选配置
+  session_id?: string;          // 会话ID
+}
+```
+
+**响应数据**:
+```typescript
+interface RagGroundingResponse {
+  answer: string;                        // AI 生成的回答
+  grounding_metadata?: GroundingMetadata; // Grounding 元数据
+  response_time_ms: number;              // 响应时间（毫秒）
+  model_used: string;                    // 使用的模型
+}
+```
+
+**使用示例**:
+```typescript
+import { queryRagGrounding } from '../services/ragGroundingService';
+
+const result = await queryRagGrounding("如何搭配牛仔裤？", {
+  sessionId: "user-session-123",
+  customConfig: {
+    temperature: 0.7,
+    max_output_tokens: 4096
+  }
+});
+
+if (result.success) {
+  console.log("回答:", result.data?.answer);
+  console.log("来源:", result.data?.grounding_metadata?.sources);
+} else {
+  console.error("查询失败:", result.error);
+}
+```
+
+### 2. 测试连接
+
+**命令**: `test_rag_grounding_connection`
+
+**响应数据**: `string` - 连接测试结果
+
+**使用示例**:
+```typescript
+import { testRagGroundingConnection } from '../services/ragGroundingService';
+
+const status = await testRagGroundingConnection();
+console.log("服务状态:", status.available ? "可用" : "不可用");
+console.log("测试结果:", status.connectionTest);
+```
+
+### 3. 获取配置信息
+
+**命令**: `get_rag_grounding_config`
+
+**响应数据**:
+```typescript
+interface RagGroundingConfigInfo {
+  base_url: string;
+  model_name: string;
+  timeout: number;
+  max_retries: number;
+  retry_delay: number;
+  temperature: number;
+  max_tokens: number;
+  cloudflare_project_id: string;
+  cloudflare_gateway_id: string;
+  google_project_id: string;
+  regions: string[];
+}
+```
+
+## 配置选项
+
+### RagGroundingConfig
+
+```typescript
+interface RagGroundingConfig {
+  project_id: string;          // Google Cloud 项目ID
+  location: string;            // 数据存储位置
+  data_store_id: string;       // 数据存储ID
+  model_id: string;            // 模型ID
+  temperature: number;         // 生成温度 (0.0-2.0)
+  max_output_tokens: number;   // 最大输出令牌数
+  system_prompt?: string;      // 系统提示词
+}
+```
+
+### 默认配置
+
+```typescript
+const DEFAULT_CONFIG = {
+  project_id: "gen-lang-client-0413414134",
+  location: "global",
+  data_store_id: "default_data_store",
+  model_id: "gemini-2.5-flash",
+  temperature: 1.0,
+  max_output_tokens: 8192,
+};
+```
+
+## Grounding 元数据
+
+### GroundingMetadata
+
+```typescript
+interface GroundingMetadata {
+  sources: GroundingSource[];    // 检索来源
+  search_queries: string[];      // 搜索查询
+}
+```
+
+### GroundingSource
+
+```typescript
+interface GroundingSource {
+  title: string;              // 来源标题
+  uri?: string;               // 来源URI
+  snippet: string;            // 内容片段
+  relevance_score?: number;   // 相关性评分 (0.0-1.0)
+}
+```
+
+## 错误处理
+
+### 错误类型
+
+```typescript
+enum RagGroundingErrorType {
+  NETWORK_ERROR = 'NETWORK_ERROR',           // 网络错误
+  AUTHENTICATION_ERROR = 'AUTHENTICATION_ERROR', // 认证错误
+  CONFIGURATION_ERROR = 'CONFIGURATION_ERROR',   // 配置错误
+  TIMEOUT_ERROR = 'TIMEOUT_ERROR',           // 超时错误
+  PARSING_ERROR = 'PARSING_ERROR',           // 解析错误
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',           // 未知错误
+}
+```
+
+### 错误处理示例
+
+```typescript
+try {
+  const result = await queryRagGrounding("测试查询");
+  if (!result.success) {
+    switch (result.error) {
+      case 'NETWORK_ERROR':
+        console.error("网络连接失败，请检查网络设置");
+        break;
+      case 'AUTHENTICATION_ERROR':
+        console.error("认证失败，请检查API密钥");
+        break;
+      default:
+        console.error("查询失败:", result.error);
+    }
+  }
+} catch (error) {
+  console.error("系统错误:", error);
+}
+```
+
+## 性能监控
+
+### 统计信息
+
+```typescript
+interface RagGroundingStats {
+  totalQueries: number;         // 总查询次数
+  successfulQueries: number;    // 成功查询次数
+  failedQueries: number;        // 失败查询次数
+  averageResponseTime: number;  // 平均响应时间
+  fastestResponseTime: number;  // 最快响应时间
+  slowestResponseTime: number;  // 最慢响应时间
+  lastQueryTime?: Date;         // 最后查询时间
+}
+```
+
+### 获取统计信息
+
+```typescript
+import { getRagGroundingStats } from '../services/ragGroundingService';
+
+const stats = getRagGroundingStats();
+console.log(`成功率: ${(stats.successfulQueries / stats.totalQueries * 100).toFixed(2)}%`);
+console.log(`平均响应时间: ${stats.averageResponseTime.toFixed(0)}ms`);
+```
+
+## 最佳实践
+
+### 1. 查询优化
+
+- 使用清晰、具体的查询语句
+- 适当设置温度参数（创意性 vs 准确性）
+- 合理设置最大输出令牌数
+
+### 2. 会话管理
+
+- 为相关查询使用相同的 session_id
+- 定期清理过期会话
+
+### 3. 错误处理
+
+- 实现重试机制
+- 提供用户友好的错误信息
+- 记录详细的错误日志
+
+### 4. 性能优化
+
+- 监控响应时间
+- 缓存常见查询结果
+- 使用适当的超时设置
+
+## 开发规范
+
+本 RAG Grounding 服务严格遵循 `promptx/tauri-desktop-app-expert` 中定义的开发规范：
+
+- **安全第一**：最小权限原则，数据加密保护
+- **性能优先**：异步处理，响应时间优化
+- **类型安全**：完整的 TypeScript 类型定义
+- **模块化设计**：清晰的架构分层
+- **错误处理完善**：全面的错误处理和用户反馈
+
+## 技术架构
+
+```
+Frontend (TypeScript)
+    ↓
+Tauri Commands
+    ↓
+Rust Backend (GeminiService)
+    ↓
+Cloudflare Gateway
+    ↓
+Google Vertex AI Search + Gemini
+```
+
+## 依赖项
+
+- **Rust**: anyhow, serde, tokio, reqwest
+- **TypeScript**: @tauri-apps/api
+- **Google Cloud**: Vertex AI Search, Gemini API
+- **Cloudflare**: Gateway 服务
diff --git a/examples/rag-grounding-usage.ts b/examples/rag-grounding-usage.ts
new file mode 100644
index 0000000..b803a83
--- /dev/null
+++ b/examples/rag-grounding-usage.ts
@@ -0,0 +1,321 @@
+/**
+ * RAG Grounding 服务使用示例
+ * 
+ * 本文件展示了如何在前端应用中使用 RAG Grounding 服务
+ * 包括基本查询、配置管理、错误处理和性能监控等功能
+ */
+
+import {
+  queryRagGrounding,
+  testRagGroundingConnection,
+  getRagGroundingConfig,
+  getRagGroundingStats,
+  ragGroundingService,
+} from '../apps/desktop/src/services/ragGroundingService';
+
+import {
+  RagGroundingQueryOptions,
+  RagGroundingConfig,
+  DEFAULT_RAG_GROUNDING_CONFIG,
+} from '../apps/desktop/src/types/ragGrounding';
+
+/**
+ * 示例 1: 基本查询
+ */
+async function basicQueryExample() {
+  console.log('=== 基本查询示例 ===');
+  
+  try {
+    const result = await queryRagGrounding("如何搭配牛仔裤？");
+    
+    if (result.success && result.data) {
+      console.log('查询成功!');
+      console.log('回答:', result.data.answer);
+      console.log('响应时间:', result.data.response_time_ms, 'ms');
+      console.log('使用模型:', result.data.model_used);
+      
+      // 显示 Grounding 来源
+      if (result.data.grounding_metadata?.sources) {
+        console.log('参考来源:');
+        result.data.grounding_metadata.sources.forEach((source, index) => {
+          console.log(`  ${index + 1}. ${source.title}`);
+          console.log(`     片段: ${source.snippet}`);
+          if (source.relevance_score) {
+            console.log(`     相关性: ${(source.relevance_score * 100).toFixed(1)}%`);
+          }
+        });
+      }
+    } else {
+      console.error('查询失败:', result.error);
+    }
+  } catch (error) {
+    console.error('系统错误:', error);
+  }
+}
+
+/**
+ * 示例 2: 带配置的查询
+ */
+async function configuredQueryExample() {
+  console.log('=== 配置查询示例 ===');
+  
+  const customConfig: Partial<RagGroundingConfig> = {
+    temperature: 0.7,        // 降低温度以获得更准确的回答
+    max_output_tokens: 4096, // 限制输出长度
+    system_prompt: "你是一个专业的服装搭配顾问，请提供实用的搭配建议。",
+  };
+
+  const options: RagGroundingQueryOptions = {
+    sessionId: "fashion-consultation-session",
+    customConfig,
+    includeMetadata: true,
+  };
+
+  try {
+    const result = await queryRagGrounding(
+      "我有一条深蓝色牛仔裤，应该搭配什么颜色的上衣？",
+      options
+    );
+
+    if (result.success && result.data) {
+      console.log('专业搭配建议:', result.data.answer);
+      console.log('查询耗时:', result.totalTime, 'ms');
+    }
+  } catch (error) {
+    console.error('配置查询失败:', error);
+  }
+}
+
+/**
+ * 示例 3: 会话式对话
+ */
+async function conversationalExample() {
+  console.log('=== 会话式对话示例 ===');
+  
+  const sessionId = `conversation-${Date.now()}`;
+  
+  const questions = [
+    "我想了解春季服装搭配的基本原则",
+    "那么对于职场女性，有什么特别的建议吗？",
+    "如果是参加正式晚宴，应该如何选择服装？"
+  ];
+
+  for (let i = 0; i < questions.length; i++) {
+    console.log(`\n问题 ${i + 1}: ${questions[i]}`);
+    
+    try {
+      const result = await queryRagGrounding(questions[i], {
+        sessionId,
+        customConfig: {
+          temperature: 0.8,
+          system_prompt: "你是一个时尚顾问，请基于之前的对话上下文回答问题。"
+        }
+      });
+
+      if (result.success && result.data) {
+        console.log(`回答 ${i + 1}:`, result.data.answer.substring(0, 200) + '...');
+      }
+    } catch (error) {
+      console.error(`问题 ${i + 1} 查询失败:`, error);
+    }
+    
+    // 模拟用户思考时间
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+}
+
+/**
+ * 示例 4: 服务状态检查
+ */
+async function serviceStatusExample() {
+  console.log('=== 服务状态检查示例 ===');
+  
+  try {
+    // 测试连接
+    const status = await testRagGroundingConnection();
+    console.log('服务状态:', status.available ? '✅ 可用' : '❌ 不可用');
+    console.log('最后检查时间:', status.lastChecked.toLocaleString());
+    
+    if (status.connectionTest) {
+      console.log('连接测试结果:', status.connectionTest);
+    }
+
+    // 获取配置信息
+    const config = await getRagGroundingConfig();
+    console.log('服务配置:');
+    console.log('  基础URL:', config.base_url);
+    console.log('  模型名称:', config.model_name);
+    console.log('  超时时间:', config.timeout, '秒');
+    console.log('  最大重试次数:', config.max_retries);
+    console.log('  支持区域:', config.regions.join(', '));
+
+  } catch (error) {
+    console.error('状态检查失败:', error);
+  }
+}
+
+/**
+ * 示例 5: 性能监控
+ */
+async function performanceMonitoringExample() {
+  console.log('=== 性能监控示例 ===');
+  
+  // 执行一些查询以生成统计数据
+  const testQueries = [
+    "什么是时尚？",
+    "如何选择适合的颜色？",
+    "职场着装有什么要求？"
+  ];
+
+  console.log('执行测试查询...');
+  for (const query of testQueries) {
+    try {
+      await queryRagGrounding(query);
+    } catch (error) {
+      console.error('查询失败:', error);
+    }
+  }
+
+  // 获取统计信息
+  const stats = getRagGroundingStats();
+  console.log('\n性能统计:');
+  console.log('  总查询次数:', stats.totalQueries);
+  console.log('  成功查询次数:', stats.successfulQueries);
+  console.log('  失败查询次数:', stats.failedQueries);
+  console.log('  成功率:', `${(stats.successfulQueries / stats.totalQueries * 100).toFixed(2)}%`);
+  console.log('  平均响应时间:', `${stats.averageResponseTime.toFixed(0)}ms`);
+  console.log('  最快响应时间:', `${stats.fastestResponseTime}ms`);
+  console.log('  最慢响应时间:', `${stats.slowestResponseTime}ms`);
+  
+  if (stats.lastQueryTime) {
+    console.log('  最后查询时间:', stats.lastQueryTime.toLocaleString());
+  }
+}
+
+/**
+ * 示例 6: 错误处理和重试
+ */
+async function errorHandlingExample() {
+  console.log('=== 错误处理示例 ===');
+  
+  // 模拟可能失败的查询
+  const problematicQuery = ""; // 空查询可能导致错误
+
+  try {
+    const result = await queryRagGrounding(problematicQuery);
+    
+    if (!result.success) {
+      console.log('查询失败，错误信息:', result.error);
+      
+      // 根据错误类型进行不同处理
+      if (result.error?.includes('网络')) {
+        console.log('检测到网络错误，建议检查网络连接');
+      } else if (result.error?.includes('认证')) {
+        console.log('检测到认证错误，建议检查API密钥');
+      } else {
+        console.log('其他错误，建议稍后重试');
+      }
+      
+      // 实现简单的重试机制
+      console.log('尝试重新查询...');
+      const retryResult = await queryRagGrounding("什么是时尚搭配？");
+      
+      if (retryResult.success) {
+        console.log('重试成功!');
+      } else {
+        console.log('重试仍然失败:', retryResult.error);
+      }
+    }
+  } catch (error) {
+    console.error('系统级错误:', error);
+  }
+}
+
+/**
+ * 示例 7: 批量查询处理
+ */
+async function batchQueryExample() {
+  console.log('=== 批量查询示例 ===');
+  
+  const queries = [
+    "春季流行色彩有哪些？",
+    "如何搭配小白鞋？",
+    "商务休闲风格的特点是什么？",
+    "如何选择适合的包包？"
+  ];
+
+  console.log(`开始处理 ${queries.length} 个查询...`);
+  
+  const results = await Promise.allSettled(
+    queries.map(query => queryRagGrounding(query))
+  );
+
+  results.forEach((result, index) => {
+    console.log(`\n查询 ${index + 1}: ${queries[index]}`);
+    
+    if (result.status === 'fulfilled' && result.value.success) {
+      const data = result.value.data!;
+      console.log('✅ 成功');
+      console.log('回答:', data.answer.substring(0, 100) + '...');
+      console.log('响应时间:', data.response_time_ms, 'ms');
+    } else {
+      console.log('❌ 失败');
+      if (result.status === 'fulfilled') {
+        console.log('错误:', result.value.error);
+      } else {
+        console.log('异常:', result.reason);
+      }
+    }
+  });
+}
+
+/**
+ * 主函数 - 运行所有示例
+ */
+async function runAllExamples() {
+  console.log('🚀 RAG Grounding 服务使用示例\n');
+  
+  try {
+    await basicQueryExample();
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    await configuredQueryExample();
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    await conversationalExample();
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    await serviceStatusExample();
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    await performanceMonitoringExample();
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    await errorHandlingExample();
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    await batchQueryExample();
+    
+    console.log('\n✅ 所有示例执行完成!');
+    
+  } catch (error) {
+    console.error('示例执行过程中发生错误:', error);
+  }
+}
+
+// 导出示例函数供外部调用
+export {
+  basicQueryExample,
+  configuredQueryExample,
+  conversationalExample,
+  serviceStatusExample,
+  performanceMonitoringExample,
+  errorHandlingExample,
+  batchQueryExample,
+  runAllExamples,
+};
+
+// 如果直接运行此文件，执行所有示例
+if (require.main === module) {
+  runAllExamples();
+}