Skip to main content

插件 Plug-and-Plai

本笔记本在插件检索的基础plugin retrieval上进行了扩展，但从plugnplai获取了所有工具 - 这是一个AI插件的目录。

设置环境​

进行必要的导入等操作。

安装plugnplai库以从https://plugplai.com 目录获取活动插件

pip install plugnplai -q
    
    [notice] A new release of pip available: 22.3.1 -> 23.1.1
    [notice] To update, run: pip install --upgrade pip
    Note: you may need to restart the kernel to use updated packages.
from langchain.agents import (
    Tool,
    AgentExecutor,
    LLMSingleActionAgent,
    AgentOutputParser,
)
from langchain.prompts import StringPromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from typing import List, Union
from langchain.schema import AgentAction, AgentFinish
from langchain.agents.agent_toolkits import NLAToolkit
from langchain.tools.plugin import AIPlugin
import re
import plugnplai

设置LLM​

llm = OpenAI(temperature=0)

设置插件​

加载和索引插件

# 从plugnplai.com获取所有插件
urls = plugnplai.get_plugins()

# 获取ChatGPT插件 - 仅ChatGPT验证的插件
urls = plugnplai.get_plugins(filter="ChatGPT")

# 获取工作插件 - 仅测试过的插件（正在进行中）
urls = plugnplai.get_plugins(filter="working")


AI_PLUGINS = [AIPlugin.from_url(url + "/.well-known/ai-plugin.json") for url in urls]

工具检索器​

我们将使用一个向量存储库为每个工具描述创建嵌入。然后，对于传入的查询，我们可以为该查询创建嵌入，并对相关工具进行相似性搜索。

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema import Document
embeddings = OpenAIEmbeddings()
docs = [
    Document(
        page_content=plugin.description_for_model,
        metadata={"plugin_name": plugin.name_for_model},
    )
    for plugin in AI_PLUGINS
]
vector_store = FAISS.from_documents(docs, embeddings)
toolkits_dict = {
    plugin.name_for_model: NLAToolkit.from_llm_and_ai_plugin(llm, plugin)
    for plugin in AI_PLUGINS
}
    Attempting to load an OpenAPI 3.0.1 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load an OpenAPI 3.0.1 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load an OpenAPI 3.0.1 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load an OpenAPI 3.0.2 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load an OpenAPI 3.0.1 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load an OpenAPI 3.0.1 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load an OpenAPI 3.0.1 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load an OpenAPI 3.0.1 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
    Attempting to load a Swagger 2.0 spec.  This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.
retriever = vector_store.as_retriever()


def get_tools(query):
    # 获取包含要使用的插件的文档
    docs = retriever.get_relevant_documents(query)
    # 获取工具包，每个插件一个
    tool_kits = [toolkits_dict[d.metadata["plugin_name"]] for d in docs]
    # 获取工具：每个端点一个单独的NLAChain
    tools = []
    for tk in tool_kits:
        tools.extend(tk.nla_tools)
    return tools

我们现在可以测试这个检索器，看看它是否有效。

tools = get_tools("What could I do today with my kiddo")
[t.name for t in tools]
    ['Milo.askMilo',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.search_all_actions',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.preview_a_zap',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.get_configuration_link',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.list_exposed_actions',
     'SchoolDigger_API_V2.0.Autocomplete_GetSchools',
     'SchoolDigger_API_V2.0.Districts_GetAllDistricts2',
     'SchoolDigger_API_V2.0.Districts_GetDistrict2',
     'SchoolDigger_API_V2.0.Rankings_GetSchoolRank2',
     'SchoolDigger_API_V2.0.Rankings_GetRank_District',
     'SchoolDigger_API_V2.0.Schools_GetAllSchools20',
     'SchoolDigger_API_V2.0.Schools_GetSchool20',
     'Speak.translate',
     'Speak.explainPhrase',
     'Speak.explainTask']
tools = get_tools("what shirts can i buy?")
[t.name for t in tools]
    ['Open_AI_Klarna_product_Api.productsUsingGET',
     'Milo.askMilo',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.search_all_actions',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.preview_a_zap',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.get_configuration_link',
     'Zapier_Natural_Language_Actions_(NLA)_API_(Dynamic)_-_Beta.list_exposed_actions',
     'SchoolDigger_API_V2.0.Autocomplete_GetSchools',
     'SchoolDigger_API_V2.0.Districts_GetAllDistricts2',
     'SchoolDigger_API_V2.0.Districts_GetDistrict2',
     'SchoolDigger_API_V2.0.Rankings_GetSchoolRank2',
     'SchoolDigger_API_V2.0.Rankings_GetRank_District',
     'SchoolDigger_API_V2.0.Schools_GetAllSchools20',
     'SchoolDigger_API_V2.0.Schools_GetSchool20']

提示模板​

提示模板非常标准，因为我们实际上并没有改变实际提示模板的太多逻辑，而是只改变了检索的方式。

# 设置基本模板
template = """Answer the following questions as best you can, but speaking as a pirate might speak. 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! Remember to speak as a pirate when giving your final answer. Use lots of "Arg"s

Question: {input}
{agent_scratchpad}"""

自定义提示模板现在具有tools_getter的概念，我们在输入上调用它以选择要使用的工具

from typing import Callable

# 设置提示模板
class CustomPromptTemplate(StringPromptTemplate):
    # 要使用的模板
    template: str
    tools_getter: Callable

    def format(self, **kwargs) -> str:
        # 获取中间步骤（AgentAction，Observation元组）
        # 以特定方式格式化它们
        intermediate_steps = kwargs.pop("intermediate_steps")
        thoughts = ""
        for action, observation in intermediate_steps:
            thoughts += action.log
            thoughts += f"\nObservation: {observation}\nThought: "
        # 将agent_scratchpad变量设置为该值
        kwargs["agent_scratchpad"] = thoughts
        tools = self.tools_getter(kwargs["input"])
        # 从提供的工具列表创建一个工具变量
        kwargs["tools"] = "\n".join(
            [f"{tool.name}: {tool.description}" for tool in tools]
        )
        # 创建一个工具名称列表，用于提供的工具
        kwargs["tool_names"] = ", ".join([tool.name for tool in tools])
        return self.template.format(**kwargs)
prompt = CustomPromptTemplate(
    template=template,
    tools_getter=get_tools,
    # 这省略了`agent_scratchpad`，`tools`和`tool_names`变量，因为这些是动态生成的
    # 这包括`intermediate_steps`变量，因为需要它
    input_variables=["input", "intermediate_steps"],
)

输出解析器​

输出解析器与上一个笔记本中的相同，因为我们没有改变输出格式的任何内容。

class CustomOutputParser(AgentOutputParser):
    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
        # 检查代理是否应该完成
        if "Final Answer:" in llm_output:
            return AgentFinish(
                # 返回值通常是一个带有单个`output`键的字典
                # 目前不建议尝试其他任何内容 :)
                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
                log=llm_output,
            )
        # 解析出操作和操作输入
        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 ValueError(f"Could not parse LLM output: `{llm_output}`")
        action = match.group(1).strip()
        action_input = match.group(2)
        # 返回操作和操作输入
        return AgentAction(
            tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output
        )
output_parser = CustomOutputParser()

设置LLM、停止序列和代理​

与上一个笔记本相同

llm = OpenAI(temperature=0)
# 由LLM和提示组成的LLM链
llm_chain = LLMChain(llm=llm, prompt=prompt)
tool_names = [tool.name for tool in tools]
agent = LLMSingleActionAgent(
    llm_chain=llm_chain,
    output_parser=output_parser,
    stop=["\nObservation:"],
    allowed_tools=tool_names,
)

使用代理​

现在我们可以使用它了！

agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent, tools=tools, verbose=True
)
agent_executor.run("what shirts can i buy?")
    
    
    > 进入新的AgentExecutor链...
    Thought: I need to find a product API
    Action: Open_AI_Klarna_product_Api.productsUsingGET
    Action Input: shirts
    
    Observation:I found 10 shirts from the API response. They range in price from $9.99 to $450.00 and come in a variety of materials, colors, and patterns. I now know what shirts I can buy
    Final Answer: Arg, I found 10 shirts from the API response. They range in price from $9.99 to $450.00 and come in a variety of materials, colors, and patterns.
    
    > 完成链。





    'Arg, I found 10 shirts from the API response. They range in price from $9.99 to $450.00 and come in a variety of materials, colors, and patterns.'