如何在您的笔记本电脑上安装GPT4All，并向AI询问您自己的领域知识（您的文档）…它仅在CPU上运行！

本文将教您如何在只有CPU的计算机上部署和使用GPT4All模型（我使用的是没有GPU的Macbook Pro！）

在本文中，我们将在本地计算机上安装GPT4All（一个强大的LLM），并发现如何使用Python与我们的文档交互。一组PDF或在线文章将成为我们问题/答案的知识库。

什么是GPT4All

从官方网站GPT4All中，它被描述为一个免费使用、本地运行、注重隐私的聊天机器人。无需GPU或互联网。

GTP4All是一个生态系统，用于训练和部署在消费级CPU上本地运行的强大的和定制的大型语言模型。

我们的GPT4All模型是一个4GB的文件，您可以下载并插入GPT4All开源生态系统软件中。Nomic AI提供高质量和安全的软件生态系统，推动使个人和组织轻松地在本地训练和实现自己的大型语言模型的努力。

它将如何工作？

该过程非常简单（当您知道它时），并且可以重复使用其他模型。步骤如下：

• 加载GPT4All模型
• 使用Langchain检索我们的文档并加载它们
• 将文档分成小块，可以由Embeddings消化
• 使用FAISS创建我们的向量数据库与嵌入
• 基于我们要传递给GPT4All的问题，在我们的向量数据库上执行相似性搜索（语义搜索）：这将用作我们问题的上下文
• 使用Langchain将问题和上下文馈送给GPT4All，等待答案。

所以我们需要的是嵌入。嵌入是信息的数字表示，例如文本、文档、图像、音频等。该表示捕获被嵌入的语义意义，这正是我们需要的。对于这个项目，我们不能依赖于重型GPU模型：因此，我们将下载Alpaca本机模型，并从Langchain中使用LlamaCppEmbeddings。不要担心！每个步骤都有详细的说明

让我们开始编码

创建虚拟环境

为您的新Python项目创建一个新文件夹，例如GPT4ALL_Fabio（放上您的名字…）：

mkdir GPT4ALL_Fabio
cd GPT4ALL_Fabio

接下来，创建一个新的Python虚拟环境。如果您安装了多个Python版本，请指定您想要的版本：在这种情况下，我将使用我的主安装，与Python 3.10相关联。

python3 -m venv .venv

命令python3 -m venv .venv创建一个名为.venv的新虚拟环境（点将创建一个名为venv的隐藏目录）。

虚拟环境提供了一个隔离的Python安装，允许您仅为特定项目安装包和依赖项，而不会影响系统范围的Python安装或其他项目。这种隔离有助于保持一致性，防止不同项目要求之间的潜在冲突。

创建虚拟环境后，可以使用以下命令激活它：

source .venv/bin/activate

要安装的库

对于我们正在构建的项目，我们不需要太多的包。我们只需要：

• GPT4All的Python绑定
• Langchain与我们的文档进行交互

LangChain是一个基于语言模型的应用程序开发框架。它不仅允许您通过API调用语言模型，还可以将语言模型连接到其他数据源，并允许语言模型与其环境进行交互。

pip install pygpt4all==1.0.1
pip install pyllamacpp==1.0.6
pip install langchain==0.0.149
pip install unstructured==0.6.5
pip install pdf2image==1.16.3
pip install pytesseract==0.3.10
pip install pypdf==3.8.1
pip install faiss-cpu==1.7.4

在LangChain上，我们指定了版本。这个库最近接收了很多更新，所以为了确保我们的设置明天也能正常工作，最好指定一个我们知道能正常工作的版本。Unstructured是pdf加载器、pytesseract和pdf2image所必需的依赖项。

注意：在GitHub存储库中，有一个requirements.txt文件（由jl adcr建议），其中包含与此项目关联的所有版本。您可以通过以下命令将其下载到主项目文件目录中，并一次性进行安装：

pip install -r requirements.txt

在文章末尾，我创建了一个故障排除部分。GitHub存储库还有一个更新的README，包含所有这些信息。

请记住，一些库有可用的版本，取决于您在虚拟环境中运行的python版本。

在您的PC上下载模型

这是一个非常重要的步骤。

对于项目，我们肯定需要GPT4All。在Nomic AI上描述的过程非常复杂，需要我们并非所有人都拥有的硬件（比如我）。因此，这里是链接到已转换并准备好使用的模型的链接。只需点击下载即可。

正如简介中简要描述的那样，我们还需要嵌入模型，一个可以在我们的CPU上运行而不会崩溃的模型。点击此链接下载已经转换为4位并准备好用作我们嵌入模型的alpaca-native-7B-ggml模型。

为什么我们需要嵌入模型？如果您还记得流程图，收集知识库文档后，第一步是将它们嵌入。来自Alpaca模型的LLamaCPP嵌入完美地适合这项工作，而且这个模型也非常小（4 Gb）。顺便说一句，您也可以将Alpaca模型用于QnA！

更新2023.05.25：许多Windows用户在使用llamaCPP嵌入时遇到问题。这主要是因为在使用以下命令安装llama-cpp-python时：

pip install llama-cpp-python

pip软件包将从源代码编译该库。Windows通常不会默认在计算机上安装CMake或C编译器。但不用担心，有解决办法。

在Windows上运行llama-cpp-python的安装，需要使用llamaEmbeddings的LangChain，CMake C编译器默认未安装，因此无法从源代码构建。

在具有Xtools的Mac用户和Linux上，通常C编译器已经可用于操作系统。

为避免这个问题，您必须使用预编译的wheel。

前往https://github.com/abetlen/llama-cpp-python/releases

并寻找适用于您体系结构和python版本的编译好的wheel版本 – 您必须选择Weels版本0.1.49，因为更高版本不兼容。

在我的情况下，我有Windows 10、64位、python 3.10

所以我的文件是llama_cpp_python-0.1.49-cp310-cp310-win_amd64.whl

这个问题在GitHub存储库中被跟踪。

下载后，您需要将这两个模型放入models目录中，如下所示。

与GPT4All的基本交互

由于我们想要控制与 GPT 模型的交互，我们必须创建一个 Python 文件（我们称其为 pygpt4all_test.py），导入依赖项并向模型提供指令。你会发现这很容易。

from pygpt4all.models.gpt4all import GPT4All

这是我们模型的 Python 绑定。现在我们可以调用它并开始提问。让我们试一个有创意的。

我们创建一个函数来读取模型的回调，然后我们要求 GPT4All 完成我们的句子。

def new_text_callback(text):
    print(text, end="")

model = GPT4All('./models/gpt4all-converted.bin')
model.generate("从前有一只猫，", n_predict=55, new_text_callback=new_text_callback)

第一条语句告诉我们的程序在哪里找到模型（记住我们在上面的部分所做的）

第二个语句要求模型生成一个响应并完成我们的提示“从前有一只猫，”。

要运行它，请确保虚拟环境仍处于激活状态，然后运行：

python3 pygpt4all_test.py

你应该会看到模型的加载文本和句子的完成。根据您的硬件资源，可能需要一些时间。

结果可能与您的不同… 但对我们来说重要的是它正在工作，我们可以继续使用 LangChain 创建一些高级内容。

注意（更新于 2023.05.23）：如果你遇到与 pygpt4all 相关的错误，请检查本主题的故障排除部分，其中包含 Rajneesh Aggarwal 或 Oscar Jeong 给出的解决方案。

GPT4All 上的 LangChain 模板

LangChain 框架是一个非常惊人的库。它提供了组件以易于使用的方式处理语言模型，并且还提供了链。链可以被视为以特定方式组装这些组件，以最好地完成特定用例。这些旨在成为一个更高级别的接口，通过这个接口，人们可以轻松地开始使用特定的用例。这些链也被设计为可定制的。

在我们的下一个 Python 测试中，我们将使用一个提示模板。语言模型以文本作为输入——这个文本通常不是一个硬编码的字符串，而是一个模板、一些示例和用户输入的组合。LangChain 提供了几个类和函数，使构建和处理提示变得容易。让我们也看看如何做。

创建一个新的 Python 文件并将其命名为 my_langchain.py

# 导入 langchain Prompt Template 和 Chain
from langchain import PromptTemplate, LLMChain

# 导入 LLM 以便能够直接从 langchain 与 GPT4All 交互
from langchain.llms import GPT4All

# 回调管理器是响应处理所需的 
from langchain.callbacks.base import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

local_path = './models/gpt4all-converted.bin' 
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])

我们从 LangChain 导入 Prompt Template 和 Chain，以及 GPT4All llm 类，以便能够直接与我们的 GPT 模型交互。

然后，在设置我们的 llm 路径之后，我们实例化回调管理器，以便我们能够捕捉对我们查询的回应。

创建模板非常容易：根据文档教程，我们可以使用这样的东西…

template = """问题: {question}

答案: 让我们逐步考虑一下。

"""
prompt = PromptTemplate(template=template, input_variables=["question"])

模板变量是一个多行字符串，包含我们与模型的交互结构：在大括号中，我们插入模板的外部变量，在我们的场景中是我们的问题。

由于它是一个变量，你可以决定它是一个硬编码问题还是一个用户输入问题：这里是两个示例。

# 硬编码问题
question = "在莱昂纳多·迪卡普里奥出生的那一年，哪位一级方程式车手获得了冠军？"

# 用户输入问题...
question = input("输入你的问题：")

在我们的测试运行中，我们将评论用户输入。现在我们只需要将我们的模板、问题和语言模型链接在一起。

template = """问题: {question}
回答: 让我们一步一步地想一想。
"""

prompt = PromptTemplate(template=template, input_variables=["question"])

# 初始化 GPT4All 实例
llm = GPT4All(model=local_path, callback_manager=callback_manager, verbose=True)

# 将语言模型与我们的提示模板链接起来
llm_chain = LLMChain(prompt=prompt, llm=llm)

# 硬编码问题
question = "在莱昂纳多·迪卡普里奥出生的那一年，哪个一级方程式车手赢得了冠军？"

# 用户输入问题…
# question = input("输入你的问题：")

# 运行查询并获取结果
llm_chain.run(question)

记得验证你的虚拟环境是否仍然处于启用状态，并运行以下命令：

python3 my_langchain.py

你可能会得到与我的不同的结果。令人惊奇的是，你可以看到 GPT4All 尝试为你获取答案的整个推理过程。调整问题可能会给你更好的结果。

在 GPT4All 上使用提示模板的 Langchain

使用 Langchain 和 GPT4All 回答关于你的文档的问题

这里我们开始神奇的部分，因为我们将使用 GPT4All 作为一个聊天机器人来回答我们的问题，并与我们的文档交流。

与 GPT4All 的 QnA 工作流程相应的步骤序列是加载我们的 pdf 文件，将它们分成块。之后，我们需要一个向量存储器来嵌入我们的文档。我们需要将我们的分块文档馈送到向量存储器中进行信息检索，然后将它们与这个数据库上的相似性搜索一起嵌入，作为我们的 LLM 查询的上下文。

为此，我们将直接使用 Langchain 库中的 FAISS。FAISS 是 Facebook AI Research 的开源库，旨在快速查找高维数据集合中相似的项。它提供索引和搜索方法，使在数据集内更容易、更快速地查找最相似的项。它对我们来说特别方便，因为它简化了信息检索，并允许我们在本地保存所创建的数据库：这意味着在第一次创建之后，任何进一步的使用都将非常快速地加载。

向量索引数据库的创建

创建一个新文件并将其命名为 my_knowledge_qna.py

from langchain import PromptTemplate, LLMChain
from langchain.llms import GPT4All
from langchain.callbacks.base import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

# 仅加载 TXT 文件的函数
from langchain.document_loaders import TextLoader

# 用于创建块的文本拆分器
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 为了能够加载 pdf 文件
from langchain.document_loaders import UnstructuredPDFLoader
from langchain.document_loaders import PyPDFLoader
from langchain.document_loaders import DirectoryLoader

# 向量存储器索引，用于创建我们关于知识的数据库
from langchain.indexes import VectorstoreIndexCreator

# LLamaCpp 嵌入来自 Alpaca 模型
from langchain.embeddings import LlamaCppEmbeddings

# 用于相似性搜索的 FAISS 库
from langchain.vectorstores.faiss import FAISS

import os  #用于与文件交互
import datetime

前几个库与我们之前使用的相同：此外，我们使用 Langchain 进行向量存储器索引的创建，使用 LlamaCppEmbeddings 与我们的 Alpaca 模型进行交互（以 4 位量化并使用 cpp 库进行编译），以及 PDF 加载程序。

让我们也使用它们各自的路径加载我们的 LLMs。

# 分配 GPT4All 和 Alpaca 嵌入的路径
gpt4all_path = './models/gpt4all-converted.bin' 
llama_path = './models/ggml-model-q4_0.bin' 
# 用于处理与模型的调用的 Calback 管理器
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])

# 创建嵌入对象
embeddings = LlamaCppEmbeddings(model_path=llama_path)
# 创建 GPT4All llm 对象
llm = GPT4All(model=gpt4all_path, callback_manager=callback_manager, verbose=True)

为了测试，让我们看看我们是否成功读取了所有的pdf文件：第一步是声明3个函数，用于处理每个单独的文档。第一个函数是将提取的文本拆分成块，第二个函数是创建元数据向量索引（如页面编号等），最后一个函数是用于测试相似性搜索（稍后会更好地解释）。

# 拆分文本
def split_chunks(sources):
    chunks = []
    splitter = RecursiveCharacterTextSplitter(chunk_size=256, chunk_overlap=32)
    for chunk in splitter.split_documents(sources):
        chunks.append(chunk)
    return chunks


def create_index(chunks):
    texts = [doc.page_content for doc in chunks]
    metadatas = [doc.metadata for doc in chunks]

    search_index = FAISS.from_texts(texts, embeddings, metadatas=metadatas)

    return search_index


def similarity_search(query, index):
    # k是与查询匹配的相似性搜索数量，默认为4
    matched_docs = index.similarity_search(query, k=3) 
    sources = []
    for doc in matched_docs:
        sources.append(
            {
                "page_content": doc.page_content,
                "metadata": doc.metadata,
            }
        )

    return matched_docs, sources

现在，我们可以测试文档目录中文档的索引生成：我们需要把所有的pdf文件都放在那里。Langchain还有一种方法可以加载整个文件夹，无论文件类型如何：由于后期处理比较复杂，我将在下一篇关于LaMini模型的文章中介绍它。

我的文档目录包含4个pdf文件

我们将把我们的函数应用于列表中的第一个文档

# 获取pdf文件列表
pdf_folder_path = './docs'
doc_list = [s for s in os.listdir(pdf_folder_path) if s.endswith('.pdf')]
num_of_docs = len(doc_list)
# 创建PDF加载器
loader = PyPDFLoader(os.path.join(pdf_folder_path, doc_list[0]))
# 使用Langchain加载文档
docs = loader.load()
# 拆分块
chunks = split_chunks(docs)
# 创建向量索引数据库
db0 = create_index(chunks)

在前几行中，我们使用os库来获取docs目录中的pdf文件列表。然后，我们使用Langchain从docs文件夹中加载第一个文档（ doc_list[0] ），拆分为块，然后使用LLama嵌入创建向量数据库。

正如您所看到的，我们正在使用pyPDF方法。这个方法使用起来有点长，因为你必须一个一个地加载文件，但是使用pypdf将PDF加载到文档数组中允许你有一个数组，其中每个文档都包含页面内容和元数据，包括page编号。当您想知道我们将用查询给GPT4All的上下文的来源时，这非常方便。这里是来自readthedocs的示例：

Langchain文档的截图

我们可以通过以下命令从终端运行python文件：

python3 my_knowledge_qna.py

在嵌入模型加载完成后，您将看到索引的令牌正在工作：不要惊慌，因为它需要时间，尤其是如果您像我一样只在CPU上运行（需要8分钟）。

第一个向量数据库的完成

正如我所解释的，pyPDF方法速度较慢，但为我们提供了相似性搜索的额外数据。为了迭代所有文件，我们将使用FAISS的一个方便的方法，它允许我们将不同的数据库合并在一起。现在我们使用上面的代码生成第一个数据库（我们称之为db0），然后用for循环创建列表中的下一个文件的索引，并立即将其与db0合并。

以下是代码：请注意，我添加了一些日志，以便使用datetime.datetime.now()获取进度状态，并打印结束时间与开始时间的时间差以计算操作花费的时间（如果您不喜欢，可以将其删除）。

合并指令如下

# 将dbi与现有的db0合并
db0.merge_from(dbi)

最后一条指令之一是将我们的数据库本地保存：整个生成过程甚至可能需要几个小时（取决于您有多少文档），因此我们只需要执行一次，这真的很好！

# 将数据库保存在本地
db0.save_local("my_faiss_index")

这里是整个代码。 当我们直接从文件夹中加载索引与GPT4All交互时，我们将对其进行许多注释。

# 从文档目录中获取pdf文件列表，并以列表格式存储
pdf_folder_path = './docs'
doc_list = [s for s in os.listdir(pdf_folder_path) if s.endswith('.pdf')]
num_of_docs = len(doc_list)
# 从路径创建PDF的加载器
general_start = datetime.datetime.now() #现在没有使用，但有用
print("starting the loop...")
loop_start = datetime.datetime.now() #现在没有使用，但有用
print("generating fist vector database and then iterate with .merge_from")
loader = PyPDFLoader(os.path.join(pdf_folder_path, doc_list[0]))
docs = loader.load()
chunks = split_chunks(docs)
db0 = create_index(chunks)
print("Main Vector database created. Start iteration and merging...")
for i in range(1,num_of_docs):
    print(doc_list[i])
    print(f"loop position {i}")
    loader = PyPDFLoader(os.path.join(pdf_folder_path, doc_list[i]))
    start = datetime.datetime.now() #现在没有使用，但有用
    docs = loader.load()
    chunks = split_chunks(docs)
    dbi = create_index(chunks)
    print("start merging with db0...")
    db0.merge_from(dbi)
    end = datetime.datetime.now() #现在没有使用，但有用
    elapsed = end - start #现在没有使用，但有用
    #total time
    print(f"completed in {elapsed}")
    print("-----------------------------------")
loop_end = datetime.datetime.now() #现在没有使用，但有用
loop_elapsed = loop_end - loop_start #现在没有使用，但有用
print(f"All documents processed in {loop_elapsed}")
print(f"the daatabase is done with {num_of_docs} subset of db index")
print("-----------------------------------")
print(f"Merging completed")
print("-----------------------------------")
print("Saving Merged Database Locally")
# 将数据库保存在本地
db0.save_local("my_faiss_index")
print("-----------------------------------")
print("merged database saved as my_faiss_index")
general_end = datetime.datetime.now() #现在没有使用，但有用
general_elapsed = general_end - general_start #现在没有使用，但有用
print(f"All indexing completed in {general_elapsed}")
print("-----------------------------------")

运行Python文件花费了22分钟

向GPT4All提问您的文档

现在我们在这里。 我们有我们的索引，可以加载它，并使用Prompt Template询问GPT4All回答我们的问题。 我们从一个硬编码的问题开始，然后我们将循环遍历我们的输入问题。

将以下代码放入Python文件db_loading.py中，并使用终端命令python3 db_loading.py运行它

from langchain import PromptTemplate, LLMChain
from langchain.llms import GPT4All
from langchain.callbacks.base import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
# 加载仅TXT文件的函数
from langchain.document_loaders import TextLoader
# 创建块的文本拆分器
from langchain.text_splitter import RecursiveCharacterTextSplitter
# 为了能够加载pdf文件
from langchain.document_loaders import UnstructuredPDFLoader
from langchain.document_loaders import PyPDFLoader
from langchain.document_loaders import DirectoryLoader
# 创建关于我们知识的数据库的向量存储索引
from langchain.indexes import VectorstoreIndexCreator
# LLamaCpp Alpaca模型的嵌入
from langchain.embeddings import LlamaCppEmbeddings
# 用于相似性搜索的FAISS库
from langchain.vectorstores.faiss import FAISS
import os  # 用于与文件交互
import datetime

# 相似性搜索测试

# 为嵌入分配2个模型GPT4All和Alpaca的路径
gpt4all_path = './models/gpt4all-converted.bin' 
llama_path = './models/ggml-model-q4_0.bin' 
# CallbackManager用于处理与模型的调用
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])

# 创建嵌入对象
embeddings = LlamaCppEmbeddings(model_path=llama_path)
# 创建GPT4All llm对象
llm = GPT4All(model=gpt4all_path, callback_manager=callback_manager, verbose=True)

# 拆分文本
def split_chunks(sources):
    chunks = []
    splitter = RecursiveCharacterTextSplitter(chunk_size=256, chunk_overlap=32)
    for chunk in splitter.split_documents(sources):
        chunks.append(chunk)
    return chunks


def create_index(chunks):
    texts = [doc.page_content for doc in chunks]
    metadatas = [doc.metadata for doc in chunks]

    search_index = FAISS.from_texts(texts, embeddings, metadatas=metadatas)

    return search_index


def similarity_search(query, index):
    # k是匹配查询的相似度搜索数
    # 默认值为4
    matched_docs = index.similarity_search(query, k=3) 
    sources = []
    for doc in matched_docs:
        sources.append(
            {
                "page_content": doc.page_content,
                "metadata": doc.metadata,
            }
        )

    return matched_docs, sources

# 加载我们的本地索引向量数据库
index = FAISS.load_local("my_faiss_index", embeddings)
# 硬编码的问题
query = "PLC是什么，与PC有什么区别"
docs = index.similarity_search(query)
# 获取匹配的前3个结果 - 在函数k = 3中定义
print(f"问题是：{query}")
print("这是在索引上进行语义搜索的结果，没有GPT4All..")
print(docs[0])

打印的文本是与查询最匹配的前 3 个来源的列表，还给出了文档名称和页码。

现在我们可以使用相似性搜索作为查询的上下文，使用提示模板替换所有代码。在 3 个函数之后，只需将所有代码替换为以下内容：

# Load our local index vector db
index = FAISS.load_local("my_faiss_index", embeddings)

# create the prompt template
template = """
请使用以下上下文回答问题。
上下文：{context}
---
问题：{question}
答案：让我们一步一步地思考。"""

# Hardcoded question
question = "PLC 是什么，与 PC 有什么区别"
matched_docs, sources = similarity_search(question, index)
# Creating the context
context = "\n".join([doc.page_content for doc in matched_docs])
# instantiating the prompt template and the GPT4All chain
prompt = PromptTemplate(template=template, input_variables=["context", "question"]).partial(context=context)
llm_chain = LLMChain(prompt=prompt, llm=llm)
# Print the result
print(llm_chain.run(question))

运行后，您将获得类似于此类的结果（但可能会有所不同）。很棒，不是吗？？？

请使用以下上下文回答问题。
上下文：1. 什么是 PLC
2. PLC 的使用场合和原因
3. PLC 与 PC 的区别
PLC 尤其在安全和可靠性至关重要的行业中非常重要，例如制造工厂、化工厂和电力厂。
PLC 与 PC 的区别
因为 PLC 是专门用于工业和制造应用的计算机，用于控制机器和过程，因此典型 PLC 的硬件组件必须能够与工业设备进行交互。因此，典型的 PLC 硬件包括：
---
问题：PLC 是什么，与 PC 有什么区别
答案：让我们一步一步地思考。1）可编程逻辑控制器（PLC），也称为工业控制系统或 ICS，是指控制各种自动化过程的工业计算机，例如通过与之连接的传感器和执行器控制制造机器/装配线等。它是一种具有多个指令执行（MIE）能力的数字计算机，由软件例程使用的内置存储器寄存器，输入输出接口卡（IOC）与其他设备进行电子/数字通信（例如通过网络或总线等）等。
2）可编程逻辑控制器广泛应用于工业自动化，因为它具有多个指令执行的能力。它可以自动执行任务和编程指令，这使其能够执行超出个人计算机（PC）容量的复杂操作。因此，ICS/PLC 包含由软件例程或固件代码使用的内置存储器寄存器，而 PC 不包含它们，因此它们需要外部接口（例如硬盘驱动器（HDD）、USB 端口、串行和并行通信协议）来存储数据以供进一步分析或报告生成。

如果您想使用用户输入的问题替换该行

question = "What is a PLC and what is the difference with a PC"

请使用以下内容之一：

question = input("您的问题：")

结论

现在是您进行实验的时候了。询问与您的文档相关的所有主题的不同问题，并查看结果。肯定有大量的改进空间，尤其是在提示和模板方面：您可以在此处查看一些灵感。但是 Langchain 文档真的很出色（我可以跟上它！！）。

您可以按照文章中的代码或在我的 github 存储库中检查它。

Fabio Matricardi 是一位教育家、教师、工程师和学习爱好者。他已经教了 15 年的年轻学生，现在他在 Key Solution Srl 培训新员工。他在 2010 年开始了自己的工业自动化工程师职业生涯。自从他还是青少年时，就对编程充满热情，他发现构建软件和人机界面带来了生命的美感。教学和辅导是他每天例行工作的一部分，他还学习和学习如何成为一个充满激情的领导者，具有最新的管理技能。加入我，踏上通向更好的设计、预测性系统集成以及机器学习和人工智能贯穿整个工程生命周期的旅程。

原始文章。经授权转载。