基础入门

1. 引言

LangChain 是一个开源框架，旨在简化与大型语言模型的交互过程。它提供了一系列工具和组件，帮助开发者轻松地构建复杂的应用程序，如聊天机器人、问答系统等。本技术文档将详细介绍 LangChain 的核心概念、主要组件及其使用方法。

2. 快速入门

2.1 安装 LangChain

确保你的 Python 环境已安装。接着，安装 LangChain 社区版：

pip install -U langchain-community

如果遇到依赖问题，可以按照以下步骤解决：

pip uninstall tenacity
pip install 'tenacity==8.3.0'

2.2 获取 Moonshot API Key

访问 Moonshot 平台 (https://platform.moonshot.cn) 注册并获取 API Key。

2.3 安装其他依赖

安装必要的依赖库：

pip install dashscope faiss-cpu chromadb

3. LangChain 核心组件

3.1 大模型包装 (LLM Wrappers)

LangChain 提供了对各种大型语言模型的支持，这些模型被封装为易于使用的接口。以下是使用 LangChain 包装 OpenAI 的 GPT-4 模型的示例：

from langchain_openai import OpenAI

# 设置 API 密钥
os.environ["OPENAI_API_KEY"] = "your-api-key"

# 创建一个 GPT-4 模型实例
model = OpenAI(model="gpt-4")

# 调用模型
response = model("Hello, how are you?")
print(response)

3.2 Prompt 模板

Prompt 模板是用于指导模型生成特定类型文本的预设模板。以下是一个简单的示例，展示如何使用 LangChain 的 PromptTemplate 类来创建一个模板，然后用它来生成文本：

from langchain_core.prompts import PromptTemplate

# 创建一个 PromptTemplate 实例
template = PromptTemplate.from_template("Tell me a joke about {topic}")

# 使用模板
prompt = template.invoke({"topic": "cats"})
print(prompt)

3.3 Chain (链)

Chain 允许将不同的组件串联起来形成复杂的工作流程。以下是一个使用 LangChain 的 LLMChain 的例子，该链将一个 PromptTemplate 和一个 LLM 组件连接起来：

from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain.chains import LLMChain

# 设置 API 密钥
os.environ["OPENAI_API_KEY"] = "your-api-key"

# 创建 PromptTemplate 实例
prompt = PromptTemplate.from_template("Tell me a joke about {topic}")

# 创建 LLM 实例
llm = OpenAI(model="gpt-4")

# 创建 LLMChain 实例
chain = LLMChain(prompt=prompt, llm=llm)

# 调用链
response = chain.invoke({"topic": "cats"})
print(response)

3.4 缓存支持

LangChain 支持多种缓存机制，例如内存缓存、SQLite 缓存、Redis 缓存等。以下是如何启用缓存的一个例子：

from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain.cache import SQLiteCache

# 设置 API 密钥
os.environ["OPENAI_API_KEY"] = "your-api-key"

# 初始化缓存
cache = SQLiteCache()

# 创建 PromptTemplate 实例
prompt = PromptTemplate.from_template("Tell me a joke about {topic}")

# 创建 LLM 实例
llm = OpenAI(model="gpt-4", cache=cache)

# 创建 LLMChain 实例
chain = LLMChain(prompt=prompt, llm=llm)

# 调用链
response = chain.invoke({"topic": "cats"})
print(response)

3.5 文档分割与向量化

处理文档，将其分割成更小的部分，并转换为向量表示。这里使用了 LangChain 的 RecursiveCharacterTextSplitter 来分割文档，并使用 DashScope 的文本嵌入服务进行向量化：

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.dashscope import DashScopeEmbeddings
from langchain.vectorstores.faiss import FAISS

# 加载文档
loader = TextLoader("example.txt")
documents = loader.load()

# 分割文档
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(documents)

# 文本向量化
embeddings = DashScopeEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)

# 查询向量存储
query = "What is the meaning of life?"
docs = vectorstore.similarity_search(query)
print(docs)

3.6 Agent

Agent 根据用户的输入执行相应的动作，并返回动作的结果。以下是一个使用 LangChain 的 create_react_agent 创建一个使用 ReAct 方法的代理的例子：

from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain.agents import create_react_agent
from langchain.tools import BaseTool, tool

# 设置 API 密钥
os.environ["OPENAI_API_KEY"] = "your-api-key"

# 创建工具
@tool
def search_info(query: str):
    """
    当搜索 Java 问题时使用该工具
    """
    print(f"\n正在查询问题: {query}")
    return "search ret"

# 创建 PromptTemplate 实例
template = PromptTemplate.from_template(
    """
    Answer the following questions as best you can. You have access to the following tools:
    {tools}
    Use the following format:
    Question: the input question you must answer
    Thought: you should always think about what to do
    Action: the action to take, should be one of [{tool_names}]
    Action Input: the input to the action
    Observation: the result of the action
    ...
    (this Thought/Action/Action Input/Observation can repeat N times)
    Thought: I now know the final answer
    Final Answer: the final answer to the original input question
    Begin!
    Question: {input}
    Thought:{agent_scratchpad}
    """
)

# 创建 LLM 实例
llm = OpenAI(model="gpt-4")

# 创建代理
agent = create_react_agent(llm, [search_info], template)

# 调用代理
response = agent.invoke({"input": "What is Java?"})
print(response)

4. 对话记忆管理

对话记忆管理是确保模型理解上下文的关键。LangChain 提供了几种不同的对话记忆管理策略。

4.1 ConversationBufferMemory

这是最基本的缓冲记忆内存对象，它会保存所有的对话历史。

from langchain.chains.conversation.memory import ConversationBufferMemory

mem = ConversationBufferMemory()

4.2 ConversationBufferWindowMemory

只保存最近的几次人类和 AI 的互动。

from langchain.chains.conversation.memory import ConversationBufferWindowMemory

mem = ConversationBufferWindowMemory(k=5)

4.3 ConversationSummaryMemory

每次新互动发生时进行汇总，而不是保存整个对话历史。

from langchain.chains.conversation.memory import ConversationSummaryMemory

mem = ConversationSummaryMemory(llm=YourLLM())

4.4 ConversationSummaryBufferMemory

综合了 ConversationSummaryMemory 和 ConversationBufferWindowMemory 的优点。

from langchain.chains.conversation.memory import ConversationSummaryBufferMemory

mem = ConversationSummaryBufferMemory(llm=YourLLM(), max_token_limit=2048)

5. 工具与代理

5.1 工具创建

工具是用户问题理解和拆分的第一步，它从工具列表中选择合适的工具，将用户的提问转化为结构化数据，传递给工具函数。

from langchain.tools import BaseTool, tool

@tool
def SearchInfo(query: str):
    """
    当搜索Java问题时使用该工具
    """
    print(f"\n正在查询问题: {query}")
    return "search ret"

5.2 使用 StructuredTool

from langchain.pydantic_v1 import BaseModel, Field
from langchain.tools import StructuredTool

class SearchInput(BaseModel):
    num1: int = Field(0, alias="a")
    num2: int = Field(0, alias="b")

@tool("javatool", args_schema=SearchInput)
def SearchInfo(a: int, b: int):
    """
    当搜索Java问题时使用该工具
    """
    print(f"\n正在查询问题: {a} + {b}")
    return a + b

t = StructuredTool.from_function(func=SearchInfo, args_schema=SearchInput, return_direct=True)
print(t.invoke({"a": 1, "b": 2}))

5.3 创建 Action Agent

Action Agent 是一种典型的代理类型，它使用先前操作的输出来决定下一步的操作。

from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.exceptions import OutputParserException
from utils.llm import Tongyi
from langchain.schema import AgentAction, AgentFinish
from typing import Union
import re
from tools.prompts import action_template1
from tools.prompts_tpl import CustomPromptTemplate
from tools.simple_tools import AddTool, SubTool

# 自定义模板
tpl = CustomPromptTemplate(
    template=action_template1,
    input_variables=["input", "intermediate_steps", "agent_scratchpad", "tools", "tool_names"],
    tools=[AddTool(), SubTool()]
)

# 创建 React Agent
agent = create_react_agent(llm=Tongyi(), tools=[AddTool(), SubTool()], prompt=tpl)

# 创建 Agent Executor
agent_executor = AgentExecutor(agent=agent, tools=[AddTool(), SubTool()])

# 调用
result = agent_executor.invoke({"input": "What is 10 plus 5?"})
print(result)

6. 向量存储与搜索

6.1 Faiss 入门

Faiss 是一个用于高效相似性搜索和密集向量聚类的库。

安装 Faiss
```
pip install faiss-cpu
```

使用通义千问进行embedding

import os
from langchain.embeddings.dashscope import DashScopeEmbeddings

key = os.environ.get("DASHSCOPE_API_KEY")
eb = DashScopeEmbeddings(dashscope_api_key=key, model="text-embedding-v1")
print(eb.embed_query("jtthink"))

6.2 Chroma 简介

Chroma 是一个用于构建带有嵌入向量的 AI 应用程序的数据库，内置了入门所需的一切，并提供了简单的 API。

安装 Chroma
```
pip install chromadb
```

基本代码

from chromadb.api.models.Collection import Collection
from chromadb.config import Settings

client = Collection(client_settings=Settings(chroma_db_impl="duckdb+parquet",
                                             persist_directory="/path/to/persist/directory",
                                             anonymized_telemetry=False))
collection = client.create_collection(name="my_collection")

# 添加数据
collection.add(
    documents=["This is a document", "This is another document"],
    metadatas=[{"source": "my_source"}, {"source": "my_source"}],
    ids=["id1", "id2"]
)

# 查询
results = collection.query(
    query_texts=["This is a query"],
    n_results=2
)
print(results)

7. LangChain 表达式语言

LangChain 表达式语言 (LCEL) 提供了一种声明式的方式链接 LangChain 组件。

7.1 RunnablePassthrough

RunnablePassthrough 是一个实用的组件，可以在不改变或添加额外键的情况下传递输入。

from langchain_core.runnables import RunnablePassthrough, Runnable, RunnableConfig

# 假设我们有一个PromptTemplate
template = """测试模板:
    {context}
    Question: {question}
    """

# 创建PromptTemplate
prompt = PromptTemplate.from_template(template)

# 使用RunnablePassthrough
context_and_question = RunnablePassthrough() | {"context": "测试上下文", "question": "测试问题"}

# 调用prompt
ret = prompt.invoke(context_and_question)
print(ret)

7.2 创建自定义Runnable

from langchain_core.runnables.utils import Input
from typing import Optional

class MyRunnable(Runnable):
    def __init__(self):
        pass
    
    def invoke(self, input: Input, config: Optional[RunnableConfig] = None) -> str:
        return "测试"

# 创建自定义Runnable实例
my_runnable = MyRunnable()

# 调用
result = my_runnable.invoke({"input": "测试输入"})
print(result)

8. 高级主题

8.1 高级 Prompt 模板

LangChain 提供了丰富的 Prompt 模板选项，可以定制化模型的输入。

from langchain.prompts import PromptTemplate

template = """Question: {question}

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

8.2 输出解析器

输出解析器负责解析代理的输出，并确定下一步的动作。

from langchain.agents import AgentOutputParser
from langchain.schema import AgentAction, AgentFinish

class CustomOutputParser(AgentOutputParser):
    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
        # Check if agent should finish
        if "Final Answer:" in llm_output:
            return AgentFinish(
                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
                log=llm_output,
            )
        # Parse out the tool and tool input
        regex = r"Action\s*\d*\s*:(.*?)\nAction\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
        match = re.search(regex, llm_output, re.DOTALL)
        if not match:
            raise OutputParserException(f"Could not parse LLM output: `{llm_output}`")
        action = match.group(1).strip()
        action_input = match.group(2)
        # Return the action and action input
        return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)

9. 结语

LangChain 提供了一个强大的框架来构建复杂的自然语言处理应用程序。通过学习本文档中的概念和技术，您可以开始探索和构建自己的应用程序。希望这份文档能成为您使用 LangChain 的宝贵资源。

上一页Langchain 下一页FastAPI

最后更新于1年前