Upload 18 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 gradio/output_files/semantic_chunk.index filter=lfs diff=lfs merge=lfs -text
+output_files/semantic_chunk.index filter=lfs diff=lfs merge=lfs -text

config.py

@@ -0,0 +1,34 @@
+class Config():
+
+    #retrievor参数
+    topd = 3    #召回文章的数量
+    topt = 6    #召回文本片段的数量
+    maxlen = 128  #召回文本片段的长度
+    topk = 5    #query召回的关键词数量
+    bert_path = '/workspace/model/embedding/tao-8k'
+    recall_way = 'embed'  #召回方式 ,keyword,embed
+
+    #generator参数
+    max_source_length = 767  #输入的最大长度
+    max_target_length = 256  #生成的最大长度
+    model_max_length = 1024  #序列最大长度
+    
+    #embedding API 参数 - 用于 text2vec.py
+    use_api = True  # 是否使用API而非本地模型
+    api_key = "sk-1c7a2cd7244e4fc7b65f2c1f4c2b949c"
+    base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    model_name = "text-embedding-v3"
+    dimensions = 1024
+    batch_size = 10
+    
+    #LLM API 参数 - 用于 rag.py
+    llm_api_key = "sk-1c7a2cd7244e4fc7b65f2c1f4c2b949c"  # 与embedding共用同一个key
+    llm_base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"  # 与embedding共用同一个URL
+    llm_model = "qwen-plus"  # 默认使用的LLM模型
+    
+    # 知识库配置
+    kb_base_dir = "knowledge_bases"  # 知识库根目录
+    default_kb = "default"  # 默认知识库名称
+    
+    # 输出目录配置 - 现在用作临时文件目录
+    output_dir = "output_files"

output/knowledge_base.txt

@@ -0,0 +1,3 @@
+# Knowledge Base
+
+This file will be populated when you upload documents.

output_files/knowledge_base.txt

@@ -0,0 +1,595 @@
+
+
+----- File: 0cb37d0c-2bae-47f9-bcd4-54636d9f15e4.pdf -----
+
+Empowering Few-Shot Relation Extraction with
+The Integration of Traditional RE Methods and
+Large Language Models
+Ye Liu, Kai Zhang(B), Aoran Gan, Linan Yue, Feng Hu,
+Qi Liu, Enhong Chen
+1School of Data Science, School of Computer Science and Technology,
+University of Science and Technology of China
+2State Key Laboratory of Cognitive Intelligence
+{liuyer,gar,lnyue,fenghufh3}@mail.ustc.edu.cn
+{kkzhang08,qiliuql,cheneh}@ustc.edu.cn
+Abstract. Few-Shot Relation Extraction (FSRE), a subtask of Relation
+Extraction (RE) that utilizes limited training instances, appeals to more
+researchers in Natural Language Processing (NLP) due to its capabil-
+ity to extract textual information in extremely low-resource scenarios.
+The primary methodologies employed for FSRE have been fine-tuning
+or prompt tuning techniques based on Pre-trained Language Models
+(PLMs). Recently, the emergence of Large Language Models (LLMs) has
+prompted numerous researchers to explore FSRE through In-Context
+Learning (ICL). However, there are substantial limitations associated
+with methods based on either traditional RE models or LLMs. Tradi-
+tional RE models are hampered by a lack of necessary prior knowledge,
+while LLMs fall short in their task-specific capabilities for RE. To ad-
+dress these shortcomings, we propose a Dual-System Augmented Rela-
+tion Extractor (DSARE), which synergistically combines traditional RE
+models with LLMs. Specifically, DSARE innovatively injects the prior
+knowledge of LLMs into traditional RE models, and conversely enhances
+LLMs’ task-specific aptitude for RE through relation extraction augmen-
+tation. Moreover, an Integrated Prediction module is employed to jointly
+consider these two respective predictions and derive the final results. Ex-
+tensive experiments demonstrate the efficacy of our proposed method.
+Keywords: Relation Extraction · Few Shot · Large Language Models.
+1
+Introduction
+Relation Extraction (RE) aims to determine the relation expressed between two
+entities within an unstructured textual context [23]. Few-Shot Relation Extrac-
+tion (FSRE), as a subtask of RE, seeks to solve the RE problem by utilizing only
+K instances per relation (K-shot) in the training and validation phases [3,20].
+The primary methodologies employed to address the FSRE task have been
+fine-tuning or prompt tuning techniques grounded on Pre-trained Language
+arXiv:2407.08967v1  [cs.CL]  12 Jul 2024
+Traditional RE Method
+LLM-based RE Method
+1. Special Design for RE Task: 
+2. Lack Prior Knowledge: 
+1. Rich Prior Knowledge: 
+2. Cannot Understand RE Task Well: 
+What's the relation between "National Action
+Network" and "Rev" in the context "Speaking..."
+Sorry, I don't understand your question. Do you
+mean ... ?
+Too fewer data to obtain 
+enough knowledge ...
+Few-Shot Data
+Typed Marker
+PLMs
+Fig. 1. The comparison between traditional RE methods and LLM-based RE methods.
+Models (PLMs) [3,23]. Recently, with the emergence of Large Language Mod-
+els (LLMs), numerous researchers have embarked on the exploration of FSRE
+through the In-Context Learning (ICL) technology [5,19,20]. However, there are
+substantial limitations associated with methods based on either traditional RE
+models or LLMs. As depicted in Figure 1, although most traditional RE methods
+are custom-built for the RE task, they still lack necessary prior knowledge that
+is crucial for resolving many domain-specific cases [3,6]. Acquiring such prior
+knowledge is particularly challenging in extremely low-resource settings, such as
+an 8-shot scenario. On the other hand, methods based on LLMs present a con-
+trasting issue. With the scaling of model size and corpus size, LLMs possess an
+extraordinary amount of prior knowledge. Nevertheless, given that these LLMs
+are designed for general usage, they lack the task-specific ability for RE, which
+makes it difficult to fully harness their prior knowledge. This dichotomy between
+the strengths and weaknesses of traditional RE models and LLMs presents a
+novel perspective in the field of few-shot relation extraction.
+To this end, this paper proposes a novel approach that amalgamates the
+traditional RE methods with LLMs. By doing so, we aim to address the afore-
+mentioned shortcomings by capitalizing on their respective strengths. Specifi-
+cally, we develop a Dual-System Augmented Relation Extractor (DSARE) for
+few-shot relation extraction. DSARE consists of three key components: (a) A
+LLM-augmented RE module: This module designs prompts that enable LLMs
+to generate additional in-domain labeled data to boost the training of traditional
+RE models, thereby effectively injecting the prior knowledge of LLMs into the
+traditional RE methods. (b) A RE-augmented LLM module: This module uti-
+lizes the trained RE model to identify and retrieve the most valuable samples
+from the training data. These samples are subsequently employed as demonstra-
+tions for the In-Context Learning of LLMs, thereby enhancing their RE-specific
+aptitude. (c) An Integrated Prediction module: It takes into account the predic-
+tions of both the LLM-augmented RE and RE-augmented LLM modules. When
+the two predictions differ, a specially designed selector is activated to make a
+final decision. Finally, extensive experiments on three publicly available datasets
+demonstrate the effectiveness of our proposed method, and further indicate the
+necessity to integrate traditional RE models and LLMs.
+Our code is available via https://github.com/liuyeah/DSARE.
+2
+Related Work
+Few-shot Relation Extraction. Due to the large computation ability of pre-
+trained language models, existing few-shot relation extraction methods mainly
+adopt the fine-tuning method to solve the few-shot relation extraction prob-
+lem [13,23]. In recent years, in order to bridge the gap between pre-training
+objectives and RE task, prompt tuning has been proposed and demonstrated
+remarkable capability in low-resource scenarios [3,6,7].
+Currently, with the arise of large language models, many researchers at-
+tempt to tackle few-shot relation extraction via In-Context Learning technol-
+ogy [5,19,20]. However, these approaches simply apply LLMs to few-shot relation
+extraction tasks through straightforward queries, which fails to fully harness the
+potential of LLMs. More importantly, they overlook the possibility that LLMs
+and traditional RE models could mutually enhance each other’s performance.
+Large Language Models. The emergence of Large Language Models (LLMs)
+such as GPT-4, LLama-2 and others [14,15,17,18], represents a significant ad-
+vancement in the field of natural language processing. By leveraging In-Context
+Learning, a novel few-shot learning paradigm was first introduced by [2]. Up to
+now, LLMs have demonstrated remarkable performance across a range of NLP
+tasks, such as text classification, named entity recognition, question answering
+and relation extraction [5,8,19,20].
+Previous research efforts [5,19,20] have sought to solve few-shot relation ex-
+traction by directly asking LLMs or retrieving more suitable demonstrations.
+For instance, Wan et al. [19] attempted to introduce the label-induced reasoning
+logic to enrich the demonstrations. Meanwhile, Xu et al. [20] designed task-
+related instructions and a schema-constrained data generation strategy, which
+could boost previous RE methods to obtain state-of-the-art few-shot results.
+3
+Problem Statement
+Let C denote the input text and esub ∈C, eobj ∈C denote the pair of subject
+and object entities. Given the entity type of esub, eobj, and a set of pre-defined
+relation classes R, relation extraction aims to predict the relation y ∈R between
+the pair of entities (esub, eobj) within the context C [19,23].
+As for the few-shot settings, following the strategy adopted by [4,20], we ran-
+domly sample K instances per relation (K-shot) for the training and validation
+phases. The whole test set is preserved to ensure the effectiveness of evaluation.
+4
+DSARE Model
+4.1
+LLM-augmented RE
+LLM Data Augmentation. In this part, we aim to implement the data aug-
+mentation via LLMs, anticipated to enrich the training data for relation extrac-
+tion. Specifically, drawing inspiration from [20], we construct prompts to tell the
+Input
+(a)  LLM-augmented RE
+One sample consists of a relation, a context,
+a pair of head and tail entities ....  Generate
+more samples like above for the relation:
+Relation: org: found_by
+Context: Steve Jobs is the co-founder of     
+                 Apple Inc.
+......
+Typed entity marker
+(punct).
+PLM
+Classification Layer
+Given a context, a pair of head and tail
+entities in the context, decide the
+relationship between .... The relation
+between xxx and xxx is 
+Relation: org: found
+(b)  RE-augmented LLM
+(c) Integrated Prediction
+Y
+N
+Document:
+      Speaking to a meeting of
+the National Action Network , a
+civil rights organization founded by
+the Rev.
+Subject Entity:
+      National Action Network
+Subject Entity Type:
+      Organization
+Object Entity:
+      Rev
+Object Entity Type:
+      Person
+(a.1) LLM Data Augmentation
+(a.2) Traditional RE Model
+(b.1) KNN Demonstration
+(b.2) LLM Inference
+Selector
+Fig. 2. The architecture of DSARE. It includes three parts: (a) LLM-augmented RE
+module; (b) RE-augmented LLM module; (c) Integrated Prediction module.
+LLM the essential components of one RE training sample, i.e., context text, sub-
+ject entity, object entity, subject entity type, object entity type and the relation.
+Then the LLM is guided to create more pseudo RE samples. Upon receiving
+the outputs from the LLM, we establish rules, such as regular expressions, to
+transform the augmented RE data into the desired format.
+Traditional RE Model. With the augmented datasets, we obtain more diverse
+data to train a traditional RE model. Here we adopt the Typed Entity Marker
+(punct) method proposed by [23] to denote the entity and context text, and
+further train a relation extraction model. Specifically, we utilize the symbols “@”
+and “#” to denote the start/end of the subject and object entities, and further
+adopt the symbols “∗” and “∧” to indicate the subject and object entity types,
+respectively. The processed text is then fed into the pre-trained language model
+to obtain the representations of the subject and object entities (hsub, hobj) via
+the special token “@” and “#”. Finally, we pass (hsub, hobj) into a classification
+layer to derive the results.
+4.2
+RE-augmented LLM
+KNN Demonstration. In Section 4.1, we train a traditional relation extraction
+model, which allows us to implement a k-nearest neighbors (KNN) search method
+to retrieve more valuable samples from the training set. Specifically, we utilize
+the obtained entity representation H = [hsub, hobj] to represent each sample,
+and further obtain the representation and label pair (Hi, ri) on the training set,
+which we denote as a datastore D.
+When inferring a new sample j, we utilize its entity representation Hj to
+query D according to the euclidean distance to obtain the k nearest neighbors:
+N = {(Hi, ri)}k
+i=1, which we adopt as demonstrations for LLM inference.
+Table 1. Data Statistics
+Dataset
+#Train
+#Dev
+#Test
+#Rel
+TACRED
+8/16/32
+8/16/32
+15,509
+42
+TACREV
+8/16/32
+8/16/32
+15,509
+42
+Re-TACRED
+8/16/32
+8/16/32
+13,418
+40
+LLM Inference. After obtaining the effective demonstrations, we design prompts
+to provide the essential information to the LLM, thus generating the LLM re-
+sults. Specifically, inspired by the various attempts about ICL [20], we first de-
+scribe the target of the relation extraction task through a instruction. Then, the
+retrieved k nearest neighbors N = {(Hi, ri)}k
+i=1 of current sample are followed,
+which provide the most relevant information to the LLM. Finally, we ask the
+LLM to predict the relation of current sample.
+4.3
+Integrated Prediction
+In Section 4.1 and 4.2, we apply traditional RE models and LLMs to conduct
+few-shot relation extraction from dual perspectives. In this part, we aim to obtain
+the final outputs by considering both the LLM-augmented RE inference result
+Pre and the RE-augmented LLM inference result Pllm.
+More specifically, as illustrated in Figure 2, if the two results are equal (i.e.,
+Pre = Pllm), our model directly yields the predicted relation. In circumstances
+where the two results diverge, we design a selector to further ask the LLM to
+make a choice between these two relations. In order to improve the effectiveness
+of the selector, we directly retrieve m samples labeled with these two relations
+from the training dataset, respectively. Subsequently, we ask the LLM via a
+similar way we introduced in LLM Inference to obtain the final results1.
+5
+Experiments
+5.1
+Experimental Setup
+Datasets and Evaluation Metrics. For extensive experiments, we conduct
+our experiments on three widely-used relation extraction datasets: TACRED [22],
+TACREV [1] and Re-TACRED [16]. More statistics about the datasets can be
+found in Table 1. Regarding the evaluation metrics, we adopt the micro-F1 scores
+of RE as the primary metric to evaluate models, considering that F1 scores can
+assess the overall performance of precision and recall [3,9,10,21].
+1 If the LLM does not make an inference or we are unable to convert the output into
+the pre-defined relations, we will conclude there is no relation between subject and
+object entities. Note that no_relation is also a relation category in these datasets.
+Implementation Details. In this paper, we utilize the zephyr-7b-alpha [18]
+model on Huggingface as the LLM to conduct experiments.
+In the Traditional RE Model part (Section 4.1), we adopt roberta-large [11]
+as the base architecture. The batch size is set to 4, and the model is optimized
+by AdamW [12] with a learning rate of 3e−5. We train the model on the training
+set for 50 epochs and choose the best epoch based on the micro-F1 performance
+on the development set.
+In the LLM Data Augmentation part (Section 4.1), we double the K-shot
+training set through LLMs. That is to say, for an 8-shot training set, we con-
+struct 8 pieces of pseudo data per relation, thereby creating the final augmented
+training set. In the KNN Demonstration part (Section 4.2), we set the number
+of retrieved nearest neighbors as k = 8. In the Integrated Prediction module
+(Section 4.3), we set the number of retrieved samples for each relation as m = 4.
+Benchmark Methods. We compare our methods with the state-of-the-art few-
+shot relation extraction methods. According to the modeling architecture, they
+can be grouped into three categories, including Traditional RE Methods (①∼
+④), LLM-based Methods (⑤∼⑦) and Hybrid Methods (⑧).
+– ①TYP Marker [23] proposes to incorporate entity representations with
+typed markers, which presents remarkable performance on the RE task.
+– ②PTR [7] designs prompt tuning with rules for relation extraction tasks
+and applies logic rules to construct prompts with several sub-prompts.
+– ③KnowPrompt [3] innovatively injects the latent knowledge contained
+in relation labels into prompt construction with the learnable virtual type
+words and answer words.
+– ④GenPT [6] proposes a novel generative prompt tuning method to re-
+formulate relation classification as an infilling problem, which exploits rich
+semantics of entity and relation types.
+– ⑤GPT-3.5 [15], ⑥LLama-2 [17], ⑦Zephyr [18] are the advanced LLMs.
+We leverage the API for GPT-3.5, while adopt the 7B version for LLama-2
+(llama-2-7b-chat-hf) and Zephyr (zephyr-7b-alpha). We utlize the prompt
+from [20] to conduct In-Context Learning.
+– ⑧Unleash [20] proposes schema-constrained data generation methods2
+through LLMs, which boost previous RE methods (i.e., KnowPrompt) to
+obtain more competitive results.
+It is worth noting that, for these LLM-based baselines (⑤∼⑦), due to the
+limitations of maximum tokens and the fact that these datasets have at least
+40 relations, we utilize the one-shot demonstration per relation following the
+strategy proposed by [20]. In contrast, our DSARE method, as introduced in the
+Implementation Details part, requires a maximum of 16 demonstrations3, which
+2 For fair comparison, we apply this data generation method to double the training
+set, which is the same as our settings introduced in the Implementation Details part.
+3 In the KNN Demonstration part (Section 4.2), the number of retrieved nearest neigh-
+bors is k = 8. And in the Integrated Prediction module (Section 4.3), we need a
+maximum of 2m = 8 additional demonstrations.
+Table 2. Experimental Results (%)
+Methods
+TACRED
+TACREV
+Re-TACRED
+K=8
+K=16 K=32
+K=8
+K=16 K=32
+K=8
+K=16 K=32
+①TYP Marker
+29.02
+31.35
+31.86
+26.28
+29.24
+31.55
+51.32
+55.60
+57.82
+②PTR
+28.34
+29.39
+30.45
+28.63
+29.75
+30.79
+47.80
+53.83
+60.99
+③KnowPrompt
+30.30
+33.53
+34.42
+30.47
+33.54
+33.86
+56.74
+61.90
+65.92
+④GenPT
+35.45
+35.58
+35.61
+33.81
+33.93
+36.72
+57.03
+57.66
+65.25
+⑤GPT-3.5
+29.72
+29.98
+39.06
+⑥LLama-2
+22.68
+21.96
+34.31
+⑦Zephyr
+37.10
+38.83
+35.81
+⑧Unleash
+32.24
+33.81
+34.76
+32.70
+34.53
+35.28
+58.29
+64.37
+66.03
+DSARE (ours) 43.84 45.40 45.94 44.69 46.61 46.94 60.04 66.83 67.13
+is much fewer than the number of the one-shot demonstration per relation setting
+(>= 40), thus avoiding unfair comparison.
+5.2
+Experimental Result
+The main results are illustrated in Table 2. Our proposed DSARE model outper-
+forms all baselines across all metrics. Particularly on the TACRED and TACREV
+datasets, our method manifests a significant advantage. This demonstrates the
+effectiveness of our designs and the benefits of integrating traditional RE models
+and LLMs. Furthermore, there are also some interesting phenomena:
+First, the vast majority of methods exhibit superior performance on the Re-
+TACRED dataset compared to the TACRED and TACREV datasets. This is
+reasonable as Re-TACRED is an improved version among these three datasets,
+which addresses some shortcomings of the original TACRED dataset, refactors
+its training set, development set and test set. The more precise labels contribute
+to the learning process of these models, thereby yielding superior performance.
+Second, among these LLM-based methods, Zephyr (7B) demonstrates compet-
+itive performance and significantly outperforms GPT-3.5 and LLama-2 on the
+TACRED and TACREV datasets. This proves its strong information extraction
+ability, as claimed in [18]. Third, Unleash introduces a schema-constrained data
+augmentation method through LLMs to enhance the Knowprompt baselines. It
+achieves a certain degree of improvement compared to Knowprompt, verifying
+the the feasibility of this line of thinking. And our DSARE model significantly
+surpasses Unleash, which further demonstrates the effectiveness of our designs
+from another perspective.
+5.3
+Ablation Study
+In this subsection, we carry out ablation experiments to validate the effectiveness
+of various components of DSARE model. Specifically, we first remove the Inte-
+grated Prediction module, consequently leading to two ablated variants: LLM-
+augmented RE and RE-augmented LLM. As shown in Table 3, there are obvious
+Table 3. Ablation Experiments (%)
+Ablation Models
+Re-TACRED
+K=8
+K=16
+K=32
+DSARE
+60.04
+66.83
+67.13
+LLM-augmented RE
+52.53
+58.01
+58.56
+RE-augmented LLM
+56.38
+64.85
+66.03
+Pure RE
+51.32
+55.60
+57.82
+Pure LLM
+35.81
+(a)
+Document:
+Subject Entity:
+Ground Truth Relation:
+      The Huntington Library, founded in 1919 by Henry 
+Huntington, is one of the world 's greatest cultural, research 
+and educational centers.
+Huntington Library
+Object Entity:
+Subject Entity Type:
+Object Entity Type:
+Henry Huntington
+Organization
+Person
+LLM-augmented RE Prediction:
+RE-augmented LLM Prediction:
+DSARE Prediction:
+Document:
+Subject Entity:
+Ground Truth Relation:
+      Piedra testified he struggled to get his career going after 
+graduating in 1998 from Tufts University School of 
+Dental Medicine.
+He
+Object Entity:
+Subject Entity Type:
+Object Entity Type:
+His
+Person
+Person
+LLM-augmented RE Prediction:
+RE-augmented LLM Prediction:
+DSARE Prediction:
+Document:
+Subject Entity:
+Ground Truth Relation:
+      "Our dad passed away when Emily was 17 and I was 18, '' 
+says Sarah Kunstler, 33, who is also an attorney.
+Sarah Kunstler
+Object Entity:
+Subject Entity Type:
+Object Entity Type:
+Emily
+Person
+Person
+LLM-augmented RE Prediction:
+RE-augmented LLM Prediction:
+DSARE Prediction:
+(b)
+(c)
+Fig. 3. The case study of the DSARE model. (a) is from the TACRED dataset (K=8),
+while (b) and (c) are from the Re-TACRED dataset (K=8).
+decreases between DSARE and its two variants, demonstrating the efficacy of
+the Integrated Prediction module.
+Subsequently, we further remove the LLM Data Augmentation part from
+LLM-augmented RE and remove the KNN Demonstration part from RE-augmented
+LLM. This yields two other variants, i.e., Pure RE and Pure LLM4. From the
+results, both these variants perform inferiorly, especially the Pure LLM. These
+findings futher demonstrate the validity and non-redundancy of our designs.
+5.4
+Case Study
+In this section, we conduct case study to more intuitively illustrate the effective-
+ness of integrating traditional RE models and LLMs. Specifically, as illustrated
+in Figure 3, we present the input information (i.e., document, subject/object
+entity, subject/object entity type), ground truth relation and the prediction of
+DSARE and its ablated variants, respectively.
+In Figure 3 (a), both the LLM-augmented RE and the RE-augmented LLM
+make the correct prediction. In Figure 3 (b) and (c), the LLM-augmented RE
+and RE-augmented LLM correctly infer the relations (per : identity and per :
+4 Note that here Pure LLM is equivalent to the baseline ⑦Zephyr.
+siblings), respectively. And with the aid of the Integrated Prediction module,
+DSARE finally derives the correct predictions. These cases intuitively demon-
+strate the significant role of integrating traditional RE methods and LLMs, and
+further verify the validity of our DSARE model.
+6
+Conclusions
+In this paper, we explored a motivated direction for empowering few-shot relation
+extraction with the integration of traditional RE models and LLMs. We first an-
+alyzed the necessity to joint utilize traditional RE models and LLMs, and further
+proposed a Dual-System Augmented Relation Extractor (DSARE). Specifically,
+we designed a LLM-augmented RE module, which could inject the prior knowl-
+edge of LLMs into the traditional RE models. Subsequently, a RE-augmented
+LLM module was proposed to identify and retrieve the most valuable samples
+from the training data, which provided more useful demonstrations for the In-
+Context Learning of LLMs. More importantly, we designed an Integrated Predic-
+tion module to joint consider the predictions of both LLM-augmented RE and
+RE-augmented LLM modules, thus taking advantages of each other’s strengths
+and deriving the final results. Finally, extensive experiments on three publicly
+available datasets demonstrated the effectiveness of our proposed method. We
+hope our work could lead to more future studies.
+Acknowledgement. This research was partially supported by grants from
+the National Natural Science Foundation of China (No. U20A20229), the An-
+hui Provincial Natural Science Foundation of China (No. 2308085QF229 and
+2308085MG226) and the Fundamental Research Funds for the Central Univer-
+sities.
+References
+1. Alt, C., Gabryszak, A., Hennig, L.: Tacred revisited: A thorough evaluation of the
+tacred relation extraction task. In: Proceedings of the 58th Annual Meeting of the
+Association for Computational Linguistics. pp. 1558–1569 (2020)
+2. Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J.D., Dhariwal, P., Nee-
+lakantan, A., Shyam, P., Sastry, G., Askell, A., et al.: Language models are few-shot
+learners. Advances in neural information processing systems 33, 1877–1901 (2020)
+3. Chen, X., Zhang, N., Xie, X., Deng, S., Yao, Y., Tan, C., Huang, F., Si, L., Chen,
+H.: Knowprompt: Knowledge-aware prompt-tuning with synergistic optimization
+for relation extraction. In: Proceedings of the ACM Web conference 2022. pp.
+2778–2788 (2022)
+4. Gao, T., Fisch, A., Chen, D.: Making pre-trained language models better few-shot
+learners. In: ACL-IJCNLP 2021. pp. 3816–3830 (2021)
+5. Gutiérrez, B.J., McNeal, N., Washington, C., Chen, Y., Li, L., Sun, H., Su, Y.:
+Thinking about gpt-3 in-context learning for biomedical ie? think again. In: Find-
+ings of EMNLP 2022. pp. 4497–4512 (2022)
+6. Han, J., Zhao, S., Cheng, B., Ma, S., Lu, W.: Generative prompt tuning for rela-
+tion classification. In: Findings of the Association for Computational Linguistics:
+EMNLP 2022. pp. 3170–3185 (2022)
+7. Han, X., Zhao, W., Ding, N., Liu, Z., Sun, M.: Ptr: Prompt tuning with rules for
+text classification. AI Open 3, 182–192 (2022)
+8. Liu, J., Shen, D., Zhang, Y., Dolan, W.B., Carin, L., Chen, W.: What makes
+good in-context examples for gpt-3? In: Proceedings of Deep Learning Inside Out
+(DeeLIO 2022). pp. 100–114 (2022)
+9. Liu, Y., Wu, H., Huang, Z., Wang, H., Ning, Y., Ma, J., Liu, Q., Chen, E.: Techpat:
+technical phrase extraction for patent mining. ACM Transactions on Knowledge
+Discovery from Data 17(9), 1–31 (2023)
+10. Liu, Y., Zhang, K., Huang, Z., Wang, K., Zhang, Y., Liu, Q., Chen, E.: Enhancing
+hierarchical text classification through knowledge graph integration. In: Findings
+of the Association for Computational Linguistics: ACL 2023. pp. 5797–5810 (2023)
+11. Liu, Y., Ott, M., Goyal, N., Du, J., Joshi, M., Chen, D., Levy, O., Lewis, M.,
+Zettlemoyer, L., Stoyanov, V.: Roberta: A robustly optimized bert pretraining
+approach. arXiv preprint arXiv:1907.11692 (2019)
+12. Loshchilov, I., Hutter, F.: Decoupled weight decay regularization. arXiv preprint
+arXiv:1711.05101 (2017)
+13. Lyu, S., Chen, H.: Relation classification with entity type restriction. In: Findings
+of ACL-IJCNLP 2021. pp. 390–395 (2021)
+14. OpenAI: Gpt-4 technical report (2023)
+15. Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., Zhang, C.,
+Agarwal, S., Slama, K., Ray, A., et al.: Training language models to follow instruc-
+tions with human feedback. Advances in Neural Information Processing Systems
+35, 27730–27744 (2022)
+16. Stoica, G., Platanios, E.A., Póczos, B.: Re-tacred: Addressing shortcomings of the
+tacred dataset. In: Proceedings of the AAAI Conference on Artificial Intelligence.
+vol. 35, pp. 13843–13850 (2021)
+17. Touvron, H., Martin, L., Stone, K., Albert, P., Almahairi, A., Babaei, Y., Bash-
+lykov, N., Batra, S., Bhargava, P., Bhosale, S., et al.: Llama 2: Open foundation
+and fine-tuned chat models. arXiv preprint arXiv:2307.09288 (2023)
+18. Tunstall, L., Beeching, E., Lambert, N., Rajani, N., Rasul, K., Belkada, Y., Huang,
+S., von Werra, L., Fourrier, C., Habib, N., et al.: Zephyr: Direct distillation of lm
+alignment. arXiv preprint arXiv:2310.16944 (2023)
+19. Wan, Z., Cheng, F., Mao, Z., Liu, Q., Song, H., Li, J., Kurohashi, S.: Gpt-re: In-
+context learning for relation extraction using large language models. arXiv preprint
+arXiv:2305.02105 (2023)
+20. Xu, X., Zhu, Y., Wang, X., Zhang, N.: How to unleash the power of large language
+models for few-shot relation extraction? In: Proceedings of The Fourth Workshop
+on Simple and Efficient Natural Language Processing (SustaiNLP). pp. 190–200
+(2023)
+21. Zhang, K., Zhang, K., Zhang, M., Zhao, H., Liu, Q., Wu, W., Chen, E.: Incorporat-
+ing dynamic semantics into pre-trained language model for aspect-based sentiment
+analysis. In: Findings of the Association for Computational Linguistics: ACL 2022.
+pp. 3599–3610 (2022)
+22. Zhang, Y., Zhong, V., Chen, D., Angeli, G., Manning, C.D.: Position-aware atten-
+tion and supervised data improve slot filling. In: Conference on Empirical Methods
+in Natural Language Processing (2017)
+23. Zhou, W., Chen, M.: An improved baseline for sentence-level relation extraction.
+AACL-IJCNLP 2022 p. 161 (2022)

output_files/semantic_chunk.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:275fffde1c5fea9575a7af7c996b3d9a771eb3cd65980b0e1c8bf7317813e738
+size 1576075

output_files/semantic_chunk_output.json

@@ -0,0 +1,972 @@
+[
+    {
+        "id": "chunk0",
+        "chunk": "激 光 生 物 学 报 ACTA LASER BIOLOGY SINICA Vol. 33 No. 5 Oct. 2024 第33 卷第5 期 2024 年10 月 收稿日期：2024-03-15",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk1",
+        "chunk": "基金项目：国家重点研发计划项目（2022YFA0912500）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk2",
+        "chunk": "深圳市科技计划资助项目（RCBS20221008093108030， ZDSYS20230626090759006）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk3",
+        "chunk": "* 通信作者：王芳，研究员，主要从事微生物与合成生物学的研究",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk4",
+        "chunk": "E-mail: [email protected]",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk5",
+        "chunk": "合成微生物与水污染治理应用 林雅倩1，帅菲斐2，王 芳2* （1. 广西中医药大学，南宁 530200",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk6",
+        "chunk": "2. 深圳市微生物基因组修饰编辑与应用重点实验室，重症医学科，深圳市 转化医学研究院，深圳市第二人民医院，深圳 518035） 摘 要：水污染是当今世界面临的严峻环境问题之一，影响人们的生活质量和经济的可持续发展",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk7",
+        "chunk": "利用微生物 的降解能力以及与之相应的生物修复技术是去除环境污染物以及修复水环境的重要手段",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk8",
+        "chunk": "但是，由于水污染环 境的复杂现状，传统微生物学治理方法受到了限制",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk9",
+        "chunk": "运用合成生物学“设计-构建-测试-学习”的理念，对目标微 生物底盘进行从头设计、改造，从而获得对污染物具有高效、广谱降解能力的合成微生物，不仅可满足现在复杂污 水环境的治理要求，还能实现绿色、高效的循环治理，是未来合成生物学的发展应用方向之一",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk10",
+        "chunk": "本文简要介绍了 水污染的现状、常用的治理技术以及当今合成微生物在水污染治理中的应用，重点介绍了合成微生物底盘的种类 以及通过底盘改造构建的合成微生物在水污染治理中的优势，以期通过合成生物学手段不断完善和优化污染物 降解和水污染治理技术，为实现水环境污染的高效治理提供参考",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk11",
+        "chunk": "环境治理 中图分类号：X52 文献标志码：A DOI：10.3969/j.issn.1007-7146.2024.05.004 Application of Synthetic Microorganisms in Water Pollution Prevention and Control LIN Yaqian1, SHUAI Feifei2, WANG Fang2* (1. Guangxi University of Chinese Medicine, Nanning 530200, China; 2. Intensive Care Unit, Shenzhen Key Laboratory of Microbiology in Genomic Modification & Editing and Application, Shenzhen Institute of Translational Medicine, Shenzhen Second People′s Hospital, Shenzhen 518035, China) Abstract: Water pollution is one of the most serious environment problems that affect people′s life quality and sustainable economic development worldwide. The degradation capability of microorganisms endows them advantages in environmental pollutants elimination and water environments repairment, with the utilization of diverse bioremediation technologies. However, due to the complex situation of water pollution environment, traditional microbiological treatment methodology is restricted and limited. With the engineering principle Design-Build-Test-Learn in synthetic biology, the designed and modified synthetic mi- croorganisms with efficient and broad-spectrum degradation ability for pollutants has attracted the researchers′ attention. The synthetic microorganisms could not only meet the wastewater treatment requirements within complex pollutants, but also could achieve the green, efficient circular treatment goal. Therefore, design and construction of synthetic microorganisms for water pollution control has becoming one of the future development and application direction of synthetic biology. Herein, we intro- duced the current situation of water pollution, the treatment technologies classically utilized, and the synthetic microorganisms′ application in water pollution control. This review focuses on different types of microbial chassis in synthetic biology and the 419 第5 期 水是生命的起源，是生命赖以生存的根本，是 经济生产不可替代的基础，是维护生态环境的要 素",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk12",
+        "chunk": "但随着科技的发展，大量环境污染物被排放， 水环境急速恶化，缺水已经成为人类日常生活面临 的主要问题之一［1］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk13",
+        "chunk": "据推断，到2050 年，全球一半 人口将面临严重的水资源短缺［1］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk14",
+        "chunk": "当前，我国生态 文明建设以降碳为重点战略方向，污水治理既是污 染防治的重要组成，也是温室气体减排的重要领 域",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk15",
+        "chunk": "推进减污降碳协同增效已成为我国新发展阶 段经济社会发展全面绿色转型的必然选择",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk16",
+        "chunk": "所以， 为了地球生态健康，也为了实现经济的可循环发 展，对水污染的治理刻不容缓",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk17",
+        "chunk": "针对不同的水污染情况，可应用物理法、化学 法和生物法等治理方法，其中基于微生物降解转化 能力进行的生物法在实际治理中发挥着关键作用， 但是由于单一微生物降解易受多重环境因素影响 等限制，其作用范围和应用场景极其有限",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk18",
+        "chunk": "随着合 成生物学作为“第三次生物科学革命”的发展，有 目的地设计、改造甚至重新合成构建生物体成为 可能，从而加速了特定污染物从无法降解到能够降 解、从低效降解到高效降解的转变［2］，为污水的高 效治理带来了新方向",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk19",
+        "chunk": "采用合成生物学使能技术，以工程化设计为理 念，对底盘微生物进行定向设计、改造、从头合成和 构建，最终构建可感知、报告并降解特定污染物的 合成微生物，是实现高效、绿色、经济、智能化治理 污水目标的未来方向",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk20",
+        "chunk": "本文简述了水污染的不同 来源、现有的不同治理方案，并介绍了可用于水污 染治理的代表性合成微生物底盘种类及对其底盘 的改造构建方法，最后对合成微生物在水污染治理 中的优势进行了评述",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk21",
+        "chunk": "1 水污染的现状 水是我们日常生活中最重要的一类资源",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk22",
+        "chunk": "地 球上大约71% 的面积被水覆盖，其中97.5% 是海 水，只有2.5% 的淡水可供人类直接使用［3］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk23",
+        "chunk": "随着全 球经济和人口的快速增长，工业化、城市化步伐加 快，多种有害污染物进入环境中，由于环境污染物 的排放和水环境的恶化，水污染已成为全球面临并 且日益严峻的挑战［4］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk24",
+        "chunk": "污水中的大量重金属和有机 污染物，不仅严重威胁环境和生态平衡，而且危害 了人类健康，对经济增长和社会发展产生了显著的 负面影响［4-5］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk25",
+        "chunk": "目前水污染的主要来源有工业污染、 农业污染、医疗污染以及生活污染等（图1）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk26",
+        "chunk": "1.1 工业污水 随着全球工业化和城市化速度的加快，工业部 门用水增加，其用水量约占全球的22%，污水排放 量约占全球污水排放总量的28%［6-7］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk27",
+        "chunk": "常见的工业 水污染物包括汞（Hg）、镉（Cd）、砷（As）等有毒重金 属，石油以及氯化物等，根据化学性质可分为无机 污染物和有机污染物［5-6］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk28",
+        "chunk": "在众多的工业机构中， 来自造纸业、煤炭制造业、石油化工业、纺织业和制 药业的废水基本上是剧毒的，已被证实对周围环境 存在最高程度的危害性［8］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk29",
+        "chunk": "1.2 农业污水 全球人口正在以惊人的速度增长，预计到2050 年，全球粮食产量需要增加50%［9］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk30",
+        "chunk": "为了满足全 球的粮食需要，在农作物种植阶段，大量农药被采 用以提高农作物的产量和质量",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk31",
+        "chunk": "基于不同的作用 目的，农药可分为除草剂、杀虫剂、灭鼠剂、杀菌剂 等，主要成分有硫磺、有毒重金属、生物碱和有机 磷等［9-10］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk32",
+        "chunk": "虽然是为了满足粮食需要，但是过度使 用农药会破坏生态系统、损害水质并造成人体损 伤［11］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk33",
+        "chunk": "农药可通过与土壤吸附结合，破坏土壤团粒 结构，并从中渗入地下水，造成地下水与地表水的 污染",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk34",
+        "chunk": "4，4′- 二氯二苯基二氯乙烷、毒死蜱（chlorpy- rifos，CP）和二嗪农等一些可溶性、挥发性农药常在 空气中富集，在降雨时，会重新汇集并随着地表水 渗透到土壤、地下水之中，从而加剧水污染的严重 程度［11-12］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk35",
+        "chunk": "merits of application of synthetic microorganisms in water pollution control. This review will facilitate the performance optimi- zation of pollutant degradation and wastewater treatment via synthetic biology and provide reference for the efficient treatment of wastewater environment. Key words: synthetic microorganisms; microbial chassis; water pollution; bioremediation technology; environmental gover- nance （Acta Laser Biology Sinica, 2024, 33(5): 418-431） 林雅倩等：合成微生物与水污染治理应用 林雅倩等：合成微生物与水污染治理应用 激 光 生 物 学 报 420 第 33 卷 1.3 医疗废水 医疗废水主要来源于医院，其成分十分复杂， 包含各种病原微生物、抗生素、有毒有机化合物、放 射性元素和离子污染物等［13］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk36",
+        "chunk": "根据科室不同，医疗 系统产生的污水成分也不尽相同",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk37",
+        "chunk": "如放射科污水 中存在造影剂，手术室排出的污水含大量麻醉类药 物［14-16］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk38",
+        "chunk": "总体来说，医疗废水具有成分复杂、难降 解甚至传染性等特点",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk39",
+        "chunk": "值得强调的是，当今大多数 医疗废水往往没有经过特殊处理就与生活污水一 起排入了污水处理厂［17-18］，这就使许多药物和微生 物在不发生结构和毒性明显变化的情况下，通过污 水处理厂并进入了地表水［13］，从而进一步导致了抗 生素耐药细菌的产生和传播［18］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk40",
+        "chunk": "1.4 生活污水 生活污水由70% 的有机物和30% 的无机物组 成，通常分为两大类，即黑水和灰水［19-20］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk41",
+        "chunk": "黑水是 厕所排放的富含有机物、氮和磷的污水，主要有粪 便、尿液和食物残渣等",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk42",
+        "chunk": "灰水是用于洗涤或洗澡的 废水，包括来自厨房水槽、淋浴间和洗衣机的废 水［19, 21-22］，主要含有酸碱性化合物、脂肪、重金属、 硝酸盐和异生化合物等［22］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk43",
+        "chunk": "生活中，灰水产量可达 黑水产量的1～7 倍［19-20］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk44",
+        "chunk": "鉴于当今许多污水处理 厂的处理能力欠缺，大量生活废水流入地下水和地 表水中，导致水质恶化，影响水生生物的生存",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk45",
+        "chunk": "2 现有水污染治理技术 目前用于治理水污染的方法主要可分为物理 方法、化学方法、生物学方法（图1），可根据污染物 浓度、污水组成、工艺成本或污水中存在的额外杂 质，选择合适的治理方法［23］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk46",
+        "chunk": "2.1 物理法 物理法是指借助物理作用来处理、回收水体中 的污染物质，通常需要在不影响污染物生化特性的 情况下进行",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk47",
+        "chunk": "其中吸附法因其灵活性、广泛的适用性、成本效 益高和实用性，成为污水治理中最有利的方法［24］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk48",
+        "chunk": "常见的吸附剂有生物吸附剂、二氧化硅、氧化铝、活 性炭、黏土、金属氧化物、二氧化钛等［23］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk49",
+        "chunk": "由于吸附 剂饱合能力有限、难以再生，且某些污染物难以通 过吸附被去除［4］，限制了吸附法的实际应用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk50",
+        "chunk": "但是， 已有研究通过合成新型纳米复合吸附剂，成功去除 污水中的苯并吡啶、氧氟沙星等污染物［25-26］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk51",
+        "chunk": "图1 水污染的来源、组成及治理 Fig. 1 Sources, types, and treatment strategies of water pollution 421 第5 期 2.2 化学法 化学法是指在进行污水治理时，借助化学反应 来治理留存于水体中污染物质的方法",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk52",
+        "chunk": "化学处理 方法主要有氧化还原法、化学沉淀法、混凝和离子 交换等，通常用来处理一些无机物质和部分难以降 解的有机污染物",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk53",
+        "chunk": "生活中常常通过化学法，如臭氧 和氯、次氯酸钠等来初步消除医院污水中的细菌和 病毒［13，27］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk54",
+        "chunk": "采用氧化还原原理的高级氧化工艺（ad- vanced oxidation process，AOP）是去除顽固有机污染 物并灭活传统技术无法处理的病原微生物的一种 极具潜力的技术，其作用方式有氢提取、自由基的 组合或加成以及电子转移［28-29］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk55",
+        "chunk": "已有研究通过电化 学氧化- 硫酸盐AOP 成功降解了化工企业高浓度含 氰有机废水中的有机物和氰化物［30］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk56",
+        "chunk": "2.3 生物法 生物法是利用微生物的代谢能力对污水中 的有机物质进行分解的方法",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk57",
+        "chunk": "由于成本效益高和 环境相容性好，生物修复具有极好的未来发展潜 力［3，31］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk58",
+        "chunk": "生物法通过使用细菌、真菌、微藻、酵母和 其他微生物菌群进行，由于体积小、比表面积大，它 们已成为当今理想的生物修复制剂［32］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk59",
+        "chunk": "生物法可 通过吸附或积累来降解污水中的各种污染物［28］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk60",
+        "chunk": "目前，已有研究使用微生物单一培养法对污水中的 染料进行降解和脱色［33］，以及采用高效藻类塘去除 污水中的抗高血压药、抗抑郁药和消炎药等［34］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk61",
+        "chunk": "以上污水治理方法各有千秋，现有的许多废水 处理研究采用组合生物、化学和/ 或物理处理的技 术来应对传统单一处理技术的局限性［5］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk62",
+        "chunk": "物理和化 学方法治理的缺点是价格昂贵、效率低、易产生副 产物，如污泥和次级代谢物等［3，35］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk63",
+        "chunk": "在某些情况下， 吸附、化学沉淀或电化学沉淀等方法不能从废水中 去除染料或其代谢物等化合物，只能将污染物从一 相转移到另一相，并未从根本上解决污染问题［35］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk64",
+        "chunk": "与物理和化学方法相比，生物处理方法虽具有环 境友好、高效且可行性高等优势［5］，但易受温度和 pH 值等环境因素的影响，导致污染物处理速度变 慢［4，32］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk65",
+        "chunk": "组合处理方法在实施时也存在多个限制， 诸如缺乏技术知识和数据的可行性，处理材料的效 率随着时间的推移而降低等［5］，且大多数研究都是 使用模拟或稀释的废水进行的，并不能代表实际污 水的发生情况［35］，所以在水污染治理中，应该结合 实际情况具体分析",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk66",
+        "chunk": "3 合成微生物在水污染治理中的应用 合成生物学是一门集合了生物化学、分子生物 学和计算机等多学科的新兴学科，通过分子生物学 工具，对生物体的遗传信息重新编辑使其具有特定 的功能［2，36］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk67",
+        "chunk": "近年来，随着合成生物学的发展，现有 技术已可将复杂的外源性代谢途径引入特定的微 生物宿主，并进行特定的人为改造，以实现特定的 目标",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk68",
+        "chunk": "合成生物学方法在一定程度上解决了微生 物中只含有单一化合物的分解代谢基因这一缺陷， 并使微生物可以监测、聚集和降解环境污染物［2，37］， 从而使合成生物学在水污染治理中受到广泛应用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk69",
+        "chunk": "采用合成生物学“设计- 构建- 测试- 学习”的 理念，对生物元件挖掘、分析，设计构建而成的具有 特定功能的微生物，称为合成微生物（图2）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk70",
+        "chunk": "底盘 作为引入具有不同代谢途径元件的宿主，其开发和 构建是合成生物学领域的一个关键，也是构建合成 微生物的基础［38］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk71",
+        "chunk": "底盘细胞的普遍含义是改善了 细菌、古细菌或植物细胞中遗传信息的宿主，也是 将合成的功能化元件、线路和途径等体系置入其中 以达到设计目标的重要合成生物学反应平台［39］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk72",
+        "chunk": "在合成生物学中，底盘为运行合成系统提供能 量，被认为是合成生物学的“硬件”，而生物部件和 生物设备则被认为是“软件”在底盘中“加载并运 行”",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk73",
+        "chunk": "合成生物学被认为是实现在“硬件”底盘中 “即插即用”的模块化“软件”的生物学［40］（图2）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk74",
+        "chunk": "在对一个底盘操作前，应了解其基因组序列， 并具有先进的遗传工具可对其进行深度编辑",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk75",
+        "chunk": "这 些遗传工具包括表达载体、启动子和先进的基因组 编辑技术",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk76",
+        "chunk": "同时一个合格的底盘应具有遗传和进 化稳定性、在目的环境中的可用性等特征［39］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk77",
+        "chunk": "目前 应用在水污染治理中的底盘细胞主要有大肠杆菌、 恶臭假单胞菌、枯草芽孢杆菌、酿酒酵母等模式微 生物，以及盐单胞菌（Halomonas spp.）、拜氏不动杆 菌和需钠弧菌等非模式微生物［38，41］（图3）（表1）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk78",
+        "chunk": "3.1 基于大肠杆菌 大肠杆菌（Escherichia coli）是一种革兰氏阴性 杆状细菌，被归类为肠杆菌科，该菌主要寄生在哺 乳动物肠道中，可通过粪便和废水在环境中传播， 造成污染［42］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk79",
+        "chunk": "由于大肠杆菌具有生长快速、培养基 简单和经济效应高等优势，在合成生物学中常作为 模式微生物底盘被研究和使用［38, 40］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk80",
+        "chunk": "林雅倩等：合成微生物与水污染治理应用 林雅倩等：合成微生物与水污染治理应用 激 光 生 物 学 报 422 第 33 卷 图2 合成微生物的构建流程 Fig. 2 Work flow of the biosynthetic microorganisms construction 图3 基于合成微生物的水污染治理 Fig. 3 Construction and application of the synthetic microorganisms in water pollution 鉴于已有多个基因编辑技术可在大肠杆菌中 高效实施，如锌指核酸酶技术（zinc finger nuclease， ZFN）、转录激活因子样效应因子核酸酶技术（tran- scription activator-like effector nuclease，TALEN）、同源重 组和成簇的规则间隔短回文重复序列系统［clustered regularly interspaced short palindromic repeats (CRISPR)/ CRISPR-associated (Cas) protein，CRISPR-Cas］等［43］，目 前大量研究以大肠杆菌为底盘进行蛋白质和代谢物 的生物合成，如血红素蛋白和5- 氨基乙酰丙酸的合 成等［44-46］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk81",
+        "chunk": "CRISPR-Cas 系统是一种天然免疫系统， 广泛分布于细菌和古细菌中［47-48］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk82",
+        "chunk": "���传统的低通量 ZFN和TALEN相比，CRISPR是一种可编程的下一代 高通量基因编辑技术，可以直接将一组首选指令传 输到微生物的基因组中，大量水污染相关研究采用 该体系构建合成微生物",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk83",
+        "chunk": "Li 等［47］基于CRISPR-Cas9 构建的pEcCas/pEcgRNA 系统可以实现E. coli BL21 423 第5 期 （DE3）的高效基因组编辑，并将此系统用于更广泛 的大肠杆菌和其他肠杆菌科物种中",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk84",
+        "chunk": "Zhu等［49］基于 CRISPR-Cas12a 系统实现了精确的DNA 靶向和切割 功能，成功建立了RAA-CRISPR-Cas12a检测系统，实 现了对食源性和水源性大肠杆菌病原体E. coli O157: H7的快速、特异和高灵敏检测",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk85",
+        "chunk": "在污染物降解方面，Wang 等［50］通过对从苯酚 降解细菌红球菌（Rhodococcus）和恶臭假单胞菌 （Pseudomonas putida）中提取的pheA1、catA和pcaI 等基因，进行一系列优化（密码子优化、GC 含量平 衡、去除不必要的切割位点等）和整合操作，使其在 E. coli BL221-AI 内表达，构建的重组菌株能迅速降 解废水中的苯酚",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk86",
+        "chunk": "对来源于红球菌的tfdA、pcaJ 和 pcaF 等9 个2，4- 二氯苯氧乙酸（2，4-dichlorophen- oxyacetic acid，2，4-D）降解基因，进行上述类似的优 化整合操作，Wang 等［51］构建的重组E. coli BL-3164 可以实现以2，4-D 为唯一碳源的生长，降低环境中 2，4-D含量的有效目标",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk87",
+        "chunk": "3.2 基于恶臭假单胞菌 恶臭假单胞菌（Pseudomonas putida）是一种革 兰氏阴性杆状细菌，属假单胞菌属（Pseudomonas）， 作为模式底盘在工业和环境生物技术中都得到了 广泛应用［52-54］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk88",
+        "chunk": "恶臭假单胞菌具有强大的氧化还原 代谢能力，对许多不同类型的物理化学损伤具有耐 受性，能在恶劣的环境中生长且具有异种生物降解 的能力，且能从受污染的地区被分离与培养［53, 55］， 这激发了研究人员对恶臭假单胞菌作为底盘降解 污染物的研究兴趣",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk89",
+        "chunk": "目前已经有大量分子工具可用于恶臭假单胞 菌遗传操作和代谢编程［53，55］，如反选择标记（coun- terselectable marker，CSM）、异源重组酶和自杀载体， 这些分子工具已被验证可促进该属细菌的等位基 因交换［54］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk90",
+        "chunk": "Aparicio 等［56］将ssDNA 重组与CRISPR- Cas9 联合应用在恶臭假单胞菌中，开发了一种高 效、快速的基因编辑方案",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk91",
+        "chunk": "Liang 等［57］构建并优化 了恶臭假单胞菌中的T7 样表达系统，提供了一套 适用的底盘和相应的质粒提高重组表达水平，可用 于表达其他底盘中难以表达的蛋白质",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk92",
+        "chunk": "此外，各种 组成型启动子，多种天然及合成的诱导启动子也已 经在恶臭假单胞菌中被发现［53］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk93",
+        "chunk": "在污染物降解方面，采用基于upp 基因作为 CSM 的基因组编辑方法，Gong 等［58］将多个降解 基因整合到P. putida KT2440 染色体中，构建的合 成菌株具有降解农药甲基对硫磷（methyl parathi- on，MP）和γ- 六氯环己烷（γ-hexachlorocyclohexane， γ-HCH）的能力",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk94",
+        "chunk": "Liang 等［59］通过自杀质粒pK- 18mobsacB 构建删除了GIs 的P. putida KT2440，所 产生的突变体KTU-U13 不仅表现出较高的质粒转 化效率和异源蛋白表达能力，且作为受体细胞时， 对γ-HCH 和1，2，3- 三氯丙烷（1，2，3-trichloropro- pane，TCP）的降解效率也显著增强",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk95",
+        "chunk": "3.3 基于枯草芽孢杆菌 枯草芽孢杆菌（Bacillus subtilis）是革兰氏阳性 芽孢杆菌，其外源蛋白具有分泌能力强、遗传可操 作性强和易培养等优势，已被广泛用作底盘生产生 物聚合物、工业酶制剂等［52, 60-61］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk96",
+        "chunk": "同时，枯草牙孢杆 菌主要分布于土壤及腐���的有机物中，具备作为合 成微生物底盘应用于污染物治理的潜在应用价值",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk97",
+        "chunk": "常应用于枯草牙孢杆菌的基因编辑手段有 CSM，位点特异性重组系统、CRISPR-Cas9 及其衍生 的CRISPRi和CRISPR-Cpf1系统［62］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk98",
+        "chunk": "CRISPR-Cas9可 用于枯草牙孢杆菌的基因突变、缺失和插入等，是 枯草牙孢杆菌基因遗传操作中最强大的工具之一",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk99",
+        "chunk": "近期，Ferrando 等［60］基于CRISPR-Cas9 的新型基因 组编辑开发了一种简单、快速、方便的方法，可在枯 草牙孢杆菌中同时插入三个基因，这为枯草牙孢杆 菌作为微生物底盘的未来发展提供了良好的前景",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk100",
+        "chunk": "Zhu 等［63］通过敲除枯草牙孢杆菌突变株ZN0871v11 中的yqfY和spo0A基因，所获得的菌株GEBS可同时 吸附废水中的有机物、阳离子和阴离子，并在几分 钟内实现共沉淀，从而达到净化水质、废水回收的 目标",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk101",
+        "chunk": "Ghataora 等［61］通过整合源自革兰氏阴性菌的 可变金属结合域与在枯草牙孢杆菌中起作用的DNA 结合结构域，并辅以结构引导设计，在枯草牙孢杆菌 中生成了具有金属敏感性的生物传感器模块",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk102",
+        "chunk": "此外，枯草牙孢杆菌的另一特性是能形成复杂 而强大的生物膜［62, 64］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk103",
+        "chunk": "生物膜是一种由紧密结合的 细菌组成的结构群落，被自身产生的细胞外基质包 裹，这种基质允许细菌附着在表面，使生物膜可抵 抗氧化应激等环境条件，因此生物膜可应用于生物 修复技术［65-66］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk104",
+        "chunk": "合成生物学的进步使人们能够对生 物膜进行重新编程，以改善其功能或提高增值产品 的产量［65］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk105",
+        "chunk": "利用含有枯草牙孢杆菌的生物膜或多 物种生物膜组合的生物反应器，可以实现废水和周 林雅倩等：合成微生物与水污染治理应用 林雅倩等：合成微生物与水污染治理应用 激 光 生 物 学 报 424 第 33 卷 围环境中有毒污染物降解的目标",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk106",
+        "chunk": "Li 等［67］将有机 腈降解过程中发挥关键作用的腈水合酶和酰胺酶 的编码基因nha、ami整合至B. subtilis N4中，构建了 B. subtilis N4/pHTnha-ami，可实现废水中有机腈的降 解，同时，联合使用带正电荷的改性聚乙烯载体移动 床生物膜反应器，促进了细菌的黏附和生物膜的形 成",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk107",
+        "chunk": "Zhu等［68］通过整合型质粒pDG1730构建了能传 感和吸附重金属离子的基因回路，并转至B. subtilis 1935ΔepsΔbslA 底盘中，所形成的菌株不仅能实时 感应三种金属离子［Pb（II）、Hg（II）和Cu（II）］且形成 的生物膜能实现对这些金属离子的特异性吸附",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk108",
+        "chunk": "3.4 基于酿酒酵母 酿酒酵母（Saccharomyces cerevisiae）是一种真 核模式生物，具有遗传背景明确、生长迅速、操作简 单等优点［69-70］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk109",
+        "chunk": "酿酒酵母与原核模式微生物相比有 许多独特的优势，如可增加特异性酶的表达和翻译 后修饰能力，为特异性酶的表达提供优越的环境， 以及具有细胞器，可以分隔产物的合成，减轻产物 积累导致的细胞代谢负担等［52］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk110",
+        "chunk": "因此，酿酒酵母成 为了用于生产燃料、食品添加剂和生物制药方面的 优质底盘候选物［70-71］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk111",
+        "chunk": "此外，基于酵母细胞对pH值 和温度变化的高适应性，酿酒酵母也成为有毒污染 物生物传感器应用中的合适底盘［72］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk112",
+        "chunk": "但是，酿酒酵母和非生产性程序的内源性因素 常常损害外源基因的表达和插入，因此，目前开发 了多种技��用来增强和提高其细胞内基因转录的 强度和效率并促进基因编辑的程序［69］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk113",
+        "chunk": "其中CRIS- PR-Cas9 系统已成功应用于多种酵母细胞的基因编 辑中，如删除细胞特定代谢过程中的相关基因，以 及在一步反应中同时进行多基因敲除、下调和过表 达等［73］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk114",
+        "chunk": "酿酒酵母中单一向导RNA（sgRNA）的最 广泛利用提高了CRISPR-Cas9 系统基因编辑的效 率［69］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk115",
+        "chunk": "Fan 等［74］通过优化半乳糖诱导系统的关键 元件Gal4 和Gal80，并利用CRISPR-Cas9 介导的基 因组编辑技术将其分别连接至铜诱导启动子CUP1 和铜抑制启动子CTR1 中，合成的酵母细胞可用于 高效检测环境中的Cu（II）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk116",
+        "chunk": "在污染物降解方面，通过把细菌lacZ 报告基 因与含酵母JLP1 启动子的质粒相连，Ito-Harashima 等［75］构建了一个携带高拷贝数pESC-JLP1-lacZ 报 告质粒的菌株，并将其用于高效、快速监测水和土 壤中的Cd 污染",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk117",
+        "chunk": "Ruta 等［76］将多种植物金属硫蛋白 分别靶向酵母质膜的内表面，改造后的酿酒酵母可 在低浓度下吸附Cu（II），且表达myrGFP-NcMT3 的 菌株可在高浓度Cu（II）、Ni（II）和Mn（II）等金属离 子条件下表现出强劲的生长力、金属耐受性和高累 积能力",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk118",
+        "chunk": "Mashangoane 等［77］将钯结合肽（4R-PdBP） 连接至pYD5 质粒上，形成重组质粒pYD5/4R-PdBP 并转化至S. cerevisiae EBY100 中，构建的重组菌株 可从水溶液中生物吸附钯［Pd（II）］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk119",
+        "chunk": "3.5 基于非模式底盘 模式底盘微生物研究时间长，研究人员多，遗 传工具丰富，目前已经得到了大量的研究和应用， 在微生物遗传与合成生物学的基础理论研究以及 应用中发挥着举足轻重的作用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk120",
+        "chunk": "但在实际应用中， 模式底盘受环境影响较大，往往不能达到预期效 果，这时，具备底盘所需特性的一些非模式底盘微 生物吸引了研究学者的目光",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk121",
+        "chunk": "在水污染治理中，能 用于降解污染物的非模式底盘有盐单胞菌、不动杆 菌和需钠弧菌等",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk122",
+        "chunk": "3.5.1 盐单胞菌 盐单胞菌是革兰氏阴性需氧细菌，属于嗜盐菌 家族，常见于盐湖、沼泽及海洋等高盐环境中",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk123",
+        "chunk": "该 菌不仅能够耐受含3%～15% NaCl 的高盐环境，而 且能在50℃的高温以及pH 为10 的高碱性环境下 存活［2, 78］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk124",
+        "chunk": "高盐环境也更有利于盐单胞菌降解合成 染料废水中的污染物［79］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk125",
+        "chunk": "由于其培养简单、生长快 速和污染抵抗性高等优势，目前盐单胞菌已被用作 底盘生产聚羟基烷酸、某些蛋白质以及小分子有机 化合物等［78, 80］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk126",
+        "chunk": "随着对盐单胞菌研究兴趣的增加，多株盐单胞 菌的全基因信息已被揭示，如Halomonas spp. MS1、 Halomonas 11-S5、Halomonas 25-S5、Halomonas spp. SpR1 和SpR8 等［81-83］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk127",
+        "chunk": "盐单胞菌株基因组测序的完 成和注释信息完善促进了学者对盐单胞菌内源基因 功能挖掘、代谢通路鉴定、代谢网络构建等方面的 研究，为构建盐单胞菌底盘提供了理论支持［78］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk128",
+        "chunk": "目 前，针对盐单胞菌还开发了一系列工具和元件，如 pSEVA系列质粒、pUCpHAw和pHA1AT_32等穿梭载 体、多种组成型和诱导型启动子、不依赖于Rho的固 有终止子以及一种新型的类T7表达系统等，奠定了 开展盐单胞菌使能技术的基础［78, 84-86］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk129",
+        "chunk": "另外，上述 在模式底盘中建立的大部分基因编辑技术，包括同 源重组、CRISPR-Cas9 和CRISPRi 等，在盐单胞菌中 425 第5 期 也同样适用［85］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk130",
+        "chunk": "最近，利用CRISPR-Cas9 基因编辑 技术与非同源末端连接修复系统相结合，Liu 等［80］ 开发了一种快速、高效删除盐单胞菌中大片段DNA 的方法",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk131",
+        "chunk": "以上元件和技术为盐单胞菌应用于合成生 物学底盘构建奠定了基础",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk132",
+        "chunk": "在污染物降解方面，Ji 等［87］通过在高拷贝质粒 pSEVA241-sgRNA 上组装phaCAB 基因表达模块， 构建的合成菌株H. bluephagenesis WZY278 可以降 解食物垃圾水解物并生产聚3- 羟基丁酸酯（poly- 3-hydroxybutyrate，PHB）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk133",
+        "chunk": "Kleinsteuber 等［88］将携带 有2，4-D、2- 甲基-4- 氯苯氧乙酸（2-methyl-4-chloro- phenoxyacetic acid，MCPA）和3- 氯苯甲酸（3-chloro- benzoic acid）降解基因的pJP4 质粒在Halomonas sp. EF43 中表达，菌株可实现在碱性条件对2，4-D 和 3-氯苯甲酸酯的降解",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk134",
+        "chunk": "3.5.2 拜氏不动杆菌 拜氏不动杆菌（Acinetobacter baylyi）是一种革 兰氏阴性需氧细菌，由于其具有高自然转化率以及 高重组效率，被认为是下一代合成生物学的理想底 盘［89-90］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk135",
+        "chunk": "A. baylyi ADP1 的无害性、代谢多样性和高 适应能力，使其已被用于各种生物技术中，如降解 有机污染物、生产各种生化产品和不同种类的生物 聚合物［89, 91］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk136",
+        "chunk": "随着合成生物学的发展，非模式底盘研究的深 入，A. baylyi ADP1 常被用于研究细菌遗传和代谢 机制［92］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk137",
+        "chunk": "可利用无痕同源重组技术和CRISPR-Cas9 系统在A. baylyi ADP1 中进行基因的插入与删除",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk138",
+        "chunk": "同时基于已建立的CRISPR-Cas9 系统，Suárez 等［92］ 开发了一个“CRISPR-Lock”技术，用以促进简单的 多组分DNA 组装和快速可靠的基因组编辑",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk139",
+        "chunk": "目前， 一系列调控生物元件已在A. baylyi ADP1 中得到 成功应用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk140",
+        "chunk": "近期，Biggs 等［90］构建了一个全面的A. baylyi ADP1 基因工具集，包括合成的组成启动子和 核糖体结合位点文库",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk141",
+        "chunk": "唐慧等［93］通过在pWH1274 质粒上插入发光基因片段luxCDABE，将重组质 粒转化至A. baylyi ADP1 中，合成的菌株可用于对 Be（II）、Ba（II）、Cu（II）、Ni（II）等急性毒物的检测",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk142",
+        "chunk": "Huang 等［94］将luxCDABE 插入pGEM-T 质粒中，重 组的ADPWH_lux 可作为生物传感器对水杨酸盐进 行快速和特异性的检测",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk143",
+        "chunk": "3.5.3 需钠弧菌 需钠弧菌（Vibrio natriegens）为杆状海洋细菌， pH 耐受范围为5.5～9.5，具有无致病性、生长迅速、 遗传可操作性强、可接收环境DNA 和利用多种碳 源生长的能力，被认为是合成生物学未来最有潜力 的底盘［85, 95］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk144",
+        "chunk": "弧菌在质粒转化和蛋白异源表达方 面表现良好，电穿孔、热休克转化和结合等方法均 可成功地将质粒DNA 转入其中，包括p15A、pMB1 和pUC 及其衍生质粒等［2, 96-97］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk145",
+        "chunk": "最近，多项研究表 明，在大肠杆菌中适用的生物元件和基因编辑技术 也适用于弧菌，如启动子、核糖体结合位点、转录 终止子、同源重组和CRISPR-Cas9 系统等［95, 97-98］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk146",
+        "chunk": "基于弧菌从环境中吸收DNA 的能力，一种自然转 化多重基因组编辑（multiplex genome editing by natu- ral transformation，MuGENT）技术已经被开发，Dalia 等［99］成功地将MuGENT 应用于弧菌中，即可一步 同时将多个基因无痕共编辑至基因组中",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk147",
+        "chunk": "在此基 础上，Stukenberg 等［100］将其与CRISPR-Cas9 反选择 相结合开发了一种高效基因组编辑技术NT-CRIS- PR，几乎可在100%的效率下进行多数基因组修饰， 如敲除、整合和点突变",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk148",
+        "chunk": "在污染物降解方面，Huang 等［101］利用V. natrie- gens Vmax 在盐胁迫环境下降解环境污染物，分析 并鉴定了其耐盐机制和相关的盐诱导启动子，并在 V. natriegens Vmax 菌株上构建了对CP、六溴环十二 烷（hexabromocyclododecane，HBCD）和聚对苯二甲 酸乙二醇酯（polyethylene terephthalate，PET）三种盐 的诱导降解模型，实现了对相应底物的有效降解， 最终将该菌株与甲壳素材料结合，实现了菌株的回 收利用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk149",
+        "chunk": "除了上述提到的重要模式细胞以及具有特殊 性状的非模式细胞外，还有许多细菌可被开发用于 水污染治理，如用于废水硝酸盐检测的蓝藻内生 物传感器［102］，体内含有降解染料废水中污染物酸 性兰113 关键酶编码基因的鞘氨醇单胞菌（Sphin- gomonas）等［103］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk150",
+        "chunk": "对于底盘细胞及降解相关元件的 进一步挖掘与开发有助于深化研究人员设计与构 建合成微生物的进程，并推动合成微生物在水污染 治理中的应用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk151",
+        "chunk": "4 合成微生物在水污染治理应用的优势 4.1 高效降解力与广泛降解谱 污水不仅来源多样，而且其中污染物数量多 而复杂",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk152",
+        "chunk": "传统的物理、化学方法通常只能对特定的 林雅倩等：合成微生物与水污染治理应用 林雅倩等：合成微生物与水污染治理应用 激 光 生 物 学 报 426 第 33 卷 污染物发挥作用，不仅作用时间长，而且易受到环 境因素的影响，从而导致治理效果不尽如人意",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk153",
+        "chunk": "生 物修复虽然较物理化学方法更高效，但直接将具有 较高降解力或代谢力的微生物投入污水中很可能 被环境中原有生物侵蚀，从而限制了其污水治理的 效率",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk154",
+        "chunk": "合成生物学可根据特定目标污染物，系统地 研究微生物降解污染物过程的本质、规律和互作网 络等，深度挖掘各类污染物的相关降解元件，针对 性地构建高效稳定的合成微生物［104］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk155",
+        "chunk": "例如，Zhao 等［105］将γ-HCH和TCP的生物降解途径整合到P. pu- tida KT2440 中，构建的合成菌株可完全降解γ-HCH 和TCP",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk156",
+        "chunk": "Zhang 等［106］对来源于伯克霍尔德氏菌 （Burkholderia sp.）的2，4-二硝基甲苯（2，4-dinitrotol- uene，2，4-DNT）降解途径的DntAa、DntAb 和DntAc 等8 个基因进行合成、优化，并在E. coli 上组装，所 构建的E. coli BL-4174能够完全降解2，4-DNT",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk157",
+        "chunk": "因此，合成生物学不仅可以针对某一特定污染 物对底盘细胞进行设计和改造，还可根据治理目标 选择性地开发和利用多重降解相关元件，如转运元 件、趋化元件和抗逆元件等，通过对不同微生物来 源的元件进行设计和组合，构建具备复合代谢网络 的合成微生物，从而提升对污染物的降解能力、环 境适应能力以及拓展其污染物降解谱",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk158",
+        "chunk": "Gong 等［107］ 通过合成生物学的方法将4 个农药降解基因mpd、 pytH、mcd 和cehA 整合至P. putida KT2440 上，所得 菌株可实现对有机磷、拟除虫菊酯和氨基甲酸酯 3种农药的同时降解",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk159",
+        "chunk": "4.2 环境友好和可持续 传统的污水治理方法可能会破坏水中的生态 系统、生物群落和生态链等",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk160",
+        "chunk": "以合成生物学技术为 基础的合成微生物可针对污染物降解及其在环境 应用中的适应性和安全性技术开展工作",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk161",
+        "chunk": "通过探 究微生物与微生物之间、微生物与环境之间的相互 作用机制，与生态学、计算生物学等学科结合，设 计构建高效智能的人工微生物降解体系，协调多重 元件在代谢水平上的相互作用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk162",
+        "chunk": "这不仅可增强合 成菌株的环境适应性，使其能够在高盐、酸碱、高 渗等极端条件下保持降解活性［108］，并且有利于实 现复杂污染条件下的环境修复",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk163",
+        "chunk": "合成微生物可通 过多重降解元件，建立能响应污染物的条件自毁基 因线路和遗传物质清除线路，使其能在自然条件 下持续主动安全的降解污染物，不产生二次污染， 具有可持续净化水环境并修复生态的特性",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk164",
+        "chunk": "例如， Liu 等［109］将感应模块、降解模块、自杀系统整合至 E. coli TOP10 中并进行优化，所获得的菌株Pfic- TAT（2）-P100-RBS35 在无外源诱导剂的情况下，可 对水杨酸（salicylicacid，SA）进行传感并降解，最后 当环境中无SA 时菌株会自主激活自杀系统，且能 长期稳定存在于水环境中发挥功能",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk165",
+        "chunk": "4.3 作用形式多样化 合成生物学的发展为合成微生物的多样化应 用提供了新的契机（图3）",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk166",
+        "chunk": "为避免单一菌株的过度 工程化及增加其代谢负担，研究者们通过构建合成 微生物群落的方式，让菌群成员间通过信号交换、 检测及相互响应等方式进行交流，并通过相关基 因表达调控协调群体行为",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk167",
+        "chunk": "合成微生物群落不仅 比传统菌群及单一微生物具有更多的复杂功能，而 且具有更高的稳定性与鲁棒性，可适用于复杂环境 和极端环境的生长及维持平稳的代谢状态［104］，因 此在水环境修复中发挥着不可替代的作用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk168",
+        "chunk": "Zhang 等［110］构建了一个由鞘氨醇单胞菌属和假单胞菌属 微生物组成的合成微生物群落，该群落可有效地利 用菲或二苯并噻吩作为唯一的碳源生长，同时还可 代谢其他多种多环芳烃（polycyclic aromatic hydrocar- bons，PAHs）和杂环衍生物",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk169",
+        "chunk": "在模拟废水试验中，该 合成群落5 d 内去除了100% 的PAHs，且在多次循 环后依旧保持稳定的降解力",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk170",
+        "chunk": "Zhang 等［111］构建了 一个由类节杆菌属、根瘤菌属、红球菌属、代尔夫 特菌属和硝酸盐还原菌属微生物组成的耐盐微生 物群落，该合成群落对模拟乙酰乙酰苯胺（acetoac- etanilide，AAA）废水和实际AAA母液有良好的降解 能力，且处理后AAA母液的综合毒性显著降低",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk171",
+        "chunk": "除了降解污染物外，合成微生物在污染物检 测方面也起着举足轻重的作用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk172",
+        "chunk": "运用合成生物学 的模块化和可编程性，将待测物质的感应元件（转 录因子和核糖开关等）与信号输出的报告元件（荧 光素酶、荧光蛋白和荧光适配体等）通过基因表达 调控的方式在微生物底盘上偶联［112］，即可形成简 单的生物传感器，识别单一目标物质并改善信号识 别、处理和输出等传感过程",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk173",
+        "chunk": "Hui 等［113］利用Cd（II） 感应元件与靛蓝生物合成基因簇融合在E. coli 中 成功构建了一个视觉生物传感器",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk174",
+        "chunk": "该传感器仅对 Cd（II）有选择性响应，且适用于水环境的分析",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk175",
+        "chunk": "将 427 第5 期 林雅倩等：合成微生物与水污染治理应用 林雅倩等：合成微生物与水污染治理应用 表1 应用于污染物降解的合成微生物底盘细胞 Tab.1 Examples of synthetic microorganisms for water pollution application Chassis cells Methodology Application References E. coli BL221-AI Insertion of pheA1, pheA2, catA, catB, catC, catD, pcaI, pcaJ and pcaF Degradation of phenol ［50］ E. coli BL21-AI Insertion of tfdA, tfdB, tfdC, tfdD, tfdE, tfdF, pcaI, pcaJ and pcaF Degradation of 2, 4-D ［51］ E. coli BL21-AI Insertion of DntAa, DntAb, DntAc, DntAd, DntB, DntD, DntG and DntE Degradation of 2, 4-DNT ［106］ E. coli TOP10 Insertion of the salicylicacid (SA) detection, degradation, and suicide pathway genes Pfic‐TAT‐P1XX‐RBS Detection and degradation of SA ［109］ E. coli TOP10 Insertion of the Cd sensing pathway gene pPcad-ind Detection of Cd ［113］ E. coli TOP10 Insertion of the Hg and Cd sensory elements and the separate reporters pR-Pcad-Pmer-G Enhanced detection of Hg and Cd ［114］ P. putida KT2440 Insertion of mpd, pnpA, pnpB, gfp, linA, linB, linC, linD and vgb Degradation of MP and γ-HCH ［58］ P. putida KT2440 Deletion of GIs, insertion of the degradation pathway genes of γ-HCH and TCP Enhanced degradation of γ-HCH and TCP ［59］ P. putida KT2440 Deletion of hsdRMS, insertion of linA, linB, linC, linD, dhaA31, hheC and echA Enhanced degradation of γ-HCH and TCP ［105］ P. putida KT2440 Insertion of mpd, pytH, mcd, cehA, gfp and vgb Degradation of multiple pesticides ［107］ B. subtilis Design and Insertion of metal sensor modules MerRZntR Detection of heavy metal ions ［61］ B. subtilis ZN0871v11 Deletion of yqfY and spo0A Adsorption of organic molecules and ions ［63］ B. subtilis N4 Insertion of nha and ami Degradation of nitriles ［67］ B. subtilis 1935 Deletion of epsA～O and bslA, and expression of mtagBFP, eGFP, mCherry and TasA-MT Detection and adsorption of mul- tiple heavy metal ions ［68］ S. cerevisiae Insertion of CTR1 and CUP1 Detection of Cu ［74］ S. cerevisiae W303a Insertion of JLP1-lacZ Detection of Cd ［75］ S. cerevisiae BY4741 Insertion of myrGFP-MTx Adsorption of heavy metal ions (Cu, Ni and Mn) ［76］ S. cerevisiae EBY100 Insertion of 4R-PdBP and aga2, overexpression of aga1 Adsorption of Pd ［77］ H. Bluephagenesi WZY278 Overexpression of phaCABCn and linkage with ompW Recovery of food wastes ［87］ Halomonas sp. EF43 Insertion of the 2, 4-D, MCPA and 3-chlorobenzoate acid degradation pathway genes Degradation of 2, 4-D and 3-chlorobenzoate acid ［88］ Acinetobacter sp. ADP1 Insertion of luxCDABE Detection of multiple metal ions ［93］ Acinetobacter sp. ADP1 Insertion of luxCDABE Detection of SA ［94］ V. natriegens Vmax Insertion of the PET, CP and HBCDs degradation pathway genes Degradation of PET, CP and HBCDs ［101］ 底盘与其他功能元件或由几个相关功能元件组成 的完成某一任务的功能模块连接，还可构建复杂的 生物传感器，用于环境中存在多种污染物时的检 测",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk176",
+        "chunk": "Hui 等［114］通过将两种荧光报告元件分别置于 Hg（II）传感元件或Cd（II）感应元件的控制下，并将 两种感应元件从不同方向整合至E. coli TOP10 中， 成功构建了一个双传感生物传感器",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk177",
+        "chunk": "由于生物传 感器对环境的抗干扰能力通常较强，且传感器细胞 内部所有基因元件可以通过基因复制和细胞增殖 而自动扩增，因此，生物传感器在生产和环境监测 应用中都具有明显优势",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk178",
+        "chunk": "5 总结与展望 随着人类社会的发展，以及工业、生活、农业、 医疗活动的进行，各种污染物如重金属、有毒有机 化合物和致病微生物等进入水环境，造成了本就脆 弱的生态系统的进一步恶化",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk179",
+        "chunk": "尽管人们对污水治 理的关注日益增加，但现阶段的污水实际治理仍然 激 光 生 物 学 报 428 第 33 卷 缺乏科学性和全面性，很难根据污水的具体情况制 定科学的治理方案，且没有完善的污水排放管理体 系，在一定程度上加大了水污染治理工作的难度",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk180",
+        "chunk": "合成生物学将工程、科学和技术结合应用于编 辑生物体的遗传信息，使其能够执行新的功能",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk181",
+        "chunk": "应 用合成生物学开发新兴污染物降解菌株，已成为 合成生物学和微生物学领域的研究前沿",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk182",
+        "chunk": "不同于 以从环境中筛选能够代谢特定污染物的天然微生 物为重点的传统环境生物技术，合成微生物是通过 在底盘细胞中插入天然或非天然功能元件、构建底 盘中原本不存在的合成代谢途径，形成全新的可感 知、降解污染物的微生物",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk183",
+        "chunk": "研究者们可根据目的定 向改造微生物，���其具有降解目标污染物、提高降 解效率和增强环境适应性等能力",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk184",
+        "chunk": "近年来，国内外 研究人员开展了各种有关合成微生物的鉴定、筛 选、关键元件挖掘和改造等方面的工作，目前已获 得众多重要突破，如开发了由多种微生物参与的污 染物传感器，构建了合成微生物降解群落以及复合 材料等［115-117］",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk185",
+        "chunk": "因此，合成微生物在环境修复领域中 的地位愈发重要",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk186",
+        "chunk": "但目前合成微生物的具体实施仍存在一些挑 战",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk187",
+        "chunk": "例如：1）污水情况复杂、难以估计，多种污染 物分解代谢途径和关键降解酶编码基因不清晰",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk188",
+        "chunk": "2）微生物具有物种和基因多样性、生态网络复杂 性，使其难以标准化，无法确保搭建的功能元件和 模块在不同系统中可拥有同样高效的工作方式和 结果",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk189",
+        "chunk": "3）在特定底盘中加载和运行的合成DNA 数 量有明显限制，添加合成生物元件无疑会给底盘带 来非自然的额外负担，产生生长速度减慢、基因变 异等副作用",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk190",
+        "chunk": "4）目前，合成微生物的构建及应用研 究多处于实验室研究阶段，多采用模拟污水进行， 要想运用合成微生物在实际污水环境中，需要进行 更多的现场试验以确保生物安全和效率",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk191",
+        "chunk": "尽管合 成微生物在污水治理应用方面面临着诸多挑战，但 是，随着合成生物学、系统生物学和基因工程等学 科的发展，学者们相信，在可预见的未来，在更多理 论和实践的支持下，合成微生物具有治理水污染、 解决环境问题的巨大潜力",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk192",
+        "chunk": "参考文献（References）： ［1］ JANET JOSHIBA G, SENTHIL KUMAR P, CHRISTOPHER F C, et al. Insights of CMNPs in water pollution control ［J］. IET Nanobiotechnology, 2019, 13(6): 553-559. ［2］ XIANG L, LI G, WEN L, et al. Biodegradation of aromatic pollut- ants meets synthetic biology ［J］. Synthetic and Systems Biotech- nology, 2021, 6(3): 153-162. ［3］ TRIPATHI M, SINGH S, PATHAK S, et al. Recent strategies for the remediation of textile dyes from wastewater: a systematic re- view ［J］. Toxics, 2023, 11(11): 940. ［4］ ZHANG Y, YU H, ZHAI R, et al. Recent progress in photocata- lytic degradation of water pollution by bismuth tungstate ［J］. Molecules, 2023, 28(24): 8011. ［5］ NAGDA A, MEENA M, SHAH M P. Bioremediation of industrial effluents: a synergistic approach ［J］. Journal of Basic Microbiol- ogy, 2022, 62(3/4): 395-414. ［6］ DUTTA D, ARYA S, KUMAR S. Industrial wastewater treatment: current trends, bottlenecks, and best practices ［J］. Chemosphere, 2021, 285: 131245. ［7］ MAO G, HAN Y, LIU X, et al. Technology status and trends of in- dustrial wastewater treatment: a patent analysis ［J］. Chemosphere, 2022, 288(Pt 2): 132483. ［8］ PRABAKAR D, SUVETHA K S, MANIMUDI V T, et al. Pre- treatment technologies for industrial effluents: critical review on bioenergy production and environmental concerns ［J］. Journal of Environmental Management, 2018, 218: 165-180. ［9］ RAJ A, DUBEY A, MALLA M A, et al. Pesticide pestilence: global scenario and recent advances in detection and degradation methods ［J］. Journal of Environmental Management, 2023, 338: 117680. ［10］ TUDI M, DANIEL RUAN H, WANG L, et al. Agriculture devel- opment, pesticide application and its impact on the environment ［J］. International Journal of Environmental Research and Public Health, 2021, 18(3): 1112. ［11］ SYAFRUDIN M, KRISTANTI R A, YUNIARTO A, et al. Pes- ticides in drinking water: a review ［J］. International Journal of Environmental Research and Public Health, 2021, 18(2): 468. ［12］ BOONUPARA T, UDOMKUN P, KHAN E, et al. Airborne pes- ticides from agricultural practices: a critical review of pathways, influencing factors, and human health implications ［J］. Toxics, 2023, 11(10): 858. ［13］ MACKULAK T, CVERENKÁROVÁ K, VOJS STAŇOVÁ A, et al. Hospital wastewater-source of specific micropollutants, antibiotic-resistant microorganisms, viruses, and their elimination ［J］. Antibiotics (Basel), 2021, 10(9): 1070. ［14］ DEKKER H M, STROOMBERG G J, PROKOP M. Tackling the increasing contamination of the water supply by iodinated contrast media ［J］. Insights into Imaging, 2022, 13(1): 30. ［15］ TANG Y, ZHAO S, PENG Z, et al. Cu2O nanoparticles anchored on carbon for the efficient removal of propofol from operating room wastewater via peroxymonosulfate activation: efficiency, mechanism, and pathway ［J］. Royal Society of Chemistry, 2021, 11(34): 20983-20991. ［16］ BALAKRISHNAN A, JACOB M M, SENTHIL KUMAR P, et al. Strategies for safe management of hospital wastewater during the COVID-19 pandemic ［J］. International Journal of Environmental Science and Technology: IJEST, 2023, 20(12): 1-16. ［17］ RODRÍGUEZ-SERIN H, GAMEZ-JARA A, DE LA CRUZ- NORIEGA M, et al. Literature review: evaluation of drug removal techniques in municipal and hospital wastewater ［J］. International Journal of Environmental Research and Public Health, 2022, 19(20): 13105. ［18］ PARIENTE M I, SEGURA Y, ÁLVAREZ-TORRELLAS S, et al. Critical review of technologies for the on-site treatment of hospital wastewater: from conventional to combined advanced processes ［J］. Journal of Environmental Management, 2022, 320: 115769. ［19］ WIDYARANI, WULAN D R, HAMIDAH U, et al. Domestic 429 第5 期 wastewater in Indonesia: generation, characteristics and treatment ［J］. Environmental Science and Pollution Research International, 2022, 29(22): 32397-32414. ［20］ BAJPAI M, KATOCH S S, CHATURVEDI N K. Comparative study on decentralized treatment technologies for sewage and graywater reuse: a review ［J］. Water Science and Technology, 2019, 80(11): 2091-2106. ［21］ ZHANG W, CHU H, YANG L, et al. Technologies for pollutant removal and resource recovery from blackwater: a review ［J］. Frontiers of Environmental Science & Engineering, 2023, 17(7): 83. ［22］ KHAJVAND M, MOSTAFAZADEH A K, DROGUI P, et al. Grey- water characteristics, impacts, treatment, and reclamation using adsorption processes towards the circular economy ［J］. Environ- mental Science and Pollution Research International, 2022, 29(8): 10966-11003. ［23］ RASHID R, SHAFIQ I, AKHTER P, et al. A state-of-the-art review on wastewater treatment techniques: the effectiveness of adsorption method ［J］. Environmental Science and Pollution Re- search International, 2021, 28(8): 1-17. ［24］ KIM S, NAM S N, JANG A, et al. Review of adsorption-mem- brane hybrid systems for water and wastewater treatment ［J］. Chemosphere, 2022, 286(Pt 3): 131916. ［25］ KARIMI-MALEH H, SHAFIEIZADEH M, TAHER M A, et al. The role of magnetite/graphene oxide nano-composite as a high- efficiency adsorbent for removal of phenazopyridine residues from water samples, an experimental/theoretical investigation ［J］. Jour- nal of Molecular Liquids, 2020, 298: 112040. ［26］ SPONZA D T, ALICANOGLU P. Reuse and recovery of raw hospital wastewater containing ofloxacin after photocatalytic treat- ment with nano graphene oxide magnetite ［J］. Water Science and Technology, 2018, 77(1/2): 304-322. ［27］ AZUMA T, KATAGIRI M, SEKIZUKA T, et al. Inactivation of bacteria and residual antimicrobials in hospital wastewater by ozone treatment ［J］. Antibiotics, 2022, 11(7): 862. ［28］ TAOUFIK N, BOUMYA W, ACHAK M, et al. Comparative over- view of advanced oxidation processes and biological approaches for the removal pharmaceuticals ［J］. Journal of Environmental Management, 2021, 288: 112404. ［29］ GARRIDO-CARDENAS J A, ESTEBAN-GARCÍA B, AGÜERA A, et al. Wastewater treatment by advanced oxidation process and their worldwide research trends ［J］. International Journal of Envi- ronmental Research and Public Health, 2019, 17(1): 170. ［30］ YANG W, LIU G, CHEN Y, et al. Persulfate enhanced electro- chemical oxidation of highly toxic cyanide-containing organic wastewater using boron-doped diamond anode ［J］. Chemosphere, 2020, 252: 126499. ［31］ SAEED M U, HUSSAIN N, SUMRIN A, et al. Microbial biore- mediation strategies with wastewater treatment potentialities: a re- view ［J］. Science of the Total Environment, 2022, 818: 151754. ［32］ SHARMA M, AGARWAL S, AGARWAL MALIK R, et al. Recent advances in microbial engineering approaches for wastewater treatment: a review ［J］. Bioengineered, 2023, 14(1): 2184518. ［33］ PATEL H, YADAV V K, YADAV K K, et al. A recent and systemic approach towards microbial biodegradation of dyes from textile industries ［J］. Water, 2022, 14(19): 3163. ［34］ MANTOVANI M, ROSSI S, FICARA E, et al. Removal of phar- maceutical compounds from the liquid phase of anaerobic sludge in a pilot-scale high-rate algae-bacteria pond ［J］. Science of the Total Environment, 2024, 908: 167881. ［35］ CERETTA M B, NERCESSIAN D, WOLSKI E A. Current trends on role of biological treatment in integrated treatment technologies of textile wastewater ［J］. Frontiers in Microbiology, 2021, 12: 651025. ［36］ AMINIAN-DEHKORDI J, RAHIMI S, GOLZAR-AHMADI M, et al. Synthetic biology tools for environmental protection ［J］. Biotechnology Advances, 2023, 68: 108239. ［37］ CHAKRABORTY R, WU C H, HAZEN T C. Systems biology ap- proach to bioremediation ［J］. Current Opinion in Biotechnology, 2012, 23(3): 483-490. ［38］ LIU Y, SU A, LI J, et al. Towards next-generation model microor- ganism chassis for biomanufacturing ［J］. Applied Microbiology and Biotechnology, 2020, 104(21): 1-14. ［39］ DE LORENZO V, KRASNOGOR N, SCHMIDT M. For the sake of the bioeconomy: define what a synthetic biology chassis is",
+        "method": "semantic_chunk"
+    },
+    {
+        "id": "chunk193",
+        "chunk": "［J］. New Biotechnology, 2021, 60: 44-51. ［40］ GARNER K L. Principles of synthetic biology ［J］. Essays in Bio- chemistry, 2021, 65(5): 791-811. ［41］ SRIDHAR S, AJO-FRANKLIN C M, MASIELLO C A. A frame- work for the systematic selection of biosensor chassis for envi- ronmental synthetic biology ［J］. ACS Synthetic Biology, 2022, 11(9): 2909-2916. ［42］ AHANKOUB M, MARDANI G, GHASEMI-DEHKORDI P, et al. Biodecomposition of phenanthrene and pyrene by a genetically en- gineered Escherichia coli ［J］. Recent Patents on Biotechnology, 2020, 14(2): 121-133. ［43］ TONG C, LIANG Y, ZHANG Z, et al. Review of knockout tech- nology approaches in bacterial drug resistance research ［J］. PeerJ, 2023, 11: e15790. ［44］ YU M, HU S, TANG B, et al. Engineering Escherichia coli Nissle 1917 as a microbial chassis for therapeutic and industrial applications ［J］. Biotechnology Advances, 2023, 67: 108202. ［45］ PU W, CHEN J, ZHOU Y, et al. Systems metabolic engineering of Escherichia coli for hyper-production of 5-aminolevulinic acid ［J］. Biotechnology for Biofuels and Bioproducts, 2023, 16(1): 31. ［46］ GE J, WANG X, BAI Y, et al. Engineering Escherichia coli for efficient assembly of heme proteins ［J］. Microbial Cell Factories, 2023, 22(1): 59. ［47］ LI Q, SUN B, CHEN J, et al. A modified pCas/pTargetF system for CRISPR-Cas9-assisted genome editing in Escherichia coli ［J］. Acta Biochim Biophys Sin (Shanghai), 2021, 53(5): 620-627. ［48］ MORI H, KATAOKA M, YANG X. Past, present, and future of genome modification in Escherichia coli ［J］. Microorganisms, 2022, 10(9): 1835. ［49］ ZHU L, LIANG Z, XU Y, et al. Ultrasensitive and rapid visual detection of Escherichia coli O157:H7 based on RAA-CRISPR/ Cas12a system ［J］. Biosensors, 2023, 13(6): 659. ［50］ WANG B, XU J, GAO J, et al. Construction of an Escherichia coli strain to degrade phenol completely with two modified meta- bolic modules ［J］. Journal of Hazardous Materials, 2019, 373: 29-38. ［51］ WANG Y, TIAN Y S, GAO J J, et al. Complete biodegradation of the oldest organic herbicide 2,4-dichlorophenoxyacetic acid by engineering Escherichia coli ［J］. Journal of Hazardous Materials, 2023, 451: 131099. ［52］ LV X, LI Y, XIU X, et al. CRISPR genetic toolkits of classical food microorganisms: current state and future prospects ［J］. Bio- technology Advances, 2023, 69: 108261. ［53］ WEIMER A, KOHLSTEDT M, VOLKE D C, et al. Industrial biotechnology of Pseudomonas putida: advances and prospects ［J］. Applied Microbiology and Biotechnology, 2020, 104(18): 7745-7766. ［54］ SUN J, WANG Q, JIANG Y, et al. Genome editing and transcrip- tional repression in Pseudomonas putida KT2440 via the type II CRISPR system ［J］. Microbial Cell Factories, 2018, 17(1): 41. 林雅倩等：合成微生物与水污染治理应用 林雅倩等：合成微生物与水污染治理应用 激 光 生 物 学 报 430 第 33 卷 ［55］ MARTÍNEZ-GARCÍA E, DE LORENZO V. Pseudomonas putida as a synthetic biology chassis and a metabolic engineering plat- form ［J］. Current Opinion in Biotechnology, 2024, 85: 103025. ［56］ APARICIO T, DE LORENZO V, MARTÍNEZ-GARCÍA E. CRIS- PR/Cas9-enhanced ssDNA recombineering for Pseudomonas putida ［J］. Microbial Biotechnology, 2019, 12(5): 1076-1089. ［57］ LIANG T, SUN J, JU S, et al. Construction of T7-like expression system in Pseudomonas putida KT2440 to enhance the heter- ologous expression level ［J］. Frontiers in Chemistry, 2021, 9: 664967. ［58］ GONG T, LIU R, ZUO Z, et al. Metabolic engineering of Pseu- domonas putida KT2440 for complete mineralization of methyl parathion and γ-Hexachlorocyclohexane ［J］. ACS Synthetic Biol- ogy, 2016, 5(5): 434-442. ［59］ LIANG P, ZHANG Y, XU B, et al. Deletion of genomic islands in the Pseudomonas putida KT2440 genome can create an optimal chassis for synthetic biology applications ［J］. Microbial Cell Fac- tories, 2020, 19(1): 70. ［60］ FERRANDO J, FILLUELO O, ZEIGLER D R, et al. Barriers to simultaneous multilocus integration in Bacillus subtilis tumble down: development of a straightforward screening method for the colorimetric detection of one-step multiple gene insertion using the CRISPR-Cas9 system ［J］. Microbial Cell Factories, 2023, 22(1): 21. ［61］ GHATAORA J S, GEBHARD S, REEKSTING B J. Chimeric MerR-Family regulators and logic elements for the design of metal sensitive genetic circuits in Bacillus subtilis ［J］. ACS Synthetic Biology, 2023, 12(3): 735-749. ［62］ SU Y, LIU C, FANG H, et al. Bacillus subtilis: a universal cell factory for industry, agriculture, biomaterials and medicine ［J］. Microbial Cell Factories, 2020, 19(1): 173. ［63］ ZHU W, LIU Y, CAO X, et al. Recovering organic matters and ions from wastewater by genetically engineered Bacillus subtilis biomass ［J］. Journal of Environmental Management, 2015, 161: 402-407. ［64］ QIN Y, ANGELINI L L, CHAI Y. Bacillus subtilis cell differ- entiation, biofilm formation and environmental prevalence ［J］. Microorganisms, 2022, 10(6): 1108. ［65］ MOHSIN M Z, OMER R, HUANG J, et al. Advances in engi- neered Bacillus subtilis biofilms and spores, and their applications in bioremediation, biocatalysis, and biomaterials ［J］. Synthetic and Systems Biotechnology, 2021, 6(3): 180-191. ［66］ SHI Y, CHEN T, SHAW P, et al. Manipulating bacterial biofilms using materiobiology and synthetic biology approaches ［J］. Fron- tiers in Microbiology, 2022, 13: 844997. ［67］ LI C, SUN Y, YUE Z, et al. Combination of a recombinant bacte- rium with organonitrile-degrading and biofilm-forming capability and a positively charged carrier for organonitriles removal ［J］. Journal of Hazardous Materials, 2018, 353: 372-380. ［68］ ZHU X, XIANG Q, CHEN L, et al. Engineered Bacillus subtilis Biofilm@Biochar living materials for in-situ sensing and biore- mediation of heavy metal ions pollution ［J］. Journal of Hazardous Materials, 2024, 465: 133119. ［69］ WU Y, FENG S, SUN Z, et al. An outlook to sophisticated tech- nologies and novel developments for metabolic regulation in the Saccharomyces cerevisiae expression system ［J］. Frontiers in Bioengineering and Biotechnology, 2023, 11: 1249841. ［70］ TANG H, WU Y, DENG J, et al. Promoter architecture and pro- moter engineering in Saccharomyces cerevisiae ［J］. Metabolites, 2020, 10(8): 320. ［71］ PARAPOULI M, VASILEIADIS A, AFENDRA A S, et al. Sac- charomyces cerevisiae and its industrial applications ［J］. AIMS Microbiology, 2020, 6(1): 1-31. ［72］ CHEN B, LEE H L, HENG Y C, et al. Synthetic biology toolkits and applications in Saccharomyces cerevisiae ［J］. Biotechnology Advances, 2018, 36(7): 1870-1881. ［73］ SATO G, KURODA K. Overcoming the limitations of CRISPR- Cas9 systems in Saccharomyces cerevisiae: off-target effects, epigenome, and mitochondrial editing ［J］. Microorganisms, 2023, 11(4): 1040. ［74］ FAN C, ZHANG D, MO Q, et al. Engineering Saccharomyces cerevisiae-based biosensors for copper detection ［J］. Microbial Biotechnology, 2022, 15(11): 2854-2860. ［75］ ITO-HARASHIMA S, MIZUTANI Y, NISHIMURA M, et al. A pilot study for construction of a new cadmium-sensing yeast strain carrying a reporter plasmid with the JLP1 promoter ［J］. The Jour- nal of Toxicological Sciences, 2017, 42(1): 103-109. ［76］ RUTA L L, LIN Y F, KISSEN R, et al. Anchoring plant metallo- thioneins to the inner face of the plasma membrane of Saccha- romyces cerevisiae cells leads to heavy metal accumulation ［J］. PLoS One, 2017, 12(5): e0178393. ［77］ MASHANGOANE B F, CHIRWA E N. Cell surface display of pal- ladium binding peptide on Saccharomyces cerevisiae EBY100 cells using the a-agglutinin anchor system developed for the bio- sorption of Pd (II) ［J］. Minerals Engineering, 2022, 176: 107325. ［78］ YE J, CHEN G. Halomonas as a chassis ［J］. Essays in Biochem- istry, 2021, 65(2): 393-403. ［79］ AMINI B, OTADI M, PARTOVINIA A. Statistical modeling and optimization of toluidine red biodegradation in a synthetic waste- water using Halomonas strain Gb ［J］. Journal of Environmental Health Science & Engineering, 2019, 17(1): 319-330. ［80］ LIU C, YUE Y, XUE Y, et al. CRISPR-Cas9 assisted non- homologous end joining genome editing system of Halomonas bluephagenesis for large DNA f",
+        "method": "semantic_chunk"
+    }
+]

rag.py

@@ -0,0 +1,2065 @@
+import torch
+import faiss
+import numpy as np
+from llama_index.core.node_parser import SentenceSplitter
+import re
+from typing import List, Dict, Any, Optional, Tuple
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import json
+import shutil
+from typing import Optional
+from openai import OpenAI
+import gradio as gr
+import os
+import fitz  # PyMuPDF
+import chardet  # 用于自动检测编码
+import traceback
+from config import Config  # 导入配置文件
+
+# 创建知识库根目录和临时文件目录
+KB_BASE_DIR = Config.kb_base_dir
+os.makedirs(KB_BASE_DIR, exist_ok=True)
+
+# 创建默认知识库目录
+DEFAULT_KB = Config.default_kb
+DEFAULT_KB_DIR = os.path.join(KB_BASE_DIR, DEFAULT_KB)
+os.makedirs(DEFAULT_KB_DIR, exist_ok=True)
+
+# 创建临时输出目录
+OUTPUT_DIR = Config.output_dir
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+client = OpenAI(
+    api_key=Config.llm_api_key,
+    base_url=Config.llm_base_url
+)
+
+class DeepSeekClient:
+    def generate_answer(self, system_prompt, user_prompt, model=Config.llm_model):
+        response = client.chat.completions.create(
+            model=Config.llm_model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            stream=False
+        )
+        return response.choices[0].message.content.strip()
+
+# 获取知识库列表
+def get_knowledge_bases() -> List[str]:
+    """获取所有知识库名称"""
+    try:
+        if not os.path.exists(KB_BASE_DIR):
+            os.makedirs(KB_BASE_DIR, exist_ok=True)
+            
+        kb_dirs = [d for d in os.listdir(KB_BASE_DIR) 
+                  if os.path.isdir(os.path.join(KB_BASE_DIR, d))]
+        
+        # 确保默认知识库存在
+        if DEFAULT_KB not in kb_dirs:
+            os.makedirs(os.path.join(KB_BASE_DIR, DEFAULT_KB), exist_ok=True)
+            kb_dirs.append(DEFAULT_KB)
+            
+        return sorted(kb_dirs)
+    except Exception as e:
+        print(f"获取知识库列表失败: {str(e)}")
+        return [DEFAULT_KB]
+
+# 创建新知识库
+def create_knowledge_base(kb_name: str) -> str:
+    """创建新的知识库"""
+    try:
+        if not kb_name or not kb_name.strip():
+            return "错误：知识库名称不能为空"
+            
+        # 净化知识库名称，只允许字母、数字、下划线和中文
+        kb_name = re.sub(r'[^\w\u4e00-\u9fff]', '_', kb_name.strip())
+        
+        kb_path = os.path.join(KB_BASE_DIR, kb_name)
+        if os.path.exists(kb_path):
+            return f"知识库 '{kb_name}' 已存在"
+            
+        os.makedirs(kb_path, exist_ok=True)
+        return f"知识库 '{kb_name}' 创建成功"
+    except Exception as e:
+        return f"创建知识库失败: {str(e)}"
+
+# 删除知识库
+def delete_knowledge_base(kb_name: str) -> str:
+    """删除指定的知识库"""
+    try:
+        if kb_name == DEFAULT_KB:
+            return f"无法删除默认知识库 '{DEFAULT_KB}'"
+            
+        kb_path = os.path.join(KB_BASE_DIR, kb_name)
+        if not os.path.exists(kb_path):
+            return f"知识库 '{kb_name}' 不存在"
+            
+        shutil.rmtree(kb_path)
+        return f"知识库 '{kb_name}' 已删除"
+    except Exception as e:
+        return f"删除知识库失败: {str(e)}"
+
+# 获取知识库文件列表
+def get_kb_files(kb_name: str) -> List[str]:
+    """获取指定知识库中的文件列表"""
+    try:
+        kb_path = os.path.join(KB_BASE_DIR, kb_name)
+        if not os.path.exists(kb_path):
+            return []
+            
+        # 获取所有文件（排除索引文件和元数据文件）
+        files = [f for f in os.listdir(kb_path) 
+                if os.path.isfile(os.path.join(kb_path, f)) and 
+                not f.endswith(('.index', '.json'))]
+        
+        return sorted(files)
+    except Exception as e:
+        print(f"获取知识库文件列表失败: {str(e)}")
+        return []
+
+# 语义分块函数
+def semantic_chunk(text: str, chunk_size=800, chunk_overlap=20) -> List[dict]:
+    class EnhancedSentenceSplitter(SentenceSplitter):
+        def __init__(self, *args, **kwargs):
+            custom_seps = ["；", "!", "?", "\n"]
+            separators = [kwargs.get("separator", "。")] + custom_seps
+            kwargs["separator"] = '|'.join(map(re.escape, separators))
+            super().__init__(*args, **kwargs)
+
+        def _split_text(self, text: str, **kwargs) -> List[str]:
+            splits = re.split(f'({self.separator})', text)
+            chunks = []
+            current_chunk = []
+            for part in splits:
+                part = part.strip()
+                if not part:
+                    continue
+                if re.fullmatch(self.separator, part):
+                    if current_chunk:
+                        chunks.append("".join(current_chunk))
+                        current_chunk = []
+                else:
+                    current_chunk.append(part)
+            if current_chunk:
+                chunks.append("".join(current_chunk))
+            return [chunk.strip() for chunk in chunks if chunk.strip()]
+
+    text_splitter = EnhancedSentenceSplitter(
+        separator="。",
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        paragraph_separator="\n\n"
+    )
+
+    paragraphs = []
+    current_para = []
+    current_len = 0
+
+    for para in text.split("\n\n"):
+        para = para.strip()
+        para_len = len(para)
+        if para_len == 0:
+            continue
+        if current_len + para_len <= chunk_size:
+            current_para.append(para)
+            current_len += para_len
+        else:
+            if current_para:
+                paragraphs.append("\n".join(current_para))
+            current_para = [para]
+            current_len = para_len
+
+    if current_para:
+        paragraphs.append("\n".join(current_para))
+
+    chunk_data_list = []
+    chunk_id = 0
+    for para in paragraphs:
+        chunks = text_splitter.split_text(para)
+        for chunk in chunks:
+            if len(chunk) < 20:
+                continue
+            chunk_data_list.append({
+                "id": f'chunk{chunk_id}',
+                "chunk": chunk,
+                "method": "semantic_chunk"
+            })
+            chunk_id += 1
+    return chunk_data_list
+
+# 构建Faiss索引
+def build_faiss_index(vector_file, index_path, metadata_path):
+    try:
+        with open(vector_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+
+        if not data:
+            raise ValueError("向量数据为空，请检查输入文件。")
+            
+        # 确认所有数据项都有向量
+        valid_data = []
+        for item in data:
+            if 'vector' in item and item['vector']:
+                valid_data.append(item)
+            else:
+                print(f"警告: 跳过没有向量的数据项 ID: {item.get('id', '未知')}")
+                
+        if not valid_data:
+            raise ValueError("没有找到任何有效的向量数据。")
+            
+        # 提取向量
+        vectors = [item['vector'] for item in valid_data]
+        vectors = np.array(vectors, dtype=np.float32)
+        
+        if vectors.size == 0:
+            raise ValueError("向量数组为空，转换失败。")
+            
+        # 检查向量维度
+        dim = vectors.shape[1]
+        n_vectors = vectors.shape[0]
+        print(f"构建索引: {n_vectors} 个向量，每个向量维度: {dim}")
+        
+        # 确定索引类型和参数
+        max_nlist = n_vectors // 39
+        nlist = min(max_nlist, 128) if max_nlist >= 1 else 1
+
+        if nlist >= 1 and n_vectors >= nlist * 39:
+            print(f"使用 IndexIVFFlat 索引，nlist={nlist}")
+            quantizer = faiss.IndexFlatIP(dim)
+            index = faiss.IndexIVFFlat(quantizer, dim, nlist)
+            if not index.is_trained:
+                index.train(vectors)
+            index.add(vectors)
+        else:
+            print(f"使用 IndexFlatIP 索引")
+            index = faiss.IndexFlatIP(dim)
+            index.add(vectors)
+
+        faiss.write_index(index, index_path)
+        print(f"成功写入索引到 {index_path}")
+        
+        # 创建元数据
+        metadata = [{'id': item['id'], 'chunk': item['chunk'], 'method': item['method']} for item in valid_data]
+        with open(metadata_path, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f, ensure_ascii=False, indent=4)
+        print(f"成功写入元数据到 {metadata_path}")
+        
+        return True
+    except Exception as e:
+        print(f"构建索引失败: {str(e)}")
+        traceback.print_exc()
+        raise
+
+# 向量化文件内容
+def vectorize_file(data_list, output_file_path, field_name="chunk"):
+    """向量化文件内容，处理长度限制并确保输入有效"""
+    if not data_list:
+        print("警告: 没有数据需要向量化")
+        with open(output_file_path, 'w', encoding='utf-8') as outfile:
+            json.dump([], outfile, ensure_ascii=False, indent=4)
+        return
+        
+    # 准备查询文本，确保每个文本有效且长度适中
+    valid_data = []
+    valid_texts = []
+    
+    for data in data_list:
+        text = data.get(field_name, "")
+        # 确保文本不为空且长度合适
+        if text and 1 <= len(text) <= 8000:  # 略小于API限制的8192，留出一些余量
+            valid_data.append(data)
+            valid_texts.append(text)
+        else:
+            # 如果文本太长，截断它
+            if len(text) > 8000:
+                truncated_text = text[:8000]
+                print(f"警告: 文本过长，已截断至8000字符。原始长度: {len(text)}")
+                data[field_name] = truncated_text
+                valid_data.append(data)
+                valid_texts.append(truncated_text)
+            else:
+                print(f"警告: 跳过空文本或长度为0的文本")
+    
+    if not valid_texts:
+        print("错误: 所有文本都无效，无法进行向量化")
+        with open(output_file_path, 'w', encoding='utf-8') as outfile:
+            json.dump([], outfile, ensure_ascii=False, indent=4)
+        return
+    
+    # 向量化有效文本
+    vectors = vectorize_query(valid_texts)
+    
+    # 检查向量化是否成功
+    if vectors.size == 0 or len(vectors) != len(valid_data):
+        print(f"错误: 向量化失败或向量数量({len(vectors) if vectors.size > 0 else 0})与数据条目({len(valid_data)})不匹配")
+        # 保存原始数据，但不含向量
+        with open(output_file_path, 'w', encoding='utf-8') as outfile:
+            json.dump(valid_data, outfile, ensure_ascii=False, indent=4)
+        return
+    
+    # 添加向量到数据中
+    for data, vector in zip(valid_data, vectors):
+        data['vector'] = vector.tolist()
+    
+    # 保存结果
+    with open(output_file_path, 'w', encoding='utf-8') as outfile:
+        json.dump(valid_data, outfile, ensure_ascii=False, indent=4)
+    
+    print(f"成功向量化 {len(valid_data)} 条数据并保存到 {output_file_path}")
+
+
+# 向量化查询 - 通用函数，被多处使用
+def vectorize_query(query, model_name=Config.model_name, batch_size=Config.batch_size) -> np.ndarray:
+    """向量化文本查询，返回嵌入向量，改进错误处理和批处理"""
+    embedding_client = OpenAI(
+        api_key=Config.api_key,
+        base_url=Config.base_url
+    )
+    
+    if not query:
+        print("警告: 传入向量化的查询为空")
+        return np.array([])
+        
+    if isinstance(query, str):
+        query = [query]
+    
+    # 验证所有查询文本，确保它们符合API要求
+    valid_queries = []
+    for q in query:
+        if not q or not isinstance(q, str):
+            print(f"警告: 跳过无效查询: {type(q)}")
+            continue
+            
+        # 清理文本并检查长度
+        clean_q = clean_text(q)
+        if not clean_q:
+            print("警告: 清理后的查询文本为空")
+            continue
+            
+        # 检查长度是否在API限制范围内
+        if len(clean_q) > 8000:
+            print(f"警告: 查询文本过长 ({len(clean_q)} 字符)，截断至 8000 字符")
+            clean_q = clean_q[:8000]
+        
+        valid_queries.append(clean_q)
+    
+    if not valid_queries:
+        print("错误: 所有查询都无效，无法进行向量化")
+        return np.array([])
+    
+    # 分批处理有效查询
+    all_vectors = []
+    for i in range(0, len(valid_queries), batch_size):
+        batch = valid_queries[i:i + batch_size]
+        try:
+            # 记录批次信息便于调试
+            print(f"正在向量化批次 {i//batch_size + 1}/{(len(valid_queries)-1)//batch_size + 1}, "
+                  f"包含 {len(batch)} 个文本，第一个文本长度: {len(batch[0][:50])}...")
+                  
+            completion = embedding_client.embeddings.create(
+                model=model_name,
+                input=batch,
+                dimensions=Config.dimensions,
+                encoding_format="float"
+            )
+            vectors = [embedding.embedding for embedding in completion.data]
+            all_vectors.extend(vectors)
+            print(f"批次 {i//batch_size + 1} 向量化成功，获得 {len(vectors)} 个向量")
+        except Exception as e:
+            print(f"向量化批次 {i//batch_size + 1} 失败：{str(e)}")
+            print(f"问题批次中的第一个文本: {batch[0][:100]}...")
+            traceback.print_exc()
+            # 如果是第一批就失败，直接返回空数组
+            if i == 0:
+                return np.array([])
+            # 否则返回已处理的向量
+            break
+    
+    # 检查是否获得了任何向量
+    if not all_vectors:
+        print("错误: 向量化过程没有产生任何向量")
+        return np.array([])
+        
+    return np.array(all_vectors)
+
+# 简单的向量搜索，用于基本对比
+def vector_search(query, index_path, metadata_path, limit):
+    """基本向量搜索函数"""
+    query_vector = vectorize_query(query)
+    if query_vector.size == 0:
+        return []
+        
+    query_vector = np.array(query_vector, dtype=np.float32).reshape(1, -1)
+
+    index = faiss.read_index(index_path)
+    try:
+        with open(metadata_path, 'r', encoding='utf-8') as f:
+            metadata = json.load(f)
+    except UnicodeDecodeError:
+        print(f"警告：{metadata_path} 包含非法字符，使用 UTF-8 忽略错误重新加载")
+        with open(metadata_path, 'rb') as f:
+            content = f.read().decode('utf-8', errors='ignore')
+            metadata = json.loads(content)
+
+    D, I = index.search(query_vector, limit)
+    results = [metadata[i] for i in I[0] if i < len(metadata)]
+    return results
+
+def clean_text(text):
+    """清理文本中的非法字符，控制文本长度"""
+    if not text:
+        return ""
+    # 移除控制字符，保留换行和制表符
+    text = re.sub(r'[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]', '', text)
+    # 移除重复的空白字符
+    text = re.sub(r'\s+', ' ', text)
+    # 确保文本长度在合理范围内
+    return text.strip()
+
+# PDF文本提取
+def extract_text_from_pdf(pdf_path):
+    try:
+        doc = fitz.open(pdf_path)
+        text = ""
+        for page in doc:
+            page_text = page.get_text()
+            # 清理不可打印字符，尝试用 UTF-8 解码，失败时忽略非法字符
+            text += page_text.encode('utf-8', errors='ignore').decode('utf-8')
+        if not text.strip():
+            print(f"警告：PDF文件 {pdf_path} 提取内容为空")
+        return text
+    except Exception as e:
+        print(f"PDF文本提取失败：{str(e)}")
+        return ""
+
+# 处理单个文件
+def process_single_file(file_path: str) -> str:
+    try:
+        if file_path.lower().endswith('.pdf'):
+            text = extract_text_from_pdf(file_path)
+            if not text:
+                return f"PDF文件 {file_path} 内容为空或无法提取"
+        else:
+            with open(file_path, "rb") as f:
+                content = f.read()
+            result = chardet.detect(content)
+            detected_encoding = result['encoding']
+            confidence = result['confidence']
+            
+            # 尝试多种编码方式
+            if detected_encoding and confidence > 0.7:
+                try:
+                    text = content.decode(detected_encoding)
+                    print(f"文件 {file_path} 使用检测到的编码 {detected_encoding} 解码成功")
+                except UnicodeDecodeError:
+                    text = content.decode('utf-8', errors='ignore')
+                    print(f"文件 {file_path} 使用 {detected_encoding} 解码失败，强制使用 UTF-8 忽略非法字符")
+            else:
+                # 尝试多种常见编码
+                encodings = ['utf-8', 'gbk', 'gb18030', 'gb2312', 'latin-1', 'utf-16', 'cp936', 'big5']
+                text = None
+                for encoding in encodings:
+                    try:
+                        text = content.decode(encoding)
+                        print(f"文件 {file_path} 使用 {encoding} 解码成功")
+                        break
+                    except UnicodeDecodeError:
+                        continue
+                
+                # 如果所有编码都失败，使用忽略错误的方式解码
+                if text is None:
+                    text = content.decode('utf-8', errors='ignore')
+                    print(f"警告：文件 {file_path} 使用 UTF-8 忽略非法字符")
+        
+        # 确保文本是干净的，移除非法字符
+        text = clean_text(text)
+        return text
+    except Exception as e:
+        print(f"处理文件 {file_path} 时出错: {str(e)}")
+        traceback.print_exc()
+        return f"处理文件 {file_path} 失败：{str(e)}"
+
+# 批量处理并索引文件 - 修改为支持指定知识库
+def process_and_index_files(file_objs: List, kb_name: str = DEFAULT_KB) -> str:
+    """处理并索引文件到指定的知识库"""
+    # 确保知识库目录存在
+    kb_dir = os.path.join(KB_BASE_DIR, kb_name)
+    os.makedirs(kb_dir, exist_ok=True)
+    
+    # 设置临时处理文件路径
+    semantic_chunk_output = os.path.join(OUTPUT_DIR, "semantic_chunk_output.json")
+    semantic_chunk_vector = os.path.join(OUTPUT_DIR, "semantic_chunk_vector.json")
+    
+    # 设置知识库索引文件路径
+    semantic_chunk_index = os.path.join(kb_dir, "semantic_chunk.index")
+    semantic_chunk_metadata = os.path.join(kb_dir, "semantic_chunk_metadata.json")
+
+    all_chunks = []
+    error_messages = []
+    try:
+        if not file_objs or len(file_objs) == 0:
+            return "错误：没有选择任何文件"
+            
+        print(f"开始处理 {len(file_objs)} 个文件，目标知识库: {kb_name}...")
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            future_to_file = {executor.submit(process_single_file, file_obj.name): file_obj for file_obj in file_objs}
+            for future in as_completed(future_to_file):
+                result = future.result()
+                file_obj = future_to_file[future]
+                file_name = file_obj.name
+                
+                if isinstance(result, str) and result.startswith("处理文件"):
+                    error_messages.append(result)
+                    print(result)
+                    continue
+                
+                # 检查结果是否为有效文本
+                if not result or not isinstance(result, str) or len(result.strip()) == 0:
+                    error_messages.append(f"文件 {file_name} 处理后内容为空")
+                    print(f"警告: 文件 {file_name} 处理后内容为空")
+                    continue
+                    
+                print(f"对文件 {file_name} 进行语义分块...")
+                chunks = semantic_chunk(result)
+                
+                if not chunks or len(chunks) == 0:
+                    error_messages.append(f"文件 {file_name} 无法生成任何分块")
+                    print(f"警告: 文件 {file_name} 无法生成任何分块")
+                    continue
+                
+                # 将处理后的文件保存到知识库目录
+                file_basename = os.path.basename(file_name)
+                dest_file_path = os.path.join(kb_dir, file_basename)
+                try:
+                    shutil.copy2(file_name, dest_file_path)
+                    print(f"已将文件 {file_basename} 复制到知识库 {kb_name}")
+                except Exception as e:
+                    print(f"复制文件到知识库失败: {str(e)}")
+                
+                all_chunks.extend(chunks)
+                print(f"文件 {file_name} 处理完成，生成 {len(chunks)} 个分块")
+
+        if not all_chunks:
+            return "所有文件处理失败或内容为空\n" + "\n".join(error_messages)
+
+        # 确保分块内容干净且长度合适
+        valid_chunks = []
+        for chunk in all_chunks:
+            # 深度清理文本
+            clean_chunk_text = clean_text(chunk["chunk"])
+            
+            # 检查清理后的文本是否有效
+            if clean_chunk_text and 1 <= len(clean_chunk_text) <= 8000:
+                chunk["chunk"] = clean_chunk_text
+                valid_chunks.append(chunk)
+            elif len(clean_chunk_text) > 8000:
+                # 如果文本太长，截断它
+                chunk["chunk"] = clean_chunk_text[:8000]
+                valid_chunks.append(chunk)
+                print(f"警告: 分块 {chunk['id']} 过长已被截断")
+            else:
+                print(f"警告: 跳过无效分块 {chunk['id']}")
+
+        if not valid_chunks:
+            return "所有生成的分块内容无效或为空\n" + "\n".join(error_messages)
+            
+        print(f"处理了 {len(all_chunks)} 个分块，有效分块数: {len(valid_chunks)}")
+
+        # 保存语义分块
+        with open(semantic_chunk_output, 'w', encoding='utf-8') as json_file:
+            json.dump(valid_chunks, json_file, ensure_ascii=False, indent=4)
+        print(f"语义分块完成: {semantic_chunk_output}")
+
+        # 向量化语义分块
+        print(f"开始向量化 {len(valid_chunks)} 个分块...")
+        vectorize_file(valid_chunks, semantic_chunk_vector)
+        print(f"语义分块向量化完成: {semantic_chunk_vector}")
+
+        # 验证向量文件是否有效
+        try:
+            with open(semantic_chunk_vector, 'r', encoding='utf-8') as f:
+                vector_data = json.load(f)
+                
+            if not vector_data or len(vector_data) == 0:
+                return f"向量化失败: 生成的向量文件为空\n" + "\n".join(error_messages)
+                
+            # 检查向量数据结构
+            if 'vector' not in vector_data[0]:
+                return f"向量化失败: 数据中缺少向量字段\n" + "\n".join(error_messages)
+                
+            print(f"成功生成 {len(vector_data)} 个向量")
+        except Exception as e:
+            return f"读取向量文件失败: {str(e)}\n" + "\n".join(error_messages)
+
+        # 构建索引
+        print(f"开始为知识库 {kb_name} 构建索引...")
+        build_faiss_index(semantic_chunk_vector, semantic_chunk_index, semantic_chunk_metadata)
+        print(f"知识库 {kb_name} 索引构建完成: {semantic_chunk_index}")
+
+        status = f"知识库 {kb_name} 更新成功！共处理 {len(valid_chunks)} 个有效分块。\n"
+        if error_messages:
+            status += "以下文件处理过程中出现问题：\n" + "\n".join(error_messages)
+        return status
+    except Exception as e:
+        error = f"知识库 {kb_name} 索引构建过程中出错：{str(e)}"
+        print(error)
+        traceback.print_exc()
+        return error + "\n" + "\n".join(error_messages)
+
+# 核心联网搜索功能
+def get_search_background(query: str, max_length: int = 1500) -> str:
+    try:
+        from retrievor import q_searching
+        search_results = q_searching(query)
+        cleaned_results = re.sub(r'\s+', ' ', search_results).strip()
+        return cleaned_results[:max_length]
+    except Exception as e:
+        print(f"联网搜索失败：{str(e)}")
+        return ""
+
+# 基本的回答生成
+def generate_answer_from_deepseek(question: str, system_prompt: str = "你是一名专业医疗助手，请根据背景知识回答问题。", background_info: Optional[str] = None) -> str:
+    deepseek_client = DeepSeekClient()
+    user_prompt = f"问题：{question}"
+    if background_info:
+        user_prompt = f"背景知识：{background_info}\n\n{user_prompt}"
+    try:
+        answer = deepseek_client.generate_answer(system_prompt, user_prompt)
+        return answer
+    except Exception as e:
+        return f"生成回答时出错：{str(e)}"
+
+# 多跳推理RAG系统 - 核心创新点
+class ReasoningRAG:
+    """
+    多跳推理RAG系统，通过迭代式的检索和推理过程回答问题，支持流式响应
+    """
+    
+    def __init__(self, 
+                 index_path: str, 
+                 metadata_path: str,
+                 max_hops: int = 3,
+                 initial_candidates: int = 5,
+                 refined_candidates: int = 3,
+                 reasoning_model: str = Config.llm_model,
+                 verbose: bool = False):
+        """
+        初始化推理RAG系统
+        
+        参数:
+            index_path: FAISS索引的路径
+            metadata_path: 元数据JSON文件的路径
+            max_hops: 最大推理-检索跳数
+            initial_candidates: 初始检索候选数量
+            refined_candidates: 精炼检索候选数量
+            reasoning_model: 用于推理步骤的LLM模型
+            verbose: 是否打印详细日志
+        """
+        self.index_path = index_path
+        self.metadata_path = metadata_path
+        self.max_hops = max_hops
+        self.initial_candidates = initial_candidates
+        self.refined_candidates = refined_candidates
+        self.reasoning_model = reasoning_model
+        self.verbose = verbose
+        
+        # 加载索引和元数据
+        self._load_resources()
+        
+    def _load_resources(self):
+        """加载FAISS索引和元数据"""
+        if os.path.exists(self.index_path) and os.path.exists(self.metadata_path):
+            self.index = faiss.read_index(self.index_path)
+            try:
+                with open(self.metadata_path, 'r', encoding='utf-8') as f:
+                    self.metadata = json.load(f)
+            except UnicodeDecodeError:
+                with open(self.metadata_path, 'rb') as f:
+                    content = f.read().decode('utf-8', errors='ignore')
+                    self.metadata = json.loads(content)
+        else:
+            raise FileNotFoundError(f"Index or metadata not found at {self.index_path} or {self.metadata_path}")
+    
+    def _vectorize_query(self, query: str) -> np.ndarray:
+        """将查询转换为向量"""
+        return vectorize_query(query).reshape(1, -1)
+    
+    def _retrieve(self, query_vector: np.ndarray, limit: int) -> List[Dict[str, Any]]:
+        """使用向量相似性检索块"""
+        if query_vector.size == 0:
+            return []
+            
+        D, I = self.index.search(query_vector, limit)
+        results = [self.metadata[i] for i in I[0] if i < len(self.metadata)]
+        return results
+    
+    def _generate_reasoning(self, 
+                           query: str, 
+                           retrieved_chunks: List[Dict[str, Any]], 
+                           previous_queries: List[str] = None,
+                           hop_number: int = 0) -> Dict[str, Any]:
+        """
+        为检索到的信息生成推理分析并识别信息缺口
+        
+        返回包含以下字段的字典:
+            - analysis: 对当前信息的推理分析
+            - missing_info: 已识别的缺失信息
+            - follow_up_queries: 填补信息缺口的后续查询列表
+            - is_sufficient: 表示信息是否足够的布尔值
+        """
+        if previous_queries is None:
+            previous_queries = []
+            
+        # 为模型准备上下文
+        chunks_text = "\n\n".join([f"[Chunk {i+1}]: {chunk['chunk']}" 
+                                 for i, chunk in enumerate(retrieved_chunks)])
+        
+        previous_queries_text = "\n".join([f"Q{i+1}: {q}" for i, q in enumerate(previous_queries)])
+        
+        system_prompt = """
+        你是医疗信息检索的专家分析系统。
+        你的任务是分析检索到的信息块，识别缺失的内容，并提出有针对性的后续查询来填补信息缺口。
+        
+        重点关注医疗领域知识，如:
+        - 疾病诊断和症状
+        - 治疗方法和药物
+        - 医学研究和临床试验
+        - 患者护理和康复
+        - 医疗法规和伦理
+        """
+        
+        user_prompt = f"""
+        ## 原始查询
+        {query}
+        
+        ## 先前查询（如果有）
+        {previous_queries_text if previous_queries else "无"}
+        
+        ## 检索到的信息（跳数 {hop_number}）
+        {chunks_text if chunks_text else "未检索到信息。"}
+        
+        ## 你的任务
+        1. 分析已检索到的信息与原始查询的关系
+        2. 确定能够更完整回答查询的特定缺失信息
+        3. 提出1-3个针对性的后续查询，以检索缺失信息
+        4. 确定当前信息是否足够回答原始查询
+        
+        以JSON格式回答，包含以下字段:
+        - analysis: 对当前信息的详细分析
+        - missing_info: 特定缺失信息的列表
+        - follow_up_queries: 1-3个具体的后续查询
+        - is_sufficient: 表示信息是否足够的布尔值
+        """
+        
+        try:
+            response = client.chat.completions.create(
+                model=Config.llm_model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                response_format={"type": "json_object"}
+            )
+            reasoning_text = response.choices[0].message.content.strip()
+            
+            # 解析JSON响应
+            try:
+                reasoning = json.loads(reasoning_text)
+                # 确保预期的键存在
+                required_keys = ["analysis", "missing_info", "follow_up_queries", "is_sufficient"]
+                for key in required_keys:
+                    if key not in reasoning:
+                        reasoning[key] = [] if key != "is_sufficient" else False
+                return reasoning
+            except json.JSONDecodeError:
+                # 如果JSON解析失败，则回退
+                if self.verbose:
+                    print(f"无法从模型输出解析JSON: {reasoning_text[:100]}...")
+                return {
+                    "analysis": "无法分析检索到的信息。",
+                    "missing_info": ["无法识别缺失信息"],
+                    "follow_up_queries": [],
+                    "is_sufficient": False
+                }
+                
+        except Exception as e:
+            if self.verbose:
+                print(f"推理生成错误: {e}")
+                print(traceback.format_exc())
+            return {
+                "analysis": "分析过程出错。",
+                "missing_info": [],
+                "follow_up_queries": [],
+                "is_sufficient": False
+            }
+    
+    def _synthesize_answer(self, 
+                          query: str, 
+                          all_chunks: List[Dict[str, Any]],
+                          reasoning_steps: List[Dict[str, Any]],
+                          use_table_format: bool = False) -> str:
+        """从所有检索到的块和推理步骤中合成最终答案"""
+        # 合并所有块，去除重复
+        unique_chunks = []
+        chunk_ids = set()
+        for chunk in all_chunks:
+            if chunk["id"] not in chunk_ids:
+                unique_chunks.append(chunk)
+                chunk_ids.add(chunk["id"])
+        
+        # 准备上下文
+        chunks_text = "\n\n".join([f"[Chunk {i+1}]: {chunk['chunk']}" 
+                                  for i, chunk in enumerate(unique_chunks)])
+        
+        # 准备推理跟踪
+        reasoning_trace = ""
+        for i, step in enumerate(reasoning_steps):
+            reasoning_trace += f"\n\n推理步骤 {i+1}:\n"
+            reasoning_trace += f"分析: {step['analysis']}\n"
+            reasoning_trace += f"缺失信息: {', '.join(step['missing_info'])}\n"
+            reasoning_trace += f"后续查询: {', '.join(step['follow_up_queries'])}"
+        
+        system_prompt = """
+        你是医疗领域的专家。基于检索到的信息块，为用户的查询合成一个全面的答案。
+        
+        重点提供有关医疗和健康的准确、基于证据的信息，包括诊断、治疗、预防和医学研究等方面。
+        
+        逻辑地组织你的答案，并在适当时引用块中的具体信息。如果信息不完整，请承认限制。
+        """
+        
+        output_format_instruction = ""
+        if use_table_format:
+            output_format_instruction = """
+            请尽可能以Markdown表格格式组织你的回答。如果信息适合表格形式展示，请使用表格；
+            如果不适合表格形式，可以先用文本介绍，然后再使用表格总结关键信息。
+            
+            表格语法示例：
+            | 标题1 | 标题2 | 标题3 |
+            | ----- | ----- | ----- |
+            | 内容1 | 内容2 | 内容3 |
+            
+            确保表格格式符合Markdown标准，以便正确渲染。
+            """
+        
+        user_prompt = f"""
+        ## 原始查询
+        {query}
+        
+        ## 检索到的信息块
+        {chunks_text}
+        
+        ## 推理过程
+        {reasoning_trace}
+        
+        ## 你的任务
+        使用提供的信息块为原始查询合成一个全面的答案。你的答案应该:
+        
+        1. 直接回应查询
+        2. 结构清晰，易于理解
+        3. 基于检索到的信息
+        4. 承认可用信息中的任何重大缺口
+        
+        {output_format_instruction}
+        
+        以直接回应提出原始查询的用户的方式呈现你的答案。
+        """
+        
+        try:
+            response = client.chat.completions.create(
+                model=Config.llm_model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ]
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            if self.verbose:
+                print(f"答案合成错误: {e}")
+                print(traceback.format_exc())
+            return "由于出错，无法生成答案。"
+    
+    def stream_retrieve_and_answer(self, query: str, use_table_format: bool = False):
+        """
+        执行多跳检索和回答生成的流式方法，逐步返回结果
+        
+        这是一个生成器函数，会在处理的每个阶段产生中间结果
+        """
+        all_chunks = []
+        all_queries = [query]
+        reasoning_steps = []
+        
+        # 生成状态更新
+        yield {
+            "status": "正在将查询向量化...",
+            "reasoning_display": "",
+            "answer": None,
+            "all_chunks": [],
+            "reasoning_steps": []
+        }
+        
+        # 初始检索
+        try:
+            query_vector = self._vectorize_query(query)
+            if query_vector.size == 0:
+                yield {
+                    "status": "向量化失败",
+                    "reasoning_display": "由于嵌入错误，无法处理查询。",
+                    "answer": "由于嵌入错误，无法处理查询。",
+                    "all_chunks": [],
+                    "reasoning_steps": []
+                }
+                return
+                
+            yield {
+                "status": "正在执行初始检索...",
+                "reasoning_display": "",
+                "answer": None,
+                "all_chunks": [],
+                "reasoning_steps": []
+            }
+            
+            initial_chunks = self._retrieve(query_vector, self.initial_candidates)
+            all_chunks.extend(initial_chunks)
+            
+            if not initial_chunks:
+                yield {
+                    "status": "未找到相关信息",
+                    "reasoning_display": "未找到与您的查询相关的信息。",
+                    "answer": "未找到与您的查询相关的信息。",
+                    "all_chunks": [],
+                    "reasoning_steps": []
+                }
+                return
+            
+            # 更新状态，展示找到的初始块
+            chunks_preview = "\n".join([f"- {chunk['chunk'][:100]}..." for chunk in initial_chunks[:2]])
+            yield {
+                "status": f"找到 {len(initial_chunks)} 个相关信息块，正在生成初步分析...",
+                "reasoning_display": f"### 检索到的初始信息\n{chunks_preview}\n\n### 正在分析...",
+                "answer": None,
+                "all_chunks": all_chunks,
+                "reasoning_steps": []
+            }
+            
+            # 初始推理
+            reasoning = self._generate_reasoning(query, initial_chunks, hop_number=0)
+            reasoning_steps.append(reasoning)
+            
+            # 生成当前的推理显示
+            reasoning_display = "### 多跳推理过程\n"
+            reasoning_display += f"**推理步骤 1**\n"
+            reasoning_display += f"- 分析: {reasoning['analysis'][:200]}...\n"
+            reasoning_display += f"- 缺失信息: {', '.join(reasoning['missing_info'])}\n"
+            if reasoning['follow_up_queries']:
+                reasoning_display += f"- 后续查询: {', '.join(reasoning['follow_up_queries'])}\n"
+            reasoning_display += f"- 信息是否足够: {'是' if reasoning['is_sufficient'] else '否'}\n\n"
+            
+            yield {
+                "status": "初步分析完成",
+                "reasoning_display": reasoning_display,
+                "answer": None,
+                "all_chunks": all_chunks,
+                "reasoning_steps": reasoning_steps
+            }
+            
+            # 检查是否需要额外的跳数
+            hop = 1
+            while (hop < self.max_hops and 
+                  not reasoning["is_sufficient"] and 
+                  reasoning["follow_up_queries"]):
+                
+                follow_up_status = f"执行跳数 {hop}，正在处理 {len(reasoning['follow_up_queries'])} 个后续查询..."
+                yield {
+                    "status": follow_up_status,
+                    "reasoning_display": reasoning_display + f"\n\n### {follow_up_status}",
+                    "answer": None,
+                    "all_chunks": all_chunks,
+                    "reasoning_steps": reasoning_steps
+                }
+                
+                hop_chunks = []
+                
+                # 处理每个后续查询
+                for i, follow_up_query in enumerate(reasoning["follow_up_queries"]):
+                    all_queries.append(follow_up_query)
+                    
+                    query_status = f"处理后续查询 {i+1}/{len(reasoning['follow_up_queries'])}: {follow_up_query}"
+                    yield {
+                        "status": query_status,
+                        "reasoning_display": reasoning_display + f"\n\n### {query_status}",
+                        "answer": None,
+                        "all_chunks": all_chunks,
+                        "reasoning_steps": reasoning_steps
+                    }
+                    
+                    # 为后续查询检索
+                    follow_up_vector = self._vectorize_query(follow_up_query)
+                    if follow_up_vector.size > 0:
+                        follow_up_chunks = self._retrieve(follow_up_vector, self.refined_candidates)
+                        hop_chunks.extend(follow_up_chunks)
+                        all_chunks.extend(follow_up_chunks)
+                        
+                        # 更新状态，显示新找到的块数量
+                        yield {
+                            "status": f"查询 '{follow_up_query}' 找到了 {len(follow_up_chunks)} 个相关块",
+                            "reasoning_display": reasoning_display + f"\n\n为查询 '{follow_up_query}' 找到了 {len(follow_up_chunks)} 个相关块",
+                            "answer": None,
+                            "all_chunks": all_chunks,
+                            "reasoning_steps": reasoning_steps
+                        }
+                
+                # 为此跳数生成推理
+                yield {
+                    "status": f"正在为跳数 {hop} 生成推理分析...",
+                    "reasoning_display": reasoning_display + f"\n\n### 正在为跳数 {hop} 生成推理分析...",
+                    "answer": None,
+                    "all_chunks": all_chunks,
+                    "reasoning_steps": reasoning_steps
+                }
+                
+                reasoning = self._generate_reasoning(
+                    query, 
+                    hop_chunks, 
+                    previous_queries=all_queries[:-1],
+                    hop_number=hop
+                )
+                reasoning_steps.append(reasoning)
+                
+                # 更新推理显示
+                reasoning_display += f"\n**推理步骤 {hop+1}**\n"
+                reasoning_display += f"- 分析: {reasoning['analysis'][:200]}...\n"
+                reasoning_display += f"- 缺失信息: {', '.join(reasoning['missing_info'])}\n"
+                if reasoning['follow_up_queries']:
+                    reasoning_display += f"- 后续查询: {', '.join(reasoning['follow_up_queries'])}\n"
+                reasoning_display += f"- 信息是否足够: {'是' if reasoning['is_sufficient'] else '否'}\n"
+                
+                yield {
+                    "status": f"跳数 {hop} 完成",
+                    "reasoning_display": reasoning_display,
+                    "answer": None,
+                    "all_chunks": all_chunks,
+                    "reasoning_steps": reasoning_steps
+                }
+                
+                hop += 1
+            
+            # 合成最终答案
+            yield {
+                "status": "正在合成最终答案...",
+                "reasoning_display": reasoning_display + "\n\n### 正在合成最终答案...",
+                "answer": "正在处理您的问题，请稍候...",
+                "all_chunks": all_chunks,
+                "reasoning_steps": reasoning_steps
+            }
+            
+            answer = self._synthesize_answer(query, all_chunks, reasoning_steps, use_table_format)
+            
+            # 为最终显示准备检索内容汇总
+            all_chunks_summary = "\n\n".join([f"**检索块 {i+1}**:\n{chunk['chunk']}" 
+                                           for i, chunk in enumerate(all_chunks[:10])])  # 限制显示前10个块
+            
+            if len(all_chunks) > 10:
+                all_chunks_summary += f"\n\n...以及另外 {len(all_chunks) - 10} 个块（总计 {len(all_chunks)} 个）"
+                
+            enhanced_display = reasoning_display + "\n\n### 检索到的内容\n" + all_chunks_summary + "\n\n### 回答已生成"
+            
+            yield {
+                "status": "回答已生成",
+                "reasoning_display": enhanced_display,
+                "answer": answer,
+                "all_chunks": all_chunks,
+                "reasoning_steps": reasoning_steps
+            }
+            
+        except Exception as e:
+            error_msg = f"处理过程中出错: {str(e)}"
+            if self.verbose:
+                print(error_msg)
+                print(traceback.format_exc())
+            
+            yield {
+                "status": "处理出错",
+                "reasoning_display": error_msg,
+                "answer": f"处理您的问题时遇到错误: {str(e)}",
+                "all_chunks": all_chunks,
+                "reasoning_steps": reasoning_steps
+            }
+    
+    def retrieve_and_answer(self, query: str, use_table_format: bool = False) -> Tuple[str, Dict[str, Any]]:
+        """
+        执行多跳检索和回答生成的主要方法
+        
+        返回:
+            包含以下内容的元组:
+            - 最终答案
+            - 包含推理步骤和所有检索到的块的调试字典
+        """
+        all_chunks = []
+        all_queries = [query]
+        reasoning_steps = []
+        debug_info = {"reasoning_steps": [], "all_chunks": [], "all_queries": all_queries}
+        
+        # 初始检索
+        query_vector = self._vectorize_query(query)
+        if query_vector.size == 0:
+            return "由于嵌入错误，无法处理查询。", debug_info
+            
+        initial_chunks = self._retrieve(query_vector, self.initial_candidates)
+        all_chunks.extend(initial_chunks)
+        debug_info["all_chunks"].extend(initial_chunks)
+        
+        if not initial_chunks:
+            return "未找到与您的查询相关的信息。", debug_info
+        
+        # 初始推理
+        reasoning = self._generate_reasoning(query, initial_chunks, hop_number=0)
+        reasoning_steps.append(reasoning)
+        debug_info["reasoning_steps"].append(reasoning)
+        
+        # 检查是否需要额外的跳数
+        hop = 1
+        while (hop < self.max_hops and 
+               not reasoning["is_sufficient"] and 
+               reasoning["follow_up_queries"]):
+            
+            if self.verbose:
+                print(f"开始跳数 {hop}，有 {len(reasoning['follow_up_queries'])} 个后续查询")
+            
+            hop_chunks = []
+            
+            # 处理每个后续查询
+            for follow_up_query in reasoning["follow_up_queries"]:
+                all_queries.append(follow_up_query)
+                debug_info["all_queries"].append(follow_up_query)
+                
+                # 为后续查询检索
+                follow_up_vector = self._vectorize_query(follow_up_query)
+                if follow_up_vector.size > 0:
+                    follow_up_chunks = self._retrieve(follow_up_vector, self.refined_candidates)
+                    hop_chunks.extend(follow_up_chunks)
+                    all_chunks.extend(follow_up_chunks)
+                    debug_info["all_chunks"].extend(follow_up_chunks)
+            
+            # 为此跳数生成推理
+            reasoning = self._generate_reasoning(
+                query, 
+                hop_chunks, 
+                previous_queries=all_queries[:-1],
+                hop_number=hop
+            )
+            reasoning_steps.append(reasoning)
+            debug_info["reasoning_steps"].append(reasoning)
+            
+            hop += 1
+        
+        # 合成最终答案
+        answer = self._synthesize_answer(query, all_chunks, reasoning_steps, use_table_format)
+        
+        return answer, debug_info
+
+# 基于选定知识库生成索引路径
+def get_kb_paths(kb_name: str) -> Dict[str, str]:
+    """获取指定知识库的索引文件路径"""
+    kb_dir = os.path.join(KB_BASE_DIR, kb_name)
+    return {
+        "index_path": os.path.join(kb_dir, "semantic_chunk.index"),
+        "metadata_path": os.path.join(kb_dir, "semantic_chunk_metadata.json")
+    }
+
+def multi_hop_generate_answer(query: str, kb_name: str, use_table_format: bool = False, system_prompt: str = "你是一名医疗专家。") -> Tuple[str, Dict]:
+    """使用多跳推理RAG生成答案，基于指定知识库"""
+    kb_paths = get_kb_paths(kb_name)
+    
+    reasoning_rag = ReasoningRAG(
+        index_path=kb_paths["index_path"],
+        metadata_path=kb_paths["metadata_path"],
+        max_hops=3,
+        initial_candidates=5,
+        refined_candidates=3,
+        reasoning_model=Config.llm_model,
+        verbose=True
+    )
+    
+    answer, debug_info = reasoning_rag.retrieve_and_answer(query, use_table_format)
+    return answer, debug_info
+
+# 使用简单向量检索生成答案，基于指定知识库
+def simple_generate_answer(query: str, kb_name: str, use_table_format: bool = False) -> str:
+    """使用简单的向量检索生成答案，不使用多跳推理"""
+    try:
+        kb_paths = get_kb_paths(kb_name)
+        
+        # 使用基本向量搜索
+        search_results = vector_search(query, kb_paths["index_path"], kb_paths["metadata_path"], limit=5)
+        
+        if not search_results:
+            return "未找到相关信息。"
+        
+        # 准备背景信息
+        background_chunks = "\n\n".join([f"[相关信息 {i+1}]: {result['chunk']}" 
+                                       for i, result in enumerate(search_results)])
+        
+        # 生成答案
+        system_prompt = "你是一名医疗专家。基于提供的背景信息回答用户的问题。"
+        
+        if use_table_format:
+            system_prompt += "请尽可能以Markdown表格的形式呈现结构化信息。"
+        
+        user_prompt = f"""
+        问题：{query}
+        
+        背景信息：
+        {background_chunks}
+        
+        请基于以上背景信息回答用户的问题。
+        """
+        
+        response = client.chat.completions.create(
+            model=Config.llm_model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        
+        return response.choices[0].message.content.strip()
+        
+    except Exception as e:
+        return f"生成答案时出错：{str(e)}"
+
+# 修改主要的问题处理函数以支持指定知识库
+def ask_question_parallel(question: str, kb_name: str = DEFAULT_KB, use_search: bool = True, use_table_format: bool = False, multi_hop: bool = False) -> str:
+    """基于指定知识库回答问题"""
+    try:
+        kb_paths = get_kb_paths(kb_name)
+        index_path = kb_paths["index_path"]
+        metadata_path = kb_paths["metadata_path"]
+
+        search_background = ""
+        local_answer = ""
+        debug_info = {}
+
+        # 并行处理
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            futures = {}
+            
+            if use_search:
+                futures[executor.submit(get_search_background, question)] = "search"
+                
+            if os.path.exists(index_path):
+                if multi_hop:
+                    # 使用多跳推理
+                    futures[executor.submit(multi_hop_generate_answer, question, kb_name, use_table_format)] = "rag"
+                else:
+                    # 使用简单向量检索
+                    futures[executor.submit(simple_generate_answer, question, kb_name, use_table_format)] = "simple"
+                
+            for future in as_completed(futures):
+                result = future.result()
+                if futures[future] == "search":
+                    search_background = result or ""
+                elif futures[future] == "rag":
+                    local_answer, debug_info = result
+                elif futures[future] == "simple":
+                    local_answer = result
+
+        # 如果同时有搜索和本地结果，合并它们
+        if search_background and local_answer:
+            system_prompt = "你是一名医疗专家，请整合网络搜索和本地知识库提供全面的解答。"
+            
+            table_instruction = ""
+            if use_table_format:
+                table_instruction = """
+                请尽可能以Markdown表格的形式呈现你的回答，特别是对于症状、治疗方法、药物等结构化信息。
+                
+                请确保你的表格遵循正确的Markdown语法：
+                | 列标题1 | 列标题2 | 列标题3 |
+                | ------- | ------- | ------- |
+                | 数据1   | 数据2   | 数据3   |
+                """
+                
+            user_prompt = f"""
+            问题：{question}
+            
+            网络搜索结果：{search_background}
+            
+            本地知识库分析：{local_answer}
+            
+            {table_instruction}
+            
+            请根据以上信息，提供一个综合的回答。
+            """
+            
+            try:
+                response = client.chat.completions.create(
+                    model="qwen-plus",
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt}
+                    ]
+                )
+                combined_answer = response.choices[0].message.content.strip()
+                return combined_answer
+            except Exception as e:
+                # 如果合并失败，回退到本地答案
+                return local_answer
+        elif local_answer:
+            return local_answer
+        elif search_background:
+            # 仅从搜索结果生成答案
+            system_prompt = "你是一名医疗专家。"
+            if use_table_format:
+                system_prompt += "请尽可能以Markdown表格的形式呈现结构化信息。"
+            return generate_answer_from_deepseek(question, system_prompt=system_prompt, background_info=f"[联网搜索结果]：{search_background}")
+        else:
+            return "未找到相关信息。"
+            
+    except Exception as e:
+        return f"查询失败：{str(e)}"
+
+# 修改以支持多知识库的流式响应函数
+def process_question_with_reasoning(question: str, kb_name: str = DEFAULT_KB, use_search: bool = True, use_table_format: bool = False, multi_hop: bool = False, chat_history: List = None):
+    """增强版process_question，支持流式响应，实时显示检索和推理过程，支持多知识库和对话历史"""
+    try:
+        kb_paths = get_kb_paths(kb_name)
+        index_path = kb_paths["index_path"]
+        metadata_path = kb_paths["metadata_path"]
+
+        # 构建带对话历史的问题
+        if chat_history and len(chat_history) > 0:
+            # 构建对话上下文
+            context = "之前的对话内容：\n"
+            for user_msg, assistant_msg in chat_history[-3:]:  # 只取最近3轮对话
+                context += f"用户：{user_msg}\n"
+                context += f"助手：{assistant_msg}\n"
+            context += f"\n当前问题：{question}"
+            enhanced_question = f"基于以下对话历史，回答用户的当前问题。\n{context}"
+        else:
+            enhanced_question = question
+
+        # 初始状态
+        search_result = "联网搜索进行中..." if use_search else "未启用联网搜索"
+        
+        if multi_hop:
+            reasoning_status = f"正在准备对知识库 '{kb_name}' 进行多跳推理检索..."
+            search_display = f"### 联网搜索结果\n{search_result}\n\n### 推理状态\n{reasoning_status}"
+            yield search_display, "正在启动多跳推理流程..."
+        else:
+            reasoning_status = f"正在准备对知识库 '{kb_name}' 进行向量检索..."
+            search_display = f"### 联网搜索结果\n{search_result}\n\n### 检索状态\n{reasoning_status}"
+            yield search_display, "正在启动简单检索流程..."
+
+        # 如果启用，并行运行搜索
+        search_future = None
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            if use_search:
+                search_future = executor.submit(get_search_background, question)
+                
+        # 检查索引是否存在
+        if not (os.path.exists(index_path) and os.path.exists(metadata_path)):
+            # 如果索引不存在，提前返回
+            if search_future:
+                # 等待搜索结果
+                search_result = "等待联网搜索结果..."
+                search_display = f"### 联网搜索结果\n{search_result}\n\n### 检索状态\n知识库 '{kb_name}' 中未找到索引"
+                yield search_display, "等待联网搜索结果..."
+                
+                search_result = search_future.result() or "未找到相关网络信息"
+                system_prompt = "你是一名医疗专家。请考虑对话历史并回答用户的问题。"
+                if use_table_format:
+                    system_prompt += "请尽可能以Markdown表格的形式呈现结构化信息。"
+                answer = generate_answer_from_deepseek(enhanced_question, system_prompt=system_prompt, background_info=f"[联网搜索结果]：{search_result}")
+                
+                search_display = f"### 联网搜索结果\n{search_result}\n\n### 检索状态\n无法在知识库 '{kb_name}' 中进行本地检索（未找到索引）"
+                yield search_display, answer
+            else:
+                yield f"知识库 '{kb_name}' 中未找到索引，且未启用联网搜索", "无法回答您的问题。请先上传文件到该知识库或启用联网搜索。"
+            return
+
+        # 开始流式处理
+        current_answer = "正在分析您的问题..."
+        
+        if multi_hop:
+            # 使用多跳推理的流式接口
+            reasoning_rag = ReasoningRAG(
+                index_path=index_path,
+                metadata_path=metadata_path,
+                max_hops=3,
+                initial_candidates=5,
+                refined_candidates=3,
+                verbose=True
+            )
+            
+            # 使用enhanced_question进行检索
+            for step_result in reasoning_rag.stream_retrieve_and_answer(enhanced_question, use_table_format):
+                # 更新当前状态
+                status = step_result["status"]
+                reasoning_display = step_result["reasoning_display"]
+                
+                # 如果有新的答案，更新
+                if step_result["answer"]:
+                    current_answer = step_result["answer"]
+                
+                # 如果搜索结果已返回，更新搜索结果
+                if search_future and search_future.done():
+                    search_result = search_future.result() or "未找到相关网络信息"
+                
+                # 构建并返回当前状态
+                current_display = f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 推理状态\n{status}\n\n{reasoning_display}"
+                yield current_display, current_answer
+        else:
+            # 简单向量检索的流式处理
+            yield f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 检索状态\n正在执行向量相似度搜索...", "正在检索相关信息..."
+            
+            # 执行简单向量搜索，使用enhanced_question
+            try:
+                search_results = vector_search(enhanced_question, index_path, metadata_path, limit=5)
+                
+                if not search_results:
+                    yield f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 检索状态\n未找到相关信息", f"知识库 '{kb_name}' 中未找到相关信息。"
+                    current_answer = f"知识库 '{kb_name}' 中未找到相关信息。"
+                else:
+                    # 显示检索到的信息
+                    chunks_detail = "\n\n".join([f"**相关信息 {i+1}**:\n{result['chunk']}" for i, result in enumerate(search_results[:5])])
+                    chunks_preview = "\n".join([f"- {result['chunk'][:100]}..." for i, result in enumerate(search_results[:3])])
+                    yield f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 检索状态\n找到 {len(search_results)} 个相关信息块\n\n### 检索到的信息预览\n{chunks_preview}", "正在生成答案..."
+                    
+                    # 生成答案
+                    background_chunks = "\n\n".join([f"[相关信息 {i+1}]: {result['chunk']}" 
+                                                   for i, result in enumerate(search_results)])
+                    
+                    system_prompt = "你是一名医疗专家。基于提供的背景信息和对话历史回答用户的问题。"
+                    if use_table_format:
+                        system_prompt += "请尽可能以Markdown表格的形式呈现结构化信息。"
+                    
+                    user_prompt = f"""
+                    {enhanced_question}
+                    
+                    背景信息：
+                    {background_chunks}
+                    
+                    请基于以上背景信息和对话历史回答用户的问题。
+                    """
+                    
+                    response = client.chat.completions.create(
+                        model=Config.llm_model,
+                        messages=[
+                            {"role": "system", "content": system_prompt},
+                            {"role": "user", "content": user_prompt}
+                        ]
+                    )
+                    
+                    current_answer = response.choices[0].message.content.strip()
+                    yield f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 检索状态\n检索完成，已生成答案\n\n### 检索到的内容\n{chunks_detail}", current_answer
+                    
+            except Exception as e:
+                error_msg = f"检索过程中出错: {str(e)}"
+                yield f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 检索状态\n{error_msg}", f"检索过程中出错: {str(e)}"
+                current_answer = f"检索过程中出错: {str(e)}"
+        
+        # 检索完成后，如果有搜索结果，可以考虑合并知识
+        if search_future and search_future.done():
+            search_result = search_future.result() or "未找到相关网络信息"
+            
+            # 如果同时有搜索结果和本地检索结果，可以考虑合并
+            if search_result and current_answer and current_answer not in ["正在分析您的问题...", "本地知识库中未找到相关信息。"]:
+                status_text = "正在合并联网搜索和知识库结果..."
+                if multi_hop:
+                    yield f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 推理状态\n{status_text}", current_answer
+                else:
+                    yield f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 检索状态\n{status_text}", current_answer
+                
+                # 合并结果
+                system_prompt = "你是一名医疗专家，请整合网络搜索和本地知识库提供全面的解答。请考虑对话历史。"
+                
+                if use_table_format:
+                    system_prompt += "请尽可能以Markdown表格的形式呈现结构化信息。"
+                
+                user_prompt = f"""
+                {enhanced_question}
+                
+                网络搜索结果：{search_result}
+                
+                本地知识库分析：{current_answer}
+                
+                请根据以上信息和对话历史，提供一个综合的回答。确保使用Markdown表格来呈现适合表格形式的信息。
+                """
+                
+                try:
+                    response = client.chat.completions.create(
+                        model="qwen-plus",
+                        messages=[
+                            {"role": "system", "content": system_prompt},
+                            {"role": "user", "content": user_prompt}
+                        ]
+                    )
+                    combined_answer = response.choices[0].message.content.strip()
+                    
+                    final_status = "已整合联网和知识库结果"
+                    if multi_hop:
+                        final_display = f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 本地知识库分析\n已完成多跳推理分析，检索到的内容已在上方显示\n\n### 综合分析\n{final_status}"
+                    else:
+                        # 获取之前检索到的内容
+                        chunks_info = "".join([part.split("### 检索到的内容\n")[-1] if "### 检索到的内容\n" in part else "" for part in search_display.split("### 联网搜索结果")])
+                        if not chunks_info.strip():
+                            chunks_info = "检索内容已在上方显示"
+                        final_display = f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 本地知识库分析\n已完成向量检索分析\n\n### 检索到的内容\n{chunks_info}\n\n### 综合分析\n{final_status}"
+                    
+                    yield final_display, combined_answer
+                except Exception as e:
+                    # 如果合并失败，使用现有答案
+                    error_status = f"合并结果失败: {str(e)}"
+                    if multi_hop:
+                        final_display = f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 本地知识库分析\n已完成多跳推理分析，检索到的内容已在上方显示\n\n### 综合分析\n{error_status}"
+                    else:
+                        # 获取之前检索到的内容
+                        chunks_info = "".join([part.split("### 检索到的内容\n")[-1] if "### 检索到的内容\n" in part else "" for part in search_display.split("### 联网搜索结果")])
+                        if not chunks_info.strip():
+                            chunks_info = "检索内容已在上方显示"
+                        final_display = f"### 联网搜索结果\n{search_result}\n\n### 知识库: {kb_name}\n### 本地知识库分析\n已完成向量检索分析\n\n### 检索到的内容\n{chunks_info}\n\n### 综合分析\n{error_status}"
+                        
+                    yield final_display, current_answer
+        
+    except Exception as e:
+        error_msg = f"处理失败：{str(e)}\n{traceback.format_exc()}"
+        yield f"### 错误信息\n{error_msg}", f"处理您的问题时遇到错误：{str(e)}"
+
+# 添加处理函数，批量上传文件到指定知识库
+def batch_upload_to_kb(file_objs: List, kb_name: str) -> str:
+    """批量上传文件到指定知识库并进行处理"""
+    try:
+        if not kb_name or not kb_name.strip():
+            return "错误：未指定知识库"
+            
+        # 确保知识库目录存在
+        kb_dir = os.path.join(KB_BASE_DIR, kb_name)
+        if not os.path.exists(kb_dir):
+            os.makedirs(kb_dir, exist_ok=True)
+            
+        if not file_objs or len(file_objs) == 0:
+            return "错误：未选择任何文件"
+            
+        return process_and_index_files(file_objs, kb_name)
+    except Exception as e:
+        return f"上传文件到知识库失败: {str(e)}"
+
+# Gradio 界面 - 修改为支持多知识库
+custom_css = """
+.web-search-toggle .form { display: flex !important; align-items: center !important; }
+.web-search-toggle .form > label { order: 2 !important; margin-left: 10px !important; }
+.web-search-toggle .checkbox-wrap { order: 1 !important; background: #d4e4d4 !important; border-radius: 15px !important; padding: 2px !important; width: 50px !important; height: 28px !important; }
+.web-search-toggle .checkbox-wrap .checkbox-container { width: 24px !important; height: 24px !important; transition: all 0.3s ease !important; }
+.web-search-toggle input:checked + .checkbox-wrap { background: #2196F3 !important; }
+.web-search-toggle input:checked + .checkbox-wrap .checkbox-container { transform: translateX(22px) !important; }
+#search-results { max-height: 400px; overflow-y: auto; border: 1px solid #2196F3; border-radius: 5px; padding: 10px; background-color: #e7f0f9; }
+#question-input { border-color: #2196F3 !important; }
+#answer-output { background-color: #f0f7f0; border-color: #2196F3 !important; max-height: 400px; overflow-y: auto; }
+.submit-btn { background-color: #2196F3 !important; border: none !important; }
+.reasoning-steps { background-color: #f0f7f0; border: 1px dashed #2196F3; padding: 10px; margin-top: 10px; border-radius: 5px; }
+.loading-spinner { display: inline-block; width: 20px; height: 20px; border: 3px solid rgba(33, 150, 243, 0.3); border-radius: 50%; border-top-color: #2196F3; animation: spin 1s ease-in-out infinite; }
+@keyframes spin { to { transform: rotate(360deg); } }
+.stream-update { animation: fade 0.5s ease-in-out; }
+@keyframes fade { from { background-color: rgba(33, 150, 243, 0.1); } to { background-color: transparent; } }
+.status-box { padding: 10px; border-radius: 5px; margin-bottom: 10px; font-weight: bold; }
+.status-processing { background-color: #e3f2fd; color: #1565c0; border-left: 4px solid #2196F3; }
+.status-success { background-color: #e8f5e9; color: #2e7d32; border-left: 4px solid #4CAF50; }
+.status-error { background-color: #ffebee; color: #c62828; border-left: 4px solid #f44336; }
+.multi-hop-toggle .form { display: flex !important; align-items: center !important; }
+.multi-hop-toggle .form > label { order: 2 !important; margin-left: 10px !important; }
+.multi-hop-toggle .checkbox-wrap { order: 1 !important; background: #d4e4d4 !important; border-radius: 15px !important; padding: 2px !important; width: 50px !important; height: 28px !important; }
+.multi-hop-toggle .checkbox-wrap .checkbox-container { width: 24px !important; height: 24px !important; transition: all 0.3s ease !important; }
+.multi-hop-toggle input:checked + .checkbox-wrap { background: #4CAF50 !important; }
+.multi-hop-toggle input:checked + .checkbox-wrap .checkbox-container { transform: translateX(22px) !important; }
+.kb-management { border: 1px solid #2196F3; border-radius: 5px; padding: 15px; margin-bottom: 15px; background-color: #f0f7ff; }
+.kb-selector { margin-bottom: 10px; }
+/* 缩小文件上传区域高度 */
+.compact-upload {
+    margin-bottom: 10px;
+}
+
+.file-upload.compact {
+    padding: 10px;  /* 减小内边距 */
+    min-height: 120px; /* 减小最小高度 */
+    margin-bottom: 10px;
+}
+
+/* 优化知识库内容显示区域 */
+.kb-files-list {
+    height: 400px;
+    overflow-y: auto;
+}
+
+/* 确保右侧列有足够空间 */
+#kb-files-group {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+}
+.kb-files-list { max-height: 250px; overflow-y: auto; border: 1px solid #ccc; border-radius: 5px; padding: 10px; margin-top: 10px; background-color: #f9f9f9; }
+#kb-management-container {
+    max-width: 800px !important;
+    margin: 0 !important; /* 移除自动边距，靠左对齐 */
+    margin-left: 20px !important; /* 添加左边距 */
+}
+.container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+}
+.file-upload {
+    border: 2px dashed #2196F3;
+    padding: 15px;
+    border-radius: 10px;
+    background-color: #f0f7ff;
+    margin-bottom: 15px;
+}
+.tabs.tab-selected {
+    background-color: #e3f2fd;
+    border-bottom: 3px solid #2196F3;
+}
+.group {
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    padding: 10px;
+    margin-bottom: 15px;
+    background-color: #fafafa;
+}
+
+/* 添加更多针对知识库管理页面的样式 */
+#kb-controls, #kb-file-upload, #kb-files-group {
+    width: 100% !important;
+    max-width: 800px !important;
+    margin-right: auto !important;
+}
+
+/* 修改Gradio默认的标签页样式以支持左对齐 */
+.tabs > .tab-nav > button {
+    flex: 0 1 auto !important; /* 修改为不自动扩展，只占用必要空间 */
+}
+.tabs > .tabitem {
+    padding-left: 0 !important; /* 移除左边距，使内容靠左 */
+}
+/* 对于首页的顶部标题部分 */
+#app-container h1, #app-container h2, #app-container h3, 
+#app-container > .prose {
+    text-align: left !important;
+    padding-left: 20px !important;
+}
+"""
+
+custom_theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="blue",
+    neutral_hue="gray",
+    text_size="lg",
+    spacing_size="md",
+    radius_size="md"
+)
+
+# 添加简单的JavaScript，通过html组件实现
+js_code = """
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    // 当页面加载完毕后，找到提交按钮，并为其添加点击事件
+    const observer = new MutationObserver(function(mutations) {
+        // 找到提交按钮
+        const submitButton = document.querySelector('button[data-testid="submit"]');
+        if (submitButton) {
+            submitButton.addEventListener('click', function() {
+                // 找到检索标签页按钮并点击它
+                setTimeout(function() {
+                    const retrievalTab = document.querySelector('[data-testid="tab-button-retrieval-tab"]');
+                    if (retrievalTab) retrievalTab.click();
+                }, 100);
+            });
+            observer.disconnect(); // 一旦找到并设置事件，停止观察
+        }
+    });
+    
+    // 开始观察文档变化
+    observer.observe(document.body, { childList: true, subtree: true });
+});
+</script>
+"""
+
+with gr.Blocks(title="医疗知识问答系统", theme=custom_theme, css=custom_css, elem_id="app-container") as demo:
+    with gr.Column(elem_id="header-container"):
+        gr.Markdown("""
+        # 🏥 医疗知识问答系统
+        **智能医疗助手，支持多知识库管理、多轮对话、普通语义检索和高级多跳推理**  
+        本系统支持创建多个知识库，上传TXT或PDF文件，通过语义向量检索或创新的多跳推理机制提供医疗信息查询服务。
+        """)
+    
+    # 添加JavaScript脚本
+    gr.HTML(js_code, visible=False)
+    
+    # 使用State来存储对话历史
+    chat_history_state = gr.State([])
+    
+    # 创建标签页
+    with gr.Tabs() as tabs:
+        # 知识库管理标签页
+        with gr.TabItem("知识库管理"):
+            with gr.Row():
+                # 左侧列：控制区
+                with gr.Column(scale=1, min_width=400):
+                    gr.Markdown("### 📚 知识库管理与构建")
+                    
+                    with gr.Row(elem_id="kb-controls"):
+                        with gr.Column(scale=1):
+                            new_kb_name = gr.Textbox(
+                                label="新知识库名称",
+                                placeholder="输入新知识库名称",
+                                lines=1
+                            )
+                            create_kb_btn = gr.Button("创建知识库", variant="primary", scale=1)
+                    
+                        with gr.Column(scale=1):
+                            current_kbs = get_knowledge_bases()
+                            kb_dropdown = gr.Dropdown(
+                                label="选择知识库",
+                                choices=current_kbs,
+                                value=DEFAULT_KB if DEFAULT_KB in current_kbs else (current_kbs[0] if current_kbs else None),
+                                elem_classes="kb-selector"
+                            )
+                            
+                            with gr.Row():
+                                refresh_kb_btn = gr.Button("刷新列表", size="sm", scale=1)
+                                delete_kb_btn = gr.Button("删除知识库", size="sm", variant="stop", scale=1)
+                    
+                    kb_status = gr.Textbox(label="知识库状态", interactive=False, placeholder="选择或创建知识库")
+                    
+                    with gr.Group(elem_id="kb-file-upload", elem_classes="compact-upload"):
+                        gr.Markdown("### 📄 上传文件到知识库")
+                        file_upload = gr.File(
+                            label="选择文件（支持多选TXT/PDF）",
+                            type="filepath",
+                            file_types=[".txt", ".pdf"],
+                            file_count="multiple",
+                            elem_classes="file-upload compact"
+                        )
+                        upload_status = gr.Textbox(label="上传状态", interactive=False, placeholder="上传后显示状态")
+                    
+                    kb_select_for_chat = gr.Dropdown(
+                        label="为对话选择知识库",
+                        choices=current_kbs,
+                        value=DEFAULT_KB if DEFAULT_KB in current_kbs else (current_kbs[0] if current_kbs else None),
+                        visible=False  # 隐藏，仅用于同步
+                    )
+                        
+                with gr.Column(scale=1, min_width=400):
+                    with gr.Group(elem_id="kb-files-group"):
+                        gr.Markdown("### 📋 知识库内容")
+                        kb_files_list = gr.Markdown(
+                            value="选择知识库查看文件...",
+                            elem_classes="kb-files-list"
+                        )
+                
+                # 用于对话界面的知识库选择器
+                kb_select_for_chat = gr.Dropdown(
+                    label="为对话选择知识库",
+                    choices=current_kbs,
+                    value=DEFAULT_KB if DEFAULT_KB in current_kbs else (current_kbs[0] if current_kbs else None),
+                    visible=False  # 隐藏，仅用于同步
+                )
+        
+        # 对话交互标签页
+        with gr.TabItem("对话交互"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### ⚙️ 对话设置")
+                    
+                    kb_dropdown_chat = gr.Dropdown(
+                        label="选择知识库进行对话",
+                        choices=current_kbs,
+                        value=DEFAULT_KB if DEFAULT_KB in current_kbs else (current_kbs[0] if current_kbs else None),
+                    )
+                    
+                    with gr.Row():
+                        web_search_toggle = gr.Checkbox(
+                            label="🌐 启用联网搜索",
+                            value=True,
+                            info="获取最新医疗动态",
+                            elem_classes="web-search-toggle"
+                        )
+                        table_format_toggle = gr.Checkbox(
+                            label="📊 表格格式输出",
+                            value=True,
+                            info="使用Markdown表格展示结构化回答",
+                            elem_classes="web-search-toggle"
+                        )
+                    
+                    multi_hop_toggle = gr.Checkbox(
+                        label="🔄 启用多跳推理",
+                        value=False,
+                        info="使用高级多跳推理机制（较慢但更全面）",
+                        elem_classes="multi-hop-toggle"
+                    )
+                    
+                    with gr.Accordion("显示检索进展", open=False):
+                        search_results_output = gr.Markdown(
+                            label="检索过程",
+                            elem_id="search-results",
+                            value="等待提交问题..."
+                        )
+                    
+                with gr.Column(scale=3):
+                    gr.Markdown("### 💬 对话历史")
+                    chatbot = gr.Chatbot(
+                        elem_id="chatbot",
+                        label="对话历史",
+                        height=550
+                    )
+            
+            with gr.Row():
+                question_input = gr.Textbox(
+                    label="输入医疗健康相关问题",
+                    placeholder="例如：2型糖尿病的症状和治疗方法有哪些？",
+                    lines=2,
+                    elem_id="question-input"
+                )
+            
+            with gr.Row(elem_classes="submit-row"):
+                submit_btn = gr.Button("提交问题", variant="primary", elem_classes="submit-btn")
+                clear_btn = gr.Button("清空输入", variant="secondary")
+                clear_history_btn = gr.Button("清空对话历史", variant="secondary", elem_classes="clear-history-btn")
+            
+            # 状态显示框
+            status_box = gr.HTML(
+                value='<div class="status-box status-processing">准备就绪，等待您的问题</div>',
+                visible=True
+            )
+            
+            gr.Examples(
+                examples=[
+                    ["2型糖尿病的症状和治疗方法有哪些？"],
+                    ["高血压患者的日常饮食应该注意什么？"],
+                    ["肺癌的早期症状和筛查方法是什么？"],
+                    ["新冠肺炎后遗症有哪些表现？如何缓解？"],
+                    ["儿童过敏性鼻炎的诊断标准和治疗方案有哪些？"]
+                ],
+                inputs=question_input,
+                label="示例问题（点击尝试）"
+            )
+    
+    # 创建知识库函数
+    def create_kb_and_refresh(kb_name):
+        result = create_knowledge_base(kb_name)
+        kbs = get_knowledge_bases()
+        # 更新两个下拉菜单
+        return result, gr.update(choices=kbs, value=kb_name if "创建成功" in result else None), gr.update(choices=kbs, value=kb_name if "创建成功" in result else None)
+    
+    # 刷新知识库列表
+    def refresh_kb_list():
+        kbs = get_knowledge_bases()
+        # 更新两个下拉菜单
+        return gr.update(choices=kbs, value=kbs[0] if kbs else None), gr.update(choices=kbs, value=kbs[0] if kbs else None)
+    
+    # 删除知识库
+    def delete_kb_and_refresh(kb_name):
+        result = delete_knowledge_base(kb_name)
+        kbs = get_knowledge_bases()
+        # 更新两个下拉菜单
+        return result, gr.update(choices=kbs, value=kbs[0] if kbs else None), gr.update(choices=kbs, value=kbs[0] if kbs else None)
+    
+    # 更新知识库文件列表
+    def update_kb_files_list(kb_name):
+        if not kb_name:
+            return "未选择知识库"
+        
+        files = get_kb_files(kb_name)
+        kb_dir = os.path.join(KB_BASE_DIR, kb_name)
+        has_index = os.path.exists(os.path.join(kb_dir, "semantic_chunk.index"))
+        
+        if not files:
+            files_str = "知识库中暂无文件"
+        else:
+            files_str = "**文件列表:**\n\n" + "\n".join([f"- {file}" for file in files])
+        
+        index_status = "\n\n**索引状态:** " + ("✅ 已建立索引" if has_index else "❌ 未建立索引")
+        
+        return f"### 知识库: {kb_name}\n\n{files_str}{index_status}"
+    
+    # 同步知识库选择 - 管理界面到对话界面
+    def sync_kb_to_chat(kb_name):
+        return gr.update(value=kb_name)
+    
+    # 同步知识库选择 - 对话界面到管理界面
+    def sync_chat_to_kb(kb_name):
+        return gr.update(value=kb_name), update_kb_files_list(kb_name)
+    
+    # 处理文件上传到指定知识库
+    def process_upload_to_kb(files, kb_name):
+        if not kb_name:
+            return "错误：未选择知识库"
+        
+        result = batch_upload_to_kb(files, kb_name)
+        # 更新知识库文件列表
+        files_list = update_kb_files_list(kb_name)
+        return result, files_list
+    
+    # 知识库选择变化时
+    def on_kb_change(kb_name):
+        if not kb_name:
+            return "未选择知识库", "选择知识库查看文件..."
+        
+        kb_dir = os.path.join(KB_BASE_DIR, kb_name)
+        has_index = os.path.exists(os.path.join(kb_dir, "semantic_chunk.index"))
+        status = f"已选择知识库: {kb_name}" + (" (已建立索引)" if has_index else " (未建立索引)")
+        
+        # 更新文件列表
+        files_list = update_kb_files_list(kb_name)
+        
+        return status, files_list
+        
+    # 创建知识库按钮功能
+    create_kb_btn.click(
+        fn=create_kb_and_refresh,
+        inputs=[new_kb_name],
+        outputs=[kb_status, kb_dropdown, kb_dropdown_chat]
+    ).then(
+        fn=lambda: "",  # 清空输入框
+        inputs=[],
+        outputs=[new_kb_name]
+    )
+    
+    # 刷新知识库列表按钮功能
+    refresh_kb_btn.click(
+        fn=refresh_kb_list,
+        inputs=[],
+        outputs=[kb_dropdown, kb_dropdown_chat]
+    )
+    
+    # 删除知识库按钮功能
+    delete_kb_btn.click(
+        fn=delete_kb_and_refresh,
+        inputs=[kb_dropdown],
+        outputs=[kb_status, kb_dropdown, kb_dropdown_chat]
+    ).then(
+        fn=update_kb_files_list,
+        inputs=[kb_dropdown],
+        outputs=[kb_files_list]
+    )
+    
+    # 知识库选择变化时 - 管理界面
+    kb_dropdown.change(
+        fn=on_kb_change,
+        inputs=[kb_dropdown],
+        outputs=[kb_status, kb_files_list]
+    ).then(
+        fn=sync_kb_to_chat,
+        inputs=[kb_dropdown],
+        outputs=[kb_dropdown_chat]
+    )
+    
+    # 知识库选择变化时 - 对话界面
+    kb_dropdown_chat.change(
+        fn=sync_chat_to_kb,
+        inputs=[kb_dropdown_chat],
+        outputs=[kb_dropdown, kb_files_list]
+    )
+    
+    # 处理文件上传
+    file_upload.upload(
+        fn=process_upload_to_kb,
+        inputs=[file_upload, kb_dropdown],
+        outputs=[upload_status, kb_files_list]
+    )
+    
+    # 清空输入按钮功能
+    clear_btn.click(
+        fn=lambda: "",
+        inputs=[],
+        outputs=[question_input]
+    )
+    
+    # 清空对话历史按钮功能
+    def clear_history():
+        return [], []
+    
+    clear_history_btn.click(
+        fn=clear_history,
+        inputs=[],
+        outputs=[chatbot, chat_history_state]
+    )
+    
+    # 提交按钮 - 开始流式处理
+    def update_status(is_processing=True, is_error=False):
+        if is_processing:
+            return '<div class="status-box status-processing">正在处理您的问题...</div>'
+        elif is_error:
+            return '<div class="status-box status-error">处理过程中出现错误</div>'
+        else:
+            return '<div class="status-box status-success">回答已生成完毕</div>'
+    
+    # 处理问题并更新对话历史
+    def process_and_update_chat(question, kb_name, use_search, use_table_format, multi_hop, chat_history):
+        if not question.strip():
+            return chat_history, update_status(False, True), "等待提交问题..."
+        
+        try:
+            # 首先更新聊天界面，显示用户问题
+            chat_history.append([question, "正在思考..."])
+            yield chat_history, update_status(True), f"开始处理您的问题，使用知识库: {kb_name}..."
+            
+            # 用于累积检索状态和答案
+            last_search_display = ""
+            last_answer = ""
+            
+            # 使用生成器进行流式处理
+            for search_display, answer in process_question_with_reasoning(question, kb_name, use_search, use_table_format, multi_hop, chat_history[:-1]):
+                # 更新检索状态和答案
+                last_search_display = search_display
+                last_answer = answer
+                
+                # 更新聊天历史中的最后一条（当前的回答）
+                if chat_history:
+                    chat_history[-1][1] = answer
+                    yield chat_history, update_status(True), search_display
+            
+            # 处理完成，更新状态
+            yield chat_history, update_status(False), last_search_display
+            
+        except Exception as e:
+            # 发生错误时更新状态和聊天历史
+            error_msg = f"处理问题时出错: {str(e)}"
+            if chat_history:
+                chat_history[-1][1] = error_msg
+            yield chat_history, update_status(False, True), f"### 错误\n{error_msg}"
+    
+    # 连接提交按钮
+    submit_btn.click(
+        fn=process_and_update_chat,
+        inputs=[question_input, kb_dropdown_chat, web_search_toggle, table_format_toggle, multi_hop_toggle, chat_history_state],
+        outputs=[chatbot, status_box, search_results_output],
+        queue=True
+    ).then(
+        fn=lambda: "",  # 清空输入框
+        inputs=[],
+        outputs=[question_input]
+    ).then(
+        fn=lambda h: h,  # 更新state
+        inputs=[chatbot],
+        outputs=[chat_history_state]
+    )
+    
+    # 支持Enter键提交
+    question_input.submit(
+        fn=process_and_update_chat,
+        inputs=[question_input, kb_dropdown_chat, web_search_toggle, table_format_toggle, multi_hop_toggle, chat_history_state],
+        outputs=[chatbot, status_box, search_results_output],
+        queue=True
+    ).then(
+        fn=lambda: "",  # 清空输入框
+        inputs=[],
+        outputs=[question_input]
+    ).then(
+        fn=lambda h: h,  # 更新state
+        inputs=[chatbot],
+        outputs=[chat_history_state]
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

requirements.txt

@@ -0,0 +1,16 @@
+protobuf
+cpm_kernels
+torch>=2.0
+jieba==0.42.1
+lxml==4.9.4
+gradio
+mdtex2html
+sentencepiece
+sse-starlette
+streamlit>=1.24.0
+pyfunctional==1.3.0
+chardet
+faiss-cpu
+PyMuPDF
+openai
+llama-index

retrievor.py

@@ -0,0 +1,254 @@
+import requests
+import json
+import re
+from lxml import etree
+import chardet
+import jieba.analyse
+from text2vec import *
+from config import Config
+
+def search_bing(query):
+    """利用newbing搜索接口，用于检索与query相关的背景信息，作为检索内容
+    input：query
+    output：{'url':'','text':'','title':''}
+    """
+    headers = {
+        'Cookie': 'MUID=2CFCFC26663D64393955ED1C623D62A4; MUIDB=2CFCFC26663D64393955ED1C623D62A4; SRCHD=AF=S00028; SRCHUID=V=2&GUID=76DC1CA8309043BBAB81CFC4C47D76DD&dmnchg=1; _UR=QS=0&TQS=0; MicrosoftApplicationsTelemetryDeviceId=64c1979f-ee59-40a7-928e-b755865bc6ae; ABDEF=V=13&ABDV=13&MRNB=1696643925014&MRB=0; ANON=A=15BC3EC2F3AC041DAD2C715CFFFFFFFF&E=1d05&W=2; NAP=V=1.9&E=1cab&C=MnJiRko1YRJfqV6H22giKijH0-4G1Ub50-Cg7gnMPMN4QFF_OeDZsQ&W=2; PPLState=1; _HPVN=CS=eyJQbiI6eyJDbiI6NiwiU3QiOjAsIlFzIjowLCJQcm9kIjoiUCJ9LCJTYyI6eyJDbiI6NiwiU3QiOjAsIlFzIjowLCJQcm9kIjoiSCJ9LCJReiI6eyJDbiI6NiwiU3QiOjAsIlFzIjowLCJQcm9kIjoiVCJ9LCJBcCI6dHJ1ZSwiTXV0ZSI6dHJ1ZSwiTGFkIjoiMjAyMy0xMi0xMVQwMDowMDowMFoiLCJJb3RkIjowLCJHd2IiOjAsIlRucyI6MCwiRGZ0IjpudWxsLCJNdnMiOjAsIkZsdCI6MCwiSW1wIjoxNiwiVG9iYnMiOjB9; _EDGE_S=SID=2E9C7DC6F71A6094195D6E28F6C8614B; USRLOC=HS=1&ELOC=LAT=30.26828956604004|LON=120.13351440429688|N=%E8%A5%BF%E6%B9%96%E5%8C%BA%EF%BC%8C%E6%B5%99%E6%B1%9F%E7%9C%81|ELT=4|; _Rwho=u=d; _SS=SID=2E9C7DC6F71A6094195D6E28F6C8614B&R=64&RB=64&GB=0&RG=0&RP=61; KievRPSSecAuth=FABKBBRaTOJILtFsMkpLVWSG6AN6C/svRwNmAAAEgAAACFAPF0afImbrCASVm1xT1K+FiXTsQgaoq6RydL+Ge3FvFrIbHVbXa7m0OlZNQJT4P62pu6xUtDTqwGPUE13tWBwVPkK1RahHVaGuUSLfwbp5o2HeLnKa+hfc6+sJiYHnxklhiJAzdi/oBbiWdDkf+5A+C0Fbsxeo4pQDt+kmeKhWpMwijA0bVP5ISXdkrLsRv5jiq97srkAMWFHqqGboI70LdX7ahqSSiykzwFdA1np3WhYhURWQ4b3z6uV7nsZpth6lpdafGZ2YLWr0Zwpv1D210P04ovzbbzvuKGoeljS4/SvdX8QUoGONzn0f2OXAOPvsnZJctbwxH/tkembDlpN4liJDCYhlYgoKtg5nuLBNihk75VctLodAQhosDNYM9stJRzQlusK+aEbDQKAgXunPwB0iPq0ECEVmLIApOeXs7DEtj29Q8zuWiOmxXnddGDm4Tf0VWUVjAEfP/PKiiTLAAS/dwPgOslgEdpy3Pw6GQYo3z3dZ16mWuXYX53utgdkK4rtqRj/FmYiTRjL6scm7Ds0UJnVNxdJcFACadTOzNVEGBp2XIb6XEAWZThz21+JJCn325RXG+zwJyjaKI941n6CbQ8Z/dXgUYMBsn/gfdGV3/+vz05pIOtB1zmzkvwds5v4M/zTcf5fgqWwLjSbIBFscYA626llQwDS6LkKwyoB/EB3L0XgLnOFpoSSpk41L/q5e0GkLVxzPA5kZue0iLTNEXUu/KCGnPOBkK0iAZVS/bJPVa3ZBPBOODwXnAUR0s0W1hbHLDW4I1ZrMuujx08DU0/nhhiq0mFgwwxHrd4vE9xdecjlpyL78pzPf5LVAiCKaWZ/BnKqHCYHA4hiEg8ffC5eFwoA6JsL0wtvTSdaAPEcUs103Um9eje8nNKwvDtesqh93lOAbNCfkfC/zAdtsR0dWaZIsYdAeMNQE+6//zLDbGIe24WVsSdiwZqdmYI2ICxE+KqPY++Ei4gfgKt0GNyiAfK0qSfALb01POx95rWOyWSPd0ge6DwM5mHAZfTePR44vBfFdhvUYBg0+47nOzY53hcO/6unDb3u1/PLHM7+rlS+76yjrZ9Dl7cFXRNBINy5afDUY+kU9JQS6QTbc5EIQTynlWkGU38m43GtWXquitzrjHuC0mYsUbLQOuZ1kFWHQXF/4I/aaxU1k0uvEOttkIUkhXi5lKo9uLoPGdha+AIGcDz8icpdDnfAHHpChm0YB8K8lcL0foY6NCib+o+LCLfriZg9Nvtkc8s1+TWPvCvHZX4bZuXyN4tHoQiysRd6j0gyJpLR4yQr5iOyBUgkM9WWKzkFmnzVYlb4ec6wpowsw2643AHs5Ge1FDjzKw3TdSVnwB2dHFh7tdNW1ywYDAGhpv8SSvQ66448UANVqB1uKwxsD0mXJR/tjMy9OuiNR; _U=1S7ve-XVb_pOh5Iig5kQlQDI6wv9BNl9HiCEtz0dS6dNV_UrQUBmAFVEZx7pYNRTwRxGG8eASH_IDUlpJu04SCp8aeYlPHkU_-0xGzlVA3nTqaE9kSUyIm1UVQYovjbOrsh4SeBbU-wrjqz6HV2DeUKJiHyTwYlDeQ8bYboyqhB4-ER5PjMGcp8daGbur9ER2KSm-nJOeUqnWeIawk0BVyw; WLS=C=26d7831f7a57e7fd&N=; SRCHUSR=DOB=20220207&T=1703137884000&TPC=1703137888000&POEX=W; SRCHHPGUSR=SRCHLANG=zh-Hans&BZA=0&BRW=HTP&BRH=M&CW=975&CH=931&SW=1920&SH=1080&DPR=1&UTC=480&DM=0&HV=1703137888&WTS=63838734684&PRVCW=975&PRVCH=931&SCW=1164&SCH=2821&PV=10.0.0; WLID=mA9cZwKIoBbQ9h07pbmfeYJEn7iBxd5sk7A9mKFJf1dP4SWmtri4X9d1xcl06hKEVmEpT+5GB21NeHYv/uk3maNbHalTEB+UwCwfS7RdzoQ=; _RwBf=r=0&ilt=1&ihpd=1&ispd=0&rc=64&rb=64&gb=0&rg=0&pc=61&mtu=0&rbb=0.0&g=0&cid=&clo=0&v=1&l=2023-12-20T08:00:00.0000000Z&lft=0001-01-01T00:00:00.0000000&aof=0&o=0&p=bingcopilotwaitlist&c=MY00IA&t=3001&s=2023-03-20T09:14:27.6545941+00:00&ts=2023-12-21T05:51:26.7082437+00:00&rwred=0&wls=2&wlb=0&lka=0&lkt=0&aad=0&TH=&mta=0&e=CS-LRz6MT6YjyZDqHmn2zXGq0iVnD2Plg7iI7uA3t-iwF4TTPdW2rejPh5N_c6syhuNr1-uNgqm8vKVLqjaaig&A=15BC3EC2F3AC041DAD2C715CFFFFFFFF&wle=1&ccp=0&ard=0001-01-01T00:00:00.0000000; ipv6=hit=1703141490169&t=4',
+        'Accept-Encoding': 'gzip, deflate',
+        'Accept-Language': 'zh-CN,zh;q=0.9',
+        'Accept': '*/*',
+        'Referer': 'https://cn.bing.com/search?',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36'
+        }
+
+    res = []
+    url = 'https://cn.bing.com/search?q=' + query + '&qs=n&form=QBRE'
+    r = requests.get(url, headers=headers)
+    try:
+        encoding = chardet.detect(r.content)['encoding']
+        r.encoding = encoding
+        dom = etree.HTML(r.content.decode(encoding))
+    except:
+        dom = etree.HTML(r.content)
+
+    url_list = []
+    tmp_url = []
+    #只采集列表的第一页
+    for sel in dom.xpath('//ol[@id="b_results"]/li/h2'):
+        l = ''.join(sel.xpath('a/@href'))
+        title = ''.join(sel.xpath('a//text()')).split('-')[0].strip()
+        if 'http' in l and l not in tmp_url and 'doc.' not in l:
+            url_list.append([l,title])
+            tmp_url.append(l)
+    for turl,title in url_list:
+        try:
+            tr = requests.get(turl, headers=headers, timeout=(5, 5))
+            tdom = etree.HTML(tr.content.decode('utf-8'))
+            text = '\n'.join(tdom.xpath('//p/text()'))
+            if len(text) > 15:
+                tmp = {}
+                tmp['url'] = turl
+                tmp['text'] = text
+                tmp['title'] = title
+                res.append(tmp)
+        except Exception as e:
+            print(e)
+            pass
+    return res
+
+
+
+
+class TextRecallRank():
+    """
+    实现对检索内容的召回与排序
+    """
+
+    def __init__(self,cfg):
+        self.topk = cfg.topk    #query关键词召回的数量
+        self.topd = cfg.topd    #召回文章的数量
+        self.topt = cfg.topt    #召回文本片段的数量
+        self.maxlen = cfg.maxlen  #召回文本片段的长度
+        self.recall_way = cfg.recall_way  #召回方式
+
+
+
+    def query_analyze(self,query):
+        """query的解析，目前利用jieba进行关键词提取
+        input:query,topk
+        output:
+            keywords:{'word':[]}
+            total_weight: float number
+        """
+        keywords = jieba.analyse.extract_tags(query, topK=self.topk, withWeight=True)
+        total_weight = self.topk / sum([r[1] for r in keywords])
+        return keywords,total_weight
+
+    def text_segmentate(self, text, maxlen, seps='\n', strips=None):
+        """将文本按照标点符号划分为若干个短句
+        """
+        text = text.strip().strip(strips)
+        if seps and len(text) > maxlen:
+            pieces = text.split(seps[0])
+            text, texts = '', []
+            for i, p in enumerate(pieces):
+                if text and p and len(text) + len(p) > maxlen - 1:
+                    texts.extend(self.text_segmentate(text, maxlen, seps[1:], strips))
+                    text = ''
+                if i + 1 == len(pieces):
+                    text = text + p
+                else:
+                    text = text + p + seps[0]
+            if text:
+                texts.extend(self.text_segmentate(text, maxlen, seps[1:], strips))
+            return texts
+        else:
+            return [text]
+
+    def recall_title_score(self,title,keywords,total_weight):
+        """计算query与标题的匹配度"""
+        score = 0
+        for item in keywords:
+            kw, weight =  item
+            if kw in title:
+                score += round(weight * total_weight,4)
+        return score
+    
+    def recall_text_score(self, text, keywords, total_weight):
+        """计算query与text的匹配程度"""
+        score = 0
+        for item in keywords:
+            kw, weight = item
+            p11 = re.compile('%s' % kw)
+            pr = p11.findall(text)
+            # score += round(weight * total_weight, 4) * len(pr)
+            score += round(weight * total_weight, 4) 
+        return score
+    
+    def rank_text_by_keywords(self,query,data):
+        """通过关键词进行召回"""
+        
+        #query分析
+        keywords,total_weight = self.query_analyze(query)
+        
+        #先召回title
+        title_score = {}
+        for line in data:
+            title = line['title']
+            title_score[title] = self.recall_title_score(title,keywords,total_weight)
+        title_score = sorted(title_score.items(),key=lambda x:x[1],reverse=True)
+        # print(title_score)
+        recall_title_list = [t[0] for t in title_score[:self.topd]]
+        
+        #召回sentence
+        sentence_score = {}
+        for line in data:
+            title = line['title']
+            text = line['text']
+            if title  in recall_title_list:
+                for ct in self.text_segmentate(text,self.maxlen, seps='\n。'):
+                    ct = re.sub('\s+', ' ', ct)
+                    if len(ct)>=20:
+                        sentence_score[ct] = self.recall_text_score(ct,keywords,total_weight)
+
+        sentence_score = sorted(sentence_score.items(),key=lambda x:x[1],reverse=True)
+        recall_sentence_list = [s[0] for s in sentence_score[:self.topt]]
+        return '\n'.join(recall_sentence_list)
+
+    def rank_text_by_text2vec(self, query, data):
+        """通过text2vec召回"""
+        if not data:
+            print("Warning: No data provided for ranking")
+            return ""
+
+        # 先召回title
+        title_list = [query]
+        for line in data:
+            title = line['title']
+            title_list.append(title)
+        
+        # 确保至少有两个标题，否则无法进行相似度计算
+        if len(title_list) <= 1:
+            print("Warning: Not enough titles for similarity calculation")
+            return ""
+            
+        title_vectors = get_vector(title_list, 8)
+        
+        # 检查向量化是否成功
+        if title_vectors.numel() == 0 or title_vectors.size(0) <= 1:
+            print("Warning: Title vectorization failed or returned insufficient vectors")
+            return ""
+            
+        title_score = get_sim(title_vectors)
+        
+        # 检查相似度计算是否成功
+        if not title_score:
+            print("Warning: Title similarity calculation failed")
+            return ""
+            
+        title_score = dict(zip(title_score, range(1, len(title_list))))
+        title_score = sorted(title_score.items(), key=lambda x:x[0], reverse=True)
+        
+        # 确保有足够的标题用于召回
+        if not title_score or self.topd <= 0:
+            print("Warning: No title scores or invalid topd parameter")
+            return ""
+            
+        recall_title_list = [title_list[t[1]] for t in title_score[:min(self.topd, len(title_score))]]
+
+        # 召回sentence
+        sentence_list = [query]
+        for line in data:
+            title = line['title']
+            text = line['text']
+            if title in recall_title_list:
+                for ct in self.text_segmentate(text, self.maxlen, seps='\n。'):
+                    ct = re.sub('\s+', ' ', ct)
+                    if len(ct) >= 20:
+                        sentence_list.append(ct)
+
+        # 确保至少有两个句子，否则无法进行相似度计算
+        if len(sentence_list) <= 1:
+            print("Warning: Not enough sentences for similarity calculation")
+            return ""
+            
+        sentence_vectors = get_vector(sentence_list, 8)
+        
+        # 检查向量化是否成功
+        if sentence_vectors.numel() == 0 or sentence_vectors.size(0) <= 1:
+            print("Warning: Sentence vectorization failed or returned insufficient vectors")
+            return ""
+        
+        sentence_score = get_sim(sentence_vectors)
+        
+        # 检查相似度计算是否成功
+        if not sentence_score:
+            print("Warning: Sentence similarity calculation failed")
+            return ""
+            
+        sentence_score = dict(zip(sentence_score, range(1, len(sentence_list))))
+        sentence_score = sorted(sentence_score.items(), key=lambda x:x[0], reverse=True)
+        
+        # 确保有足够的句子用于召回
+        if not sentence_score or self.topt <= 0:
+            print("Warning: No sentence scores or invalid topt parameter")
+            return ""
+            
+        recall_sentence_list = [sentence_list[s[1]] for s in sentence_score[:min(self.topt, len(sentence_score))]]
+        return '\n'.join(recall_sentence_list)
+
+
+    def query_retrieve(self,query):
+        #利用搜索引擎获取相关信息
+        data = search_bing(query)
+        #对获取的相关信息进行召回与排序，得到背景信息
+        if self.recall_way == 'keyword':
+            bg_text = self.rank_text_by_keywords(query,data)
+        else:
+            bg_text = self.rank_text_by_text2vec(query,data)
+        return bg_text
+
+
+cfg = Config()
+trr = TextRecallRank(cfg)
+q_searching = trr.query_retrieve

text2vec.py

@@ -0,0 +1,160 @@
+import os
+import torch
+from functional import seq
+import numpy as np
+import torch.nn.functional as F  
+from torch import cosine_similarity
+from config import Config
+from openai import OpenAI
+
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+class TextVector():
+    def __init__(self, cfg):
+        self.bert_path = cfg.bert_path
+        
+        # 从配置文件读取API相关设置
+        self.use_api = getattr(cfg, 'use_api', True)
+        self.api_key = getattr(cfg, 'api_key', "sk-5b45aa67249a44d38abca3c02cc78a70")
+        self.base_url = getattr(cfg, 'base_url', "https://dashscope.aliyuncs.com/compatible-mode/v1")
+        self.model_name = getattr(cfg, 'model_name', "text-embedding-v3")
+        self.dimensions = getattr(cfg, 'dimensions', 1024)
+        self.batch_size = getattr(cfg, 'batch_size', 10)
+        
+        # 只有在不使用API时才加载本地模型
+        if not self.use_api:
+            self.load_model()
+
+    def load_model(self):
+        """载入模型"""
+        self.tokenizer = AutoTokenizer.from_pretrained(self.bert_path)
+        self.model = AutoModel.from_pretrained(self.bert_path)
+
+    def mean_pooling(self, model_output, attention_mask):
+        """采用序列mean-pooling获得句子的表征向量"""
+        token_embeddings = model_output[0]  # First element of model_output contains all token embeddings
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+    def get_vec(self, sentences):
+        """通过模型获取句子的向量"""
+        if self.use_api:
+            # 如果使用API，重定向到API方法
+            return self.get_vec_api(sentences)
+            
+        # 否则使用原始BERT方法
+        encoded_input = self.tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
+        with torch.no_grad():
+            model_output = self.model(**encoded_input)
+        sentence_embeddings = self.mean_pooling(model_output, encoded_input['attention_mask'])
+        sentence_embeddings = sentence_embeddings.data.cpu().numpy().tolist()
+        return sentence_embeddings
+    
+    def get_vec_api(self, query, batch_size=None):
+        """通过API获取句子的向量"""
+        if batch_size is None:
+            batch_size = self.batch_size
+            
+        # 空查询检查
+        if not query:
+            print("Warning: Empty query provided to get_vec_api")
+            return []
+            
+        client = OpenAI(
+            api_key=self.api_key,
+            base_url=self.base_url
+        )
+        
+        if isinstance(query, str):
+            query = [query]
+        
+        # 移除空字符串和None值，确保输入数据有效
+        query = [q for q in query if q and isinstance(q, str) and q.strip()]
+        if not query:
+            print("Warning: No valid text to vectorize after filtering")
+            return []
+        
+        all_vectors = []
+        retry_count = 0
+        max_retries = 2  # 允许重试几次
+        
+        while retry_count <= max_retries and not all_vectors:
+            try:
+                for i in range(0, len(query), batch_size):
+                    batch = query[i:i + batch_size]
+                    try:
+                        completion = client.embeddings.create(
+                            model=self.model_name,
+                            input=batch,
+                            dimensions=self.dimensions,
+                            encoding_format="float"
+                        )
+                        vectors = [embedding.embedding for embedding in completion.data]
+                        all_vectors.extend(vectors)
+                    except Exception as e:
+                        print(f"向量化批次 {i//batch_size + 1} 失败：{str(e)}")
+                        # 不立即返回空数组，继续处理其他批次
+                        continue
+                
+                # 检查是否有成功获取的向量
+                if all_vectors:
+                    break
+                else:
+                    retry_count += 1
+                    print(f"未获取到任何向量，第 {retry_count} 次重试...")
+                    
+            except Exception as outer_e:
+                print(f"向量化过程中发生错误：{str(outer_e)}")
+                retry_count += 1
+                if retry_count <= max_retries:
+                    print(f"第 {retry_count} 次重试...")
+                
+        # 返回向量数组，如果仍然为空，确保返回一个正确形状的空数组
+        if not all_vectors and self.dimensions > 0:
+            print("Warning: 返回一个空的向量数组，形状为 [0, dimensions]")
+            return np.zeros((0, self.dimensions))
+            
+        return all_vectors
+
+    def get_vec_batch(self, data, bs=None):
+        """batch方式获取，提高效率"""
+        if bs is None:
+            bs = self.batch_size
+            
+        if self.use_api:
+            # 如果使用API，直接调用API方法
+            vectors = self.get_vec_api(data, bs)
+            return torch.tensor(np.array(vectors)) if len(vectors) > 0 else torch.tensor(np.array([]))
+        
+        # 否则使用原始BERT方法
+        data = seq(data).grouped(bs)
+        all_vectors = []
+        for batch in data:
+            vecs = self.get_vec(batch)
+            all_vectors.extend(vecs)
+        all_vectors = torch.tensor(np.array(all_vectors))
+        return all_vectors
+
+    def vector_similarity(self, vectors):
+        """以[query，text1，text2...]来计算query与text1，text2,...的cosine相似度"""
+        # Add dimension checking to prevent errors
+        if vectors.size(0) <= 1:
+            print("Warning: Not enough vectors for similarity calculation")
+            return []
+            
+        if len(vectors.shape) < 2:
+            print("Warning: Vectors must be 2-dimensional")
+            return []
+        
+        vectors = F.normalize(vectors, p=2, dim=1)
+        q_vec = vectors[0,:]
+        o_vec = vectors[1:,:]
+        sim = cosine_similarity(q_vec, o_vec)
+        sim = sim.data.cpu().numpy().tolist()
+        return sim
+
+# 修正函数名拼写错误：get_vec_bath -> get_vec_batch
+cfg = Config()
+tv = TextVector(cfg)
+get_vector = tv.get_vec_batch  # 修正名称
+get_sim = tv.vector_similarity