AI Agent LangChain使用方法记录

已于 2024-05-23 16:23:31 修改
阅读量176 收藏
点赞数 1
文章标签： langchain
于 2024-05-15 11:16:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43196262/article/details/138899091
版权

1. 准备工作

本教程大部分来自于LangChain官网，运行本教程代码的前提条件：

  • 能科学上网
  • OPENAI账户里需要充值，因为调用OPENAI的API是付费的

(1). B站教程
(2). 几个API密钥获取方法
（1）OpenAI官网获取密钥：
OPENAI官网获取KEY
在这里插入图片描述
（2）LangChain API获取API_KEY
LangChain
在这里插入图片描述
事先获取以上几个API的密钥，密钥获取以后，需要设置环境变量，这里采用的是终端设置：

  • OPENAI_API_KEY
    linux:
export OPENAI_API_KEY=xxxxxxxxxxxxxx

windows:

set OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  • LANGCHAIN_API_KEY
    下面这个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其实是LANGCHAIN_API_KEI
    linux:
export TAVILY_API_KEY=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

windows:

set TAVILY_API_KEY=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
  • SERPAPI_API_KEY
    linux：
export SERPAPI_API_KEY=499bc8cbbd74f3cee704a689a2ff6895cdc109e592032b7bff0f4789eb6508cf

windows：

set SERPAPI_API_KEY=499bc8cbbd74f3cee704a689a2ff6895cdc109e592032b7bff0f4789eb6508cf

2 LangChain官网的示例

LangChain官网一直在更新，所以以下代码可能会有变动

import os
import sys
os.path.dirname(sys.executable)
os.environ['http_proxy'] = 'http://127.0.0.1:9300'
os.environ['https_proxy'] = 'http://127.0.0.1:9300'

from langchain_community.document_loaders import WebBaseLoader
from langchain.indexes import VectorstoreIndexCreator
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OpenAIEmbeddings

# Langchain共有140多个加载器
loader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")
# 加载之后的数据放在 data 里面
data = loader.load()

index = VectorstoreIndexCreator().from_loaders([loader])
print(index.query("What is Task Decomposition?"))

# --------------step2 Split 分裂------------------------#
# 上万字符，LLM消耗不了，需要分裂
# RecursiveCharacterTextSplitter切分器
text_splitter = RecursiveCharacterTextSplitter(chunk_size = 500, chunk_overlap = 0)
all_splits = text_splitter.split_documents(data)
# print(len(all_splits))
# print(all_splits[0])


# --------------step3 Store 将切分以后的向量存储------------------------#
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
# 下面这一句消耗了OPENAI了OpenAIEmbeddings()的API,是付费的，需要OPENAI账户里有钱
vectorstore = Chroma.from_documents(documents=all_splits, embedding=OpenAIEmbeddings())

# --------------step4 Retrieve 检索，向sqlite数据库提问------------------#
question = "What are the approaches to Task Decomposition?"
# 相关度检索
docs = vectorstore.similarity_search(question)
print(len(docs))
print(docs[0])

# --------------step5 Generate 生成，用大语言模型进行生成------------------#
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
qa_chain = RetrievalQA.from_chain_type(llm,retriever=vectorstore.as_retriever())
print(qa_chain({"query": question}))

在终端运行后效果：
在这里插入图片描述

3. 以RAG的形式重构上述代码

示例来源于LangChain的官网Use cases->Q&A with RAG->Quickstart

import bs4
from langchain import hub
from langchain_community.document_loaders import WebBaseLoader
from langchain_chroma import Chroma
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
import getpass
import os
from langchain_openai import ChatOpenAI

# 定义llm，使用的gpt3.5
llm = ChatOpenAI(model="gpt-3.5-turbo-0125")

# Load, chunk and index the contents of the blog.
loader = WebBaseLoader(
    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
    bs_kwargs=dict(
        parse_only=bs4.SoupStrainer(
            class_=("post-content", "post-title", "post-header")
        )
    ),
)
docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(docs)
vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())

# Retrieve and generate using the relevant snippets of the blog.
retriever = vectorstore.as_retriever()
# We’ll use a prompt for RAG that is checked into the LangChain prompt hub (here)
# 可以使用预定义的提示词模板
prompt = hub.pull("rlm/rag-prompt")

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# 我们将使用LCEL Runnable 协议来定义链，使我们能够 - 以透明的方式将组件和函数连接在一起 - 在 LangSmith 中自动跟踪我们的链 - 开箱即用地进行流式传输、异步和批量调用
# rag_chain = (
#     {"context": retriever | format_docs, "question": RunnablePassthrough()}
#     | prompt
#     | llm
#     | StrOutputParser()
# )


# 也可以使用自定义的提示词模板
from langchain_core.prompts import PromptTemplate
template = """Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
Use three sentences maximum and keep the answer as concise as possible.
Always say "thanks for asking!" at the end of the answer.

{context}

Question: {question}

Helpful Answer:"""
custom_rag_prompt = PromptTemplate.from_template(template)
# 构造chain
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | custom_rag_prompt
    | llm
    | StrOutputParser()
)

rag_chain.invoke("What is Task Decomposition?")
for chunk in rag_chain.stream("What is Task Decomposition?"):
    print(chunk, end="", flush=True)
# cleanup
# vectorstore.delete_collection()

在终端运行结果，很有礼貌的在最后一句加上了一个Thanks for asking!
在这里插入图片描述
再重新问一个

rag_chain.invoke("What is Beijing?")

回答如下
在这里插入图片描述

4. 试一下LangChain的抽取结构化输出

以下示例来自LangChain官网的Use cases->Extracting structured output->Quickstart

from typing import Optional

from langchain_core.pydantic_v1 import BaseModel, Field


class Person(BaseModel):
    """Information about a person."""

    # ^ Doc-string for the entity Person.
    # This doc-string is sent to the LLM as the description of the schema Person,
    # and it can help to improve extraction results.

    # Note that:
    # 1. Each field is an `optional` -- this allows the model to decline to extract it!
    # 2. Each field has a `description` -- this description is used by the LLM.
    # Having a good description can help improve extraction results.
    name: Optional[str] = Field(default=None, description="The name of the person")
    hair_color: Optional[str] = Field(
        default=None, description="The color of the peron's hair if known"
    )
    height_in_meters: Optional[str] = Field(
        default=None, description="Height measured in meters"
    )

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_openai import ChatOpenAI

# Define a custom prompt to provide instructions and any additional context.
# 1) You can add examples into the prompt template to improve extraction quality
# 2) Introduce additional parameters to take context into account (e.g., include metadata
#    about the document from which the text was extracted.)
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are an expert extraction algorithm. "
            "Only extract relevant information from the text. "
            "If you do not know the value of an attribute asked to extract, "
            "return null for the attribute's value.",
        ),
        # Please see the how-to about improving performance with
        # reference examples.
        # MessagesPlaceholder('examples'),
        ("human", "{text}"),
    ]
)

# from langchain_mistralai import ChatMistralAI
# llm = ChatMistralAI(model="mistral-large-latest", temperature=0)

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo-0125")

runnable = prompt | llm.with_structured_output(schema=Person)

text = "Alan Smith is 6 feet tall and has blond hair."
print(runnable.invoke({"text": text}))

在终端运行时报错：

File "D:\Code\LangChain\envLangChain\lib\site-packages\httpx\_transports\default.py", line 86, in map_httpcore_exceptions
    raise mapped_exc(message) from exc
httpx.LocalProtocolError: Illegal header value b'Bearer '

搜了一下，百度给出以下答案

httpx.LocalProtocolError: Illegal header value b’Bearer ’
错误解释：
httpx.LocalProtocolError: Illegal header value b’Bearer ’ 表示你在使用 httpx 库发送 HTTP 请求时，试图设置一个 HTTP 头部的值为 Bearer ，但这个值是非法的。HTTP 规范不允许在头部字段中有空格，并且 Bearer 后面应该有一个访问令牌。
解决方法：
确保在设置 Authorization 头部时，提供完整的 Bearer 认证令牌。例如，如果你的访问令牌是 your_token，则应该设置为 Authorization: Bearer your_token。
代码示例：

import httpx
 
# 假设你有一个访问令牌
token = "your_token"
 
headers = {
    "Authorization": f"Bearer {token}"  # 确保这里不包含任何空格
}
 
url = "http://example.com"
 
try:
    async with httpx.AsyncClient() as client:
        response = await client.get(url, headers=headers)
        print(response.status_code)
        print(response.text)
except httpx.LocalProtocolError as e:
    print(f"Error: {e}")

于是按照上面的提示，找到default.py文件，将其416行和427行的空格删掉
在这里插入图片描述
运行后又报以下错误，搜了一下，应该是需要API_KEY

httpx.HTTPStatusError: Error response 401 while fetching https://api.mistral.ai/v1/chat/completions: Bearer token not found

在这里插入图片描述
偷懒先没有去找MistralAI的KEY了，直接把MistralAI模型换成OPENAI的试试：
注释掉了这两行

# from langchain_mistralai import ChatMistralAI
# llm = ChatMistralAI(model="mistral-large-latest", temperature=0)

换成以下两行

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo-0125")

就text = "Alan Smith is 6 feet tall and has blond hair."这个简单的抽取任务来说，抽取效果还不错！
在这里插入图片描述

5. 使用Agent+LLM组合的形式多次调用工具并呈现解决问题的思考过程

以下示例来自LangChain官网Use cases->Tool use and agents->Quickstart

# -------------------Step1 创建自定义的工具---------------------------
# 首先需要创建一个调用的工具。对于此示例，我们将从函数创建自定义工具。有关创建自定义工具的更多信息，请参阅本指南
from langchain_core.tools import tool
@tool
def multiply(first_int: int, second_int: int) -> int:
    """Multiply two integers together."""
    return first_int * second_int

# print(multiply.name)
# print(multiply.description)
# print(multiply.args)

# 非agent的方式试一下
multiply.invoke({"first_int": 4, "second_int": 5})

# 使用bind_tools将工具的定义作为对llm的每次调用的一部分传入，以便llm可以在适当的时候调用该工具
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo-0125")
# 将自定义的工具multiply传入llm
llm_with_tools = llm.bind_tools([multiply])
msg = llm_with_tools.invoke("whats 5 times forty two")
msg.tool_calls

# -----------------------Invoking the tool-------------------------------
from operator import itemgetter
chain=llm_with_tools | (lambda x: x.tool_calls[0]["args"]) | multiply
# print(chain.invoke("What's four times 23"))

# -------------------------------关于Agent---------------------------------
'''
上述的问题在于，当我们知道用户输入所需的工具的特定顺序时，链就足够了。但大多数情况下，llm使用某个工具（比如本例中的乘法），
是取决于用户问了什么，即用户输入。在这些情况下，我们希望让llm本身去决定使用工具的次数和顺序，Agent能够
帮助我们实现。
LangChain提供了很多针对不同用例进行优化的内置代理
我们将使用tool calling agent，这通常是最可靠的类型，也是大多数用例推荐的类型
'''
from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent

# 使用langchain预定义的prompt
# Get the prompt to use - can be replaced with any prompt that includes variables "agent_scratchpad" and "input"!
prompt = hub.pull("hwchase17/openai-tools-agent")
prompt.pretty_print()

# Agent可以方便的使用各种工具
@tool
def add(first_int: int, second_int: int)->int:
    "Add two integers."
    return first_int + second_int

@tool
def exponentiate(base:int, exponent:int)->int:
    "Exponentiate the base to the exponent power."
    return base**exponent
# 将自己定义的三个tool放在一起
tools = [multiply, add, exponentiate]
# Construct the tool calling agent
agent = create_tool_calling_agent(llm, tools, prompt)
# Create an agent executor by passing in the agent and tools
# 创建一个代理执行器，把代理和工具传给它
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# With an agent, we can ask questions that require arbitrarily-many uses of our tools:
# 使用代理，我们可以提出需要任意多次使用我们的工具的问题：
# text="input": "Take 3 to the fifth power and multiply that by the sum of twelve and three, then square the whole result"
agent_executor.invoke(
    {
        "input": "Take 3 to the fifth power and multiply that by the sum of twelve and three, then square the whole result"
    }
)

终端的运行结果，可以看出，用户提问取3的五次方，乘以12和3的总和，然后将整个结果平方这个问题时，Agent将这个过程每一步的思考与实施结果呈现出来。
在这里插入图片描述

6. 让LLM在多种工具之间进行选择

以下示例来自Use cases->Tool use and agents->Choosing between multiple tools

使用一个工具和使用多个工具之间的主要区别在于，我们无法确定模型将预先调用哪个工具，
因此我们无法像在快速入门中那样将特定工具硬编码到我们的链中。
相反，我们将添加call_tools, 一个RunnableLambda，它通过工具调用获取输出 AI 消息并路由到正确的工具。

# 回想一下我们已经有了一个multiply工具
from langchain_core.tools import tool
@tool
def multiply(first_int: int, second_int: int) -> int:
    """Multiply two integers together."""
    return first_int * second_int
# 现在我们可以向其中添加一个exponentiateandadd工具：
@tool
def add(first_int: int, second_int: int) -> int:
    "Add two integers."
    return first_int + second_int
@tool
def exponentiate(base: int, exponent: int) -> int:
    "Exponentiate the base to the exponent power."
    return base**exponent
'''
使用一个工具和使用多个工具之间的主要区别在于，我们无法确定模型将预先调用哪个工具，
因此我们无法像在快速入门中那样将特定工具硬编码到我们的链中。
相反，我们将添加call_tools, 一个RunnableLambda，它通过工具调用获取输出 AI 消息并路由到正确的工具。
'''
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo-0125")
from operator import itemgetter
from typing import Dict, List, Union
from langchain_core.messages import AIMessage
from langchain_core.runnables import (
    Runnable,
    RunnableLambda,
    RunnableMap,
    RunnablePassthrough,
)
tools = [multiply, exponentiate, add]
llm_with_tools = llm.bind_tools(tools)
tool_map = {tool.name: tool for tool in tools}
def call_tools(msg: AIMessage) -> Runnable:
    """Simple sequential tool calling helper."""
    tool_map = {tool.name: tool for tool in tools}
    tool_calls = msg.tool_calls.copy()
    for tool_call in tool_calls:
        tool_call["output"] = tool_map[tool_call["name"]].invoke(tool_call["args"])
    return tool_calls
chain = llm_with_tools | call_tools
# 试一下，可以看到，llm会根据不同的问题，选择调用不同的工具
print(chain.invoke("What's 23 times 7"))
print(chain.invoke("add a million plus a billion"))
print(chain.invoke("cube thirty-seven"))

在终端结果如图，可以看到，llm会根据不同的问题，选择调用不同的工具
结果

7. 使用不支持工具调用的模型

本节主题是，使用不支持工具调用的模型，我们将构建一个不依赖于任何特殊模型 API。
示例来自Use cases->Tool use and agents->Using models that don't support tool calling添加链接描述

# 本节主题是：使用不支持工具调用的模型，我们将构建一个不依赖于任何特殊模型 API

# ----------step1 创建一个工具-------------------------
from langchain_core.tools import tool

@tool
def multiply(first_int: int, second_int: int) -> int:
    """Multiply two integers together."""
    return first_int * second_int

# ----------step2 创建我们的提示-------------------------
'''
我们需要编写一个提示，指定模型可以访问的工具、这些工具的参数以及模型所需的输出格式。
在本例中，我们将指示它输出以下形式的 JSON blob {"name": "...", "arguments": {...}}。
'''
from langchain.tools.render import render_text_description
rendered_tools = render_text_description([multiply])
rendered_tools

from langchain_core.prompts import ChatPromptTemplate
system_prompt = f"""You are an assistant that has access to the following set of tools. Here are the names and descriptions for each tool:
{rendered_tools}
Given the user input, return the name and input of the tool to use. Return your response as a JSON blob with 'name' and 'arguments' keys."""

prompt = ChatPromptTemplate.from_messages(
    [("system", system_prompt), ("user", "{input}")]
)

# ----------step3 使用JsonOutputParser将模型输出解析为JSON-------------------------
from langchain_core.output_parsers import JsonOutputParser
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
chain = prompt | model | JsonOutputParser()
print(chain.invoke({"input": "what's thirteen times 4"}))

# ----------------------------step3 调用该工具------------------------------------
# 我们可以通过向该工具传递llm生成的“参数”来调用该工具作为“链”的一部分
# 上述chain.invoke以后，根据我们预先定义的prompt，输出为：{'name': 'multiply', 'arguments': {'first_int': 13, 'second_int': 4}}
# 可以看出，llm已经决定了对于用户提出的问题，将调用multiply这个工具，并且也解析出了参数为13和4
# 下一步，可以通过向multiply工具传递llm解析出的“参数”来调用该工具作为“链”的一部分
from operator import itemgetter
chain = prompt | model | JsonOutputParser() | itemgetter("arguments") | multiply
print(chain.invoke({"input": "what's thirteen times 4"})) # 这样以后，模型就直接输出了结果52

# ----------------------------------multiply从多种工具调用------------------------------------
# 假设我们有很多个工具，希望链能够从中进行选择
@tool
def add(first_int: int, second_int: int) -> int:
    "Add two integers."
    return first_int + second_int


@tool
def exponentiate(base: int, exponent: int) -> int:
    "Exponentiate the base to the exponent power."
    return base**exponent

# 通过函数调用，我们可以这样做
# 如果我们想运行模型选择的工具，我们可以使用基于llm输出返回工具的函数来执行此操作
# 具体来说，函数将返回它自己的子链，该子链获取模型输出的“参数”不分并将其传递给所选工具
tools = [add, exponentiate, multiply]
def tool_chain(model_output):
    tool_map = {tool.name: tool for tool in tools}
    chosen_tool = tool_map[model_output["name"]]
    return itemgetter("arguments") | chosen_tool

rendered_tools = render_text_description(tools)
system_prompt = f"""you are an assistant that has access to the following set of tools. Here are the names and 
description for each tool:
{rendered_tools}
Given the user input, return the name and input of the tool to use.
Return your response as a JSON blob with 'name' and 'arguments' keys.
"""
prompt = ChatPromptTemplate.from_messages([("system", system_prompt), ("user", "{input}")])
print(chain.invoke({"input": "what's 3 plus 1132"}))

# -----------------------------返回工具 | 输入----------------------------------------------
# 不仅返回工具输出，而且返回工具输入也很有帮助。我们可以通过RunnablePassthrough.assign工具输出使用 LCEL 轻松完成此操作。
# 这将获取 RunnablePassrthrough 组件（假设是字典）的任何输入，并为其添加一个键，同时仍然传递当前输入中的所有内容
from langchain_core.runnables import RunnablePassthrough
chain = (prompt | model | JsonOutputParser() | RunnablePassthrough.assign(output=tool_chain))
# 试一下
print(chain.invoke({"input":"waht's 3 times 1132"}))

在终端的运行效果，最后一行，输出了llm选用的tool，即multiply，输出了解析出的两个参数即3和1132，输出了结果即3396
在这里插入图片描述

8. 人在环，人机交互，加入人的干预

有些工具我们不信任模型能够自行执行。在这种情况下，我们可以做的一件事是在调用工具之前要求人工批准。
下面的示例来自Use cases->Tool use and agents->Human-in-the-loop

# 有些工具我们不信任模型能够自行执行。在这种情况下，我们可以做的一件事是在调用工具之前要求人工批准。
# import getpass
# import os
# os.environ["OPENAI_API_KEY"] = getpass.getpass()

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo-0125")

# | echo: false
# | outout: false

# from langchain_anthropic import ChatAnthropic
# llm = ChatAnthropic(model="claude-3-sonnet-20240229", temperature=0)
from operator import itemgetter
from typing import Dict, List
from langchain_core.messages import AIMessage
from langchain_core.runnables import Runnable, RunnablePassthrough
from langchain_core.tools import tool
@tool
def count_emails(last_n_days: int) -> int:
    """Multiply two integers together."""
    return last_n_days * 2
@tool
def send_email(message: str, recipient: str) -> str:
    "Add two integers."
    return f"Successfully sent email to {recipient}."
tools = [count_emails, send_email]
llm_with_tools = llm.bind_tools(tools)
def call_tools(msg: AIMessage) -> List[Dict]:
    """Simple sequential tool calling helper."""
    tool_map = {tool.name: tool for tool in tools}
    tool_calls = msg.tool_calls.copy()
    for tool_call in tool_calls:
        tool_call["output"] = tool_map[tool_call["name"]].invoke(tool_call["args"])
    return tool_calls


chain = llm_with_tools | call_tools
print(chain.invoke("how many emails did i get in the last 5 days?"))
# 可以向我们的 tool_chain 函数添加一个简单的人工批准步骤:
import json
def human_approval(msg: AIMessage) -> Runnable:
    tool_strs = "\n\n".join(
        json.dumps(tool_call, indent=2) for tool_call in msg.tool_calls
    )
    input_msg = (
        f"Do you approve of the following tool invocations\n\n{tool_strs}\n\n"
        "Anything except 'Y'/'Yes' (case-insensitive) will be treated as a no."
    )
    resp = input(input_msg)
    if resp.lower() not in ("yes", "y"):
        raise ValueError(f"Tool invocations not approved:\n\n{tool_strs}")
    return msg
chain = llm_with_tools | human_approval | call_tools
# 加入了人工交互环节，需要人按下确定按钮
print(chain.invoke("how many emails did i get in the last 5 days?"))
print(chain.invoke("Send sally@gmail.com an email saying 'What's up homie'"))

9. Few-shot prompt template 少样本提示模板

构建一个小的提示词模板，如下

examples = [
    {'input': '海盗', 'output': '船'},
    {'input': '飞行员', 'output': '飞机'},
    {'input': '驾驶员', 'output': '汽车'},
    {'input': '鸟', 'output': '鸟巢'},
    {'input': '医生', 'output': '手术台'},
    {'input': '苏轼','output':'北宋'},
    {'input': '辛弃疾', 'output': '抗金'}
]

用上述这个微小型的提示词模板，调用gpt3.5，代码如下。
LangChain官网上FewShotPromptTemplateAPI文档(https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.few_shot.FewShotPromptTemplate.html)

import os
from langchain.prompts import PromptTemplate, FewShotPromptTemplate
from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from langchain_openai import OpenAIEmbeddings
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage
from langchain_chroma import Chroma

llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0.9)

# 构造一个很小的提示模板
examples = [
    {'input': '海盗', 'output': '船'},
    {'input': '飞行员', 'output': '飞机'},
    {'input': '驾驶员', 'output': '汽车'},
    {'input': '鸟', 'output': '鸟巢'},
    {'input': '医生', 'output': '手术台'},
    {'input': '苏轼','output':'北宋'},
    {'input': '辛弃疾', 'output': '抗金'}
]
example_prompt = PromptTemplate(
    input_variables=["input", "output"], template="输入: {input}\n输出:{output}")
# print(example_prompt)

example_selector = SemanticSimilarityExampleSelector.from_examples(
    # 可供选择的示例列表
    examples,
    # 用于生成用于测量语义相似性的嵌入的模型
    OpenAIEmbeddings(),
    # 用于存储嵌入和进行相似性搜索的vectorstores类
    Chroma,
    # 这次生成的示例次数
    k=2
)
# print(example_selector)

similar_prompt = FewShotPromptTemplate(
    # 有助于选择示例对象
    example_selector=example_selector,
    # 提示词
    example_prompt=example_prompt,
    # 添加提示词顶部和底部的自定义项
    prefix = '根据下面示例，写出输出',
    suffix='输入:{noun}\n输出:',
    #提示词接收的输入
    input_variables = ['noun'],
)
# print(similar_prompt)

# 试一下，输入'李白'
final_prompt = similar_prompt.format(noun='李白')
print(final_prompt)
response = llm([HumanMessage(content=final_prompt)])
print(response)
# 再试一个，输入'老师'
final_prompt = similar_prompt.format(noun='老师')
response = llm([HumanMessage(content=final_prompt)])
print(final_prompt)
print(response)

测试了两个用例，用户输入李白，输出唐代，输入老师，输出学生
在这里插入图片描述

10. 用不同的相似度构造器实现Fewshot

用FewShotPromptTemplate构造提示词模板时，有一个重要的参数example_selector需要传入，example_selector可以用来衡量Fewshot时examples与llm已有知识之间相似度的一个工具。Langchain提供了3种衡量相似度的工具：Select by length，Select by maximal marginal relevance (MMR)，Select by n-gram overlap

"""
Select by maxim marginal relevance (MMR)
https://python.langchain.com/v0.1/docs/modules/model_io/prompts/example_selectors/ngram_overlap/
"""
from langchain_community.vectorstores import FAISS
from langchain_core.example_selectors import (
MaxMarginalRelevanceExampleSelector,
SemanticSimilarityExampleSelector
)
from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Input: {input}\nOutput: {output}",
)
examples = [
    {"input": "happy", "output": "sad"},
    {"input": "tall", "output": "short"},
    {"input": "energetic", "output": "lethargic"},
    {"input": "sunny", "output": "gloomy"},
    {"input": "windy", "output": "calm"},
]

example_selector = MaxMarginalRelevanceExampleSelector.from_examples(
    examples,
    OpenAIEmbeddings(),
    Chroma,
    k=2
)

mmr_prompt = FewShotPromptTemplate(
    example_selector = example_selector,
    example_prompt = example_prompt,
    prefix = "Give the antonym of every input",
    suffix="Input: {adjective}\nOutput:",
    input_variables=["adjective"],
)

print(mmr_prompt.format(adjective = "worried"))

"""
select by n-gram overlap
https://python.langchain.com/v0.1/docs/modules/model_io/prompts/example_selectors/ngram_overlap/
"""
"""
NGramOverlapExampleSelector根据 ngram 重叠分数，选择并排序与输入最相似的示例。ngram 重叠分数是介于 0.0 和 1.0 之间的浮点数（含）。
选择器允许设置阈值分数。 ngram 重叠分数小于或等于阈值的示例被排除。默认情况下，阈值设置为 -1.0，因此不会排除任何示例，
只会对它们重新排序。将阈值设置为 0.0 将排除与输入没有 ngram 重叠的示例。
"""
from langchain_community.example_selectors.ngram_overlap import (
NGramOverlapExampleSelector,
)

from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate

# 用PromptTemplate构造器构造一个例子
PromptTemplate(
    input_variables = ["input", "output"],
    template = "输入:{input}\n输出{output}"
)
# Examples of a fictional translation task.
# 一个简单的翻译任务
examples = [
    {"input": "See Spot run.", "output": "Ver correr a Spot."},
    {"input": "My dog barks.", "output": "Mi perro ladra."},
    {"input": "Spot can run.", "output": "Spot puede correr."},
]
NGramOverlapExampleSelector(
    # 可选择的示例
    examples=examples,
    example_prompt=example_prompt,
    # selector停止时的阈值，默认是-1.0
    threshold = -1.0,
    # For negative threshold:
    # Selector sorts examples by ngram overlap score, and excludes none.
    # For threshold greater than 1.0:
    # Selector excludes all examples, and returns an empty list.
    # For threshold equal to 0.0:
    # Selector sorts examples by ngram overlap score,
    # and excludes those with no ngram overlap with input.
)

dynamic_prompt = FewShotPromptTemplate(
    # 提供exampleSelector而不是examples
    example_selector = example_selector,
    example_prompt = example_prompt,
    prefix = "把输入翻译成西班牙语/法语",
    suffix = "输入：{sentence}\n输出：",
    input_variables = ["sentence"], # 输入参数叫做sentence
)
# 打印一下看构造是否成功
print(dynamic_prompt.format(sentence="I love you"))

# 可以给NGramOverlapExampleSelector新加examples
new_example = {"input": "Spot plays fetch.", "output": "Spot juega a buscar."}
example_selector.add_example(new_example)

from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage

llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0.9)
final_prompt = dynamic_prompt.format(sentence="I love you")
message = HumanMessage(content=final_prompt)
print(llm([message]).content)
Eva215665
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Generative AI with LangChain
06-10
Build large language model (LLM) apps with Python, ChatGPT, and other LLMs Ben Auffarth ------------------------------------------ First published: December 2023
AI Agent智能应用从0到1定制开发
04-17
AI Agent智能应用从0到1定制开发 关键特点： 自动化：AI Agent可以自动执行重复性任务，提高效率并减少人力成本。 智能决策：基于复杂的算法，AI Agent能够进行决策支持，分析数据并提供洞察。 自然语言处理：许多...
谷歌Gemini API 应用(二)：LangChain 加持
weixin_42608414的博客
12-16 2321
今天我们学习了在langchain中使用gemin模型的的一些方法，总的来说使用方法和其他的模型如openai的模型的方法都是类似的。今天我们还尝试了langchain的stream和beath方法在gemini模型上的应用，还介绍了RAG、PAL Chain的应用，最后我们用一个简单例子介绍了langchain中使用gemini多模态模型的方法。希望今天的内容对大家学习gemini大模型有所帮助。
使用langchain支持openai，如何支持自定义api_key和base_url ？
无求
11-01 3651
langchain目前还使用的是旧版的openai的接口，需要注意。核心其实在于key和url的设置。示例代码，使用LLM进行预测。
LangSmith 入门
行步至春深
04-06 637
在新的页面需要登录，然后点击头像，然后是Settings。第一行API keys，然后Create Api Key。设置环境变量(windows10)查看LangSmith输出轨迹。
LangChain入门指南
lht0909的博客
04-27 3万+
LangChain是一个强大的框架，旨在帮助开发人员使用语言模型构建端到端的应用程序。它提供了一套工具、组件和接口，可简化创建由大型语言模型 (LLM) 和聊天模型提供支持的应用程序的过程。LangChain 可以轻松管理与语言模型的交互，将多个组件链接在一起，并集成额外的资源，例如 API 和数据库。官方文档：https://python.langchain.com/en/latest/
如何获取 ChatGPT 的 OpenAI API 密钥
xipintao的博客
12-29 2293
无论您是一家想要构建第一个产品的初创公司，还是一家想要向您的服务添加 AI 功能的老牌公司，OpenAI API 都可以大规模处理请求，无论您的运营规模如何，它都是一个不错的选择。将弹出一个框，要求您命名您的 API 密钥。为不同的应用程序和网站使用不同的密钥是个好主意，因此请确保您为它命名的名称可以让您在将来某一天查看它时记住它的用途。借助 OpenAI API 密钥，您可以利用预先训练的模型，节省时间和资源，同时仍然获得高质量的结果。注册后，您将收到一封来自 OpenAI 的电子邮件以确认您的帐户。
Medical Chatbot Agent - using Langchain.rar
04-29
Website Interaction: The chatbot uses the latest version of LangChain to interact with and extract information from various websites, providing insightful responses. Large Language Model Integration: ...
人工智能：计算Agent基础
07-23
资源名称：人工智能：计算Agent基础资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
Suno AI介绍及使用方法
04-12
Suno AI介绍及使用方法
（14-2）Langchin基础知识：使用LangChain构建应用
码农三叔
02-06 2155
上下文压缩是指对文本中的上下文信息进行压缩或简化，以便在给定的令牌数量限制下处理文档。在处理文档时需要进行上下文压缩工作，因为 Llama2 模型的最大令牌数量为 2048。（1）请看下面的代码，功能是使用库 LangChain创建一个上下文压缩的检索器。
LangChain 中文入门教程笔记
weixin_43147226的博客
08-01 1207
假如我们想要用 openai api 对一个段文本进行总结，我们通常的做法就是直接发给 api 让他总结。但是如果文本超过了 api 最大的 token 限制就会报错。这时，我们一般会进行对文章进行分段，比如通过 tiktoken 计算并分割，然后将各段发送给 api 进行总结，最后将各段的总结再进行一个全部的总结。如果，你用是 LangChain，他很好的帮我们处理了这个过程，使得我们编写代码变的非常简单# 导入文本# 将文本转成 Document 对象# 初始化文本分割器。
如何获取OpenAI API Key
热门推荐
cbbxn的博客
04-01 6万+
如果您还没有创建 API Key，请点击“Create New API Key”按钮。如果您已经创建了 API Key，则可以在此页面上找到您的 API Key。现在您已经成功创建了 OpenAI API Key，可以使用它来访问 OpenAI API 并使用 OpenAI 的语言模型和其他人工智能工具。在“Create API Key”对话框中，输入您的 API Key 名称，然后点击“Create API Key”按钮。在“Settings”页面中，点击“API Keys”选项卡。
大模型从入门到应用——LangChain：记忆（Memory）-[记忆的存储与应用]
冯·诺依曼
08-15 5530
Zep 是一个存储、摘要、嵌入、索引和丰富对话式人工智能聊天历史记录的工具，并通过简单、低延迟的API进行访问。[3] LangChain中文网 - LangChain 是一个用于开发由语言模型驱动的应用程序的框架：http://www.cnlangchain.com/[2] LangChain 🦜️🔗 中文网，跟着LangChain一起学LLM/GPT开发：https://www.langchain.com.cn/[1] LangChain官方网站：https://www.langchain.com/
在树莓派4B上，在ubuntu20.04中设置包含ros节点的文件自启动
06-16
在树莓派4B上，在ubuntu20.04中设置包含ros节点的文件自启动
TLBB服务端综合工具
最新发布
06-16
潇湘综合工具
数据库管理工具:dbeaver-ce-23.0.1-linux.gtk.aarch64-nojdk.tar.gz
06-16
1.DBeaver是一款通用数据库工具，专为开发人员和数据库管理员设计。 2.DBeaver支持多种数据库系统，包括但不限于MySQL、PostgreSQL、Oracle、DB2、MSSQL、Sybase、Mimer、HSQLDB、Derby、SQLite等，几乎涵盖了市场上所有的主流数据库。 3.支持的操作系统：包括Windows（2000/XP/2003/Vista/7/10/11）、Linux、Mac OS、Solaris、AIX、HPUX等。 4.主要特性： 数据库管理：支持数据库元数据浏览、元数据编辑（包括表、列、键、索引等）、SQL语句和脚本的执行、数据导入导出等。 用户界面：提供图形界面来查看数据库结构、执行SQL查询和脚本、浏览和导出数据，以及处理BLOB/CLOB数据等。用户界面设计简洁明了，易于使用。 高级功能：除了基本的数据库管理功能外，DBeaver还提供了一些高级功能，如数据库版本控制（可与Git、SVN等版本控制系统集成）、数据分析和可视化工具（如图表、统计信息和数据报告）、SQL代码自动补全等。
langchain initialize_agent
09-02
在langchain库中，initialize_agent函数用于初始化一个Agent。具体使用过程如下：首先导入所需的模块和类，包括initialize_agent、OpenAI、WeatherTool和CustomCalculatorTool。然后创建一个OpenAI对象，其中temperature参数设置为0。接下来创建一个包含WeatherTool和CustomCalculatorTool的工具列表。然后使用initialize_agent函数，传入工具列表、OpenAI对象和agent参数（默认为"zero-shot-react-description"）。最后，调用agent对象的run方法并传入查询语句，即可运行该Agent。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Langchain-agent入门笔记（1）](https://blog.csdn.net/weixin_41032724/article/details/131082277)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值