add chains

chains/dialogue_answering/__init__.py

@@ -0,0 +1,7 @@
+from .base import (
+    DialogueWithSharedMemoryChains
+)
+
+__all__ = [
+    "DialogueWithSharedMemoryChains"
+]

chains/dialogue_answering/__main__.py

@@ -0,0 +1,36 @@
+import sys
+import os
+import argparse
+import asyncio
+from argparse import Namespace
+sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../../')
+from chains.dialogue_answering import *
+from langchain.llms import OpenAI
+from models.base import (BaseAnswer,
+                         AnswerResult)
+import models.shared as shared
+from models.loader.args import parser
+from models.loader import LoaderCheckPoint
+
+async def dispatch(args: Namespace):
+
+    args_dict = vars(args)
+    shared.loaderCheckPoint = LoaderCheckPoint(args_dict)
+    llm_model_ins = shared.loaderLLM()
+    if not os.path.isfile(args.dialogue_path):
+        raise FileNotFoundError(f'Invalid dialogue file path for demo mode: "{args.dialogue_path}"')
+    llm = OpenAI(temperature=0)
+    dialogue_instance = DialogueWithSharedMemoryChains(zero_shot_react_llm=llm, ask_llm=llm_model_ins, params=args_dict)
+
+    dialogue_instance.agent_chain.run(input="What did David say before, summarize it")
+
+
+if __name__ == '__main__':
+
+    parser.add_argument('--dialogue-path', default='', type=str, help='dialogue-path')
+    parser.add_argument('--embedding-model', default='', type=str, help='embedding-model')
+    args = parser.parse_args(['--dialogue-path', '/home/dmeck/Downloads/log.txt',
+                              '--embedding-mode', '/media/checkpoint/text2vec-large-chinese/'])
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(dispatch(args))

chains/dialogue_answering/base.py

@@ -0,0 +1,99 @@
+from langchain.base_language import BaseLanguageModel
+from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
+from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory
+from langchain.chains import LLMChain, RetrievalQA
+from langchain.embeddings.huggingface import HuggingFaceEmbeddings
+from langchain.prompts import PromptTemplate
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.vectorstores import Chroma
+
+from loader import DialogueLoader
+from chains.dialogue_answering.prompts import (
+    DIALOGUE_PREFIX,
+    DIALOGUE_SUFFIX,
+    SUMMARY_PROMPT
+)
+
+
+class DialogueWithSharedMemoryChains:
+    zero_shot_react_llm: BaseLanguageModel = None
+    ask_llm: BaseLanguageModel = None
+    embeddings: HuggingFaceEmbeddings = None
+    embedding_model: str = None
+    vector_search_top_k: int = 6
+    dialogue_path: str = None
+    dialogue_loader: DialogueLoader = None
+    device: str = None
+
+    def __init__(self, zero_shot_react_llm: BaseLanguageModel = None, ask_llm: BaseLanguageModel = None,
+                 params: dict = None):
+        self.zero_shot_react_llm = zero_shot_react_llm
+        self.ask_llm = ask_llm
+        params = params or {}
+        self.embedding_model = params.get('embedding_model', 'GanymedeNil/text2vec-large-chinese')
+        self.vector_search_top_k = params.get('vector_search_top_k', 6)
+        self.dialogue_path = params.get('dialogue_path', '')
+        self.device = 'cuda' if params.get('use_cuda', False) else 'cpu'
+
+        self.dialogue_loader = DialogueLoader(self.dialogue_path)
+        self._init_cfg()
+        self._init_state_of_history()
+        self.memory_chain, self.memory = self._agents_answer()
+        self.agent_chain = self._create_agent_chain()
+
+    def _init_cfg(self):
+        model_kwargs = {
+            'device': self.device
+        }
+        self.embeddings = HuggingFaceEmbeddings(model_name=self.embedding_model, model_kwargs=model_kwargs)
+
+    def _init_state_of_history(self):
+        documents = self.dialogue_loader.load()
+        text_splitter = CharacterTextSplitter(chunk_size=3, chunk_overlap=1)
+        texts = text_splitter.split_documents(documents)
+        docsearch = Chroma.from_documents(texts, self.embeddings, collection_name="state-of-history")
+        self.state_of_history = RetrievalQA.from_chain_type(llm=self.ask_llm, chain_type="stuff",
+                                                            retriever=docsearch.as_retriever())
+
+    def _agents_answer(self):
+
+        memory = ConversationBufferMemory(memory_key="chat_history")
+        readonly_memory = ReadOnlySharedMemory(memory=memory)
+        memory_chain = LLMChain(
+            llm=self.ask_llm,
+            prompt=SUMMARY_PROMPT,
+            verbose=True,
+            memory=readonly_memory,  # use the read-only memory to prevent the tool from modifying the memory
+        )
+        return memory_chain, memory
+
+    def _create_agent_chain(self):
+        dialogue_participants = self.dialogue_loader.dialogue.participants_to_export()
+        tools = [
+            Tool(
+                name="State of Dialogue History System",
+                func=self.state_of_history.run,
+                description=f"Dialogue with {dialogue_participants} - The answers in this section are very useful "
+                            f"when searching for chat content between {dialogue_participants}. Input should be a "
+                            f"complete question. "
+            ),
+            Tool(
+                name="Summary",
+                func=self.memory_chain.run,
+                description="useful for when you summarize a conversation. The input to this tool should be a string, "
+                            "representing who will read this summary. "
+            )
+        ]
+
+        prompt = ZeroShotAgent.create_prompt(
+            tools,
+            prefix=DIALOGUE_PREFIX,
+            suffix=DIALOGUE_SUFFIX,
+            input_variables=["input", "chat_history", "agent_scratchpad"]
+        )
+
+        llm_chain = LLMChain(llm=self.zero_shot_react_llm, prompt=prompt)
+        agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)
+        agent_chain = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True, memory=self.memory)
+
+        return agent_chain

chains/dialogue_answering/prompts.py

@@ -0,0 +1,22 @@
+from langchain.prompts.prompt import PromptTemplate
+
+
+SUMMARY_TEMPLATE = """This is a conversation between a human and a bot:
+
+{chat_history}
+
+Write a summary of the conversation for {input}:
+"""
+
+SUMMARY_PROMPT = PromptTemplate(
+    input_variables=["input", "chat_history"],
+    template=SUMMARY_TEMPLATE
+)
+
+DIALOGUE_PREFIX = """Have a conversation with a human,Analyze the content of the conversation.
+You have access to the following tools: """
+DIALOGUE_SUFFIX = """Begin!
+
+{chat_history}
+Question: {input}
+{agent_scratchpad}"""

chains/local_doc_qa.py

@@ -0,0 +1,364 @@
+from langchain.embeddings.huggingface import HuggingFaceEmbeddings
+from vectorstores import MyFAISS
+from langchain.document_loaders import UnstructuredFileLoader, TextLoader, CSVLoader
+from configs.model_config import *
+import datetime
+from textsplitter import ChineseTextSplitter
+from typing import List
+from utils import torch_gc
+from tqdm import tqdm
+from pypinyin import lazy_pinyin
+from models.base import (BaseAnswer,
+                         AnswerResult)
+from models.loader.args import parser
+from models.loader import LoaderCheckPoint
+import models.shared as shared
+from agent import bing_search
+from langchain.docstore.document import Document
+from functools import lru_cache
+from textsplitter.zh_title_enhance import zh_title_enhance
+from langchain.chains.base import Chain
+
+
+# patch HuggingFaceEmbeddings to make it hashable
+def _embeddings_hash(self):
+    return hash(self.model_name)
+
+
+HuggingFaceEmbeddings.__hash__ = _embeddings_hash
+
+
+# will keep CACHED_VS_NUM of vector store caches
+@lru_cache(CACHED_VS_NUM)
+def load_vector_store(vs_path, embeddings):
+    return MyFAISS.load_local(vs_path, embeddings)
+
+
+def tree(filepath, ignore_dir_names=None, ignore_file_names=None):
+    """返回两个列表，第一个列表为 filepath 下全部文件的完整路径, 第二个为对应的文件名"""
+    if ignore_dir_names is None:
+        ignore_dir_names = []
+    if ignore_file_names is None:
+        ignore_file_names = []
+    ret_list = []
+    if isinstance(filepath, str):
+        if not os.path.exists(filepath):
+            print("路径不存在")
+            return None, None
+        elif os.path.isfile(filepath) and os.path.basename(filepath) not in ignore_file_names:
+            return [filepath], [os.path.basename(filepath)]
+        elif os.path.isdir(filepath) and os.path.basename(filepath) not in ignore_dir_names:
+            for file in os.listdir(filepath):
+                fullfilepath = os.path.join(filepath, file)
+                if os.path.isfile(fullfilepath) and os.path.basename(fullfilepath) not in ignore_file_names:
+                    ret_list.append(fullfilepath)
+                if os.path.isdir(fullfilepath) and os.path.basename(fullfilepath) not in ignore_dir_names:
+                    ret_list.extend(tree(fullfilepath, ignore_dir_names, ignore_file_names)[0])
+    return ret_list, [os.path.basename(p) for p in ret_list]
+
+
+def load_file(filepath, sentence_size=SENTENCE_SIZE, using_zh_title_enhance=ZH_TITLE_ENHANCE):
+
+    if filepath.lower().endswith(".md"):
+        loader = UnstructuredFileLoader(filepath, mode="elements")
+        docs = loader.load()
+    elif filepath.lower().endswith(".txt"):
+        loader = TextLoader(filepath, autodetect_encoding=True)
+        textsplitter = ChineseTextSplitter(pdf=False, sentence_size=sentence_size)
+        docs = loader.load_and_split(textsplitter)
+    elif filepath.lower().endswith(".pdf"):
+        # 暂且将paddle相关的loader改为动态加载，可以在不上传pdf/image知识文件的前提下使用protobuf=4.x
+        from loader import UnstructuredPaddlePDFLoader
+        loader = UnstructuredPaddlePDFLoader(filepath)
+        textsplitter = ChineseTextSplitter(pdf=True, sentence_size=sentence_size)
+        docs = loader.load_and_split(textsplitter)
+    elif filepath.lower().endswith(".jpg") or filepath.lower().endswith(".png"):
+        # 暂且将paddle相关的loader改为动态加载，可以在不上传pdf/image知识文件的前提下使用protobuf=4.x
+        from loader import UnstructuredPaddleImageLoader
+        loader = UnstructuredPaddleImageLoader(filepath, mode="elements")
+        textsplitter = ChineseTextSplitter(pdf=False, sentence_size=sentence_size)
+        docs = loader.load_and_split(text_splitter=textsplitter)
+    elif filepath.lower().endswith(".csv"):
+        loader = CSVLoader(filepath)
+        docs = loader.load()
+    else:
+        loader = UnstructuredFileLoader(filepath, mode="elements")
+        textsplitter = ChineseTextSplitter(pdf=False, sentence_size=sentence_size)
+        docs = loader.load_and_split(text_splitter=textsplitter)
+    if using_zh_title_enhance:
+        docs = zh_title_enhance(docs)
+    write_check_file(filepath, docs)
+    return docs
+
+
+def write_check_file(filepath, docs):
+    folder_path = os.path.join(os.path.dirname(filepath), "tmp_files")
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)
+    fp = os.path.join(folder_path, 'load_file.txt')
+    with open(fp, 'a+', encoding='utf-8') as fout:
+        fout.write("filepath=%s,len=%s" % (filepath, len(docs)))
+        fout.write('\n')
+        for i in docs:
+            fout.write(str(i))
+            fout.write('\n')
+        fout.close()
+
+
+def generate_prompt(related_docs: List[str],
+                    query: str,
+                    prompt_template: str = PROMPT_TEMPLATE, ) -> str:
+    context = "\n".join([doc.page_content for doc in related_docs])
+    prompt = prompt_template.replace("{question}", query).replace("{context}", context)
+    return prompt
+
+
+def search_result2docs(search_results):
+    docs = []
+    for result in search_results:
+        doc = Document(page_content=result["snippet"] if "snippet" in result.keys() else "",
+                       metadata={"source": result["link"] if "link" in result.keys() else "",
+                                 "filename": result["title"] if "title" in result.keys() else ""})
+        docs.append(doc)
+    return docs
+
+
+class LocalDocQA:
+    llm_model_chain: Chain = None
+    embeddings: object = None
+    top_k: int = VECTOR_SEARCH_TOP_K
+    chunk_size: int = CHUNK_SIZE
+    chunk_conent: bool = True
+    score_threshold: int = VECTOR_SEARCH_SCORE_THRESHOLD
+
+    def init_cfg(self,
+                 embedding_model: str = EMBEDDING_MODEL,
+                 embedding_device=EMBEDDING_DEVICE,
+                 llm_model: Chain = None,
+                 top_k=VECTOR_SEARCH_TOP_K,
+                 ):
+        self.llm_model_chain = llm_model
+        self.embeddings = HuggingFaceEmbeddings(model_name=embedding_model_dict[embedding_model],
+                                                model_kwargs={'device': embedding_device})
+        self.top_k = top_k
+
+    def init_knowledge_vector_store(self,
+                                    filepath: str or List[str],
+                                    vs_path: str or os.PathLike = None,
+                                    sentence_size=SENTENCE_SIZE):
+        loaded_files = []
+        failed_files = []
+        if isinstance(filepath, str):
+            if not os.path.exists(filepath):
+                print("路径不存在")
+                return None
+            elif os.path.isfile(filepath):
+                file = os.path.split(filepath)[-1]
+                try:
+                    docs = load_file(filepath, sentence_size)
+                    logger.info(f"{file} 已成功加载")
+                    loaded_files.append(filepath)
+                except Exception as e:
+                    logger.error(e)
+                    logger.info(f"{file} 未能成功加载")
+                    return None
+            elif os.path.isdir(filepath):
+                docs = []
+                for fullfilepath, file in tqdm(zip(*tree(filepath, ignore_dir_names=['tmp_files'])), desc="加载文件"):
+                    try:
+                        docs += load_file(fullfilepath, sentence_size)
+                        loaded_files.append(fullfilepath)
+                    except Exception as e:
+                        logger.error(e)
+                        failed_files.append(file)
+
+                if len(failed_files) > 0:
+                    logger.info("以下文件未能成功加载：")
+                    for file in failed_files:
+                        logger.info(f"{file}\n")
+
+        else:
+            docs = []
+            for file in filepath:
+                try:
+                    docs += load_file(file)
+                    logger.info(f"{file} 已成功加载")
+                    loaded_files.append(file)
+                except Exception as e:
+                    logger.error(e)
+                    logger.info(f"{file} 未能成功加载")
+        if len(docs) > 0:
+            logger.info("文件加载完毕，正在生成向量库")
+            if vs_path and os.path.isdir(vs_path) and "index.faiss" in os.listdir(vs_path):
+                vector_store = load_vector_store(vs_path, self.embeddings)
+                vector_store.add_documents(docs)
+                torch_gc()
+            else:
+                if not vs_path:
+                    vs_path = os.path.join(KB_ROOT_PATH,
+                                           f"""{"".join(lazy_pinyin(os.path.splitext(file)[0]))}_FAISS_{datetime.datetime.now().strftime("%Y%m%d_%H%M%S")}""",
+                                           "vector_store")
+                vector_store = MyFAISS.from_documents(docs, self.embeddings)  # docs 为Document列表
+                torch_gc()
+
+            vector_store.save_local(vs_path)
+            return vs_path, loaded_files
+        else:
+            logger.info("文件均未成功加载，请检查依赖包或替换为其他文件再次上传。")
+
+            return None, loaded_files
+
+    def one_knowledge_add(self, vs_path, one_title, one_conent, one_content_segmentation, sentence_size):
+        try:
+            if not vs_path or not one_title or not one_conent:
+                logger.info("知识库添加错误，请确认知识库名字、标题、内容是否正确！")
+                return None, [one_title]
+            docs = [Document(page_content=one_conent + "\n", metadata={"source": one_title})]
+            if not one_content_segmentation:
+                text_splitter = ChineseTextSplitter(pdf=False, sentence_size=sentence_size)
+                docs = text_splitter.split_documents(docs)
+            if os.path.isdir(vs_path) and os.path.isfile(vs_path + "/index.faiss"):
+                vector_store = load_vector_store(vs_path, self.embeddings)
+                vector_store.add_documents(docs)
+            else:
+                vector_store = MyFAISS.from_documents(docs, self.embeddings)  ##docs 为Document列表
+            torch_gc()
+            vector_store.save_local(vs_path)
+            return vs_path, [one_title]
+        except Exception as e:
+            logger.error(e)
+            return None, [one_title]
+
+    def get_knowledge_based_answer(self, query, vs_path, chat_history=[], streaming: bool = STREAMING):
+        vector_store = load_vector_store(vs_path, self.embeddings)
+        vector_store.chunk_size = self.chunk_size
+        vector_store.chunk_conent = self.chunk_conent
+        vector_store.score_threshold = self.score_threshold
+        related_docs_with_score = vector_store.similarity_search_with_score(query, k=self.top_k)
+        torch_gc()
+        if len(related_docs_with_score) > 0:
+            prompt = generate_prompt(related_docs_with_score, query)
+        else:
+            prompt = query
+
+        # 接入baichuan的代码分支：
+        if LLM_MODEL == "Baichuan-13B-Chat":
+            for answer_result in self.llm_model_chain._generate_answer(prompt=prompt, history=chat_history,
+                                                                       streaming=streaming):
+                resp = answer_result.llm_output["answer"]
+                history = answer_result.history
+                response = {"query": query,
+                            "result": resp,
+                            "source_documents": related_docs_with_score}
+                yield response, history
+        else:  # 原本逻辑分支：
+            answer_result_stream_result = self.llm_model_chain(
+                {"prompt": prompt, "history": chat_history, "streaming": streaming})
+
+            for answer_result in answer_result_stream_result['answer_result_stream']:
+                resp = answer_result.llm_output["answer"]
+                history = answer_result.history
+                history[-1][0] = query
+                response = {"query": query,
+                            "result": resp,
+                            "source_documents": related_docs_with_score}
+                yield response, history
+
+    # query      查询内容
+    # vs_path    知识库路径
+    # chunk_conent   是否启用上下文关联
+    # score_threshold    搜索匹配score阈值
+    # vector_search_top_k   搜索知识库内容条数，默认搜索5条结果
+    # chunk_sizes    匹配单段内容的连接上下文长度
+    def get_knowledge_based_conent_test(self, query, vs_path, chunk_conent,
+                                        score_threshold=VECTOR_SEARCH_SCORE_THRESHOLD,
+                                        vector_search_top_k=VECTOR_SEARCH_TOP_K, chunk_size=CHUNK_SIZE):
+        vector_store = load_vector_store(vs_path, self.embeddings)
+        # FAISS.similarity_search_with_score_by_vector = similarity_search_with_score_by_vector
+        vector_store.chunk_conent = chunk_conent
+        vector_store.score_threshold = score_threshold
+        vector_store.chunk_size = chunk_size
+        related_docs_with_score = vector_store.similarity_search_with_score(query, k=vector_search_top_k)
+        if not related_docs_with_score:
+            response = {"query": query,
+                        "source_documents": []}
+            return response, ""
+        torch_gc()
+        prompt = "\n".join([doc.page_content for doc in related_docs_with_score])
+        response = {"query": query,
+                    "source_documents": related_docs_with_score}
+        return response, prompt
+
+    def get_search_result_based_answer(self, query, chat_history=[], streaming: bool = STREAMING):
+        results = bing_search(query)
+        result_docs = search_result2docs(results)
+        prompt = generate_prompt(result_docs, query)
+
+        answer_result_stream_result = self.llm_model_chain(
+            {"prompt": prompt, "history": chat_history, "streaming": streaming})
+
+        for answer_result in answer_result_stream_result['answer_result_stream']:
+            resp = answer_result.llm_output["answer"]
+            history = answer_result.history
+            history[-1][0] = query
+            response = {"query": query,
+                        "result": resp,
+                        "source_documents": result_docs}
+            yield response, history
+
+    def delete_file_from_vector_store(self,
+                                      filepath: str or List[str],
+                                      vs_path):
+        vector_store = load_vector_store(vs_path, self.embeddings)
+        status = vector_store.delete_doc(filepath)
+        return status
+
+    def update_file_from_vector_store(self,
+                                      filepath: str or List[str],
+                                      vs_path,
+                                      docs: List[Document], ):
+        vector_store = load_vector_store(vs_path, self.embeddings)
+        status = vector_store.update_doc(filepath, docs)
+        return status
+
+    def list_file_from_vector_store(self,
+                                    vs_path,
+                                    fullpath=False):
+        vector_store = load_vector_store(vs_path, self.embeddings)
+        docs = vector_store.list_docs()
+        if fullpath:
+            return docs
+        else:
+            return [os.path.split(doc)[-1] for doc in docs]
+
+
+if __name__ == "__main__":
+    # 初始化消息
+    args = None
+    args = parser.parse_args(args=['--model-dir', '/media/checkpoint/', '--model', 'chatglm-6b', '--no-remote-model'])
+
+    args_dict = vars(args)
+    shared.loaderCheckPoint = LoaderCheckPoint(args_dict)
+    llm_model_ins = shared.loaderLLM()
+
+    local_doc_qa = LocalDocQA()
+    local_doc_qa.init_cfg(llm_model=llm_model_ins)
+    query = "本项目使用的embedding模型是什么，消耗多少显存"
+    vs_path = "/media/gpt4-pdf-chatbot-langchain/dev-langchain-ChatGLM/vector_store/test"
+    last_print_len = 0
+    # for resp, history in local_doc_qa.get_knowledge_based_answer(query=query,
+    #                                                              vs_path=vs_path,
+    #                                                              chat_history=[],
+    #                                                              streaming=True):
+    for resp, history in local_doc_qa.get_search_result_based_answer(query=query,
+                                                                     chat_history=[],
+                                                                     streaming=True):
+        print(resp["result"][last_print_len:], end="", flush=True)
+        last_print_len = len(resp["result"])
+    source_text = [f"""出处 [{inum + 1}] {doc.metadata['source'] if doc.metadata['source'].startswith("http")
+    else os.path.split(doc.metadata['source'])[-1]}：\n\n{doc.page_content}\n\n"""
+                   # f"""相关度：{doc.metadata['score']}\n\n"""
+                   for inum, doc in
+                   enumerate(resp["source_documents"])]
+    logger.info("\n\n" + "\n\n".join(source_text))
+    pass

chains/text_load.py

@@ -0,0 +1,52 @@
+import os
+import pinecone 
+from tqdm import tqdm
+from langchain.llms import OpenAI
+from langchain.text_splitter import SpacyTextSplitter
+from langchain.document_loaders import TextLoader
+from langchain.document_loaders import DirectoryLoader
+from langchain.indexes import VectorstoreIndexCreator
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Pinecone
+
+#一些配置文件
+openai_key="你的key" # 注册 openai.com 后获得
+pinecone_key="你的key" # 注册 app.pinecone.io 后获得
+pinecone_index="你的库" #app.pinecone.io 获得
+pinecone_environment="你的Environment"  # 登录pinecone后，在indexes页面 查看Environment
+pinecone_namespace="你的Namespace" #如果不存在自动创建
+
+#科学上网你懂得
+os.environ['HTTP_PROXY'] = 'http://127.0.0.1:7890'
+os.environ['HTTPS_PROXY'] = 'http://127.0.0.1:7890'
+
+#初始化pinecone
+pinecone.init(
+    api_key=pinecone_key,
+    environment=pinecone_environment
+)
+index = pinecone.Index(pinecone_index)
+
+#初始化OpenAI的embeddings
+embeddings = OpenAIEmbeddings(openai_api_key=openai_key)
+
+#初始化text_splitter
+text_splitter = SpacyTextSplitter(pipeline='zh_core_web_sm',chunk_size=1000,chunk_overlap=200)
+
+# 读取目录下所有后缀是txt的文件
+loader = DirectoryLoader('../docs', glob="**/*.txt", loader_cls=TextLoader)
+
+#读取文本文件
+documents = loader.load()
+
+# 使用text_splitter对文档进行分割
+split_text = text_splitter.split_documents(documents)
+try:
+	for document in tqdm(split_text):
+		# 获取向量并储存到pinecone
+		Pinecone.from_documents([document], embeddings, index_name=pinecone_index)
+except Exception as e:
+    print(f"Error: {e}")
+    quit()
+
+