import os
#设置HTTP代理，本地IP地址以及端口号，查看IP可以通过Win/Linux下的IPCONFIG/IFCONFIG命令查看，也可以直接默认设置为127.0.0.1,端口要写挂载VPN的端口号。
os.environ['HTTP_PROXY'] = 'http://127.0.0.1:XXX'
#设置HTTPS代理，同上
os.environ['HTTPS_PROXY'] = 'http://127.0.0.1:XXX'

#检查代理是否有用
def check_proxy():
    import urllib.request
    url = "https://www.google.com"
    #url = "https://www.baidu.com"
    filename = "google.html"
    urllib.request.urlretrieve(url, filename)#保存在当前文件夹下

check_proxy()

#openai的key
os.environ["OPENAI_API_KEY"] = "填上你自己的openai api  key"

#搜索api的key,仅在agent中使用，这步不是必要的
os.environ['SERPAPI_API_KEY']='填上你自己的serpapi api key'

from serpapi import GoogleSearch
search = GoogleSearch({
    "q": "coffee",
    "location": "Austin,Texas",
  })
result = search.get_dict()
print(result)

import openai
"""
调用ChatGPT API，其中的engine是使用的chatgpt的davinci引擎，
输入提示是prompt，生成文本的最大长度限制为5个tokens，一个token可以
是一个单词或者一个子词，n=1是设置的生成文本的数量，即表示生成一条回复，stop是
来指定生成文本结束的条件的，这里设为None，表示不设置停止的条件，temperature是
用来控制文本生成的随机性的，数值越大代表生成的文本越随机，数值越小表示生成的文本
很确定和保守。返回的内容就是response对象。
"""
response = openai.Completion.create(
    engine="davinci",
    prompt="Hello, my name is",
    max_tokens=5,
    n=1,
    stop=None,
    temperature=0.5,
)
#输出ChatGPT的回复
print("response : {}".format(response))
print("--------")
print(response.choices[0].text)

from langchain.llms import OpenAI
import os

"""model_name是选择的OpenAI的模型名称，n=2是生成的文本内容是两条，best_of是从2个里面选择出最佳的一条作为输出"""
llm = OpenAI(model_name="text-ada-001", n=2, best_of=2)

print(llm)

llm("Tell me a scared story")

llm_result = llm.generate(["How to study English", "How to generate a new idea"]*3)
print(llm_result)
print(len(llm_result.generations))
print(llm_result.generations[0])
print(llm_result.generations[1])

print(llm_result.llm_output)

print(llm.get_num_tokens("假设你是个教师，如何教英语"))

#导入我们所需要的相关库函数
from langchain.chat_models import ChatOpenAI
from langchain import PromptTemplate, LLMChain
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    AIMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)
#定义聊天机器人使用的聊天问答模型
chat = ChatOpenAI(temperature=0)
#由AI回复human的消息
#human给出的信息是一个字符串内容，给到chat之后会返回一个AIMessage信息，其中的内容将是给出的反馈答案
chat([HumanMessage(content="Translate this sentence from English to Chinese. I love programming.")])

messages = [
    SystemMessage(content="You are a helpful assistant that translates English to Chinese."),
    HumanMessage(content="Translate this sentence from English to Chinese. I love programming.")
]
chat(messages)

batch_messages = [
    [
        SystemMessage(content="You are a helpful assistant that translates English to French."),
        HumanMessage(content="Translate this sentence from English to French. I love programming.")
    ],
    [
        SystemMessage(content="You are a helpful assistant that translates English to Chinese."),
        HumanMessage(content="Translate this sentence from English to Chinese. I love artificial intelligence.")
    ],
]
result = chat.generate(batch_messages)
print(result)

OUT：
LLMResult(generations=[[ChatGeneration(text="J'aime programmer.", generation_info=None, message=AIMessage(content="J'aime programmer.", additional_kwargs={}))], [ChatGeneration(text='我喜欢人工智能。', generation_info=None, message=AIMessage(content='我喜欢人工智能。', additional_kwargs={}))]], llm_output={'token_usage': {'prompt_tokens': 73, 'completion_tokens': 16, 'total_tokens': 89}, 'model_name': 'gpt-3.5-turbo'})

result.llm_output

下面使用模板包装SystemMessage和HumanMessage。方便使用。
#首先构建模版，用几个完形待填项表示要传入的内容，input_variables在这个模版中是两个
template="You are a helpful assistant that translates {input_language} to {output_language}."
#定义systemmessage的提示模版，进行相应的模版格式化
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
#构建human模版，用来传入我们想要查询的内容
human_template="{text}"
#将human模版进行格式化
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
#将上面的两类模版，也就是system和human的模版，将两个模版通过合并的方式创建
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
#使用聊天提示模版来创建一个聊天补全，其中的各项参数都是input_variables，通过to_messages方法传递给chat模型完成聊天对话
chat(chat_prompt.format_prompt(input_language="English", output_language="French", text="I love programming.").to_messages())

prompt=PromptTemplate(
    template="You are a helpful assistant that translates {input_language} to {output_language}.",
    input_variables=["input_language", "output_language"],
)
system_message_prompt = SystemMessagePromptTemplate(prompt=prompt)

chain = LLMChain(llm=chat, prompt=chat_prompt)
chain.run(input_language="English", output_language="Chinese", text="I love programming and swimming")

from langchain.callbacks.base import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
"""
streaming=True是启用了聊天的流式模式，也就是响应的内容将会在逐步生成的数据块中逐步返回；
而callback_manger用于管理聊天过程中的回调函数的对象，流式对象将会逐步返回内容而不是整个
响应完成之后一次性返回，如果不传递callback_manager参数，则聊天过程中将会以默认的方式运行，也
就是响应完成之后一次性返回；verbose是详细模式，决定是否打印出具体的信息；temperature的设置
则是决定随机性
"""
chat = ChatOpenAI(streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), verbose=True, temperature=0)
resp = chat([HumanMessage(content="帮我分析一下为什么一加一等于二？")])

一加一等于二是因为这是我们所接受的基本数学原理之一。在十进制数系统中，我们将数字1表示为一个单位，数字2表示为两个单位。当我们将一个单位与另一个单位相加时，我们得到两个单位，即数字2。这是因为加法是一种基本的算术运算，它表示将两个或多个数值相加以得到它们的总和。因此，一加一等于二是数学中的基本原理之一，它被广泛接受并被用于各种数学和科学应用中。

resp_another = chat([HumanMessage(content="tell me how to become a superman?")])

As an AI language model, I cannot provide instructions on how to become a fictional character like Superman. However, I can suggest some ways to become a better version of yourself:

1. Set goals and work towards them consistently.
2. Exercise regularly to improve physical strength and endurance.
3. Learn new skills and knowledge to enhance mental abilities.
4. Practice empathy and kindness towards others.
5. Be courageous and stand up for what is right.
6. Develop a positive mindset and attitude towards life.
7. Surround yourself with supportive and positive people.
8. Take care of your health by eating a balanced diet and getting enough rest.
9. Continuously challenge yourself to grow and improve.
10. Believe in yourself and your abilities.

#我们使用较多的也是OpenAI的embeddings方法
from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
text = "This is a test document."
query_result = embeddings.embed_query(text)
print(query_result)
doc_result = embeddings.embed_documents([text])
print(doc_result)

from langchain.embeddings import HuggingFaceEmbeddings
embeddings_hf = HuggingFaceEmbeddings()
text_hf = "I just test the embeddings method in huggingface"
query_result = embeddings_hf.embed_query(text_hf)
doc_result = embeddings_hf.embed_documents([text_hf])

#一般导入的必要库，为了进一步模版化处理
from langchain import PromptTemplate
#具体的模版内容，其中要进行补全的地方（也就是为了定制我们具体问题以及要求的地方用一个变量进行代替）用中括号
#进行变量的放置，不需要其他的操作，类似于字符串中对于某一个变量对其的format格式化
template = """
I want you to act as a naming consultant for new companies.
Here are some examples of good company names:
- search engine, Google
- social media, Facebook
- video sharing, YouTube
The name should be short, catchy and easy to remember.
What is a good name for a company that makes {product}?
"""

"""input_variables就是模版中需要填补的变量，在prompttemplate中格式化模版可以将变量以及模版内容进行很好的组合"""
prompt = PromptTemplate(
    input_variables=["product"],
    template=template,
)

print(prompt)

PromptTemplate(input_variables=['product'], output_parser=None, partial_variables={}, template='\nI want you to act as a naming consultant for new companies.\nHere are some examples of good company names:\n- search engine, Google\n- social media, Facebook\n- video sharing, YouTube\nThe name should be short, catchy and easy to remember.\nWhat is a good name for a company that makes {product}?\n', template_format='f-string', validate_template=True)

from langchain import PromptTemplate

#input_variables的值可以为空，说明其中没有任何变量
no_input_prompt = PromptTemplate(input_variables=[], template="Tell me a joke.")
no_input_prompt.format()

#一个input_variable的示例，这样模版化之后的提示将把adjective作为参数传入
one_input_prompt = PromptTemplate(input_variables=["adjective"], template="Tell me a {adjective} joke.")
one_input_prompt.format(adjective="funny")

#多个input_variables的示例，模版后的提示将adjective和content作为参数传入
multiple_input_prompt = PromptTemplate(
    input_variables=["adjective", "content"],
    template="Tell me a {adjective} joke about {content}."
)
multiple_input_prompt.format(adjective="funny", content="chickens")

from langchain.prompts import load_prompt
#可以加载用json格式写好的prompt
test_prompt = PromptTemplate(
    input_variables=["input"],
    template="{input}, tell me the answer by using Chinese."
)
#将创建好的提示模版格式化，其中的补全的变量就是1+1等于几？
test_prompt.format(input="what is 1+1?")
#然后将创建好的模版保存在指定位置处
test_prompt.save("test_prompt.json")
#加载本地的模版使用到的方法是固定的，将具体文件的位置传入即可
prompt = load_prompt("./test_prompt.json")

from langchain import PromptTemplate, FewShotPromptTemplate
#如下是几个提示示例，让大模型知道几个例子回答的时候可以类比着回答
few_examples = [
    {"word": "happy", "antonym": "sad"},
    {"word": "tall", "antonym": "short"},
]

#我们定义如下的提示模版
example_formatter_template = """
Word: {word}
Antonym: {antonym}\n
"""
#模版格式化提示模版
example_prompt = PromptTemplate(
    input_variables=["word", "antonym"],
    template=example_formatter_template,
)

#现在构建一个少样本提示模版对象：few_shot_prompt
'''
其中的参数有examples, example_prompt, prefix, suffix, input_variables和example_separator。其中，
    examples:示例，样例，这个就是我们写好的几个供大模型了解格式以及例子的具体样例
    example_prompt:具体的模版化后的提示模版，这个可以就是通过promptTemplate构建的提示模版，只等待填入具体的变量，
其格式内容中已经将待补全的变量放在其中
    prefix:前缀，一般作为大模型接受指令的入口，可以去声明大模型即将承担的角色以及告诉大模型即将要做的事情等
    suffix:后缀，一般放置于样例之后，作为提示模版的最后一部分
    input_variables:填补的变量
    example_separator:分割符，分割前缀、样例和后缀的标志
'''
few_shot_prompt = FewShotPromptTemplate(
    examples=few_examples,
    example_prompt=example_prompt,
    prefix="Give the antonym of every input",
    suffix="Word: {input}\nAntonym:",
    input_variables=["input"],
    example_separator="\n\n",
)

print(few_shot_prompt.format(input="big"))

from langchain.prompts.example_selector import LengthBasedExampleSelector
#依然和上面一样，反义词对儿的组合，这里给出下面几种：
few_examples = [
    {"word": "beautiful", "antonym": "ugly"},
    {"word": "outgoing", "antonym": "incoming"},
    {"word": "happy", "antonym": "sad"},
    {"word": "tall", "antonym": "short"},
    {"word": "energetic", "antonym": "lethargic"},
    {"word": "sunny", "antonym": "gloomy"},
    {"word": "windy", "antonym": "calm"},
]
#我们定义如下的提示模版
example_formatter_template = """
Word: {word}
Antonym: {antonym}\n
"""
#模版格式化提示模版
example_prompt = PromptTemplate(
    input_variables=["word", "antonym"],
    template=example_formatter_template,
)

'''
使用LengthBasedExampleSelector选择例子。
其中的examples:同上示例中的作用
example_prompt:同上示例中的作用
max_length:这是格式化后的例子的最大长度。长度由下面的get_text_length函数决定。
'''
example_selector = LengthBasedExampleSelector(
    examples=few_examples,
    example_prompt=example_prompt,
    max_length=25,
)

#现在使用example_selector来创建fewshotprompttemplate
dynamic_prompt = FewShotPromptTemplate(
    example_selector=example_selector,
    example_prompt=example_prompt,
    prefix="Give the antonym of every input",
    suffix="Word: {input}\nAntonym:",
    input_variables=["input"],
    example_separator="\n\n",
)

print(dynamic_prompt.format(input="big"))

long_string = "big and huge and massive and large and gigantic and tall and much much much much much bigger than everything else"
print(dynamic_prompt.format(input=long_string))

from langchain.prompts import (
    ChatPromptTemplate,
    PromptTemplate,
    SystemMessagePromptTemplate,
    AIMessagePromptTemplate,
    HumanMessagePromptTemplate,
)
from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)

system_template="You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(system_template)
human_template="{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
#从格式化的信息中获取完整的聊天信息
chat_prompt.format_prompt(input_language="English", output_language="French", text="I love programming.").to_messages()

prompt=PromptTemplate(
    template="You are a helpful assistant that translates {input_language} to {output_language}.",
    input_variables=["input_language", "output_language"],
)
system_message_prompt = SystemMessagePromptTemplate(prompt=prompt)

from abc import ABC, abstractmethod
from typing import Dict,List
'''它是一个抽象基类，不能被示例化，而是用于定义其他类的接口和规范'''
class BaseExampleSelector(ABC):
    """
    这是一个抽象方法，由派生类实现，以满足BaseExampleSelector接口的要求，这个方法是根据输入变量选择要包含在提示中的示例，返回一个字典列表
    """
    @abstractmethod
    def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:

from langchain.prompts.example_selector.base import BaseExampleSelector
from typing import Dict, List
import numpy as np

class CustomExampleSelector(BaseExampleSelector):

    def __init__(self, examples: List[Dict[str, str]]):
        self.examples = examples

    def add_example(self, example: Dict[str, str]) -> None:
        """添加新的例子来存储一个键"""
        self.examples.append(example)

    def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:
        """根据输入的信息选择要使用的例子"""
        return np.random.choice(self.examples, size=2, replace=False)

examples = [
    {"foo": "1"},
    {"foo": "2"},
    {"foo": "3"}
]

#初始化示例选择器
example_selector = CustomExampleSelector(examples)
#选择示例
example_selector.select_examples({"foo": "foo"})
#将新的例子添加到例子集中
example_selector.add_example({"foo": "4"})
example_selector.examples
#选择示例
example_selector.select_examples({"foo": "foo"})

from langchain.prompts import PromptTemplate
from langchain.prompts import FewShotPromptTemplate
from langchain.prompts.example_selector import LengthBasedExampleSelector
#这些是很多关于创造反义词的例子。
examples = [
    {"input": "happy", "output": "sad"},
    {"input": "tall", "output": "short"},
    {"input": "energetic", "output": "lethargic"},
    {"input": "sunny", "output": "gloomy"},
    {"input": "windy", "output": "calm"},
]
example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Input: {input}\nOutput: {output}",
)
example_selector = LengthBasedExampleSelector(
    examples=examples,
    example_prompt=example_prompt,
    max_length=25,
)
dynamic_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(dynamic_prompt.format(adjective="big"))
long_string = "big and huge and massive and large and gigantic and tall and much much much much much bigger than everything else"
print(dynamic_prompt.format(adjective=long_string))
#You can add an example to an example selector as well.
new_example = {"input": "big", "output": "small"}
dynamic_prompt.example_selector.add_example(new_example)
print(dynamic_prompt.format(adjective="enthusiastic"))

from langchain.prompts.example_selector import SemanticSimilarityExampleSelector
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import FewShotPromptTemplate, PromptTemplate

example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Input: {input}\nOutput: {output}",
)

#这些是很多关于创造反义词的例子。
few_examples = [
    {"input": "happy", "output": "sad"},
    {"input": "tall", "output": "short"},
    {"input": "energetic", "output": "lethargic"},
    {"input": "sunny", "output": "gloomy"},
    {"input": "windy", "output": "calm"},
]
example_selector = SemanticSimilarityExampleSelector.from_examples(
    #这是可以选择的例子清单。
    few_examples,
    #这里使用OpenAI的嵌入方法，用于产生嵌入，而嵌入是用来衡量语义相似性的。
    OpenAIEmbeddings(),
    #这是VectorStore类，用于存储嵌入并进行相似度搜索。
    Chroma,
    #这是要产生的例子的数量。
    k=1
)
similar_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(similar_prompt.format(adjective="worried"))
print(similar_prompt.format(adjective="fat"))
#您也可以向SimilarityExampleSelector添加新的示例。
similar_prompt.example_selector.add_example({"input": "enthusiastic", "output": "apathetic"})
print(similar_prompt.format(adjective="joyful"))

from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI

from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field, validator
from typing import List

#指定使用的大模型
model_name = 'text-davinci-003'
#设置对应的随机性
temperature = 0.0
#model即是调用到的大模型
model = OpenAI(model_name=model_name, temperature=temperature)

#定义你想要的数据结构
"""定义了一个名为Joke的Pydantic模型类，用来表示一个笑话，示例化之后用于提示大模型来填充这个数据结构"""
class Joke(BaseModel):
    """
    setup:字符串类型，使用Field函数指定一个描述字符串，该属性表示笑话的问题部分，也就是笑话的开头
    punchline:字符串类型，同样使用Field函数指定一个描述字符串，表示笑话的答案部分也就是笑话的结尾
    """
    setup: str = Field(description="question to set up a joke")
    punchline: str = Field(description="answer to resolve the joke")
    #你可以用Pydantic轻松地添加自定义逻辑结构。
    """
    装饰器成分，用于标记接下来的方法是一个验证器，验证器是一个函数，接受一个字段值，并返回一个经过验证的值，这里标记的就是
    question_ends_with_question_mark方法是一个验证器，将会用于setup属性
    """
    @validator('setup')
    def question_ends_with_question_mark(cls, field):
        if field[-1] != '?':
            raise ValueError("Badly formed question!")
        return field
#参数值是之前定义的joke类，parser对象的作用是把输出结果解析成一个joke对象
parser = PydanticOutputParser(pydantic_object=Joke)
'''
prompttemplate的两个模版参数占位符是format_instructions和query，但是指定的input_variables是query,
而partial_variables则是指定一个字典，其中包含了键为format_instructions的变量信息，这个值是之前定义的parser对象
调用get_format_instructions方法返回的格式说明字符串
'''
prompt = PromptTemplate(
    template="Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)
#将用户的query传入提示模版中
joke_query = "Tell me a joke."
_input = prompt.format_prompt(query=joke_query)
output = model(_input.to_string())
parser.parse(output)

"""
下面这段代码定一个了一个名为actor的数据结构，它也是基于basemodel类创建的，这个actor有两个属性，分别是name
和file_names，用来表示姓名和演员出演的电影列表，这两个属性上，同样适用field类，为两者分别指定了description属性，用来
描述这两个属性的作用。
其中：
    actor_query:用户输入的问题
    parser:PydanticOutputParser类实例，作用是将输出的结果解析成一个actor对象
    prompt: prompttemplate类实例，包含一个字符串模版和一些变量
"""
class Actor(BaseModel):
    name: str = Field(description="name of an actor")
    film_names: List[str] = Field(description="list of names of films they starred in")

actor_query = "Generate the filmography for a random actor."

parser = PydanticOutputParser(pydantic_object=Actor)

prompt = PromptTemplate(
    template="Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)

_input = prompt.format_prompt(query=actor_query)

output = model(_input.to_string())

parser.parse(output)

from abc import ABC, abstractmethod
from typing import List
from langchain.schema import Document

"""
定义了一个名为BaseRetriever的抽象基类，继承自ABC。该类包含了一个名为get_relevant_documents的方法，该方法接受一个字符串类型的
参数query,并返回一个文档列表(List[Document])。注释中提到了abstractmethod装饰器，这表示get_relevant_documents方法是一个抽象方
法，子类必须实现该方法。
"""
class BaseRetriever(ABC):
    #这个函数的作用是根据输入的查询语句(query)获取相关的文本内容。返回值为一个文档列表，每个文档都是一个Document对象。
    @abstractmethod
    def get_relevant_documents(self, query: str) -> List[Document]:
        """Get texts relevant for a query.

        Args:
            query: string to find relevant texts for

        Returns:
            List of relevant documents
        """

from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.document_loaders import TextLoader
#用于从文件中加载文本数据。其中，参数'state_of_the_union.txt'表示要加载的文件名，
#encoding='utf-8'表示文件的编码格式为UTF-8。具体来说，
#作用是将文件state_of_the_union.txt中的内容读取到内存中，并以字符串的形式存储在变量loader中。
loader = TextLoader('state_of_the_union.txt',encoding='utf-8')

"""
VectorstoreIndexCreator类用于创建向量空间索引(Vector Space Index)。通过调用from_loaders方法来创建一个名为index的对象，
该方法接受一个参数列表，列表中只包含一个元素，即之前提到的TextLoader对象loader。from_loaders方法的作用是将多个文本数据加载器(TextLoader)
封装成一个向量空间索引对象。因此，index的作用是将state_of_the_union.txt文件中的内容读取到内存中，并以字符串的形式存储在变量loader中，然后
使用VectorstoreIndexCreator类将其封装成一个向量空间索引对象index。
"""
from langchain.indexes import VectorstoreIndexCreator
index = VectorstoreIndexCreator().from_loaders([loader])

query = "What did the president say about Ketanji Brown Jackson"
index.query(query)
query = "What did the president say about Ketanji Brown Jackson"
index.query_with_sources(query)

print(index.vectorstore)

index.vectorstore.as_retriever()

#加载文档
documents = loader.load()
#文档切块
from langchain.text_splitter import CharacterTextSplitter
"""
CharacterTextSplitter类用于将文本数据按照指定的大小进行划分(chunking)。接下来，代码通过调用split_documents方法来创建一个名为
text_splitter的对象，该方法接受两个参数：chunk_size表示每个文档被划分成的大小，chunk_overlap表示文档之间的重叠大小。chunk_size被
设置为1000,chunk_overlap被设置为0。然后，代码调用split_documents方法来将documents列表中的文档按照指定的大小进行划分，并返回一个包
含所有划分后文档的列表texts。具体来说，split_documents方法的作用是将一个文本列表按照指定的大小进行划分，并返回一个包含所有划分后文档的
列表。
"""
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
#根据需要从合适的词嵌入方法中选一个进行词嵌入
from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
#下面用词嵌入和块创建向量池
from langchain.vectorstores import Chroma
"""
Chroma类用于将向量空间索引(Vector Space Index)与文本数据结合起来，以实现对文本数据的向量化表示。接下来，代码通过调用
from_documents方法来创建一个名为db的对象，该方法接受两个参数：texts和embeddings。其中，texts是一个包含所有文本数据的列表，
embeddings是一个包含所有向量数据的二维数组。from_documents方法的作用是将指定的文本数据和向量数据结合起来，并返回一个包含所有
文档向量的二维数组。具体来说，from_documents方法的作用是将指定的文本数据和向量数据结合起来，以实现对文本数据的向量化表示。texts
是一个包含所有文本数据的列表，embeddings是一个包含所有向量数据的二维数组。
"""
db = Chroma.from_documents(texts, embeddings)
#创建索引
"""
调用db对象的as_retriever方法来创建一个名为retriever的对象。
该方法的作用是将db对象转换为一个检索器(retriever),以便在后续的计算中使用。
retriever将被用于从数据库中检索与给定查询相关的文档向量。
"""
retriever = db.as_retriever()
#接下来创建一个链并问问题
"""
RetrievalQA类用于实现基于检索器的问答(Question Answering)任务。接下来，代码通过调用from_chain_type方法来创建一个名为qa的对象，
该方法接受三个参数：llm、chain_type和retriever。其中，llm表示语言模型(Language Model),chain_type表示查询类型(query type),
retriever表示检索器(retriever)。from_chain_type方法的作用是根据指定的查询类型和检索器创建一个名为qa的对象，以便在后续的计算中使用。
llm被设置为OpenAI(),chain_type被设置为"stuff",retriever被设置为之前创建的retriever对象。
"""
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=retriever)
query = "What did the president say about Ketanji Brown Jackson"
"""
run方法将执行以下操作：首先从数据库中检索与给定查询相关的文档向量；然后将用户输入的问题与每个文档向量进行匹配，找到最佳的文档向量作为答案；
最后将答案封装成一个三元组返回给用户。
"""
qa.run(query)

index_creator = VectorstoreIndexCreator(
    vectorstore_cls=Chroma,
    embedding=OpenAIEmbeddings(),
    text_splitter=CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
)

from langchain.memory import ConversationBufferMemory

"""
ConversationBufferMemory类用于实现基于记忆缓存(Memories)的对话系统(Conversational System)。接下来，代码通过调用
from_memory方法来创建一个名为memory的对象，该方法不接受任何参数。该方法的作用是根据默认配置创建一个名为memory的对象，以便
在后续的计算中使用。
memory将被用于存储用户和AI之间的对话历史记录。
然后，调用memory对象的chat_memory属性来创建一个名为chat_memory的对话缓存(Conversation Buffer),并向其添加两条消息：一条
是用户发送的消息"hi!",另一条是AI发送的消息"whats up?"。具体来说，chat_memory.add_user_message()方法的作用是将一条用户消
息添加到对话缓存中；而chat_memory.add_ai_message()方法的作用是将一条AI消息添加到对话缓存中。这样，聊天历史记录就被成功地添加
到了对话缓存中。
"""
memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("whats up?")
#加载对话缓存中存储的变量。该方法接受一个空字典作为参数，表示不需要加载任何变量
memory.load_memory_variables({})
#也可以用列表返回历史消息
memory = ConversationBufferMemory(return_messages=True)
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("whats up?")
memory.load_memory_variables({})

from langchain.llms import OpenAI
from langchain.chains import ConversationChain
from langchain import LLMChain, PromptTemplate

"""
最重要的一步是正确设置提示。在下面的提示中，我们有两个输入键：一个用于实际输入，
另一个用于来自 Memory 类的输入。重要的是，我们确保 PromptTemplate 和 ConversationBufferMemory 中的键匹配 ( chat_history)。
"""

template = """You are a chatbot having a conversation with a human.
{chat_history}
Human: {human_input}
Chatbot:"""

prompt = PromptTemplate(
    input_variables=["chat_history", "human_input"], 
    template=template
)
"""
调用ConversationBufferMemory类的构造函数来创建一个名为memory的对话缓存对象，该对象将用于存储对话历史记录。
memory对象将使用"chat_history"作为key来存储对话历史记录。最后，代码调用LLMChain类的构造函数来创建一个名为
llm_chain的对象，该对象将用于执行长文本链模型。llm_chain对象将使用OpenAI()作为llm参数来执行长文本链模型；
将prompt作为prompt参数；将verbose设置为True以打印调试信息；将memory作为memory参数来加载对话缓存中存储的
历史记录。
"""
memory = ConversationBufferMemory(memory_key="chat_history")

llm_chain = LLMChain(
    llm=OpenAI(), 
    prompt=prompt, 
    verbose=True, 
    memory=memory,
)
llm_chain.predict(human_input="Hi there!")

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:

Human: Hi there!
AI:

> Finished chain.

llm_chain.predict(human_input="I'm doing well! Just having a conversation with an AI.")

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: Hi there!
AI:  Hi there! It's nice to meet you. My name is AI. What's your name?
Human: I'm doing well! Just having a conversation with an AI.
AI:

> Finished chain.

llm_chain.predict(input="Tell me about yourself.")

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: Hi there!
AI:  Hi there! It's nice to meet you. My name is AI. What's your name?
Human: I'm doing well! Just having a conversation with an AI.
AI:  That's great! It's always nice to have a conversation with someone new. What would you like to talk about?
Human: Tell me about yourself.
AI:

> Finished chain.

import json

from langchain.memory import ChatMessageHistory
from langchain.schema import messages_from_dict, messages_to_dict

#代码创建了一个名为history的ChatMessageHistory对象
history = ChatMessageHistory()
#向对话历史记录中添加一条用户输入的消息："hi!"
history.add_user_message("hi!")
#向对话历史记录中添加一条AI发出的消息："whats up?"。
history.add_ai_message("whats up?")
dicts = messages_to_dict(history.messages)
print(dicts)

[{'type': 'human', 'data': {'content': 'hi!', 'additional_kwargs': {}}},
 {'type': 'ai', 'data': {'content': 'whats up?', 'additional_kwargs': {}}}]

new_messages = messages_from_dict(dicts)
print(new_messages)

[HumanMessage(content='hi!', additional_kwargs={}),
 AIMessage(content='whats up?', additional_kwargs={})] 

from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
from langchain.memory import ConversationBufferMemory
from langchain import OpenAI, LLMChain
from langchain.utilities import GoogleSearchAPIWrapper

search = GoogleSearchAPIWrapper()
tools = [
    Tool(
        name = "Search",
        func=search.run,
        description="useful for when you need to answer questions about current events"
    )
]

#chat_history请注意PromptTemplate 中变量的用法，它与 ConversationBufferMemory 中的动态键名相匹配。

prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!"

{chat_history}
Question: {input}
{agent_scratchpad}"""

prompt = ZeroShotAgent.create_prompt(
    tools, 
    prefix=prefix, 
    suffix=suffix, 
    input_variables=["input", "chat_history", "agent_scratchpad"]
)
memory = ConversationBufferMemory(memory_key="chat_history")

#我们现在可以使用 Memory 对象构造 LLMChain，然后创建代理。
llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)
agent_chain = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True, memory=memory)

agent_chain.run(input="How many people live in canada?")

agent_chain.run(input="what is their national anthem called?")

prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!"

Question: {input}
{agent_scratchpad}"""

prompt = ZeroShotAgent.create_prompt(
    tools, 
    prefix=prefix, 
    suffix=suffix, 
    input_variables=["input", "agent_scratchpad"]
)
llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)
agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)
agent_without_memory = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
agent_without_memory.run("How many people live in canada?")
agent_without_memory.run("what is their national anthem called?")

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
#使用OpenAI的大模型，默认是text-davinci-003，设置随机性为0.9
llm = OpenAI(temperature=0.9)
#提示模版格式化变量内容
prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)
from langchain.chains import LLMChain
#实例化chain对象
chain = LLMChain(llm=llm, prompt=prompt)

#用chain的run方法来运行指定输入变量的链 
print(chain.run("colorful socks"))

from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
    ChatPromptTemplate,
    HumanMessagePromptTemplate,
)
human_message_prompt = HumanMessagePromptTemplate(
        prompt=PromptTemplate(
            template="What is a good name for a company that makes {product}?",
            input_variables=["product"],
        )
    )
chat_prompt_template = ChatPromptTemplate.from_messages([human_message_prompt])
chat = ChatOpenAI(temperature=0.9)
chain = LLMChain(llm=chat, prompt=chat_prompt_template)
print(chain.run("colorful socks"))

from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
    ChatPromptTemplate,
    HumanMessagePromptTemplate,
)
human_message_prompt = HumanMessagePromptTemplate(
        prompt=PromptTemplate(
            template="What is a good name for a company that makes {product}?",
            input_variables=["product"],
        )
    )
#定义第二个prompt，然后使用llmchain实例化这个对象
second_prompt = PromptTemplate(
    input_variables=["company_name"],
    template="Write a catchphrase for the following company: {company_name}",
)
chat_prompt_template = ChatPromptTemplate.from_messages([human_message_prompt])
chat = ChatOpenAI(temperature=0.9)
chain_one = LLMChain(llm=chat, prompt=chat_prompt_template)
chain_two = LLMChain(llm=llm, prompt=second_prompt)

from langchain.chains import SimpleSequentialChain
overall_chain = SimpleSequentialChain(chains=[chain, chain_two], verbose=True)
#运行chain的run方法，只需要指定第一个链的输入变量。
catchphrase = overall_chain.run("colorful socks")
print(catchphrase)

> Entering new SimpleSequentialChain chain...
Rainbow Sock Co.


"Walk on the wild side with Rainbow Socks!"

> Finished chain.


"Walk on the wild side with Rainbow Socks!"

from langchain.chains import LLMChain
from langchain.chains.base import Chain
from typing import Dict, List
"""
这段代码定义了一个名为ConcatenateChain的类，继承自Chain。该类表示一个将两个链连接在一起的链。
首先从langchain.chains模块中导入LLMChain和Chain类，以及从typing模块中导入Dict和List类型注解。
在ConcatenateChain类中，有两个属性：chain_1和chain_2,分别表示要连接的两个链。这两个属性都是LLMChain类型的实例。
该类还定义了两个方法：input_keys()和output_keys()。其中，input_keys()方法返回连接后输入变量的集合，即两个原始链
的输入变量的并集；而output_keys()方法返回一个字符串列表，表示连接后的输出变量只有一个，名称为concat_output。
最后，该类实现了一个私有方法_call(),用于实际执行连接操作。该方法接受一个字典类型的参数inputs,表示输入变量及其取值。
该方法先调用两个链的run()方法，分别获取它们的输出结果，然后将它们相加得到新的输出结果，并将其存储在一个字典中返回。
"""

class ConcatenateChain(Chain):
    chain_1: LLMChain
    chain_2: LLMChain

    @property
    def input_keys(self) -> List[str]:
        #两个链的输入键的并集
        all_input_vars = set(self.chain_1.input_keys).union(set(self.chain_2.input_keys))
        return list(all_input_vars)

    @property
    def output_keys(self) -> List[str]:
        return ['concat_output']

    def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
        output_1 = self.chain_1.run(inputs)
        output_2 = self.chain_2.run(inputs)
        return {'concat_output': output_1 + output_2}

"""
    prompt_1: PromptTemplate类型，表示一个提示模板，其中包含输入变量"product",
模板为"What is a good name for a company that makes {product}?"。
    chain_1: LLMChain类型，表示一个LLMChain实例，其中llm参数设置为之前定义的llm对象，prompt参数设置为prompt_1。
    chain_2: LLMChain类型，表示一个LLMChain实例，其中llm参数设置为之前定义的llm对象，prompt参数设置为prompt_2。
    concat_chain: ConcatenateChain类型，表示一个连接两个链的对象。其中，chain_1和chain_2属性分别对应上面定义的两个链实例。
    concat_output: 字符串类型，表示调用concat_chain.run()方法后得到的结果。该结果是将chain_1和chain_2输出的结果进行连接
得到的。最后通过打印输出的方式展示连接结果。
"""
prompt_1 = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)
chain_1 = LLMChain(llm=llm, prompt=prompt_1)

prompt_2 = PromptTemplate(
    input_variables=["product"],
    template="What is a good slogan for a company that makes {product}?",
)
chain_2 = LLMChain(llm=llm, prompt=prompt_2)

concat_chain = ConcatenateChain(chain_1=chain_1, chain_2=chain_2)
concat_output = concat_chain.run("colorful socks")
print(f"Concatenated output:\n{concat_output}")

Concatenated output:


Vivid Sockery.

"Step Into Colorful Comfort!"

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI
"""
llm是创建一个OpenAI的LLM模型，温度参数设置为0。
tools 是从指定路径加载工具库，包括"serpapi"和"llm-math"两个工具，并将加载的工具与LLM模型绑定。
agent 是初始化代理，选择指定类型，并使用加载的工具和LLM模型对其进行训练。同时，在训练过程中打印详细输出信息。
"""
llm = OpenAI(temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?")

> Entering new AgentExecutor chain...
 I need to find out who Leo DiCaprio's girlfriend is and then calculate her age raised to the 0.43 power.
Action: Search
Action Input: "Leo DiCaprio girlfriend"
Observation: Nina Agdal: 2016 to 2017 ... Leo and Nina were together for almost exactly a year until a source confirmed their breakup with a very familiar ...
Thought: I need to find out Nina Agdal's age
Action: Search
Action Input: "Nina Agdal age"
Observation: 31 years
Thought: I need to calculate 31 raised to the 0.43 power
Action: Calculator
Action Input: 31^0.43
Observation: Answer: 4.378098500976803

Thought: I now know the final answer
Final Answer: Nina Agdal is Leo DiCaprio's girlfriend and her current age raised to the 0.43 power is 4.378098500976803.

> Finished chain.

"Nina Agdal is Leo DiCaprio's girlfriend and her current age raised to the 0.43 power is 4.378098500976803."

from langchain.agents import load_tools
tool_names = [...]
tools = load_tools(tool_names)
llm = ...
tools = load_tools(tool_names, llm=llm)

import os
os.environ["BING_SUBSCRIPTION_KEY"] = ""
os.environ["BING_SEARCH_URL"] = ""

#导入BingSearchAPIWrapper类，该类用于与Bing搜索引擎进行交互。
from langchain.utilities import BingSearchAPIWrapper
#创建一个BingSearchAPIWrapper对象，并将其赋值给变量search。
search = BingSearchAPIWrapper()
#调用search对象的run()方法，传入参数"python",表示在Bing搜索引擎上搜索关于Python的信息。
search.run("python")
#设置k控制输出结果数目
search = BingSearchAPIWrapper(k=1)
search.run("python")

search = BingSearchAPIWrapper()
search.results("apples", 5)

import os
os.environ["GOOGLE_CSE_ID"] = ""
os.environ["GOOGLE_API_KEY"] = ""
#导入GoogleSearchAPIWrapper类，该类用于与Google搜索引擎进行交互。
from langchain.utilities import GoogleSearchAPIWrapper
#创建一个GoogleSearchAPIWrapper对象，并将其赋值给变量search。
search = GoogleSearchAPIWrapper()
#调用search对象的run()方法，传入参数"Obama's first name?",表示在Google搜索引擎上搜索关于"Obama的名"的信息。
search.run("Obama's first name?")

"""
首先创建一个GoogleSearchAPIWrapper对象search,并传入参数k=1,以便在搜索结果中只返回前一条结果。
然后调用search对象的run()方法，传入参数"python",以在Google搜索引擎上搜索关于Python的信息。
接着再次创建一个GoogleSearchAPIWrapper对象search,并传入空值，以便清空之前搜索的结果。
最后调用search对象的results()方法，传入参数"apples"和5,以在Google搜索引擎上搜索关于苹果的信息，并返回前5个结果。
"""
search = GoogleSearchAPIWrapper(k=1)
search.run("python")
search = GoogleSearchAPIWrapper()
search.results("apples", 5)

import os
os.environ["SERPER_API_KEY"] = ""

from langchain.utilities import GoogleSerperAPIWrapper
search = GoogleSerperAPIWrapper()
search.run("Obama's first name?")
os.environ['OPENAI_API_KEY'] = "YOUR_OPENAI_KEY"
from langchain.utilities import GoogleSerperAPIWrapper
from langchain.llms.openai import OpenAI
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType

"""
首先创建一个OpenAI的LLM模型，温度参数设置为0。
然后创建一个GoogleSerperAPIWrapper对象search,用于在Google搜索引擎上进行搜索。
接着定义一个包含一个工具的列表tools,其中工具名称为"Intermediate Answer",其功能
为调用search对象的run()方法进行搜索，并将搜索结果作为答案返回。
接下来初始化一个agent，也就是self_ask_with_search,该agent使用tools列表中的工具与LLM模型
交互，并支持使用"self ask with search"方式进行提问。
最后调用self_ask_with_search对象的run()方法，传入问题,以获取相应的答案。
"""
llm = OpenAI(temperature=0)
search = GoogleSerperAPIWrapper()
tools = [
    Tool(
        name="Intermediate Answer",
        func=search.run,
        description="useful for when you need to ask with search"
    )
]

self_ask_with_search = initialize_agent(tools, llm, agent=AgentType.SELF_ASK_WITH_SEARCH, verbose=True)
self_ask_with_search.run("What is the hometown of the reigning men's U.S. Open champion?")

"""
首先导入PythonREPL类，该类用于在Python解释器中执行交互式代码。
接着创建一个PythonREPL对象python_repl,以便在Python解释器中执行代码。
最后调用python_repl对象的run()方法，传入一条简单的Python语句"print(3**3)",以打印出数字27的值。
"""
from langchain.utilities import PythonREPL
python_repl = PythonREPL()
python_repl.run("print(3**3)")

"""
首先导入BashProcess类，该类用于在Linux系统中执行命令行操作。
接着创建一个BashProcess对象bash,以便在Linux系统中执行命令行操作。
最后调用bash对象的run()方法，传入一条简单的命令"echo 'My name is 
name'",以在终端上打印出字符串"My name is name"。
"""
from langchain.utilities import BashProcess
bash = BashProcess()
print(bash.run(' echo "My name is name" '))

from langchain.utilities import WikipediaAPIWrapper
wikipedia = WikipediaAPIWrapper()
wikipedia.run('HUNTER X HUNTER')

from langchain.agents import Tool,AgentExecutor
from langchain.agents import BaseSingleActionAgent
from langchain import OpenAI, SerpAPIWrapper
from typing import List, Tuple, Any, Union
from langchain.schema import AgentAction, AgentFinish
"""
创建了一个名为 search 的 SerpAPIWrapper 对象。然后，定义了一个名为 tools 的列表，
其中包含了一个名为 "Search" 的 Tool 对象。这个 Tool 对象可以被调用，其功能是搜索相关信息。
接着，定义了一个名为 FakeAgent 的类，继承自 BaseSingleActionAgent。这个类的作用是模拟一
个假的智能体，它有一个输入键(input_keys)属性，用于接收用户输入。在 plan() 方法中，根据当前
状态和用户输入决定要采取什么行动，返回一个 AgentAction 或 AgentFinish 对象。最后，创建了
一个名为 agent 的 FakeAgent 对象，并通过 AgentExecutor.from_agent_and_tools() 方法
创建了一个 AgentExecutor 对象。然后调用了 run() 方法，传入了一个查询语句 "How many people
 live in canada as of 2023?",该查询将由智能体执行。
"""
search = SerpAPIWrapper()
tools = [
    Tool(
        name = "Search",
        func=search.run,
        description="useful for when you need to answer questions about current events",
        return_direct=True
    )
]
class FakeAgent(BaseSingleActionAgent):
    @property
    def input_keys(self):
        return ["input"]
    
    def plan(
        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
    ) -> Union[AgentAction, AgentFinish]:
        return AgentAction(tool="Search", tool_input=kwargs["input"], log="")

    async def aplan(
        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
    ) -> Union[AgentAction, AgentFinish]:
        return AgentAction(tool="Search", tool_input=kwargs["input"], log="")

agent = FakeAgent()
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
agent_executor.run("How many people live in canada as of 2023?")

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
import re
"""定义了一个名为 search 的搜索引擎对象，并将其封装成一个 Tool 对象添加到
tools 列表中，以便在后续的任务执行过程中使用。
"""
search = SerpAPIWrapper()
tools = [
    Tool(
        name = "Search",
        func=search.run,
        description="useful for when you need to answer questions about current events"
    )
]

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}"""
template

class CustomPromptTemplate(StringPromptTemplate):
    template: str
    tools: List[Tool]
    def format(self, **kwargs) -> str:
        intermediate_steps = kwargs.pop("intermediate_steps")
        thoughts = ""
        for action, observation in intermediate_steps:
            thoughts += action.log
            thoughts += f"\nObservation: {observation}\nThought: "
        kwargs["agent_scratchpad"] = thoughts
        kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
        return self.template.format(**kwargs)

prompt = CustomPromptTemplate(
    template=template,
    tools=tools,
    input_variables=["input", "intermediate_steps"]
)