【大模型从入门到精通37】开源库框架LangChain 利用LangChain构建聊天机器人4

实践

创建并填充向量存储

def embed_document(document_text):
    """
    占位符函数用于文档嵌入。
    在真实场景中，此函数会将文档文本转换为数值向量。
    """
    return [hash(document_text) % 100]  # 模拟嵌入以供演示用途

def create_vector_store(documents):
    """
    将一系列文档转换为嵌入，并将它们存储在一个简单的内存结构中。

    参数:
        documents (list of str): 要转换为嵌入的文档文本列表。

    返回:
        list: 表示输入文档的嵌入列表。
    """
    vector_store = [embed_document(doc) for doc in documents]
    return vector_store

# 示例用法
documents = [
    "这是文档1的内容。",
    "这是文档2的内容，可能有所不同。",
    "这是第三个文档。"
]
vector_store = create_vector_store(documents)
print("向量存储:", vector_store)

带有语义搜索的高级检索

def calculate_similarity(query_embedding, document_embedding):
    """
    占位符函数用于计算两个嵌入之间的相似度。
    实际上，这可能会使用余弦相似度、欧几里得距离等。

    参数:
        query_embedding (list): 查询的嵌入。
        document_embedding (list): 文档的嵌入。

    返回:
        float: 查询与文档之间的模拟相似度分数。
    """
    # 简化相似度计算以供演示
    return -abs(query_embedding[0] - document_embedding[0])

def perform_semantic_search(query, vector_store):
    """
    执行语义搜索以找到与查询最相似的文档在向量存储中的位置。

    参数:
        query (str): 搜索查询。
        vector_store (list): 存储文档嵌入的内存结构。

    返回:
        int: 向量存储中最相似文档的索引。
    """
    query_embedding = embed_document(query)
    similarity_scores = [calculate_similarity(query_embedding, doc_embedding) for doc_embedding in vector_store]

    # 查找最高相似度分数的索引
    most_similar_index = similarity_scores.index(max(similarity_scores))
    return most_similar_index

# 示例用法
query = "与文档1更相似的文档内容。"
most_similar_doc_index = perform_semantic_search(query, vector_store)
print("最相似的文档索引:", most_similar_doc_index)

将聊天历史纳入响应生成

class Chatbot:
    def __init__(self):
        # 初始化一个空列表来存储聊天历史，其中每个元素都是一个元组 (query, response)
        self.history = []

    def generate_response(self, query, context):
        """
        占位符函数用于模拟基于当前查询和上下文的响应生成。

        参数:
            query (str): 用户当前的查询。
            context (list of tuples): 聊天历史，其中每个元组包含一个 (query, response) 对。

        返回:
            str: 模拟的响应。
        """
        # 为了简化，响应只是将查询反转，并附带关于过往交互次数的信息
        return f"对'{query}'的响应 (共有{len(context)}次过往交互)。"

    def respond_to_query(self, query):
        """
        接受用户的查询作为输入，根据聊天历史生成响应，并更新历史记录。

        参数:
            query (str): 用户的查询。

        返回:
            str: 生成的响应。
        """
        # 使用当前的历史状态作为上下文生成响应
        response = self.generate_response(query, self.history)

        # 更新聊天历史记录，加入当前的查询和响应
        self.history.append((query, response))

        return response

# 示例用法
chatbot = Chatbot()
print(chatbot.respond_to_query("你好，你怎么样？"))
print(chatbot.respond_to_query("今天天气怎么样？"))
print(chatbot.respond_to_query("谢谢！"))

构建对话检索链

class LanguageModel:
    def predict(self, input_text):
        # 占位符预测方法
        return f"模拟响应: {input_text}"

class DocumentRetriever:
    def retrieve(self, query):
        # 占位符文档检索方法
        return f"模拟文档，与之相关: {query}"

class ConversationMemory:
    def __init__(self):
        self.memory = []

    def add_to_memory(self, query, response):
        self.memory.append((query, response))

    def reset_memory(self):
        self.memory = []

    def get_memory(self):
        return self.memory

def setup_conversational_retrieval_chain():
    # 初始化检索链的各个组件
    language_model = LanguageModel()
    document_retriever = DocumentRetriever()
    conversation_memory = ConversationMemory()

    # 为了演示目的，此函数将仅返回一个字典
    # 代表初始化的组件。在真实的实现中，
    # 这些组件将被整合到一个更复杂的检索系统中。
    retrieval_chain = {
        "language_model": language_model,
        "document_retriever": document_retriever,
        "conversation_memory": conversation_memory
    }

    return retrieval_chain

# 示例用法
retrieval_chain = setup_conversational_retrieval_chain()
print(retrieval_chain)

增强型聊天机器人

class EnhancedChatbot(Chatbot):
    def __init__(self):
        super().__init__()
        # 使用来自上一个任务的`ConversationMemory`管理聊天历史
        self.conversation_memory = ConversationMemory()

    def add_to_history(self, query, response):
        """
        将新的条目添加到对话历史中。

        参数:
            query (str): 用户的查询。
            response (str): 聊天机器人的响应。
        """
        self.conversation_memory.add_to_memory(query, response)

    def reset_history(self):
        """
        重置对话历史，清除所有过往交互。
        """
        self.conversation_memory.reset_memory()

    def respond_to_query(self, query):
        """
        重写方法以合并对话记忆管理。
        """
        # 根据更新的历史生成响应
        response = super().generate_response(query, self.conversation_memory.get_memory())

        # 更新对话历史，加入新的交互
        self.add_to_history(query, response)

        return response

# 示例用法
enhanced_chatbot = EnhancedChatbot()
print(enhanced_chatbot.respond_to_query("你好，你怎么样？"))
enhanced_chatbot.reset_history()
print(enhanced_chatbot.respond_to_query("开始新的对话。"))

基于文档分块的问答系统

def embed_document(document_text):
    # 占位符函数用于模拟文档文本嵌入
    return sum(ord(char) for char in document_text) % 100  # 简单哈希用于演示

def split_document_into_chunks(document, chunk_size=100):
    # 将文档文本分割成可管理的块
    return [document[i:i+chunk_size] for i in range(0, len(document), chunk_size)]

def perform_semantic_search(query_embedding, vector_store):
    # 根据嵌入相似性查找最相关的文档块（占位符逻辑）
    similarities = [abs(query_embedding - chunk_embedding) for chunk_embedding in vector_store]
    return similarities.index(min(similarities))

def generate_answer_from_chunk(chunk):
    # 占位符函数用于模拟从选定文档块生成答案
    return f"根据您的问题，相关信息是: \"{chunk[:50]}...\""

# 主问答系统逻辑
document = "这是一篇很长的文章。 " * 100  # 模拟文档
chunks = split_document_into_chunks(document, 100)
vector_store = [embed_document(chunk) for chunk in chunks]

# 模拟用户提问及其嵌入
user_question = "这篇文档讲的是什么？"
question_embedding = embed_document(user_question)

# 找到最相关的块
relevant_chunk_index = perform_semantic_search(question_embedding, vector_store)
relevant_chunk = chunks[relevant_chunk_index]

# 根据最相关的块生成答案
answer = generate_answer_from_chunk(relevant_chunk)
print(answer)

集成记忆系统的对话检索链

def integrate_memory_with_retrieval_chain(retrieval_chain, user_query):
    """
    将对话检索链与记忆系统集成以保持上下文。

    参数:
        retrieval_chain (dict): 包含语言模型、文档检索器和对话记忆的模拟检索链。
        user_query (str): 要处理的用户的查询。
    """
    # 从检索链中获取组件
    conversation_memory = retrieval_chain["conversation_memory"]
    language_model = retrieval_chain["language_model"]
    document_retriever = retrieval_chain["document_retriever"]

    # 模拟使用文档检索器找到相关信息
    relevant_info = document_retriever.retrieve(user_query)

    # 获取对话历史作为上下文
    context = conversation_memory.get_memory()

    # 模拟使用语言模型根据查询和上下文生成响应
    response = language_model.predict(f"查询: {user_query}, 上下文: {context}, 相关信息: {relevant_info}")

    # 更新对话记忆，加入新的交互
    conversation_memory.add_to_memory(user_query, response)

    return response

# 使用来自任务4的检索链和一个示例查询以供演示
dummy_query = "请告诉我更多关于这篇文档的信息。"
response = integrate_memory_with_retrieval_chain(retrieval_chain, dummy_query)
print("生成的响应:", response)

命令行界面聊天机器人

def chatbot_cli():
    enhanced_chatbot = EnhancedChatbot()  # 假设EnhancedChatbot是从前面的任务中扩展而来的版本

    while True:
        print("\n选项: ask [问题], 查看历史, 重置历史, 退出")
        user_input = input("你想做什么？ ").strip().lower()

        if user_input.startswith("ask "):
            question = user_input[4:]
            response = enhanced_chatbot.respond_to_query(question)
            print("聊天机器人:", response)
        elif user_input == "查看历史":
            for i, (q, a) in enumerate(enhanced_chatbot.conversation_memory.get_memory(), 1):
                print(f"{i}. 问: {q} 答: {a}")
        elif user_input == "重置历史":
            enhanced_chatbot.reset_history()
            print("对话历史已重置。")
        elif user_input == "退出":
            break
        else:
            print("无效选项。请再次尝试。")

# 要运行CLI，只需调用该函数（注释掉以防止在非交互环境中执行）
# chatbot_cli()

以上代码展示了如何进一步扩展聊天机器人功能，包括增强型聊天机器人的实现、基于文档分块的问答系统、集成记忆系统的对话检索链以及一个命令行界面聊天机器人。这些实例提供了更深入的理解和应用能力。