初始化项目

README.md

@@ -1,10 +1,10 @@
 ---
-title: Hello Embed
-emoji: 🌍
-colorFrom: pink
-colorTo: indigo
+title: Hellow LangChain
+emoji: 🐨
+colorFrom: purple
+colorTo: green
 sdk: gradio
-sdk_version: 4.19.2
+sdk_version: 4.19.1
 app_file: app.py
 pinned: false
 license: mit

app.py

@@ -0,0 +1,163 @@
+from typing import Callable, Optional
+
+import gradio as gr
+from langchain.vectorstores import Zilliz
+from langchain.document_loaders import TextLoader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.chains import RetrievalQAWithSourcesChain
+from langchain.chains.llm import LLMChain
+from langchain.chains import StuffDocumentsChain
+from langchain_core.prompts import PromptTemplate
+import hashlib
+import os
+from project.embeddings.local_embed import LocalEmbed
+from project.llm.check_embed_llm import CheckEmbedLlm
+
+chain: Optional[Callable] = None
+
+db_host = os.getenv("DB_HOST")
+db_user = os.getenv("DB_USER")
+db_password = os.getenv("DB_PASSWORD")
+zhipuai_api_key = os.getenv("ZHIPU_AI_KEY")
+
+
+def generate_article_id(content):
+    # 使用SHA-256哈希算法
+    sha256 = hashlib.sha256()
+
+    # 将文章内容编码为字节流并更新哈希对象
+    sha256.update(content.encode('utf-8'))
+
+    # 获取哈希值的十六进制表示
+    article_id = sha256.hexdigest()
+
+    return article_id
+
+
+def web_loader(file):
+    if not file:
+        return "please upload file"
+    loader = TextLoader(file)
+    docs = loader.load()
+
+    text_splitter = CharacterTextSplitter(chunk_size=512, chunk_overlap=0)
+    docs = text_splitter.split_documents(docs)
+    #embeddings = OpenAIEmbeddings(model="text-embedding-ada-002", openai_api_key=openai_key)
+    #embeddings = ZhipuAIEmbeddings(zhipuai_api_key=zhipuai_api_key)
+    embeddings = LocalEmbed(zhipuai_api_key=zhipuai_api_key)
+
+
+    if not embeddings:
+        return "embeddings not"
+
+    texts = [d.page_content for d in docs]
+    article_ids = []
+    # 遍历texts列表
+    for text in texts:
+        # 使用generate_article_id函数生成文章ID，并将其添加到article_ids列表中
+        article_id = generate_article_id(text)
+        article_ids.append(article_id)
+
+    docsearch = Zilliz.from_documents(
+        docs,
+        embedding=embeddings,
+        ids=article_ids,
+        connection_args={
+            "uri": db_host,
+            "user": db_user,
+            "password": db_password,
+            "secure": True,
+        },
+        collection_name="LangChainCollectionYin"
+    )
+
+    if not docsearch:
+        return "docsearch not"
+
+    global chain
+
+    llm = CheckEmbedLlm(model="glm-3-turbo", temperature=0.1, zhipuai_api_key=zhipuai_api_key)
+
+    document_prompt = PromptTemplate(
+        input_variables=["page_content"],
+        template="{page_content}"
+    )
+    document_variable_name = "context"
+    # The prompt here should take as an input variable the
+    # `document_variable_name`
+    prompt = PromptTemplate.from_template(
+        """查询到的文档如下：
+        {context}
+
+        问题: {question}
+        答:"""
+    )
+    llm_chain = LLMChain(llm=llm, prompt=prompt)
+    combine_documents_chain = StuffDocumentsChain(
+        llm_chain=llm_chain,
+        document_prompt=document_prompt,
+        document_variable_name=document_variable_name
+    )
+
+    chain = RetrievalQAWithSourcesChain(combine_documents_chain=combine_documents_chain,
+                                        retriever=docsearch.as_retriever(search_kwargs={'k': 3}))
+    return "success to load data"
+
+
+def query(question):
+    global chain
+    # "What is milvus?"
+    if not chain:
+        return "please load the data first"
+    return chain(inputs={"question": question}, return_only_outputs=True).get(
+        "answer", "fail to get answer"
+    )
+
+
+if __name__ == "__main__":
+    block = gr.Blocks()
+    with block as demo:
+        gr.Markdown(
+            """
+        <h1><center>Langchain And Embed App</center></h1>
+        
+        v.2.29.14.55
+        
+        """
+        )
+        # url_list_text = gr.Textbox(
+        #     label="url list",
+        #     lines=3,
+        #     placeholder="https://milvus.io/docs/overview.md",
+        # )
+        file = gr.File(label='请上传知识库文件\n可以处理 .txt, .md, .docx, .pdf 结尾的文件',
+                       file_types=['.txt', '.md', '.docx', '.pdf'])
+        #openai_key_text = gr.Textbox(label="openai api key", type="password", placeholder="sk-******")
+        #puzhiai_key_text = gr.Textbox(label="puzhi api key", type="password", placeholder="******")
+
+        loader_output = gr.Textbox(label="load status")
+        loader_btn = gr.Button("Load Data")
+        loader_btn.click(
+            fn=web_loader,
+            inputs=[
+                file,
+            ],
+            outputs=loader_output,
+            api_name="web_load",
+        )
+
+        question_text = gr.Textbox(
+            label="question",
+            lines=3,
+            placeholder="What is milvus?",
+        )
+        query_output = gr.Textbox(label="question answer", lines=3)
+        query_btn = gr.Button("Generate")
+        query_btn.click(
+            fn=query,
+            inputs=[question_text],
+            outputs=query_output,
+            api_name="generate_answer",
+        )
+
+        demo.queue().launch(server_name="0.0.0.0", share=False)

project/embeddings/local_embed.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from langchain.embeddings.base import Embeddings
+from langchain.pydantic_v1 import BaseModel, root_validator
+from langchain.utils import get_from_dict_or_env
+from FlagEmbedding import LLMEmbedder
+
+logger = logging.getLogger(__name__)
+
+
+class LocalEmbed(BaseModel, Embeddings):
+    """`Zhipuai Embeddings` embedding models."""
+
+    zhipuai_api_key: Optional[str] = None
+    """Zhipuai application apikey"""
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """
+        Validate whether zhipuai_api_key in the environment variables or
+        configuration file are available or not.
+
+        Args:
+
+            values: a dictionary containing configuration information, must include the
+            fields of zhipuai_api_key
+        Returns:
+
+            a dictionary containing configuration information. If zhipuai_api_key
+            are not provided in the environment variables or configuration
+            file, the original values will be returned; otherwise, values containing
+            zhipuai_api_key will be returned.
+        Raises:
+
+            ValueError: zhipuai package not found, please install it with `pip install
+            zhipuai`
+        """
+        values["zhipuai_api_key"] = get_from_dict_or_env(
+            values,
+            "zhipuai_api_key",
+            "ZHIPUAI_API_KEY",
+        )
+
+        values["client"] = LLMEmbedder('BAAI/bge-large-zh-v1.5',
+                                     query_instruction_for_retrieval="为这个句子生成表示以用于检索相关文章：",
+                                     use_fp16=True)
+        return values
+
+    def _embed(self, texts: str) -> List[float]:
+        print("cal embed:", texts)
+
+        embeddings = self.client.encode(texts)
+
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """
+        Embedding a text.
+
+        Args:
+
+            Text (str): A text to be embedded.
+
+        Return:
+
+            List [float]: An embedding list of input text, which is a list of floating-point values.
+        """
+        resp = self.embed_documents([text])
+        return resp[0]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """
+        Embeds a list of text documents.
+
+        Args:
+            texts (List[str]): A list of text documents to embed.
+
+        Returns:
+            List[List[float]]: A list of embeddings for each document in the input list.
+                            Each embedding is represented as a list of float values.
+        """
+        return [self._embed(text) for text in texts]
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Asynchronous Embed search docs."""
+        raise NotImplementedError(
+            "Please use `embed_documents`. Official does not support asynchronous requests")
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """Asynchronous Embed query text."""
+        raise NotImplementedError(
+            "Please use `aembed_query`. Official does not support asynchronous requests")

project/embeddings/zhipuai_embedding.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from langchain.embeddings.base import Embeddings
+from langchain.pydantic_v1 import BaseModel, root_validator
+from langchain.utils import get_from_dict_or_env
+
+logger = logging.getLogger(__name__)
+
+
+class ZhipuAIEmbeddings(BaseModel, Embeddings):
+    """`Zhipuai Embeddings` embedding models."""
+
+    zhipuai_api_key: Optional[str] = None
+    """Zhipuai application apikey"""
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """
+        Validate whether zhipuai_api_key in the environment variables or
+        configuration file are available or not.
+
+        Args:
+
+            values: a dictionary containing configuration information, must include the
+            fields of zhipuai_api_key
+        Returns:
+
+            a dictionary containing configuration information. If zhipuai_api_key
+            are not provided in the environment variables or configuration
+            file, the original values will be returned; otherwise, values containing
+            zhipuai_api_key will be returned.
+        Raises:
+
+            ValueError: zhipuai package not found, please install it with `pip install
+            zhipuai`
+        """
+        values["zhipuai_api_key"] = get_from_dict_or_env(
+            values,
+            "zhipuai_api_key",
+            "ZHIPUAI_API_KEY",
+        )
+
+        try:
+            from zhipuai import ZhipuAI
+            values["client"] = ZhipuAI(api_key=values["zhipuai_api_key"])
+
+        except ImportError:
+            raise ValueError(
+                "Zhipuai package not found, please install it with "
+                "`pip install zhipuai`"
+            )
+        return values
+
+    def _embed(self, texts: str) -> List[float]:
+        # send request
+        try:
+            print("cal embed:", texts)
+            resp = self.client.embeddings.create(
+                model="embedding-2",
+                input=texts
+            )
+            #print("resp:", resp)
+        except Exception as e:
+            raise ValueError(f"Error raised by inference endpoint: {e}")
+
+        if not resp.data :
+            raise ValueError(
+                "Error raised by inference API HTTP code: %s, %s"
+                % (resp["code"], resp["msg"])
+            )
+        embeddings = resp.data[0].embedding
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """
+        Embedding a text.
+
+        Args:
+
+            Text (str): A text to be embedded.
+
+        Return:
+
+            List [float]: An embedding list of input text, which is a list of floating-point values.
+        """
+        resp = self.embed_documents([text])
+        return resp[0]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """
+        Embeds a list of text documents.
+
+        Args:
+            texts (List[str]): A list of text documents to embed.
+
+        Returns:
+            List[List[float]]: A list of embeddings for each document in the input list.
+                            Each embedding is represented as a list of float values.
+        """
+        return [self._embed(text) for text in texts]
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Asynchronous Embed search docs."""
+        raise NotImplementedError(
+            "Please use `embed_documents`. Official does not support asynchronous requests")
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """Asynchronous Embed query text."""
+        raise NotImplementedError(
+            "Please use `aembed_query`. Official does not support asynchronous requests")

project/llm/check_embed_llm.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+'''
+@File    :   zhipuai_llm.py
+@Time    :   2023/10/16 22:06:26
+@Author  :   0-yy-0
+@Version :   1.0
+@Contact :   310484121@qq.com
+@License :   (C)Copyright 2017-2018, Liugroup-NLPR-CASIA
+@Desc    :   基于智谱 AI 大模型自定义 LLM 类
+'''
+
+from __future__ import annotations
+
+import logging
+from typing import (
+    Any,
+    AsyncIterator,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+)
+
+from langchain.callbacks.manager import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain.llms.base import LLM
+from langchain.pydantic_v1 import Field, root_validator
+from langchain.schema.output import GenerationChunk
+from langchain.utils import get_from_dict_or_env
+from project.llm.self_llm import Self_LLM
+import re
+
+logger = logging.getLogger(__name__)
+
+
+class CheckEmbedLlm(Self_LLM):
+    """Zhipuai hosted open source or customized models.
+
+    To use, you should have the ``zhipuai`` python package installed, and
+    the environment variable ``zhipuai_api_key`` set with
+    your API key and Secret Key.
+
+    zhipuai_api_key are required parameters which you could get from
+    https://open.bigmodel.cn/usercenter/apikeys
+
+    Example:
+        .. code-block:: python
+
+            from langchain.llms import ZhipuAILLM
+            zhipuai_model = ZhipuAILLM(model="chatglm_std", temperature=temperature)
+
+    """
+
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+
+    client: Any
+
+    model: str = "chatglm_std"
+    """Model name in chatglm_pro, chatglm_std, chatglm_lite. """
+
+    zhipuai_api_key: Optional[str] = None
+
+    incremental: Optional[bool] = True
+    """Whether to incremental the results or not."""
+
+    streaming: Optional[bool] = False
+    """Whether to streaming the results or not."""
+    # streaming = -incremental
+
+    request_timeout: Optional[int] = 60
+    """request timeout for chat http requests"""
+
+    top_p: Optional[float] = 0.8
+    temperature: Optional[float] = 0.95
+    request_id: Optional[float] = None
+
+    @root_validator()
+    def validate_enviroment(cls, values: Dict) -> Dict:
+
+        values["zhipuai_api_key"] = get_from_dict_or_env(
+            values,
+            "zhipuai_api_key",
+            "ZHIPUAI_API_KEY",
+        )
+
+        params = {
+            "zhipuai_api_key": values["zhipuai_api_key"],
+            "model": values["model"],
+        }
+        try:
+            #import zhipuai
+
+            #zhipuai.api_key = values["zhipuai_api_key"]
+            #values["client"] = zhipuai()
+
+            from zhipuai import ZhipuAI
+
+            conf_api_key = values["zhipuai_api_key"]
+            client = ZhipuAI(api_key=conf_api_key)
+            values["client"] = client
+        except ImportError:
+            raise ValueError(
+                "zhipuai package not found, please install it with "
+                "`pip install zhipuai`"
+            )
+        return values
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        return {
+            **{"model": self.model},
+            **super()._identifying_params,
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "zhipuai"
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling OpenAI API."""
+        normal_params = {
+            "streaming": self.streaming,
+            "top_p": self.top_p,
+            "temperature": self.temperature,
+            "request_id": self.request_id,
+        }
+
+        return {**normal_params, **self.model_kwargs}
+
+    def _convert_prompt_msg_params(
+            self,
+            prompt: str,
+            **kwargs: Any,
+    ) -> dict:
+        return {
+            **{"prompt": prompt, "model": self.model},
+            **self._default_params,
+            **kwargs,
+        }
+
+    def _call(
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> str:
+        """Call out to an zhipuai models endpoint for each generation with a prompt.
+        Args:
+            prompt: The prompt to pass into the model.
+        Returns:
+            The string generated by the model.
+
+        Example:
+            .. code-block:: python
+                response = zhipuai_model("Tell me a joke.")
+        """
+        if self.streaming:
+            completion = ""
+            for chunk in self._stream(prompt, stop, run_manager, **kwargs):
+                completion += chunk.text
+            return completion
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        all_word = params['prompt']
+
+        keyword = "问题"
+        matches = re.finditer(keyword, all_word)
+        indexes = [match.start() for match in matches]
+        last_index = indexes[len(indexes) -1]
+
+        params = {"messages": [
+            {"role": "system", "content": all_word[0:last_index]},
+            {"role": "user", "content": all_word[last_index:len(all_word)]}],
+            "model": self.model, "stream": False, "top_p": 0.8, "temperature": 0.01, "request_id": None}
+
+        print("params:", params)
+        response_payload = params
+
+        return response_payload
+
+    async def _acall(
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> str:
+        if self.streaming:
+            completion = ""
+            async for chunk in self._astream(prompt, stop, run_manager, **kwargs):
+                completion += chunk.text
+            return completion
+
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        response = await self.client.async_invoke(**params)
+
+        return response_payload
+
+    def _stream(
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> Iterator[GenerationChunk]:
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        for res in self.client.invoke(**params):
+            if res:
+                chunk = GenerationChunk(text=res)
+                yield chunk
+                if run_manager:
+                    run_manager.on_llm_new_token(chunk.text)
+
+    async def _astream(
+
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> AsyncIterator[GenerationChunk]:
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        async for res in await self.client.ado(**params):
+            if res:
+                chunk = GenerationChunk(text=res["data"]["choices"]["content"])
+
+                yield chunk
+                if run_manager:
+                    await run_manager.on_llm_new_token(chunk.text)

project/llm/self_llm.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+'''
+@File    :   self_llm.py
+@Time    :   2023/10/16 18:48:08
+@Author  :   Logan Zou
+@Version :   1.0
+@Contact :   loganzou0421@163.com
+@License :   (C)Copyright 2017-2018, Liugroup-NLPR-CASIA
+@Desc    :   在 LangChain LLM 基础上封装的项目类，统一了 GPT、文心、讯飞、智谱多种 API 调用
+'''
+
+from langchain.llms.base import LLM
+from typing import Dict, Any, Mapping
+from pydantic import Field
+
+class Self_LLM(LLM):
+    # 自定义 LLM
+    # 继承自 langchain.llms.base.LLM
+    # 原生接口地址
+    url : str =  None
+    # 默认选用 GPT-3.5 模型，即目前一般所说的百度文心大模型
+    model_name: str = "gpt-3.5-turbo"
+    # 访问时延上限
+    request_timeout: float = None
+    # 温度系数
+    temperature: float = 0.1
+    # API_Key
+    api_key: str = None
+    # 必备的可选参数
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+
+    # 定义一个返回默认参数的方法
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """获取调用默认参数。"""
+        normal_params = {
+            "temperature": self.temperature,
+            "request_timeout": self.request_timeout,
+        }
+        # print(type(self.model_kwargs))
+        return {**normal_params}
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {**{"model_name": self.model_name}, **self._default_params}

project/llm/zhipuai_llm.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+'''
+@File    :   zhipuai_llm.py
+@Time    :   2023/10/16 22:06:26
+@Author  :   0-yy-0
+@Version :   1.0
+@Contact :   310484121@qq.com
+@License :   (C)Copyright 2017-2018, Liugroup-NLPR-CASIA
+@Desc    :   基于智谱 AI 大模型自定义 LLM 类
+'''
+
+from __future__ import annotations
+
+import logging
+from typing import (
+    Any,
+    AsyncIterator,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+)
+
+from langchain.callbacks.manager import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain.llms.base import LLM
+from langchain.pydantic_v1 import Field, root_validator
+from langchain.schema.output import GenerationChunk
+from langchain.utils import get_from_dict_or_env
+from project.llm.self_llm import Self_LLM
+import re
+
+logger = logging.getLogger(__name__)
+
+
+class ZhipuAILLM(Self_LLM):
+    """Zhipuai hosted open source or customized models.
+
+    To use, you should have the ``zhipuai`` python package installed, and
+    the environment variable ``zhipuai_api_key`` set with
+    your API key and Secret Key.
+
+    zhipuai_api_key are required parameters which you could get from
+    https://open.bigmodel.cn/usercenter/apikeys
+
+    Example:
+        .. code-block:: python
+
+            from langchain.llms import ZhipuAILLM
+            zhipuai_model = ZhipuAILLM(model="chatglm_std", temperature=temperature)
+
+    """
+
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+
+    client: Any
+
+    model: str = "chatglm_std"
+    """Model name in chatglm_pro, chatglm_std, chatglm_lite. """
+
+    zhipuai_api_key: Optional[str] = None
+
+    incremental: Optional[bool] = True
+    """Whether to incremental the results or not."""
+
+    streaming: Optional[bool] = False
+    """Whether to streaming the results or not."""
+    # streaming = -incremental
+
+    request_timeout: Optional[int] = 60
+    """request timeout for chat http requests"""
+
+    top_p: Optional[float] = 0.8
+    temperature: Optional[float] = 0.95
+    request_id: Optional[float] = None
+
+    @root_validator()
+    def validate_enviroment(cls, values: Dict) -> Dict:
+
+        values["zhipuai_api_key"] = get_from_dict_or_env(
+            values,
+            "zhipuai_api_key",
+            "ZHIPUAI_API_KEY",
+        )
+
+        params = {
+            "zhipuai_api_key": values["zhipuai_api_key"],
+            "model": values["model"],
+        }
+        try:
+            #import zhipuai
+
+            #zhipuai.api_key = values["zhipuai_api_key"]
+            #values["client"] = zhipuai()
+
+            from zhipuai import ZhipuAI
+
+            conf_api_key = values["zhipuai_api_key"]
+            client = ZhipuAI(api_key=conf_api_key)
+            values["client"] = client
+        except ImportError:
+            raise ValueError(
+                "zhipuai package not found, please install it with "
+                "`pip install zhipuai`"
+            )
+        return values
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        return {
+            **{"model": self.model},
+            **super()._identifying_params,
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "zhipuai"
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling OpenAI API."""
+        normal_params = {
+            "streaming": self.streaming,
+            "top_p": self.top_p,
+            "temperature": self.temperature,
+            "request_id": self.request_id,
+        }
+
+        return {**normal_params, **self.model_kwargs}
+
+    def _convert_prompt_msg_params(
+            self,
+            prompt: str,
+            **kwargs: Any,
+    ) -> dict:
+        return {
+            **{"prompt": prompt, "model": self.model},
+            **self._default_params,
+            **kwargs,
+        }
+
+    def _call(
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> str:
+        """Call out to an zhipuai models endpoint for each generation with a prompt.
+        Args:
+            prompt: The prompt to pass into the model.
+        Returns:
+            The string generated by the model.
+
+        Example:
+            .. code-block:: python
+                response = zhipuai_model("Tell me a joke.")
+        """
+        if self.streaming:
+            completion = ""
+            for chunk in self._stream(prompt, stop, run_manager, **kwargs):
+                completion += chunk.text
+            return completion
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        all_word = params['prompt']
+
+        keyword = "问题"
+        matches = re.finditer(keyword, all_word)
+        indexes = [match.start() for match in matches]
+        last_index = indexes[len(indexes) -1]
+
+        params = {"messages": [
+            {"role": "system", "content": all_word[0:last_index]},
+            {"role": "user", "content": all_word[last_index:len(all_word)]}],
+                  "model": self.model, "stream": False, "top_p": 0.8, "temperature": 0.01, "request_id": None}
+
+        print("params:", params)
+        response_payload = self.client.chat.completions.create(**params)
+        print("response_payload", response_payload)
+
+        return response_payload.choices[0].message.content
+
+    async def _acall(
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> str:
+        if self.streaming:
+            completion = ""
+            async for chunk in self._astream(prompt, stop, run_manager, **kwargs):
+                completion += chunk.text
+            return completion
+
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        response = await self.client.async_invoke(**params)
+
+        return response_payload
+
+    def _stream(
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> Iterator[GenerationChunk]:
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        for res in self.client.invoke(**params):
+            if res:
+                chunk = GenerationChunk(text=res)
+                yield chunk
+                if run_manager:
+                    run_manager.on_llm_new_token(chunk.text)
+
+    async def _astream(
+
+            self,
+            prompt: str,
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+    ) -> AsyncIterator[GenerationChunk]:
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+
+        async for res in await self.client.ado(**params):
+            if res:
+                chunk = GenerationChunk(text=res["data"]["choices"]["content"])
+
+                yield chunk
+                if run_manager:
+                    await run_manager.on_llm_new_token(chunk.text)

project/prompt/answer_by_private_prompt.py

@@ -0,0 +1,63 @@
+from langchain_core.prompts import PromptTemplate
+
+question_prompt_template = """用提供给你的文档去回答问题，不需要编造或者虚构答案，也不需要回答文档之外的内容。
+如果在文档中没有找到相关的答案，那么就直接回答'知识库中没有相关问题解答'
+请用中文回答。 
+下边是我给你提供的文档，其中文档格式都是一问一答。问题答案也完全来自所提供的回答：
+{context}
+
+问题: {question}
+答:"""
+QUESTION_PROMPT = PromptTemplate(
+    template=question_prompt_template, input_variables=["context", "question"]
+)
+
+combine_prompt_template = """
+QUESTION: {question}
+=========
+{summaries}
+=========
+FINAL ANSWER:"""
+COMBINE_PROMPT = PromptTemplate(
+    template=combine_prompt_template, input_variables=["summaries", "question"]
+)
+
+EXAMPLE_PROMPT = PromptTemplate(
+    template="Content: {page_content}\nSource: {source}",
+    input_variables=["page_content", "source"],
+)
+
+DEFAULT_REFINE_PROMPT_TMPL = (
+    "The original question is as follows: {question}\n"
+    "We have provided an existing answer, including sources: {existing_answer}\n"
+    "We have the opportunity to refine the existing answer"
+    "(only if needed) with some more context below.\n"
+    "------------\n"
+    "{context_str}\n"
+    "------------\n"
+    "Given the new context, refine the original answer to better "
+    "answer the question. "
+    "If you do update it, please update the sources as well. "
+    "If the context isn't useful, return the original answer."
+)
+DEFAULT_REFINE_PROMPT = PromptTemplate(
+    input_variables=["question", "existing_answer", "context_str"],
+    template=DEFAULT_REFINE_PROMPT_TMPL,
+)
+
+
+DEFAULT_TEXT_QA_PROMPT_TMPL = (
+"""用提供给你的文档去回答问题，不需要编造或者虚构答案，也不需要回答文档之外的内容。
+如果在文档中没有找到相关的答案，那么就直接回答'知识库中没有相关问题解答'
+请用中文回答。 
+下边是我给你提供的文档，其中文档格式都是一问一答。问题答案也完全来自所提供的回答：
+---------------------
+{context_str}
+---------------------
+
+问题: {question}
+答:"""
+)
+DEFAULT_TEXT_QA_PROMPT = PromptTemplate(
+    input_variables=["context_str", "question"], template=DEFAULT_TEXT_QA_PROMPT_TMPL
+)

requirements.txt

@@ -0,0 +1,10 @@
+pymilvus
+langchain
+openai
+tiktoken
+gradio
+bs4
+uuid
+zhipuai
+transformers
+FlagEmbedding