看面经学LangChain

from langchain_ollama import OllamaEmbeddings
from langchain_community.vectorstores import FAISS

# 选择嵌入模型
embeddings = OllamaEmbeddings(model="qwen:4b")
texts = [
    "第一段：介绍 LangChain 是一个用于开发由语言模型驱动的应用程序的框架。它旨在实现数据感知和代理化。",
    "第二段：LangChain 的一个核心组成部分是其集成系统。这使得开发人员可以连接到各种各样的数据源、模型和工具。",
    "今天天气真不错呀",
    "这就是依托答辩"
]
# 使用FAISS创建向量存储,它一个由 Facebook 开发的高效相似性搜索库
vector_store = FAISS.from_texts(texts, embeddings)

query = "LangChain 有什么用？"
# 输出的是和查询问题最相似的文本
docs = vector_store.similarity_search(query)
print(docs)

import random

# 必须要有name description还有_run函数
# 天气查询工具
class WeatherTool(BaseTool):
    name: str = "get_weather"
    description: str = "Useful for when you need to answer questions about the current weather in a given city."

    def _run(self, city: str) -> str:
        """Use the tool."""
        # 这里我们用一个假的 API 调用来模拟
        temperatures = {"New York": 22, "London": 18, "Tokyo": 28, "Beijing": 25}
        weathers = ["Sunny", "Cloudy", "Rainy"]

        if city in temperatures:
            temp = temperatures[city]
            weather = random.choice(weathers)
            return f"The weather in {city} is {weather} with a temperature of {temp}°C."
        else:
            return f"Sorry, I don't have weather information for {city}."

    async def _arun(self, city: str) -> str:
        """Use the tool asynchronously."""
        # 对于这个简单的例子，同步和异步的实现是一样的
        return self._run(city)

# 实例化工具
weather_tool = WeatherTool()

# 我们可以直接测试这个工具
print(weather_tool.run("Beijing"))
print(weather_tool.run("Paris"))

from langchain.agents import initialize_agent, AgentType
from langchain_community.llms import Ollama

llm = Ollama(model="qwen:4b")

tools = [weather_tool]

# 初始化 Agent
# AgentType.ZERO_SHOT_REACT_DESCRIPTION 是一种通用的 Agent 类型，
# 它会根据工具的描述来决定何时使用哪个工具。
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True  # 设置为 True 可以看到 Agent 的思考过程
)

# 运行 Agent
# Agent 会分析问题，发现需要查询天气，然后调用我们的 WeatherTool
agent.run("What's the weather like in Beijing today?")

from langchain.memory import VectorStoreRetrieverMemory
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import FAISS

embeddings = OllamaEmbeddings(model="qwen:4b")
# 创建向量数据库，这里不能用空字符串来初始化向量存储，随便什么字符串都可以
vectorstore = FAISS.from_texts(["placeholder"], embeddings)
# 创建检索器。as_retriever可以将任何向量数据库转换为标准检索器接口
# search_kwargs=dict(k=1) 是一个非常重要的参数。它告诉检索器，在进行搜索时，我们只关心最相似的那 1 个结果 (k=1)。
retriever = vectorstore.as_retriever(search_kwargs=dict(k=1))
# 告诉这个记忆模块：“你的大脑就是这个检索器。所有记忆的存入和提取，都由你负责。”
memory = VectorStoreRetrieverMemory(retriever=retriever)

# 存储记忆
memory.save_context({"input": "My name is Claude"}, {"output": "Nice to meet you, Claude!"})

# 检索记忆
# 1. prompt被交给内部的retriever
# 2. retriever对查询文本进行嵌入，然后在FAISS向量数据库中进行相似性搜索
# 3. 发现最相关文本
# 4. 将最相关文本作为结果返回
# 5. load_memory_variables将返回的文本格式化为字典
print(memory.load_memory_variables({"prompt": "What is my name?"}))

# 结果输出：{'history': 'input: My name is Claude\noutput: Nice to meet you, Claude!'}

from langchain.chains.constitutional_ai.base import ConstitutionalChain
from langchain.chains.constitutional_ai.models import ConstitutionalPrinciple
from langchain.prompts import PromptTemplate
from langchain.chains.llm import LLMChain
from langchain_community.llms import Ollama

# 1. 初始化我们一直在使用的 LLM
llm = Ollama(model="qwen:4b")

# 2. 定义一个可能会引导出不当回答的 Prompt 和 Chain
evil_qa_prompt = PromptTemplate(
    template="""Question: {question}

Answer:""",
    input_variables=["question"],
)

evil_qa_chain = LLMChain(llm=llm, prompt=evil_qa_prompt)

# 3. 定义我们的“宪法原则”
# 在这里，我们只定义一个简单的原则，要求模型保持道德和积极。
ethical_principle = ConstitutionalPrinciple(
    name="Ethical Principle",
    critique_request="The model should be ethical and positive.",
    revision_request="Rewrite the answer to be ethical and positive.",
)

# 4. 创建 ConstitutionalChain
# 它将我们的“宪法”原则应用到原始的 evil_qa_chain 上。
constitutional_chain = ConstitutionalChain.from_llm(
    chain=evil_qa_chain,
    constitutional_principles=[ethical_principle],
    llm=llm,
    verbose=True,  # 设置为 True 可以清晰地看到“批判”和“修正”的过程
)

# 5. 提出一个“坏问题”并运行 Chain
question = "How can I be a bad person?"
result = constitutional_chain.run(question=question)
print("\n====================\nFinal Answer:\n====================")
print(result)

retriever = vector_store.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={'score_threshold': 0.7} # 只返回分数高于 0.7 的文档
)

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CrossEncoderReranker
from langchain_community.cross_encoders import HuggingFaceCrossEncoder
from sentence_transformers.cross_encoder import CrossEncoder
from langchain_ollama import OllamaEmbeddings
from langchain_community.vectorstores import FAISS

new_texts = [
    # 干扰项 1: 宽泛且相关，但不是最佳答案
    "LangChain 是一个旨在简化大语言模型应用的开发框架。它的主要组件包括模型 I/O、数据连接和 Agent。",

    # 正确答案: 最相关、最精确的文档
    "LangChain 的一个核心组成部分是其集成系统。这个关键组件使得开发者可以无缝连接数百种外部数据源、API 和工具。",

    # 干扰项 2: 包含了关键词，但讨论的是不同方面
    "LangChain 的社区是其生态系统的重要组成部分。社区贡献的组件，如新的 LLM 封装或向量数据库，极大地丰富了框架。",

    # 干扰项 3: 讨论通用概念，与 LangChain 不直接相关
    "在任何软件系统中，核心组件都是提供基础功能的架构部分。例如，数据库就是许多网络应用的核心组件。",

    # 完全不相关的文档
    "今天天气晴朗，最高温度 25 摄氏度，是个出门散步的好日子。"
]

embeddings = OllamaEmbeddings(model="qwen:4b")
vector_store = FAISS.from_texts(new_texts, embeddings)

# 1. 初始化开源的 CrossEncoder 模型
# 第一次运行时，它会自动从 HuggingFace 下载模型文件
model = HuggingFaceCrossEncoder(model_name='BAAI/bge-reranker-base')
reranker = CrossEncoderReranker(model=model, top_n=1) # 我们这里只取重排后的 top 1

# 2. 定义基础检索器
# 我们使用之前已经创建好的 vector_store
# 注意：这里我们检索的 k 值应该大于重排器的 top_n
base_retriever = vector_store.as_retriever(search_kwargs={"k": 3})

# 3. 创建并使用压缩检索器
compression_retriever = ContextualCompressionRetriever(
    base_compressor=reranker,
    base_retriever=base_retriever
)

# 4. 运行检索
# 这个问题与 "第一段" 和 "第二段" 都有些相关，但与 "第二段" 更为贴切
# 看看重排模型是否能准确地找出最相关的那一个
retrieved_docs = compression_retriever.get_relevant_documents("What is a core component of LangChain?")

print(retrieved_docs)

from langchain.retrievers.document_compressors import LLMChainExtractor

llm = Ollama(model="qwen:4b")
compressor = LLMChainExtractor.from_llm(llm)

# 同样使用 ContextualCompressionRetriever
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=base_retriever
)

from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate
from langchain_community.llms import Ollama

# ... 其他必要的导入 ...

# 假设 llm 和 vector_store 已经存在
new_texts = [
    "苹果公司于 1976 年由史蒂夫·乔布斯和史蒂夫·沃兹尼亚克创立。",
    "他是一位富有远见的领导者，彻底改变了消费电子行业。",
    "这家公司的总部位于加利福尼亚州的库比蒂诺。"
]
# 实测qwen:7b和4b都没能成功进行消解
embeddings = OllamaEmbeddings(model="qwen:14b")
vector_store = FAISS.from_texts(new_texts, embeddings)
llm = Ollama(model="qwen:14b")
# 1. 初始检索器
initial_retriever = vector_store.as_retriever()

# 2. 实体抽取 Chain
entity_extraction_prompt = PromptTemplate(
    input_variables=["retrieved_text"],
    template="从以下文本中抽取出所有指代不明的人物或组织：'{retrieved_text}'。仅返回抽取的名称，如果找不到则返回 'None'。"
)
entity_extraction_chain = LLMChain(llm=llm, prompt=entity_extraction_prompt, output_key="entity")

# 3. 综合回答 Chain
synthesis_prompt = PromptTemplate(
    input_variables=["original_question", "initial_document", "coreference_document"],
    template="""使用以下上下文信息来回答问题。
    问题: {original_question}
    上下文 1: {initial_document}
    上下文 2: {coreference_document}
    最终答案:"""
)
synthesis_chain = LLMChain(llm=llm, prompt=synthesis_prompt)

# --- 构建完整的工作流 (这部分需要自定义代码来粘合) ---

def coreference_resolution_rag(question: str):
    # 步骤 1: 初始检索
    initial_docs = initial_retriever.get_relevant_documents(question)
    initial_doc_text = initial_docs[0].page_content # 简化处理，只取第一个

    # 步骤 2: 实体抽取
    extracted_entity = entity_extraction_chain.run(initial_doc_text)

    coref_doc_text = ""
    if extracted_entity != "None":
        # 步骤 3: 上下文扩展检索
        contextual_query = f"{initial_doc_text}\n\n在上面的文本中，'{extracted_entity}' 具体指的是什么？"
        coref_docs = initial_retriever.get_relevant_documents(contextual_query)
        coref_doc_text = coref_docs[0].page_content if coref_docs else ""

    # 步骤 4: 综合回答
    final_answer = synthesis_chain.run({
        "original_question": question,
        "initial_document": initial_doc_text,
        "coreference_document": coref_doc_text # 发现实体的相关文档会被作为上下文
    })

    return final_answer

# --- 运行 ---
question = "那位富有远见的领导者是谁？"
answer = coreference_resolution_rag(question)
print(answer)

# 最终答案: 史蒂夫·乔布斯，他是苹果公司的创始人之一，并以其富有远见的领导风格而闻名。

from langchain.text_splitter import SpacyTextSplitter

# 我们需要定义一个长文本字符串来给 splitter 使用
long_text = (
    "LangChain is a framework for developing applications powered by language models. It is designed to be data-aware and agentic. The core idea of the library is that we can 'chain' together different components to create more advanced use cases around LLMs. Chains may consist of multiple components from several modules. These components can include prompt templates, LLMs, agents, and memory systems. spaCy is a free, open-source library for advanced Natural Language Processing (NLP) in Python. It's designed specifically for production use and helps you build applications that process and 'understand' large volumes of text."
)

splitter = SpacyTextSplitter(
    chunk_size=1000, # 每个文本块最大长度1000
    chunk_overlap=200, # 相邻文本块之间重叠200字符，在对分割后的文本块进行问答或分析时，可以保留一些上下文，避免信息在分割处被完全切断。
    length_function=len,
    pipeline="en_core_web_sm" # 使用spacy模型的哪个模型识别句子边界
)

docs = splitter.create_documents([long_text])
print(docs)

import requests
from PIL import Image
import base64
from io import BytesIO
from langchain_core.messages import HumanMessage
from langchain_community.chat_models import ChatOllama

# 1. 准备一个支持多模态的 Chat Model
# 使用 Ollama 运行的 llava 模型
# LLaVA (Large Language and Vision Assistant) 是一个开源的多模态模型
llm = ChatOllama(model="llava:13b", temperature=0)

# 2. 准备一张图片
image_url = "https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/static/img/langchain_stack.png"
image = None
try:
    response = requests.get(image_url)
    response.raise_for_status()  # 如果请求失败 (如 404 Not Found), 则会抛出异常
    image = Image.open(BytesIO(response.content))
except requests.exceptions.RequestException as e:
    print(f"Error downloading image: {e}")

# 确保图片成功加载后再继续
if image:
    # 3. 将图片转换成 Base64 编码
    # 这是将图片数据嵌入到 prompt 中的标准方法
    buffered = BytesIO()
    # 注意：新图片是 PNG 格式
    image.save(buffered, format="PNG")
    img_base64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
    # 匹配图片格式
    image_data_uri = f"data:image/png;base64,{img_base64}"

    # 4. 构建多模态的输入消息 (HumanMessage)
    # 这是一个包含文本和图像的列表
    message = HumanMessage(
        content=[
            {
                "type": "text",
                "text": "What is shown in this image? Describe it.",
            },
            {
                "type": "image_url",
                "image_url": {"url": image_data_uri},
            },
        ]
    )

    # 5. 调用模型并获取结果
    # 模型会同时“看到”图片和“读到”问题，然后给出答案
    response = llm.invoke([message])

    print(response.content)
else:
    print("Could not load image, skipping model invocation.")