更新riper-5.mdc配置以启用自动应用，优化DifyApi类，新增文档子分段管理功能，包括获取、添加、更新和删除子分段的方法，同时改进OpenAiLLM类的初始化逻辑以支持环境变量配置。

.cursor/rules/riper-5.mdc

@@ -1,7 +1,7 @@
 ---
 description: 
 globs: 
-alwaysApply: false
+alwaysApply: true
 ---
 背景入门
 您是 Claude 3.7，并且已集成到 Cursor IDE（一个基于 AI 的 VS Code 分支）。由于您拥有强大的功能，您往往过于急躁，经常在没有明确请求的情况下实施更改，并自以为比我更了解代码，从而破坏了现有逻辑。这会导致代码出现不可接受的灾难。在我的代码库上工作时——无论是 Web 应用程序、数据管道、嵌入式系统还是任何其他软件项目——您未经授权的修改都可能引入细微的 bug 并破坏关键功能。为了避免这种情况，您必须遵循以下严格协议：
@@ -17,7 +17,6 @@ RIPER-5 模式
 允许：阅读文件、提出澄清问题、理解代码结构
 禁止：建议、实施、计划或任何行动暗示
 要求：你只能试图了解存在什么，而不是可能是什么
-持续时间：直到我明确发出信号进入下一个模式
 输出格式：以[模式：研究]开头，然后仅观察和问题
 模式二：创新
 [模式：创新]
@@ -26,7 +25,6 @@ RIPER-5 模式
 允许：讨论想法、优点/缺点、寻求反馈
 禁止：具体规划、实施细节或任何代码编写
 要求：所有想法都必须以可能性而非决定的形式呈现
-持续时间：直到我明确发出信号进入下一个模式
 输出格式：以[模式：创新]开头，然后仅包含可能性和考虑因素
 模式 3：计划
 [模式：计划]
@@ -44,7 +42,6 @@ IMPLEMENTATION CHECKLIST:
 2. [Specific action 2]
 ...
 n. [Final action]
-持续时间：直到我明确批准计划并发出进入下一模式的信号
 输出格式：以 [MODE: PLAN] 开头，然后仅包含规范和实施细节
 模式 4：执行
 [模式：执行]
@@ -52,7 +49,6 @@ n. [Final action]
 目的：准确执行模式 3 中的计划
 允许：仅执行批准计划中明确详述的内容
 禁止：任何不在计划内的偏差、改进或创造性添加
-进入要求：仅在我明确发出“进入执行模式”命令后才能进入
 偏差处理：如果发现任何需要偏差的问题，立即返回计划模式
 输出格式：以 [MODE: EXECUTE] 开头，然后仅执行与计划匹配的执行
 模式五：回顾
@@ -72,5 +68,6 @@ n. [Final action]
 在审查模式下，你必须标记哪怕是最小的偏差
 您无权在声明模式之外做出独立决定
 不遵守此协议将给我的代码库带来灾难性的后果
-模式转换信号
+
-按照顺序依次执行研究模式->计划模式->执行模式->审核模式
+
+请依次执行：研究模式->创新模式->计划模式->执行模式->回顾模式->审查模式

rag2_0/dify/DifyCompareTest.py

@@ -572,9 +572,8 @@ content: "{content}"
                     slot_info_data = json.loads(slot_info)
                 else:
                     slot_info_data = slot_info
-                slot_missing = slot_info_data.get("slot_missing", None)
+                slot_missing = slot_info_data.get("missing_slots", {})
-                slot_missing_str = "完整" if not slot_missing else "缺失"
+                slot_missing_str = "完整" if len(slot_missing) == 0 else "缺失"
-                
                 # 返回结果
                 return {
                     "问题": query,

rag2_0/dify/dify_client/dify_api.py

@@ -0,0 +1,645 @@
+import json
+import logging
+import os
+import time
+import mimetypes
+
+import requests
+from typing import Dict, List
+import urllib3
+# 禁用 SSL 警告
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+class DifyApi:
+    """
+    用于与Dify API进行交互的类。
+    """
+
+    def __init__(self, dify_url: str="http://10.1.16.39/v1", 
+                 dify_dataset_api_key: str="dataset-skLjmPVonjHo119OWNf3kAmY", 
+                 dify_app_api_key: str="app-wUdkWJx5zeOvmvBUZizMoSw3"):
+        self.dify_url = dify_url
+        self.dify_dataset_api_key = dify_dataset_api_key
+        self.dify_app_api_key = dify_app_api_key
+
+    def get_document_indexing_status(self, datasets_id: str, batch: str) -> bool:
+        """
+        获取文档的索引状态。
+
+        :param datasets_id: 数据集ID。
+        :param batch: 批次ID。
+        :return: 索引状态是否完成。
+        """
+        url = f'{self.dify_url}/datasets/{datasets_id}/documents/{batch}/indexing-status'
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}'
+        }
+
+        try:
+            response = requests.get(url, headers=headers, verify=False)
+            response.raise_for_status()
+            return response.json().get("data", [{}])[0].get("indexing_status") == "completed"
+        except Exception as e:
+            logging.error(f"获取索引状态失败: {e}")
+            return False
+
+    def upload_text_to_document(self, text_name: str, text: str, dataset_id: str, enable_subchunk:bool=False) -> str:
+        """
+        上传文本作为文档到Dify API并返回文档ID。
+
+        :param text_name: 文本文档的名称。
+        :param text: 文本文档的内容。
+        :param dataset_id: 数据集ID。
+        :return: 创建的文档ID。
+        :raises Exception: 如果文档创建失败。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/document/create_by_text"
+        headers = {
+            "Authorization": f"Bearer {self.dify_dataset_api_key}",
+            "Content-Type": "application/json"
+        }
+        if enable_subchunk:
+            doc_form='hierarchical_model'
+            mode='hierarchical'
+        else:
+            doc_form='text_model'
+            mode='custom'           
+        process_rule = {
+            "rules": {
+                "pre_processing_rules": [
+                    {"id": "remove_extra_spaces", "enabled": True},
+                    {"id": "remove_urls_emails", "enabled": False}
+                ],
+                "segmentation": {
+                    "separator": "==================================",
+                    "max_tokens": 1999,
+                    "chunk_overlap": 300
+                },
+                "parent_mode":"paragraph",
+                "subchunk_segmentation": {
+                    "separator": "\\n",
+                    "max_tokens": 100,
+                    "chunk_overlap": 20
+                },
+            },
+            "mode": mode
+        }
+        # 启用父子级模式 doc_form==hierarchical_model and mode==hierarchical
+        # 不启用父子级模式 doc_form==text_model and mode==custom
+        data = {
+            "name": text_name,
+            "text": text,
+            "indexing_technique": "high_quality",
+            "doc_form": doc_form,
+            "process_rule": process_rule,
+            "doc_language": "Chinese",
+        }
+
+        try:
+            response = requests.post(url=url, headers=headers, data=json.dumps(data), verify=False)
+            response.raise_for_status()
+        except Exception as e:
+            logging.error(f"上传文档失败: {e}")
+            raise
+
+        idx = 0
+        while idx < 5:
+            if self.get_document_indexing_status(dataset_id, response.json().get("batch")):
+                break
+            time.sleep(1)
+            idx += 1
+        else:
+            logging.warning("文档索引超时，可能需要手动检查。")
+
+        return response.json().get("document", {}).get("id", "")
+
+    def get_or_create_dataset_by_name(self, dataset_name: str, create_if_not_exist: bool=True) -> str:
+        """
+        通过名称获取或创建数据集。
+
+        :param dataset_name: 数据集名称。
+        :param create_if_not_exist: 如果数据集不存在是否创建。
+        :return: 数据集ID。
+        """
+        list_dataset = self.get_all_dataset_list()
+        for dataset in list_dataset:
+            if dataset["name"] == dataset_name:
+                return dataset["id"]
+        if create_if_not_exist:
+            logging.info(f"数据集不存在，创建数据集: {dataset_name}")
+            return self.create_dataset(dataset_name)
+        else:
+            raise Exception(f"数据集不存在: {dataset_name}")
+
+    def get_documents(self, dataset_id: str, keyword: str = None) -> Dict[str, dict]:
+        """
+        获取指定数据集的所有文档。
+
+        :param dataset_id: 数据集ID。
+        :param keyword: 关键词，用于过滤文档。
+        :return: 文档字典，键为文档ID，值为文档信息。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents"
+        headers = {"Authorization": f"Bearer {self.dify_dataset_api_key}"}
+        limit = 100
+        page = 0
+        all_document = {}
+        while True:
+            page += 1
+            params = {
+                'keyword': keyword,
+                'page': page,
+                'limit': limit
+            }
+
+            response = requests.get(url, headers=headers, params=params, verify=False)
+
+            if response.status_code == 200:
+                data = response.json()
+                parsed_data = {item["id"]: item for item in data['data']}
+                all_document.update(parsed_data)
+                if not data["has_more"]:
+                    break
+            else:
+                print(f"获取文档失败：{response.status_code}，{response.text}")
+                break
+
+        return all_document
+
+    def remove_dataset_all_doc(self, dataset_id: str):
+        """
+        删除数据集中所有的文档。
+
+        :param dataset_id: 数据集ID。
+        :raises: Exception 如果文档删除失败。
+        """
+        list_doc_id = self.get_documents(dataset_id=dataset_id)
+
+        delete_url = f"{self.dify_url}/datasets/{dataset_id}/documents"
+
+        headers = {"Authorization": f"Bearer {self.dify_dataset_api_key}"}
+        # 删除每个文档
+        for doc_id in list_doc_id:
+            response = requests.delete(url=f"{delete_url}/{doc_id}", headers=headers, verify=False)
+            if response.status_code != 200:
+                raise Exception(f"删除失败：{doc_id}，状态码：{response.status_code}，响应内容：{response.text}")
+
+        print(f"已删除文档ID列表: {list_doc_id}")
+
+    def create_dataset(self, dataset_name: str) -> str:
+        """
+        创建数据集。
+
+        :param dataset_name: 数据集名称。
+        :return: 创建的数据集ID。
+        :raises: Exception 如果数据集创建失败。
+        """
+        url = f'{self.dify_url}/datasets'
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        data = {'name': dataset_name, 
+                "indexing_technique": "high_quality", 
+                "permission": "all_team_members",}
+
+        response = requests.post(url, headers=headers, data=json.dumps(data), verify=False)
+
+        if response.status_code == 200:
+            return response.json()['id']
+        else:
+            raise Exception(f"请求失败，状态码: {response.status_code}, 响应内容: {response.text}")
+
+    def get_document_id(self, dataset_id: str, document_name: str) -> str:
+        """
+        获取指定名称的文档ID。
+
+        :param dataset_id: 数据集ID。
+        :param document_name: 文档名称。
+        :return: 文档ID，如果未找到则返回空字符串。
+        """
+        # 获取所有文档
+        doc_info = self.get_documents(dataset_id, keyword=document_name)
+        for doc_id, info in doc_info.items():
+            if info["name"].split('.')[0] == document_name:
+                return doc_id
+
+        print(f'获取文档ID失败。名称: {document_name}。原因：未找到文档ID')
+        return ''
+
+    def get_document_last_update_time(self, dataset_id: str, document_name: str) -> str:
+        """
+        获取指定文档的最后更新时间。
+
+        :param dataset_id: 数据集ID。
+        :param document_name: 文档名称。
+        :return: 最后更新时间字符串。
+        """
+        doc_dict = self.get_documents(dataset_id, keyword=document_name)
+
+        if len(doc_dict) != 1:
+            print(f'获取失败，{doc_dict}')
+            return ''
+        val = list(doc_dict.values())
+        return val[0]['created_at']
+
+    def del_document_by_name(self, dataset_id: str, document_name: str) -> bool:
+        """
+        通过文档名称删除文档。
+
+        :param dataset_id: 数据集ID。
+        :param document_name: 文档名称。
+        :return: 如果删除成功返回True，否则返回False。
+        """
+        document_id = self.get_document_id(dataset_id, document_name)
+        if document_id == '':
+            return False
+
+        return self.del_document_by_id(dataset_id, document_id)
+
+    def del_document_by_id(self, dataset_id: str, document_id: str) -> bool:
+        """
+        删除指定ID的文档。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :return: 如果删除成功返回True，否则返回False。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}'
+        }
+        response = requests.delete(url, headers=headers, verify=False)
+        if response.status_code == 200:
+            print("Document deleted successfully.")
+            return True
+        else:
+            print(f"Failed to delete document. Status code: {response.status_code}, Response: {response.text}")
+            return False
+
+    def get_all_dataset_list(self) -> List[dict]:
+        """
+        获取所有数据集列表。
+
+        :return: 数据集列表。
+        :raises: Exception 如果请求失败。
+        """
+        url = f'{self.dify_url}/datasets'
+        params = {
+            'page': 1,
+            'limit': 100
+        }
+
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}'
+        }
+
+        response = requests.get(url, headers=headers, params=params, verify=False)
+
+        if response.status_code == 200:
+            return response.json()['data']
+        else:
+            raise Exception(f"请求失败，状态码: {response.status_code}, 响应内容: {response.text}")
+
+    def add_document_segments(self, dataset_id: str, document_id: str, segments_list: List[dict]) -> bool:
+        """
+        向文档添加段落。每次最多上传50条数据。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :param segments_list: 段落列表。
+        :return: 如果所有段落添加成功则返回True，否则返回False。
+        :raises: Exception 如果请求失败。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}/segments"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        # 将segments_list按每50条数据分组
+        batch_size = 50
+        success = True
+        
+        for i in range(0, len(segments_list), batch_size):
+            batch = segments_list[i:i + batch_size]
+            segments = [
+                {
+                    "content": str(seg['content']),
+                    "answer": str(seg['answer']),
+                    "keywords": seg['keywords']
+                }
+                for seg in batch
+            ]
+
+            data = {'segments': segments}
+
+            try:
+                response = requests.post(url, headers=headers, data=json.dumps(data), verify=False)
+                if response.status_code == 200:
+                    response_data = response.json()['data']
+                    if response_data[0]['status'] == 'error':
+                        logging.error(f"分段上传失败： {response_data[0]['error']}")
+                        success = False
+                else:
+                    raise Exception(f"添加段落失败。状态码：{response.status_code}，响应：{response.text}")
+                    
+                # 添加短暂延时，避免请求过于频繁
+                time.sleep(0.5)
+                
+            except Exception as e:
+                logging.error(f"上传段落批次 {i//batch_size + 1} 失败: {e}")
+                success = False
+
+        return success
+
+    def get_document_segments(self, dataset_id: str, document_id: str) -> List[Dict]:
+        """
+        获取指定文档的分段信息。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :return: 分段信息列表。
+        :raises: Exception 如果请求失败。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}/segments"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        limit = 100
+        page = 0
+        all_segments = []
+
+        try:
+            while True:
+                page += 1
+                params = {
+                    'page': page,
+                    'limit': limit
+                }
+                
+                response = requests.get(url, headers=headers, params=params, verify=False)
+                response.raise_for_status()  # 如果响应状态码不是200，抛出异常
+                
+                data = response.json()
+                all_segments.extend(data.get("data", []))
+                
+                if not data.get("has_more", False):
+                    break
+                    
+            return all_segments
+        except Exception as e:
+            logging.error(f"获取文档分段失败: {e}")
+            raise
+
+    def update_document_segment(
+            self,
+            dataset_id: str,
+            document_id: str,
+            segment_id: str,
+            content: str,
+            answer: str,
+            keywords: List[str],
+            enabled: bool
+    ) -> Dict:
+        """
+        更新指定文档的某个分段信息。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :param segment_id: 分段ID。
+        :param content: 分段内容。
+        :param answer: 分段答案。
+        :param keywords: 分段关键词列表。
+        :param enabled: 是否启用分段。
+        :return: 更新后的分段信息。
+        :raises: Exception 如果请求失败。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        # 构造请求数据
+        data = {
+            "segment": {
+                "content": content,
+                "answer": answer,
+                "keywords": keywords,
+                "enabled": enabled,
+                "regenerate_child_chunks": True
+            }
+        }
+
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(data), verify=False)
+            response.raise_for_status()  # 如果响应状态码不是200，抛出异常
+            if response.json()["data"]['error']:
+                logging.error(f"更新文档分段失败: {response.json()['data']['error']}")
+                raise
+            return response.json().get("data", {})  # 返回更新后的分段信息
+        except Exception as e:
+            logging.error(f"更新文档分段失败: {e}")
+            raise
+
+    def upload_file(self, file_path: str, max_retries: int = 3) -> str:
+        url = f"{self.dify_url}/files/upload"
+        headers = {
+            'Authorization': f'Bearer {self.dify_app_api_key}'
+        }
+        
+        # 获取文件的MIME类型
+        mime_type = mimetypes.guess_type(file_path)[0]
+        if not mime_type:
+            raise Exception(f"无法确定文件类型: {file_path}")
+        
+        # 读取文件内容
+        with open(file_path, 'rb') as file:
+            file_content = file.read()
+        
+        for attempt in range(max_retries):
+            try:
+                files = {
+                    'file': (
+                        os.path.basename(file_path),
+                        file_content,
+                        mime_type
+                    )
+                }
+                response = requests.post(url, headers=headers, files=files, verify=False)
+                if response.ok:
+                    logging.info(f"上传文件成功，文件: {file_path}")
+                    return response.json()['id']
+                else:
+                    error_msg = f"上传文件失败，状态码: {response.status_code}, 响应: {response.text}"
+                    if attempt == max_retries - 1:  # 最后一次尝试
+                        raise Exception(error_msg)
+                    logging.warning(f"第{attempt + 1}次尝试失败: {error_msg}")
+                    time.sleep(1)  # 重试前等待1秒
+            except Exception as e:
+                if attempt == max_retries - 1:  # 最后一次尝试
+                    logging.error(f"上传文件失败: {e}")
+                    raise Exception(f"上传文件失败: {e}")
+                logging.warning(f"第{attempt + 1}次尝试失败: {e}")
+                time.sleep(1)  # 重试前等待1秒
+
+    def add_document_child_chunk(
+            self,
+            dataset_id: str,
+            document_id: str,
+            segment_id: str,
+            content: str
+    ) -> Dict:
+        """
+        新增文档子分段。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :param segment_id: 分段ID。
+        :param content: 子分段内容。
+        :return: 新增的子分段信息。
+        :raises: Exception 如果请求失败。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}/child_chunks"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        # 构造请求数据
+        data = {
+            "content": content
+        }
+
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(data), verify=False)
+            response.raise_for_status()  # 如果响应状态码不是200，抛出异常
+            return response.json().get("data", {})  # 返回新增的子分段信息
+        except Exception as e:
+            logging.error(f"新增文档子分段失败: {e}")
+            raise
+
+    def get_document_child_chunks(
+            self,
+            dataset_id: str,
+            document_id: str,
+            segment_id: str,
+            page: int = 1,
+            limit: int = 100
+    ) -> Dict:
+        """
+        获取文档子分段列表。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :param segment_id: 分段ID。
+        :param page: 页码，默认为1。
+        :param limit: 每页数量，默认为20。
+        :return: 子分段列表信息，包含分页信息。
+        :raises: Exception 如果请求失败。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}/child_chunks"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}'
+        }
+        
+        params = {
+            'page': page,
+            'limit': limit
+        }
+
+        try:
+            response = requests.get(url, headers=headers, params=params, verify=False)
+            response.raise_for_status()  # 如果响应状态码不是200，抛出异常
+            return response.json()  # 返回子分段列表信息，包含分页信息
+        except Exception as e:
+            logging.error(f"获取文档子分段列表失败: {e}")
+            raise
+
+    def del_document_child_chunk(
+            self,
+            dataset_id: str,
+            document_id: str,
+            segment_id: str,
+            child_chunk_id: str
+    ) -> bool:
+        """
+        删除文档子分段。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :param segment_id: 分段ID。
+        :param child_chunk_id: 子分段ID。
+        :return: 如果删除成功返回True，否则返回False。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}/child_chunks/{child_chunk_id}"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}'
+        }
+
+        try:
+            response = requests.delete(url, headers=headers, verify=False)
+            if response.status_code == 200:
+                logging.info(f"删除子分段成功: {child_chunk_id}")
+                return True
+            else:
+                logging.error(f"删除子分段失败，状态码: {response.status_code}, 响应: {response.text}")
+                return False
+        except Exception as e:
+            logging.error(f"删除子分段失败: {e}")
+            return False
+
+    def update_document_child_chunk(
+            self,
+            dataset_id: str,
+            document_id: str,
+            segment_id: str,
+            child_chunk_id: str,
+            content: str
+    ) -> Dict:
+        """
+        更新文档子分段内容。
+
+        :param dataset_id: 数据集ID。
+        :param document_id: 文档ID。
+        :param segment_id: 分段ID。
+        :param child_chunk_id: 子分段ID。
+        :param content: 更新的子分段内容。
+        :return: 更新后的子分段信息。
+        :raises: Exception 如果请求失败。
+        """
+        url = f"{self.dify_url}/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}/child_chunks/{child_chunk_id}"
+        headers = {
+            'Authorization': f'Bearer {self.dify_dataset_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        # 构造请求数据
+        data = {
+            "content": content
+        }
+
+        try:
+            response = requests.patch(url, headers=headers, data=json.dumps(data), verify=False)
+            response.raise_for_status()  # 如果响应状态码不是200，抛出异常
+            return response.json().get("data", {})  # 返回更新后的子分段信息
+        except Exception as e:
+            logging.error(f"更新文档子分段失败: {e}")
+            raise
+
+
+if __name__ == '__main__':
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+    d = DifyApi()
+    id = d.upload_file(r"D:\Code\DataConvertUpload\wiki3todify\images\5fd27f31858f808f7659165628bfb8a7.png")
+    print(id)
+    
+    # d.remove_dataset_all_doc("0b835829-4d47-4419-832f-3cd6d9510b87")
+    # d.remove_dataset_all_doc("78abfb73-7e12-4dd4-92ff-b377b0235690")
+    # d.remove_dataset_all_doc("841b890e-c769-4839-8314-70756c0bf3c1")

rag2_0/dify/dify_tool.py

@@ -341,7 +341,7 @@ content: "{content}"
         except Exception as e:
             return -1
     
-    def get_retrieve_info(self, query: str, outputs: dict, reranker_sorce_info:list) -> tuple:
+    def get_retrieve_info(self, query: str, outputs: list[dict], reranker_sorce_info:list) -> tuple:
         """
         获取检索信息并计算分数
         
@@ -357,6 +357,7 @@ content: "{content}"
         total_score = 0
         valid_scores = 0
         retrieve_title = []
+        segmentid_to_title = { result["segment_id"]:result["title"].split("/")[-1] for result in outputs}
         
         # 使用线程池并发计算分数
         with ThreadPoolExecutor() as executor:
@@ -372,7 +373,7 @@ content: "{content}"
             for future in as_completed(future_to_content):
                 content, segment_id = future_to_content[future]
                 score = future.result()
-                content_title = content.split("\n")[0]
+                content_title = segmentid_to_title[segment_id]
                 
                 if score != -1:
                     max_score = max(max_score, score)

rag2_0/tool/ModelTool.py

@@ -127,16 +127,22 @@ class XinferenceReRankerModel:
 class OpenAiLLM:
 
     def __init__(self, **kwargs):
-        if kwargs.get("api_key") == None or  kwargs.get("base_url") == None or kwargs.get("model") == None:
+        if "api_key" in kwargs:
-            raise ValueError("api_key, base_url, model 不能为空")
+            self._api_key = kwargs.get("api_key")
+            kwargs.pop("api_key")
 
-        self._api_key = kwargs.get("api_key")
+        if "base_url" in kwargs:
-        self._url = kwargs.get("base_url")
+            self._url = kwargs.get("base_url")
-        self._model = kwargs.get("model")
+            kwargs.pop("base_url")
+        else:
+            self._url = os.getenv("OPENAI_API_BASE")
+
+        if "model" in kwargs:
+            self._model = kwargs.get("model")
+            kwargs.pop("model")
+        else:
+            self._model = os.getenv("LLM_MODEL_NAME")
 
-        kwargs.pop("api_key")
-        kwargs.pop("base_url")
-        kwargs.pop("model")
         self._kwargs = kwargs
 
     def invoke(self, user_prompt="你是谁？", need_retry=True):

rag2_0/tool/WikijsTool.py

@@ -148,7 +148,7 @@ class WikijsTool:
         response = requests.post(WikijsTool.BASE_URL, headers=WikijsTool.HEADERS, json=data)
         if "errors" in response.text:
             result = json.loads(response.content)['errors'][0]['message']
-            return {}
+            raise ValueError(f"查询文档失败，原因：“{result}")
         else:
             return json.loads(response.content)['data']['pages']['single']