bisheng-langchain 0.3.0rc1__py3-none-any.whl → 0.3.1.1__py3-none-any.whl

bisheng_langchain/document_loaders/elem_unstrcutured_loader.py

@@ -85,16 +85,18 @@ class ElemUnstructuredLoader(BasePDFLoader):
                        mode='partition',
                        parameters=parameters)
 
-        resp = requests.post(self.unstructured_api_url, headers=self.headers, json=payload).json()
+        resp = requests.post(self.unstructured_api_url, headers=self.headers, json=payload)
+        if resp.status_code != 200:
+            raise Exception(f'file partition {os.path.basename(self.file_name)} failed resp={resp.text}')
 
+        resp = resp.json()
         if 200 != resp.get('status_code'):
-            logger.info(f'not return resp={resp}')
+            logger.info(f'file partition {os.path.basename(self.file_name)} error resp={resp}')
         partitions = resp['partitions']
         if not partitions:
             logger.info(f'partition_error resp={resp}')
         logger.info(f'unstruct_return code={resp.get("status_code")}')
 
-        partitions = resp['partitions']
         content, metadata = merge_partitions(partitions)
         metadata['source'] = self.file_name
 

bisheng_langchain/gpts/agent_types/llm_functions_agent.py

@@ -1,5 +1,5 @@
 import json
-
+import re
 from bisheng_langchain.gpts.message_types import LiberalFunctionMessage, LiberalToolMessage
 from langchain.tools import BaseTool
 from langchain.tools.render import format_tool_to_openai_tool
@@ -39,6 +39,12 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
         last_message = messages[-1]
         # If there is no function call, then we finish
         if 'tool_calls' not in last_message.additional_kwargs:
+            if '|<instruct>|' in system_message:
+                # cohere model
+                pattern = r"Answer:(.+)\nGrounded answer"
+                match = re.search(pattern, last_message.content)
+                if match:
+                    last_message.content = match.group(1)
             return 'end'
         # Otherwise if there is, we continue
         else:

bisheng_langchain/gpts/assistant.py

@@ -126,11 +126,14 @@ class BishengAssistant:
 if __name__ == "__main__":
     from langchain.globals import set_debug
 
-    set_debug(True)
-    # chat_history = []
-    chat_history = ['你好', '你好，有什么可以帮助你吗？', '福蓉科技股价多少?', '福蓉科技（股票代码：300049）的当前股价为48.67元。']
-    query = "去年这个时候的股价是多少？"
-    bisheng_assistant = BishengAssistant("config/base_scene.yaml")
+    # set_debug(True)
+    chat_history = []
+    query = "请简要分析中科创达软件股份有限公司2019年聘任、解聘会计师事务的情况。"
+    # chat_history = ['你好', '你好，有什么可以帮助你吗？', '福蓉科技股价多少?', '福蓉科技（股票代码：300049）的当前股价为48.67元。']
+    # query = '去年这个时候的股价是多少？'
+    # bisheng_assistant = BishengAssistant("config/base_scene.yaml")
+    # bisheng_assistant = BishengAssistant("config/knowledge_scene.yaml")
+    bisheng_assistant = BishengAssistant("config/rag_scene.yaml")
     result = bisheng_assistant.run(query, chat_history=chat_history)
     for r in result:
         print(f'------------------')

bisheng_langchain/gpts/load_tools.py

@@ -26,6 +26,7 @@ from langchain_core.callbacks import BaseCallbackManager, Callbacks
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.tools import BaseTool, Tool
 from mypy_extensions import Arg, KwArg
+from bisheng_langchain.rag import BishengRAGTool
 
 
 def _get_current_time() -> BaseTool:
@@ -86,6 +87,7 @@ _EXTRA_PARAM_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[Optio
     'dalle_image_generator': (_get_dalle_image_generator, ['openai_api_key', 'openai_proxy'], []),
     'bing_search': (_get_bing_search, ['bing_subscription_key', 'bing_search_url'], []),
     'bisheng_code_interpreter': (_get_native_code_interpreter, ["minio"], ['files']),
+    'bisheng_rag': (BishengRAGTool.get_rag_tool, ['name', 'description'], ['vector_store', 'keyword_store', 'llm', 'collection_name', 'max_content', 'sort_by_source_and_index']),
 }
 
 _API_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[str]]] = {**ALL_API_TOOLS}  # type: ignore

bisheng_langchain/gpts/prompts/__init__.py

@@ -1,12 +1,14 @@
 from bisheng_langchain.gpts.prompts.assistant_prompt_opt import ASSISTANT_PROMPT_OPT
-from bisheng_langchain.gpts.prompts.base_prompt import DEFAULT_SYSTEM_MESSAGE
+from bisheng_langchain.gpts.prompts.assistant_prompt_base import ASSISTANT_PROMPT_DEFAULT
+from bisheng_langchain.gpts.prompts.assistant_prompt_cohere import ASSISTANT_PROMPT_COHERE
 from bisheng_langchain.gpts.prompts.breif_description_prompt import BREIF_DES_PROMPT
 from bisheng_langchain.gpts.prompts.opening_dialog_prompt import OPENDIALOG_PROMPT
 from bisheng_langchain.gpts.prompts.select_tools_prompt import HUMAN_MSG, SYS_MSG
 
 
 __all__ = [
-    "DEFAULT_SYSTEM_MESSAGE",
+    "ASSISTANT_PROMPT_DEFAULT",
+    "ASSISTANT_PROMPT_COHERE",
     "ASSISTANT_PROMPT_OPT",
     "OPENDIALOG_PROMPT",
     "BREIF_DES_PROMPT",

bisheng_langchain/gpts/prompts/assistant_prompt_base.py

@@ -0,0 +1 @@
+ASSISTANT_PROMPT_DEFAULT = "You are a helpful assistant."

bisheng_langchain/gpts/prompts/assistant_prompt_cohere.py

@@ -0,0 +1,19 @@
+preamble="""You are a helpful assistant.
+"""
+
+ASSISTANT_PROMPT_COHERE="""{preamble}|<instruct>|Carefully perform the following instructions, in order, starting each with a new line.
+Firstly, You may need to use complex and advanced reasoning to complete your task and answer the question. Think about how you can use the provided tools to answer the question and come up with a high level plan you will execute.
+Write 'Plan:' followed by an initial high level plan of how you will solve the problem including the tools and steps required.
+Secondly, Carry out your plan by repeatedly using actions, reasoning over the results, and re-evaluating your plan. Perform Action, Observation, Reflection steps with the following format. Write 'Action:' followed by a json formatted action containing the "tool_name" and "parameters"
+ Next you will analyze the 'Observation:', this is the result of the action.
+After that you should always think about what to do next. Write 'Reflection:' followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next including if you know the answer to the question.
+... (this Action/Observation/Reflection can repeat N times)
+Thirdly, Decide which of the retrieved documents are relevant to the user's last input by writing 'Relevant Documents:' followed by comma-separated list of document numbers. If none are relevant, you should instead write 'None'.
+Fourthly, Decide which of the retrieved documents contain facts that should be cited in a good answer to the user's last input by writing 'Cited Documents:' followed a comma-separated list of document numbers. If you dont want to cite any of them, you should instead write 'None'.
+Fifthly, Write 'Answer:' followed by a response to the user's last input. Use the retrieved documents to help you. Do not insert any citations or grounding markup.
+Finally, Write 'Grounded answer:' followed by a response to the user's last input in high quality natural english. Use the symbols <co: doc> and </co: doc> to indicate when a fact comes from a document in the search result, e.g <co: 4>my fact</co: 4> for a fact from document 4.
+
+Additional instructions to note:
+- If the user's question is in Chinese, please answer it in Chinese. 
+- 当问题中有涉及到时间信息时，比如最近6个月、昨天、去年等，你需要用时间工具查询时间信息。
+""".format(preamble=preamble)

bisheng_langchain/gpts/tools/api_tools/flow.py

@@ -1,10 +1,11 @@
 from loguru import logger
-from pydantic import BaseModel, Field
+from langchain_core.pydantic_v1 import BaseModel, Field
 from typing import Any
 from .base import APIToolBase
 from .base import MultArgsSchemaTool
 from langchain_core.tools import BaseTool
 
+
 class FlowTools(APIToolBase):
 
     def run(self, query: str) -> str:
@@ -52,9 +53,8 @@ class FlowTools(APIToolBase):
         }
 
         class InputArgs(BaseModel):
-            """args_schema"""
             query: str = Field(description='questions to ask')
-              
+
         return cls(url=url, params=params, input_key=input_key, args_schema=InputArgs)
     
     @classmethod

bisheng_langchain/gpts/tools/api_tools/openapi.py

@@ -0,0 +1,101 @@
+from typing import Any
+
+from langchain_core.tools import BaseTool
+from loguru import logger
+from pydantic import BaseModel, create_model
+
+from .base import APIToolBase, MultArgsSchemaTool, Field
+
+
+class OpenApiTools(APIToolBase):
+
+    def get_real_path(self):
+        return self.url + self.params["path"]
+
+    def get_request_method(self):
+        return self.params["method"]
+
+    def get_params_json(self, **kwargs):
+        params_define = {}
+        for one in self.params["parameters"]:
+            params_define[one["name"]] = one
+
+        params = {}
+        json_data = {}
+        for k, v in kwargs.items():
+            if params_define.get(k):
+                if params_define[k]["in"] == "query":
+                    params[k] = v
+                else:
+                    json_data[k] = v
+            else:
+                params[k] = v
+        return params, json_data
+
+    def parse_args_schema(self):
+        params = self.params["parameters"]
+        model_params = {}
+        for one in params:
+            field_type = one["schema"]["type"]
+            if field_type == "number":
+                field_type = "float"
+            elif field_type == "integer":
+                field_type = "int"
+            elif field_type == "string":
+                field_type = "str"
+            else:
+                raise Exception(f"schema type is not support: {field_type}")
+            model_params[one["name"]] = (eval(field_type), Field(description=one["description"]))
+        return create_model("InputArgs", __module__='bisheng_langchain.gpts.tools.api_tools.openapi',
+                            __base__=BaseModel, **model_params)
+
+    def run(self, **kwargs) -> str:
+        """Run query through api and parse result."""
+        path = self.get_real_path()
+        logger.info('api_call url={}', path)
+        method = self.get_request_method()
+        params, json_data = self.get_params_json(**kwargs)
+
+        if method == "get":
+            resp = self.client.get(path, params=params)
+        elif method == 'post':
+            resp = self.client.post(path, params=params, json=self.params)
+        elif method == 'put':
+            resp = self.client.put(path, params=params, json=self.params)
+        elif method == 'delete':
+            resp = self.client.delete(path, params=params, json=self.params)
+        else:
+            raise Exception(f"http method is not support: {method}")
+        if resp.status_code != 200:
+            logger.info(f'api_call_fail code={resp.status_code} res={resp.text}')
+            raise Exception(f"api_call_fail: {resp.status_code} {resp.text}")
+        return resp.text
+
+    async def arun(self, **kwargs) -> str:
+        """Run query through api and parse result."""
+        path = self.get_real_path()
+        logger.info('api_call url={}', path)
+        method = self.get_request_method()
+        params, json_data = self.get_params_json(**kwargs)
+
+        if method == "get":
+            resp = await self.async_client.aget(path, params=params)
+        elif method == 'post':
+            resp = await self.async_client.apost(path, params=params, json=self.params)
+        elif method == 'put':
+            resp = await self.async_client.aput(path, params=params, json=self.params)
+        elif method == 'delete':
+            resp = await self.async_client.adelete(path, params=params, json=self.params)
+        else:
+            raise Exception(f"http method is not support: {method}")
+        return resp
+
+    @classmethod
+    def get_api_tool(cls, name, **kwargs: Any) -> BaseTool:
+        description = kwargs.pop("description", "")
+        obj = cls(**kwargs)
+        return MultArgsSchemaTool(name=name,
+                                  description=description,
+                                  func=obj.run,
+                                  coroutine=obj.arun,
+                                  args_schema=obj.parse_args_schema())

bisheng_langchain/rag/__init__.py

@@ -0,0 +1,5 @@
+from bisheng_langchain.rag.bisheng_rag_tool import BishengRAGTool
+
+__all__ = [
+    "BishengRAGTool",
+]

bisheng_langchain/rag/bisheng_rag_pipeline.py

@@ -0,0 +1,320 @@
+import argparse
+import copy
+import inspect
+import time
+import os
+from collections import defaultdict
+
+import httpx
+import pandas as pd
+import yaml
+from loguru import logger
+from tqdm import tqdm
+from bisheng_langchain.retrievers import EnsembleRetriever
+from bisheng_langchain.vectorstores import ElasticKeywordsSearch, Milvus
+from langchain.chains.question_answering import load_qa_chain
+from bisheng_langchain.rag.init_retrievers import (
+    BaselineVectorRetriever,
+    KeywordRetriever,
+    MixRetriever,
+    SmallerChunksVectorRetriever,
+)
+from bisheng_langchain.rag.scoring.ragas_score import RagScore
+from bisheng_langchain.rag.utils import import_by_type, import_class
+
+
+class BishengRagPipeline:
+
+    def __init__(self, yaml_path) -> None:
+        self.yaml_path = yaml_path
+        with open(self.yaml_path, 'r') as f:
+            self.params = yaml.safe_load(f)
+
+        # init data
+        self.origin_file_path = self.params['data']['origin_file_path']
+        self.question_path = self.params['data']['question']
+        self.save_answer_path = self.params['data']['save_answer']
+
+        # init embeddings
+        embedding_params = self.params['embedding']
+        embedding_object = import_by_type(_type='embeddings', name=embedding_params['type'])
+        if embedding_params['type'] == 'OpenAIEmbeddings' and embedding_params['openai_proxy']:
+            embedding_params.pop('type')
+            self.embeddings = embedding_object(
+                http_client=httpx.Client(proxies=embedding_params['openai_proxy']), **embedding_params
+            )
+        else:
+            embedding_params.pop('type')
+            self.embeddings = embedding_object(**embedding_params)
+
+        # init llm
+        llm_params = self.params['chat_llm']
+        llm_object = import_by_type(_type='llms', name=llm_params['type'])
+        if llm_params['type'] == 'ChatOpenAI' and llm_params['openai_proxy']:
+            llm_params.pop('type')
+            self.llm = llm_object(http_client=httpx.Client(proxies=llm_params['openai_proxy']), **llm_params)
+        else:
+            llm_params.pop('type')
+            self.llm = llm_object(**llm_params)
+
+        # milvus
+        self.vector_store = Milvus(
+            embedding_function=self.embeddings,
+            connection_args={
+                "host": self.params['milvus']['host'],
+                "port": self.params['milvus']['port'],
+            },
+        )
+
+        # es
+        self.keyword_store = ElasticKeywordsSearch(
+            index_name='default_es',
+            elasticsearch_url=self.params['elasticsearch']['url'],
+            ssl_verify=self.params['elasticsearch']['ssl_verify'],
+        )
+
+        # init retriever
+        retriever_list = []
+        retrievers = self.params['retriever']['retrievers']
+        for retriever in retrievers:
+            retriever_type = retriever.pop('type')
+            retriever_params = {
+                'vector_store': self.vector_store,
+                'keyword_store': self.keyword_store,
+                'splitter_kwargs': retriever['splitter'],
+                'retrieval_kwargs': retriever['retrieval'],
+            }
+            retriever_list.append(self._post_init_retriever(retriever_type=retriever_type, **retriever_params))
+        self.retriever = EnsembleRetriever(retrievers=retriever_list)
+
+    def _post_init_retriever(self, retriever_type, **kwargs):
+        retriever_classes = {
+            'KeywordRetriever': KeywordRetriever,
+            'BaselineVectorRetriever': BaselineVectorRetriever,
+            'MixRetriever': MixRetriever,
+            'SmallerChunksVectorRetriever': SmallerChunksVectorRetriever,
+        }
+        if retriever_type not in retriever_classes:
+            raise ValueError(f'Unknown retriever type: {retriever_type}')
+
+        input_kwargs = {}
+        splitter_params = kwargs.pop('splitter_kwargs')
+        for key, value in splitter_params.items():
+            splitter_obj = import_by_type(_type='textsplitters', name=value.pop('type'))
+            input_kwargs[key] = splitter_obj(**value)
+
+        retrieval_params = kwargs.pop('retrieval_kwargs')
+        for key, value in retrieval_params.items():
+            input_kwargs[key] = value
+
+        input_kwargs['vector_store'] = kwargs.pop('vector_store')
+        input_kwargs['keyword_store'] = kwargs.pop('keyword_store')
+
+        retriever_class = retriever_classes[retriever_type]
+        return retriever_class(**input_kwargs)
+
+    def file2knowledge(self):
+        """
+        file to knowledge
+        """
+        df = pd.read_excel(self.question_path)
+        if ('文件名' not in df.columns) or ('知识库名' not in df.columns):
+            raise Exception(f'文件名 or 知识库名 not in {self.question_path}.')
+
+        loader_params = self.params['loader']
+        loader_object = import_by_type(_type='documentloaders', name=loader_params.pop('type'))
+
+        all_questions_info = df.to_dict('records')
+        collectionname2filename = defaultdict(set)
+        for info in all_questions_info:
+            # 存入set，去掉重复的文件名
+            collectionname2filename[info['知识库名']].add(info['文件名'])
+
+        for collection_name in tqdm(collectionname2filename):
+            all_file_paths = []
+            for file_name in collectionname2filename[collection_name]:
+                file_path = os.path.join(self.origin_file_path, file_name)
+                if not os.path.exists(file_path):
+                    raise Exception(f'{file_path} not exists.')
+                # file path可以是文件夹或者单个文件
+                if os.path.isdir(file_path):
+                    # 文件夹包含多个文件
+                    all_file_paths.extend(
+                        [os.path.join(file_path, name) for name in os.listdir(file_path) if not name.startswith('.')]
+                    )
+                else:
+                    # 单个文件
+                    all_file_paths.append(file_path)
+
+            # 当前知识库需要存储的所有文件
+            collection_name = f"{collection_name}_{self.params['retriever']['suffix']}"
+            for index, each_file_path in enumerate(all_file_paths):
+                logger.info(f'each_file_path: {each_file_path}')
+                loader = loader_object(
+                    file_name=os.path.basename(each_file_path), file_path=each_file_path, **loader_params
+                )
+                documents = loader.load()
+                logger.info(f'documents: {len(documents)}')
+                if len(documents[0].page_content) == 0:
+                    logger.error(f'{each_file_path} page_content is empty.')
+
+                vector_drop_old = self.params['milvus']['drop_old'] if index == 0 else False
+                keyword_drop_old = self.params['elasticsearch']['drop_old'] if index == 0 else False
+                for idx, retriever in enumerate(self.retriever.retrievers):
+                    retriever.add_documents(documents, f"{collection_name}_{idx}", vector_drop_old)
+                    # retriever.add_documents(documents, collection_name, vector_drop_old)
+
+    def retrieval_and_rerank(self, question, collection_name):
+        """
+        retrieval and rerank
+        """
+        collection_name = f"{collection_name}_{self.params['retriever']['suffix']}"
+
+        # EnsembleRetriever直接检索召回会默认去重
+        # docs = self.retriever.get_relevant_documents(query=question, collection_name=collection_name)
+        docs = []
+        for idx, retriever in enumerate(self.retriever.retrievers):
+            docs.extend(retriever.get_relevant_documents(query=question, collection_name=f"{collection_name}_{idx}"))
+            # docs.extend(retriever.get_relevant_documents(query=question, collection_name=collection_name))
+        logger.info(f'retrieval docs: {len(docs)}')
+
+        # delete duplicate
+        if self.params['post_retrieval']['delete_duplicate']:
+            logger.info(f'origin docs: {len(docs)}')
+            all_contents = []
+            docs_no_dup = []
+            for index, doc in enumerate(docs):
+                doc_content = doc.page_content
+                if doc_content in all_contents:
+                    continue
+                all_contents.append(doc_content)
+                docs_no_dup.append(doc)
+            docs = docs_no_dup
+            logger.info(f'delete duplicate docs: {len(docs)}')
+
+        # rerank
+        if self.params['post_retrieval']['with_rank'] and len(docs):
+            if not hasattr(self, 'ranker'):
+                rerank_params = self.params['post_retrieval']['rerank']
+                rerank_type = rerank_params.pop('type')
+                rerank_object = import_class(f'bisheng_langchain.rag.rerank.{rerank_type}')
+                self.ranker = rerank_object(**rerank_params)
+            docs = getattr(self, 'ranker').sort_and_filter(question, docs)
+
+        return docs
+
+    def load_documents(self, file_name, max_content=100000):
+        """
+        max_content: max content len of llm
+        """
+        file_path = os.path.join(self.origin_file_path, file_name)
+        if not os.path.exists(file_path):
+            raise Exception(f'{file_path} not exists.')
+        if os.path.isdir(file_path):
+            raise Exception(f'{file_path} is a directory.')
+
+        loader_params = copy.deepcopy(self.params['loader'])
+        loader_object = import_by_type(_type='documentloaders', name=loader_params.pop('type'))
+        loader = loader_object(file_name=file_name, file_path=file_path, **loader_params)
+
+        documents = loader.load()
+        logger.info(f'documents: {len(documents)}, page_content: {len(documents[0].page_content)}')
+        for doc in documents:
+            doc.page_content = doc.page_content[:max_content]
+        return documents
+
+    def question_answering(self):
+        """
+        question answer over knowledge
+        """
+        df = pd.read_excel(self.question_path)
+        all_questions_info = df.to_dict('records')
+        if 'prompt_type' in self.params['generate']:
+            prompt_type = self.params['generate']['prompt_type']
+            prompt = import_class(f'bisheng_langchain.rag.prompts.{prompt_type}')
+        else:
+            prompt = None
+        qa_chain = load_qa_chain(
+            llm=self.llm, chain_type=self.params['generate']['chain_type'], prompt=prompt, verbose=False
+        )
+        file2docs = dict()
+        for questions_info in tqdm(all_questions_info):
+            question = questions_info['问题']
+            file_name = questions_info['文件名']
+            collection_name = questions_info['知识库名']
+
+            if self.params['generate']['with_retrieval']:
+                # retrieval and rerank
+                docs = self.retrieval_and_rerank(question, collection_name)
+            else:
+                # load document
+                if file_name not in file2docs:
+                    docs = self.load_documents(file_name)
+                    file2docs[file_name] = docs
+                else:
+                    docs = file2docs[file_name]
+
+            # question answer
+            try:
+                ans = qa_chain({"input_documents": docs, "question": question}, return_only_outputs=False)
+            except Exception as e:
+                logger.error(f'question: {question}\nerror: {e}')
+                ans = {'output_text': str(e)}
+
+            # context = '\n\n'.join([doc.page_content for doc in docs])
+            # content = prompt.format(context=context, question=question)
+
+            # # for rate_limit
+            # time.sleep(15)
+
+            rag_answer = ans['output_text']
+            logger.info(f'question: {question}\nans: {rag_answer}\n')
+            questions_info['rag_answer'] = rag_answer
+            # questions_info['rag_context'] = '\n----------------\n'.join([doc.page_content for doc in docs])
+            # questions_info['rag_context'] = content
+
+        df = pd.DataFrame(all_questions_info)
+        df.to_excel(self.save_answer_path, index=False)
+
+    def score(self):
+        """
+        score
+        """
+        metric_params = self.params['metric']
+        if metric_params['type'] == 'bisheng-ragas':
+            score_params = {
+                'excel_path': self.save_answer_path,
+                'save_path': os.path.dirname(self.save_answer_path),
+                'question_column': metric_params['question_column'],
+                'gt_column': metric_params['gt_column'],
+                'answer_column': metric_params['answer_column'],
+                'query_type_column': metric_params.get('query_type_column', None),
+                'contexts_column': metric_params.get('contexts_column', None),
+                'metrics': metric_params['metrics'],
+                'batch_size': metric_params['batch_size'],
+                'gt_split_column': metric_params.get('gt_split_column', None),
+                'whether_gtsplit': metric_params.get('whether_gtsplit', False), # 是否需要模型对gt进行要点拆分
+            }
+            rag_score = RagScore(**score_params)
+            rag_score.score()
+        else:
+            # todo: 其他评分方法
+            pass
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Process some integers.')
+    # 添加参数
+    parser.add_argument('--mode', type=str, default='qa', help='upload or qa or score')
+    parser.add_argument('--params', type=str, default='config/test/baseline_s2b.yaml', help='bisheng rag params')
+    # 解析参数
+    args = parser.parse_args()
+
+    rag = BishengRagPipeline(args.params)
+
+    if args.mode == 'upload':
+        rag.file2knowledge()
+    elif args.mode == 'qa':
+        rag.question_answering()
+    elif args.mode == 'score':
+        rag.score()