Instruction:
Provide a detailed plan to solve the following problem using the available tools. Each plan should correspond to an evidence value, which will be the output of one of the available functions given an input string. This string could be the user's question, one or more previous evidence values, or a combination of both.

Here are the tools at your disposal:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding a suitable list of sites that may or may not contain the answer to the user's question. The function does not directly answer the question; instead, it locates a list of sites that might have the answer.
PageLoader[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and the output is plain text containing the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and generates a plain text, newline-delimited response of links.
KnowledgeModel[input]: A question-answering language model, particularly effective in answering questions based on an input passage of text. The input must be a text question that refers to an :evidence[n]: variable, e.g., What color is the dog, given :evidence1:?

Each function requires a simple string as input, without quotation marks or "+" to concatenate a string with an evidence variable, e.g., KnowledgeModel[What is the population of New York City, given :evidence3:?]

Ensure that there is only one evidence output per plan step.

The output should adhere to the following format:
Plan: [First action to take based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action to take, based on the result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :evidence0"]
...
Final Answer: [:evidence[n]: Containing the final answer.]

Question: Who designed the Eiffel Tower and what other notable structures did they design?

Response:
Plan: Initiate a web search to determine who designed the Eiffel Tower.
:evidence0: = DuckDuckGo[Eiffel Tower designer]
Plan: Utilize the knowledge model to interpret the search results and identify the designer.
:evidence1: = KnowledgeModel[Who designed the Eiffel Tower, given :evidence0:?]
Plan: Carry out another web search to locate other notable structures designed by the identified architect.
:evidence2: = DuckDuckGo[Notable structures designed by :evidence1:]
Plan: Extract pertinent links from the DuckDuckGo search results for a more targeted search.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Employ the page loader tool to extract data from the relevant links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, use the knowledge model to identify and summarize the other notable structures designed by the architect from the extracted information.
:evidence5: = KnowledgeModel[What other notable structures were designed by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Please develop a plan to answer the following question using the tools provided. Each step of your plan should be followed by an evidence variable that corresponds to the output of one of the available functions, given an input string that can either be the user's question, previous evidence values, or both.

Here are the tools you have at your disposal:

1. DuckDuckGo[input]: This tool allows users to search for information using the DuckDuckGo search engine. It is useful in finding relevant websites that may contain answers to the user's question. The function does not directly provide an answer; it generates a list of sites that might have the answer.
2. TextParser[input]: Extracts and organizes important information from plain text. The input must be a plain text string.
3. LinkExtractor[input]: Pulls out links from plain text and provides a plain text response containing newline-separated links.
4. KnowledgeBaseQA[input]: A question-answering tool particularly adept at answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

The input to each function should be a simple string without quotes or "+" signs to concatenate a string with an evidence variable (for example, KnowledgeBaseQA[What is the capital of France, given :evidence3:?]).

Each step of your plan should include only one evidence output.

Your output should follow this format:
Plan: [first action to take based on input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some major achievements of Elon Musk?

Response:
Plan: Start by conducting a web search to find information about Elon Musk's major achievements.
:evidence0: = DuckDuckGo[Elon Musk major achievements]
Plan: Use the link extractor to get the relevant links from the search results.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Extract information from the selected links using the TextParser tool.
:evidence2: = TextParser[:evidence1:]
Plan: Finally, use the KnowledgeBaseQA tool to summarize Elon Musk's major achievements from the extracted information.
:evidence3: = KnowledgeBaseQA[What are some major achievements of Elon Musk? Given :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Create a plan to answer the following question using the available tools. Each step in your plan should be followed by an evidence value that is generated from one of the available functions.

Here are the tools you can use:
SearchEngine[input]: A tool that allows users to search for information on the internet. The input should be a string related to the query.
InfoExtractor[input]: This tool extracts specific pieces of information from a given text. The input must be a text and a query about the text.
TextSummarizer[input]: Summarizes large texts into smaller, more manageable chunks. The input should be a lengthy piece of text.
QA[input]: Tool that answers questions based on common sense and general world knowledge or from a given context.

The output format should be as follows:
Plan: [First action]
#E1 = [Function call with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next function call with input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: What is the history of the Eiffel Tower and who designed it?

Response:
Plan: Search for information about the Eiffel Tower.
#E1 = SearchEngine[Eiffel Tower]
Plan: Extract information about the designer of the Eiffel Tower.
#E2 = InfoExtractor[Who designed the Eiffel Tower? Given context: #E1]
Plan: Extract information about the history of the Eiffel Tower.
#E3 = InfoExtractor[What is the history of the Eiffel Tower? Given context: #E1]
Plan: Summarize the history of the Eiffel Tower.
#E4 = TextSummarizer[#E3]
Final Answer: #E4 and #E2

System: A chat.


Instruction:
Generate a comprehensive plan to respond to the user's request using the designated tools. Be sure to attach an evidence tag to every stage of your plan.

Available Tools:
CurrencyConverter[input]: Converts between different currencies.
WeatherAPI[input]: Provides weather forecasts for specified locations.
FlightTracker[input]: Gives real-time updates on flight statuses.
HotelFinder[input]: Finds hotels based on user-specified criteria.
GeniusAI[input]: Answers questions based on general knowledge or given context.

Output Format:
Plan: Initial step according to the input question
:Evidence0: = Function to perform with appropriate input
Plan: Following step influenced by the result of :Evidence0:
:Evidence1: = Upcoming function to execute with its input, potentially referencing earlier evidence such as "Based on :Evidence0:"
...
Answer: [:EvidenceN: containing the ultimate solution.]

Question: I'm planning a trip from London to Tokyo next week. Can you tell me the current exchange rate, the weather forecast in Tokyo, my flight status, and suggest a good hotel? Also, what is the time difference between London and Tokyo?

Response:
Plan: Start by finding the current exchange rate from London to Tokyo.
:Evidence0: = CurrencyConverter[GBP to JPY]

Plan: After getting the exchange rate, proceed to get the weather forecast in Tokyo for next week.
:Evidence1: = WeatherAPI[Tokyo, next week]

Plan: Following the weather forecast, check the status of the user's flight from London to Tokyo.
:Evidence2: = FlightTracker[London to Tokyo, next week]

Plan: Once we have the flight details, find a good hotel in Tokyo based on user-specified criteria.
:Evidence3: = HotelFinder[Tokyo, next week]

Plan: Finally, determine the time difference between London and Tokyo.
:Evidence4: = GeniusAI[What is the time difference between London and Tokyo?]

Answer: The current exchange rate from GBP to JPY is :Evidence0:. The weather forecast in Tokyo for next week is :Evidence1:. Your flight status from London to Tokyo is :Evidence2:. Based on your preferences, I suggest this hotel in Tokyo: :Evidence3:. The time difference between London and Tokyo is :Evidence4:.

System: A chat.


Instruction:
Create a plan to answer the following question using these available tools. Each tool should be followed by one evidence variable.

Tools:
Bing[input]: This function allows you to search for information on Bing. It can find a list of sites that may contain the answer.
TextReader[input]: This tool reads and extracts text from an input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIML[input]: A language model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should follow this format:
Plan: [first action]
:evidence0: = [function with input parameter]
Plan: [next action]
:evidence1: = [next function with input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who is the current president of Microsoft and what are some of their major achievements?

Response:
Plan: Start by conducting a web search to identify the current president of Microsoft.
:evidence0: = Bing[Current president of Microsoft]
Plan: Use the AIML tool to interpret the search results and determine the name of the president.
:evidence1: = AIML[Who is the current president of Microsoft, given :evidence0:?]
Plan: Conduct another web search to find the major achievements of the identified president of Microsoft.
:evidence2: = Bing[Major achievements of :evidence1:]
Plan: Extract the relevant links from the Bing search results for further analysis.
:evidence3: = LinkCollector[:evidence2:]
Plan: Use the TextReader tool to extract information from the relevant links.
:evidence4: = TextReader[:evidence3:]
Plan: Finally, use the AIML tool to summarize the major achievements of the president from the extracted information.
:evidence5: = AIML[What are the major achievements of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to respond to the following user instruction using the provided tools. For each step in your plan, provide an associated evidence value, which will be the output of a function given an input string that could be the user's query, prior evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: A tool that lets users perform searches on DuckDuckGo. Useful for identifying potential sources of answers to the user's question.
WebCrawler[input]: Takes one or more URLs from the input string (separated by newlines) and outputs the plaintext contents of those pages.
URLPicker[input]: Extracts URLs from plaintext and provides a plaintext, newline-separated list of URLs.
InfoBot[input]: A question-answering language model. Its input should be a textual question that references an :evidence[n]: variable.

Output format:
Plan: [initial action based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action, informed by the outcome of :evidence0:]
:evidence1: = [following function to call and its input parameter, potentially referring back to earlier evidence]
...
Final Answer: [:evidence[n]: holding the ultimate answer]

Question: Who was Nikola Tesla and what were his most significant inventions?

Response:
Plan: Start with a DuckDuckGo search to gather information on Nikola Tesla and his inventions.
:evidence0: = DuckDuckGo[Nikola Tesla inventions]
Plan: Extract pertinent URLs from the DuckDuckGo search results for deeper analysis.
:evidence1: = URLPicker[:evidence0:]
Plan: Deploy the WebCrawler tool to glean information from the chosen URLs.
:evidence2: = WebCrawler[:evidence1:]
Plan: Lastly, employ InfoBot to identify and summarise Nikola Tesla's biography and his most notable inventions from the collated data.
:evidence3: = InfoBot[Who was Nikola Tesla and what were his most significant inventions? Given :evidence2:]
Final Answer: :evidence3:

System: A chat.


Instruction:
Develop a systematic plan to solve the following problem using the listed tools. Each step in your plan should be accompanied by an evidence value representing the output of a function.

Tools Available:
NetSearch[input]: Searches the internet for information related to the input.
URLExtractor[input]: Extracts URLs from a block of text.
PageReader[input]: Reads webpage content from the provided URLs.
QuerySolver[input]: Answers questions based on a given context. The input should reference a #Evidence[n] variable.

Output Format:
Plan: [Initial action based on the input question]
#Evidence1 = [Function to call with input parameter]
Plan: [Following action based on the result of #Evidence1]
#Evidence2 = [Next function to call with input parameter, possibly referencing previous evidence]
...
Final Solution: #Evidence[n]

Question: When did the Renaissance period begin and end, and what were its major contributions to art?

Response:
Plan: Initiate a NetSearch to gather information about the Renaissance period.
#Evidence1 = NetSearch[Renaissance period]
Plan: Use QuerySolver to find out when the Renaissance period began and ended.
#Evidence2 = QuerySolver[When did the Renaissance period begin and end? Given context: #Evidence1]
Plan: Extract URLs from the initial search to delve deeper into the topic.
#Evidence3 = URLExtractor[#Evidence1]
Plan: Read the content of the webpages linked in the URLs.
#Evidence4 = PageReader[#Evidence3]
Plan: Lastly, use QuerySolver to identify the major contributions of the Renaissance period to art.
#Evidence5 = QuerySolver[What were the major contributions of the Renaissance period to art? Given context: #Evidence4]
Final Solution: #Evidence2 and #Evidence5

System: A chat.


Instruction:
Create a sequential plan to solve the user's question using the tools listed below. Each step in your plan should produce an evidence value, which will be the output of one of the available functions given an input string that could be the user's question, prior evidence values, or a combination of both.

Tools available:
DuckDuckGo[input]: Allows users to perform searches using the DuckDuckGo search engine. Useful for locating websites that might contain the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string (which contains newline separated links), producing a plain text output containing the website(s)' content.
URLExtractor[input]: Extracts URLs from plain text and returns a plain text, newline-separated list of URLs.
InfoBot[input]: A question-answering language model that provides answers based on an input text passage. The input must be a textual question that references an :info[n]: variable.

Function inputs should be plain strings, without quotes or "+" symbols to concatenate a string with an info variable, e.g., InfoBot[What is the population of New York City, given :info1:?]

Make sure to include only one evidence output per plan step.

Output format:
Plan: [First action based on input question]
:info0: = [Function call with input parameter]
Plan: [Next action based on result of :info0:]
:info1: = [Next function call and input parameter, potentially referencing previous evidence, e.g., "Given context :info0"]
...
Final Answer: [:info[n]: Containing the final answer.]

Question: Who was Leonardo da Vinci and what were some of his most famous works?

Response:
Plan: Begin by performing a web search to gather information about Leonardo da Vinci.
:info0: = DuckDuckGo[Leonardo da Vinci]
Plan: Use the language model to interpret the search results and provide information about Leonardo da Vinci.
:info1: = InfoBot[Who was Leonardo da Vinci, given :info0:?]
Plan: Perform another web search to find out about Leonardo da Vinci's most famous works.
:info2: = DuckDuckGo[Leonardo da Vinci famous works]
Plan: Extract the relevant URLs from the search results for further examination.
:info3: = URLExtractor[:info2:]
Plan: Load the content of the identified websites for detailed information.
:info4: = SiteLoader[:info3:]
Plan: Finally, utilize the language model to summarize Leonardo da Vinci's most famous works from the loaded website content.
:info5: = InfoBot[What are some of Leonardo da Vinci's most famous works, given :info4:?]
Final Answer: :info1: and :info5:

System: A chat.


Instruction:
Formulate a comprehensive plan to answer the user's inquiry utilizing the provided tools. Each stage of your plan should produce an evidence value, representing the outcome of one of the available functions when supplied with an appropriate input string. This string could be the original user question, one or more earlier evidence values, or a mix of both.

Available Tools:
WikiSearch[input]: Searches Wikipedia for information related to the input query.
QA_Solver[input]: Answers questions using either general world knowledge or a given context that may contain the answer.
NewsSearch[input]: Finds recent news articles related to the input query.
ArticleSummarizer[input]: Summarizes long articles into shorter texts.

Output Format:
Plan: [Initial action based on the user's question]
#E1 = [Called function with necessary input]
Plan: [Next action based on the result of #E1]
#E2 = [Following function to call with necessary input, potentially referring to previous evidence such as "Given context #E1"]
...
Final Answer: #E[n]

Question: What is quantum computing and how has it been used recently?

Response:
Plan: Start by searching for information about quantum computing.
#E1 = WikiSearch[Quantum computing]
Plan: Use the QA solver to extract a simple explanation of what quantum computing is.
#E2 = QA_Solver[What is quantum computing? Given context: #E1]
Plan: Look for recent news about the application of quantum computing.
#E3 = NewsSearch[Recent applications of quantum computing]
Plan: Summarize the found news articles to get a brief overview of their content.
#E4 = ArticleSummarizer[#E3]
Plan: Finally, use the QA solver to understand how quantum computing has been used recently.
#E5 = QA_Solver[How has quantum computing been used recently? Given context: #E4]
Final Answer: #E2 and #E5

System: A chat.


Instruction:
Construct a plan to solve: "What are the ingredients of a Margherita pizza and where did it originate?"

Tools available:
RecipeFinder[input]: Tool that provides recipes and ingredient lists for various dishes.
FoodOrigin[input]: Tool that provides information about the origin of different foods.
QA[input]: Tool that answers questions using general world knowledge.

Output format:
Plan: first action
#E1 = function with input parameter
Plan: next action, based on #E1
#E2 = next function with input parameter (may reference previous evidence)
...
Final Answer: #E[n]

Response:
Plan: first action
#E1 = RecipeFinder["Margherita pizza"]
Plan: next action, based on #E1
#E2 = FoodOrigin["Margherita pizza"]
Final Answer: The ingredients of a Margherita pizza are {#E1.ingredients} and it originated in {#E2.origin}.

System: A chat.


Instruction:
Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools.  Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string
 that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
BERT[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

Be sure to only include one evidence output per plan step.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what was their most famous work?

Response:
Plan: Start by searching who won the Nobel Prize in Literature in 2020.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2020 winner]
Plan: Use BERT to determine the winner from the search results.
:evidence1: = BERT[Who won the Nobel Prize in Literature in 2020? Given context: :evidence0:]
Plan: Search for the most famous work of the identified author.
:evidence2: = DuckDuckGo[Most famous work of :evidence1:]
Plan: Extract the relevant links from the search results.
:evidence3: = URLFinder[:evidence2:]
Plan: Scrape the contents of the obtained links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use BERT to identify the most famous work of the author from the scraped contents.
:evidence5: = BERT[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Question answering AI model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the population of Tokyo and what are some of its most popular tourist attractions?

Response:
Plan: Begin by conducting a web search to find out the current population of Tokyo.
:evidence0: = Bing[Current population of Tokyo]
Plan: Utilize the AIQA model to interpret the search results and find the population figure.
:evidence1: = AIQA[What is the current population of Tokyo, given :evidence0:?]
Plan: Conduct another web search to find the most popular tourist attractions in Tokyo.
:evidence2: = Bing[Most popular tourist attractions in Tokyo]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the WebScraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the AIQA model to identify and summarize the most popular tourist attractions in Tokyo from the extracted information.
:evidence5: = AIQA[What are the most popular tourist attractions in Tokyo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to solve the problem presented in the following question using the tools outlined below. For each step in your plan, assign an associated evidence value (#E[index]) that represents the output of a specific function given its input parameters.

Tools Available:
BingSearch[input]: Tool that enables users to perform a Bing search. It does not provide direct answers but generates a list of potentially relevant websites.
URLLoader[input]: Loads the content of one or more websites from an input string containing newline separated URLs.
HyperlinkExtractor[input]: Extracts hyperlinks from a block of plain text and returns them in a newline-separated format.
KnowledgeInterpreter[input]: Language model designed to answer questions based on a given piece of text. The input should be a question referencing a #E[index] variable.

Output Format:
Plan: [Initial action based on the question]
#E1 = [Function to execute with input parameters]
Plan: [Subsequent action based on #E1]
#E2 = [Next function to execute with input parameters, possibly referring to prior evidence like "Considering #E1"]
...
Final Answer: #E[n]

Question: Who invented the telephone and what were some significant events in their life?

Response:
Plan: Begin by performing a Bing search to determine who invented the telephone.
#E1 = BingSearch[Inventor of the telephone]
Plan: Utilize the KnowledgeInterpreter to process the search results and identify the inventor.
#E2 = KnowledgeInterpreter[Who invented the telephone? Considering #E1]
Plan: Perform another Bing search to uncover significant events in the life of the inventor.
#E3 = BingSearch[Significant events in the life of #E2]
Plan: Extract pertinent links from the search results for further exploration.
#E4 = HyperlinkExtractor[#E3]
Plan: Load the content of the chosen links using URLLoader.
#E5 = URLLoader[#E4]
Plan: Lastly, employ the KnowledgeInterpreter to summarize the significant events in the inventor's life from the loaded content.
#E6 = KnowledgeInterpreter[What were significant events in the life of #E2? Considering #E5]
Final Answer: #E6

System: A chat.


Instruction:
Please generate a plan to solve the following question using the available tools. Each step of your plan should be followed by an evidence value, which will represent the output of one of the functions with an input string that can be the user's question, previous evidence values, or both.

Here are the tools you can use:
Bing[input]: This tool allows users to search for information on Bing. It is useful in finding relevant websites that may contain answers to the user's questions.
TextExtractor[input]: Extracts text from a website given its URL. The input must be a single link and the output is plain text containing the content of the webpage.
LinkFinder[input]: Finds links within plain text and produces a list of URLs.
AIAnswerer[input]: A language model designed to answer questions based on provided context. The input must be a question that references an :evidence[n]: variable.

Each function only accepts plain strings as inputs. To concatenate a string with an evidence variable, simply write them together without quotes or "+" symbols, e.g., AIAnswerer[What is the capital of France, given :evidence3:?]

The format of your response should be:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action, based on result of :evidence0:]
:evidence1: = [next function call with input parameter, possibly referencing previous evidence]
...
Final Answer: [:evidence[n]: with final answer.]

Question: Who was the architect of the Eiffel Tower and what other structures did they design?

Response:
Plan: Use Bing to find out who the architect of the Eiffel Tower was.
:evidence0: = Bing[Eiffel Tower architect]
Plan: Use AIAnswerer to interpret the search results and identify the architect.
:evidence1: = AIAnswerer[Who was the architect of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another Bing search to find other structures designed by this architect.
:evidence2: = Bing[:evidence1: + ' other designs']
Plan: Extract the relevant links from the Bing search results.
:evidence3: = LinkFinder[:evidence2:]
Plan: Extract text from the most relevant link.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use AIAnswerer to summarize the other structures designed by the architect.
:evidence5: = AIAnswerer[What other structures were designed by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Develop a step-by-step execution plan to respond to the user's query, utilizing the set of available tools. Each plan will correspond to an evidence value, which is the output of one of the available functions given an input string that could be the user's question, previous evidence values, or both.

Here are the tools available to be called:
BingSearch[input]: Tool that allows the user to search for information using Bing. It helps in finding sites that might contain the answer to the user's question.
SiteReader[input]: Load a website from the input string (a single link) and produce plain text output containing the content of the link.
URLCollector[input]: Extract URLs from plain text and produce a newline-delimited response of URLs.
AIAnswerer[input]: An AI model that answers questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable, e.g., What is the population of New York City, given :evidence1:?

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who is the current Prime Minister of Canada and what are some significant policies they implemented?

Response:
Plan: Start by conducting a web search to determine the current Prime Minister of Canada.
:evidence0: = BingSearch[Current Prime Minister of Canada]
Plan: Use the AI Answerer to parse the search results and identify the name of the Prime Minister.
:evidence1: = AIAnswerer[Who is the current Prime Minister of Canada, given :evidence0:?]
Plan: Perform another web search to find significant policies implemented by the identified Prime Minister.
:evidence2: = BingSearch[Significant policies implemented by :evidence1:]
Plan: Extract the relevant URLs from the Bing search results for more focused research.
:evidence3: = URLCollector[:evidence2:]
Plan: Use the SiteReader tool to extract information from the relevant URLs.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, use the AI Answerer to identify and summarize the significant policies implemented by the Prime Minister from the extracted information.
:evidence5: = AIAnswerer[What are the significant policies implemented by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a comprehensive plan to answer the following user inquiry, utilizing the listed tools. Each step in your plan should produce a piece of evidence, which represents the output of a particular function after receiving its input. This input could be the initial user question, any previously generated evidence, or a combination thereof.

Here are the tools at your disposal:
YahooSearch[input]: Allows users to perform searches via Yahoo. It generates a list of potential sites that might hold the answer, but does not provide the answer directly.
WebReader[input]: Accepts one or more URLs (divided by newlines) as input and yields the plaintext contents of those pages.
HyperlinkGatherer[input]: Gathers hyperlinks from plaintext and delivers them as newline-separated plaintext.
InfoProcessor[input]: An AI language model that can answer questions if supplied with a textual context. The input has to be a question referring to an :evidence[n]: variable, like "How old is Queen Elizabeth II, given :evidence1:?"

Each function's input should be a straightforward string, devoid of quotation marks or '+' symbols used to merge strings with evidence variables. For example, InfoProcessor[What is the population of Tokyo, given :evidence3:?].

Make sure every plan step includes just one piece of evidence.

Your output should follow this structure:
Plan: [First action derived from input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Next action, influenced by the result of :evidence0:]
:evidence1: = [Following function to call with input parameter, possibly referring to earlier evidence like "In light of :evidence0"]
...
Final Response: [:evidence[n]: which holds the final answer.]

Question: How did the Great Fire of London start and what were its consequences?

Response:
Plan: Initiate a web search to discover how the Great Fire of London started.
:evidence0: = YahooSearch[Great Fire of London cause]
Plan: Extract relevant URLs from the search results for deeper analysis.
:evidence1: = HyperlinkGatherer[:evidence0:]
Plan: Read the contents of the chosen websites for detailed inspection.
:evidence2: = WebReader[:evidence1:]
Plan: Use the info processor to ascertain how the Great Fire of London began based on the read website contents.
:evidence3: = InfoProcessor[How did the Great Fire of London start, given :evidence2:?]
Plan: Now, initiate a separate web search to learn about the consequences of the Great Fire of London.
:evidence4: = YahooSearch[Great Fire of London consequences]
Plan: Gather pertinent URLs from this fresh batch of search results.
:evidence5: = HyperlinkGatherer[:evidence4:]
Plan: Read the contents of these newly-chosen websites.
:evidence6: = WebReader[:evidence5:]
Plan: Lastly, employ the info processor to understand the consequences of the Great Fire of London based on the second round of website contents.
:evidence7: = InfoProcessor[What were the consequences of the Great Fire of London, given :evidence6:?]
Final Response: :evidence3: and :evidence7:

System: A chat.


Instruction:
Develop a plan to solve the query: "Who invented the telephone and when was it patented?" Here are the available tools:

1. Encyclopedia[input]: Searches for factual information from an online encyclopedia.
2. TimeMachine[input]: Provides historical data related to a specific event or person.
3. AnswerBot[input]: Answers questions given a certain context.

Each step should have a corresponding evidence value. The final output should be presented as follows:
Step 1: [action]
#Evidence1 = [tool with input]
Step 2: [action]
#Evidence2 = [tool with input]
...
Final Result: #EvidenceN

Response:
Step 1: Search for who invented the telephone using the Encyclopedia tool.
#Evidence1 = Encyclopedia[Inventor of Telephone]
Step 2: Use AnswerBot to extract the inventor's name from the obtained information.
#Evidence2 = AnswerBot[Who invented the telephone? Given context: #Evidence1]
Step 3: Use the TimeMachine tool to find out when the telephone was patented.
#Evidence3 = TimeMachine[Telephone patent date]
Step 4: Use AnswerBot to confirm the patent date from the obtained information.
#Evidence4 = AnswerBot[When was the telephone patented? Given context: #Evidence3]
Final Result: #Evidence2 and #Evidence4

System: A chat.


Instruction:
Develop a plan to solve the following problem using the tools at your disposal. For each step in your plan, specify an evidence value that corresponds to the output of a particular function, taking into account the user's query, prior evidence values, or both.

These are the tools you can use:
DuckDuckGo[input]: A tool that lets users search for information via DuckDuckGo. It helps locate potential sources that might contain the user's desired information.
SiteReader[input]: Reads websites specified by newline-separated links in the input string. Outputs plain text comprising the contents of these sites.
URLGrabber[input]: Pulls URLs from plain text, producing a newline-separated list of links.
RoboQA[input]: A robot-powered Q&A model adept at generating answers from an input text passage. Input should be a text-based question that references an :evidence[n]: variable.

Each function requires a basic string as input, devoid of quotation marks or "+" signs used to concatenate strings with evidence variables (for example, RoboQA[Who won the 1998 World Cup, given :evidence3:?]).

Output should follow this format:
Plan: [initial action based on the input question]
:evidence0: = [call to function with input parameter]
Plan: [subsequent action based on the outcome of :evidence0:]
:evidence1: = [next call to function and input parameter, potentially referencing earlier evidence such as "Given context :evidence0"]
...
Answer: [:evidence[n]: that contains the ultimate answer.]

Question: Who was Ada Lovelace and what were her contributions to computing?

Response:
Plan: Initiate a web search to learn who Ada Lovelace was.
:evidence0: = DuckDuckGo[Ada Lovelace]
Plan: Extract pertinent links from the search results.
:evidence1: = URLGrabber[:evidence0:]
Plan: Read the content of the extracted links for more comprehensive data.
:evidence2: = SiteReader[:evidence1:]
Plan: Utilize the robot-powered Q&A model to determine Ada Lovelace's identity and contributions to computing from the read content.
:evidence3: = RoboQA[Who was Ada Lovelace and what were her contributions to computing, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. Each step of your plan should correspond with an evidence value, which will be the output of one of the available functions given an input string that can be the user question, previous evidence values, or both.

Here are the tools available to you:
WebSearch[input]: This tool allows you to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkGatherer[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: A question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2005 and what was their most famous work?

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2005.
:evidence0: = WebSearch[Nobel Prize in Literature 2005 winner]
Plan: Use AnswerBot to interpret the search results and identify the winner.
:evidence1: = AnswerBot[Who won the Nobel Prize in Literature in 2005, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = WebSearch[Most famous work of :evidence1:]
Plan: Extract relevant links from the Google search results for detailed information.
:evidence3: = LinkGatherer[:evidence2:]
Plan: Use TextScraper to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, use AnswerBot to identify and summarize the most famous work of the laureate from the extracted information.
:evidence5: = AnswerBot[What is the most famous work of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Devise a systematic approach to answer this question using these tools:
EncyclopediaLookup[input]: Looks up encyclopedia entries related to the input.
BookScanner[input]: Scans books for relevant sections.
SummaryGenerator[input]: Generates summaries of large bodies of text.
AccuracyTester[input]: Tests the accuracy of statements.
ContextualReplier[input]: Replies to inquiries based on contextual understanding.

Question: What are the origins and cultural significance of the Japanese tea ceremony?

Response:
1. Use EncyclopediaLookup["Japanese tea ceremony"] to get a general understanding and background information about the Japanese tea ceremony.

2. Use BookScanner["Japanese tea ceremony origins"] and BookScanner["Japanese tea ceremony cultural significance"] to gather more detailed information from books related to these topics.

3. Feed the results obtained from the encyclopedia lookup and book scanner into SummaryGenerator to create concise summaries of the origins and cultural significance of the Japanese tea ceremony.

4. To ensure the accuracy of the gathered information, use AccuracyTester on the generated summaries.

5. Finally, use ContextualReplier to formulate a comprehensive answer to the question based on the accurate summaries.

System: A chat.


Instruction:
Develop a comprehensive plan to solve the following user instruction using the tools provided. Each plan must correspond to an evidence value, which will be the output of one of the functions using an input string that could be the user's question, one or more previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: A tool that enables users to conduct an internet search using Bing. This tool provides a list of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from the input string containing newline delimited links. Input is one or more links, and outputs plain text containing the site's content.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
NLPModel[input]: Natural language processing model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., Who won the world series in 2020, given :evidence1:?

The output should be in the following format:
Plan: [first action to take based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what challenges did they face?

Response:
Plan: Begin by conducting a web search to find out who was the first person to climb Mount Everest without supplemental oxygen.
:evidence0: = Bing[First person to climb Mount Everest without supplemental oxygen]
Plan: Utilize the NLP model to interpret the search results and find the name of the climber.
:evidence1: = NLPModel[Who was the first person to climb Mount Everest without supplemental oxygen, given :evidence0:?]
Plan: Conduct another web search to find the challenges faced by the identified climber during their ascent.
:evidence2: = Bing[Challenges faced by :evidence1: climbing Mount Everest without supplemental oxygen]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use the SiteReader tool to extract information from the relevant links.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, utilize the NLP model to identify and summarize the challenges faced by the climber from the extracted information.
:evidence5: = NLPModel[What were the challenges faced by :evidence1: while climbing Mount Everest without supplemental oxygen, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a detailed plan to solve the following query, making use of the provided tools. Store the output of each tool into an evidence variable (#E[index]).

Available Tools:
1. Encyclopedia[input]: Searches for comprehensive and detailed information about a topic from online encyclopedias.
2. QA_System[input]: Answers questions based on general knowledge or given context.
3. CurrencyConverter[input]: Converts one currency to another at the current exchange rate.

Output Format:
Plan: [first action]
#E1 = [tool call with input]
Plan: [second action]
#E2 = [next tool call with input referencing previous evidence if needed]
...
Final Answer: #E[n]

Question: How much would 1000 Euros be worth in the country where the author of "War and Peace" was born?

Response:
Plan: Search for the author of "War and Peace".
#E1 = Encyclopedia["War and Peace"]
Plan: Identify the birthplace of the author.
#E2 = QA_System[Who is the author of "War and Peace" and where were they born? Given context: #E1]
Plan: Determine the local currency of the author's birthplace.
#E3 = Encyclopedia[#E2]
Plan: Convert 1000 Euros to the local currency of the author's birthplace.
#E4 = CurrencyConverter[1000 Euros to #E3]
Final Answer: #E4

System: A chat.


Instruction:
Design a plan to answer the question: "Who wrote the novel 'Pride and Prejudice'?"

Here are the tools available:
BookLookup[input]: Tool that provides information about books and their authors.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
AuthorInfo[input]: Provides information about authors and their works.
LitAnalysis[input]: Analyses literary texts and extracts key details.
LLM[input]: Question answering language model.

The output should be in format:
Plan: first action to take based in input question
#E1 = function to call with input parameter
Plan: next action to take, based on result of #E1
#E2 = next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"
...
Final answer: #E[n]

Response:
Plan: The first action is to use the QA tool which can answer questions from common sense and general world knowledge.
#E1 = QA["Who wrote the novel 'Pride and Prejudice'?"]

Final answer: #E1

System: A chat.


Instruction:
Develop a detailed plan to solve the problem at hand. Each plan should utilize one of the available tools and store the output in a variable #E[index].

Available Tools:
Wiki[input]: Searches Wikipedia for information related to the input query.
Translate[input]: Translates the input text into English.
KnowledgeBase[input]: Can answer questions directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

The output should follow this format:
Plan: [First Action]
#E1 = [Function with Input Parameter]
Plan: [Next Action Based on Result of #E1]
#E2 = [Next Function Call and Input Parameter]
...
Final Answer: #E[n]

Question: What is the significance of the Sistine Chapel ceiling and who painted it?

Response:
Plan: Begin by searching for information about the Sistine Chapel ceiling on Wikipedia.
#E1 = Wiki[Sistine Chapel Ceiling]
Plan: Translate the obtained information into English.
#E2 = Translate[#E1]
Plan: Use the KnowledgeBase tool to determine the significance of the Sistine Chapel ceiling.
#E3 = KnowledgeBase[What is the significance of the Sistine Chapel ceiling? Given context: #E2]
Plan: Use the same KnowledgeBase tool to identify who painted the Sistine Chapel ceiling.
#E4 = KnowledgeBase[Who painted the Sistine Chapel ceiling? Given context: #E2]
Final Answer: #E3 and #E4

System: A chat.


Instruction:
Create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Physics in 2020 and what was their contribution?

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = Bing[Nobel Prize in Physics 2020 winner]
Plan: Use a language model to interpret the search results and find the name of the laureate.
:evidence1: = SAM[Who won the Nobel Prize in Physics in 2020, given :evidence0:?]
Plan: Conduct another web search to find the key contributions made by the identified laureate.
:evidence2: = Bing[:evidence1: + ' key contributions']
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use a web reader tool to extract information from the relevant links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the key contributions made by the laureate from the extracted information.
:evidence5: = SAM[What were the key contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a step-by-step execution plan to respond to the user's request using the tools provided. Each step corresponds to an evidence value, which represents the output of a function given specific inputs.

Tools Available:
DuckDuckGo[input]: A tool that enables users to conduct a web search using DuckDuckGo. It finds a list of websites that might contain the answer to the user's question.
HTMLParser[input]: Loads one or more websites from the input string (containing newline-separated links), producing a plain-text output of the website contents.
URLExtractor[input]: Extracts URLs from plain text, providing a plain-text, newline-separated list of URLs.
TransformerQA[input]: A QA language model effective at answering questions based on an input text passage. The input should be a textual question referencing a #E[index] variable.

Output Format:
Plan: [Initial action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Subsequent action based on the outcome of #E1]
#E2 = [Next function to call with input parameter, potentially referring to prior evidence]
...
Final Answer: #E[n]

Question: Who designed the Sydney Opera House and what was their architectural style?

Response:
Plan: Start by performing a web search to identify the designer of the Sydney Opera House.
#E1 = DuckDuckGo[Designer of Sydney Opera House]
Plan: Use a language model to interpret the search results and identify the designer.
#E2 = TransformerQA[Who designed the Sydney Opera House? Given context: #E1]
Plan: Perform another web search to learn about the architectural style of the identified designer.
#E3 = DuckDuckGo[Architectural style of #E2]
Plan: Extract relevant URLs from the search results for further investigation.
#E4 = URLExtractor[#E3]
Plan: Use the HTML parser to extract information from the selected URLs.
#E5 = HTMLParser[#E4]
Plan: Lastly, use the language model to determine and summarize the architectural style of the designer from the parsed information.
#E6 = TransformerQA[What is the architectural style of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Please provide a step-by-step plan to answer the following question using the available tools. Each step should have an associated evidence value, which will be the output of one of the available functions given an input string that can be the user's query, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from a website and produces plain text output containing the content of the site.
LinkFinder[input]: Extracts links from plain text and produces a plain text response of links.
KnowledgeBase[input]: A tool that answers questions based on common knowledge and facts. The input must be a text question that references a :data[n]: variable, e.g., What color is the sky, given :data1:?

The input to each function should just be a plain string, without quotes or "+" to concatenate a string with a data variable, e.g., KnowledgeBase[What is the capital of France, given :data3:?]

Each plan should only include one evidence output.

The output should be in format:
Plan: [first action to take based on input question]
:data0: = [function to call with input parameter]
Plan: [next action to take, based on result of :data0:]
:data1: = [next function to call and input parameter, which may include reference to previous data, e.g., "Given context :data0"]
...
Answer: [:data[n]: containing the final answer.]

Question: Who wrote the book "To Kill a Mockingbird" and what other books did they write?

Response:
Plan: Start by conducting a web search to find out who wrote "To Kill a Mockingbird".
:data0: = WebSearch["Author of To Kill a Mockingbird"]
Plan: Use the KnowledgeBase tool to interpret the search results and identify the author.
:data1: = KnowledgeBase[Who wrote the book "To Kill a Mockingbird", given :data0:?]
Plan: Conduct another web search to find other books written by the identified author.
:data2: = WebSearch[Other books written by :data1:]
Plan: Extract the relevant links from the search results for further investigation.
:data3: = LinkFinder[:data2:]
Plan: Use the TextExtractor tool to extract information from the relevant links.
:data4: = TextExtractor[:data3:]
Plan: Finally, use the KnowledgeBase tool to summarize the other books written by the author from the extracted information.
:data5: = KnowledgeBase[What other books were written by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
For the following tasks, make plans that can solve the problem step-by-step. For each plan, indicate which external tool together with tool input to retrieve evidence. You can store the evidence into a variable #E[index] that can be called by later tools.

Here are the tools available to be called:
WikiBot[input]: Tool that allows the user to search for information from Wikipedia.
QueryMaster[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Each plan should be followed by exactly one evidence (#E[index]) value.

The output should be in format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence]
...
Final answer: #E[n]

Question: What is the significance of Fibonacci sequence in nature?

Response:
Plan: Search for more information about Fibonacci sequence in nature.
#E1 = WikiBot[Fibonacci sequence in nature]
Plan: Find out the significance of Fibonacci sequence in nature.
#E2 = QueryMaster[What is the significance of Fibonacci sequence in nature? Given context: #E1]
Final answer: #E2

And so on until 10 unique instruction/response pairs are generated.

System: A chat.


Instruction:
Develop a comprehensive plan to address the user's inquiry utilizing the following tools. Each step in your plan should correspond to an evidence value, which will be the output of one of the available functions given an input string that can be the user's question, earlier evidence values, or both.

Here are the tools available to use:
NetSearch[input]: Tool that enables the user to perform an internet search. This tool is beneficial in locating suitable websites that may hold the answer to the user's question.
ContentExtractor[input]: Extracts plain text from a webpage link provided as input and outputs plain text containing the contents of the page.
HyperlinkFinder[input]: Extracts hyperlinks from plain text and generates a plain text response of links.
QueryBot[input]: A question-answering bot that provides answers based on an input text passage. The input must be a text question that refers to a #E[n] variable, e.g., How tall is the Eiffel Tower, given #E1?

Each function's input should simply be a plain string, without quotation marks or "+" to concatenate a string with an evidence variable, e.g., QueryBot[Who wrote War and Peace, given #E3?]

Ensure that there is only one evidence output per plan step.

The output format should be:
Plan: [initial action based on input question]
#E1 = [function to call with input parameter]
Plan: [subsequent action based on result of #E1]
#E2 = [next function to call and input parameter, which may refer to previous evidence, e.g., "Given context #E1"]
...
Final Answer: #E[n]

Question: Who were the key players involved in the Apollo 11 mission and what were their roles?

Response:
Plan: Begin by performing an internet search to find out who the key players in the Apollo 11 mission were.
#E1 = NetSearch[Key players in Apollo 11 mission]
Plan: Utilize the QueryBot to interpret the search results and identify the names of the key players.
#E2 = QueryBot[Who were the key players in the Apollo 11 mission, given #E1?]
Plan: Perform another internet search to find out the roles of these key players in the mission.
#E3 = NetSearch[Roles of #E2 in Apollo 11 mission]
Plan: Extract the relevant links from the search results for further investigation.
#E4 = HyperlinkFinder[#E3]
Plan: Use the ContentExtractor tool to extract information from the relevant links.
#E5 = ContentExtractor[#E4]
Plan: Finally, utilize the QueryBot to identify and summarize the roles of the key players in the Apollo 11 mission from the extracted information.
#E6 = QueryBot[What were the roles of #E2 in the Apollo 11 mission, given #E5?]
Final Answer: #E6

System: A chat.


Instruction:
Develop a plan to solve the following query using the mentioned tools. Every tool must be utilized at least once and every plan step should produce an evidence value.

Tools Available:
DuckDuckGo[input]: This tool lets you search for information via the DuckDuckGo search engine. It helps in locating a range of websites that might hold the answer to the user's query.
PlainTextParser[input]: This tool examines a text chunk and pinpoints crucial details like names, locations, dates, etc.
URLGatherer[input]: Gathers all URLs from a specified text.
WebpageDataExtractor[input]: Pulls out specific data from a website using a URL.
QnA[input]: A tool capable of answering questions based on general knowledge or context supplied by preceding evidence.

Output Format:
Plan: [First action to take based on input question]
#Evidence1 = [Function to call with input parameter]
Plan: [Subsequent action to take, depending on the outcome of #Evidence1]
#Evidence2 = [Next function to call and input parameter, possibly referencing prior evidence, e.g., "Considering context #Evidence1"]
...
Final Answer: #Evidence[n]

Question: What year did NASA launch the Mars Rover Perseverance and what were its primary objectives?

Response:
Plan: Utilize DuckDuckGo to discover when NASA launched the Mars Rover Perseverance.
#Evidence1 = DuckDuckGo[Mars Rover Perseverance launch date]
Plan: Employ PlainTextParser to determine the launch year from the search results.
#Evidence2 = PlainTextParser[#Evidence1]
Plan: Again use DuckDuckGo to look up the primary objectives of the Mars Rover Perseverance.
#Evidence3 = DuckDuckGo[Primary objectives of Mars Rover Perseverance]
Plan: Apply URLGatherer to accumulate links pertaining to the rover's primary objectives.
#Evidence4 = URLGatherer[#Evidence3]
Plan: Leverage WebpageDataExtractor to draw out information about the rover's primary objectives from one of the gathered links.
#Evidence5 = WebpageDataExtractor[#Evidence4]
Plan: Lastly, utilize QnA to validate the primary objectives of the Mars Rover Perseverance.
#Evidence6 = QnA[What were the primary objectives of Mars Rover Perseverance? Considering context: #Evidence5]
Final Answer: #Evidence6

System: A chat.


Instruction:
Create a step-by-step plan to answer the user's question, making use of available tools. Each plan will have an associated evidence value, which is the output from one of the available functions given an input string that can be the user's question, previous evidence values, or both.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a website link provided as input and produces a plain text output containing the content of the site.
LinkLister[input]: Extracts links from plain text and provides a list of links as output.
NLPModel[input]: Natural Language Processing model capable of answering questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., What color is the cat, given #E1?

The input to each function should be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g., NLPModel[What is the capital of Michigan, given #E3?]

Each plan should be followed by exactly one evidence (#E[index]) value.

The output should be in format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"]
...
Final answer: #E[n]

Question: Who won the Nobel Prize in Literature in 2020 and what was their most acclaimed work?

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
#E1 = DuckDuckGo[Nobel Prize in Literature 2020 winner]
Plan: Use the NLP Model to interpret the search results and identify the winner.
#E2 = NLPModel[Who won the Nobel Prize in Literature in 2020, given #E1?]
Plan: Conduct another web search to find the most acclaimed work of the identified laureate.
#E3 = DuckDuckGo[Most acclaimed work of #E2]
Plan: Extract the relevant links from the DuckDuckGo search results for more detailed information.
#E4 = LinkLister[#E3]
Plan: Use the TextExtractor tool to extract information from the relevant links.
#E5 = TextExtractor[#E4]
Plan: Finally, utilize the NLP Model to identify and summarize the most acclaimed work of the laureate from the extracted information.
#E6 = NLPModel[What is the most acclaimed work of #E2, given #E5?]
Final answer: #E6

System: A chat.


Instruction:
Construct a systematic plan to generate an optimal response to the user's query, leveraging the range of tools at your disposal. Each phase of your plan should correspond to an evidence value, which will be the output of one of the accessible functions when supplied with an input string that could be the user's question, preceding evidence values, or both.

The following tools are available for use:
1. Ecosia[input]: This tool enables the user to carry out an internet search using the Ecosia search engine. It creates a list of possible websites that might hold the answer to the user's question.
2. PageLoader[input]: This function retrieves one or more websites from the input string, which comprises newline-separated links, and delivers plain text output containing the content of the pages.
3. URLCollector[input]: This tool mines links from plain text and produces a plain text, newline-separated list of links.
4. KnowledgeEngine[input]: A question-answering language model, particularly skilled at delivering answers based on an input text passage. The input has to be a text question that refers to an :evidence[n]: variable.

The output should comply with the following format:
Plan: [First action to undertake based on the input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Next action to undertake, based on the outcome of :evidence0:]
:evidence1: = [Next function to invoke and input parameter, which may refer to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the origin story of Batman and how has the character evolved over time?

Response:
Plan: Kick off by conducting a web search to gather information about the origin story of Batman.
:evidence0: = Ecosia[Origin story of Batman]
Plan: Deploy the KnowledgeEngine to interpret the search results and provide a succinct overview of Batman's origin story.
:evidence1: = KnowledgeEngine[What is the origin story of Batman? Given context: :evidence0:?]
Plan: Execute another web search to trace the evolution of the Batman character over time.
:evidence2: = Ecosia[Evolution of Batman character over time]
Plan: Extract the pertinent links from the search results for a more comprehensive study.
:evidence3: = URLCollector[:evidence2:]
Plan: Use the PageLoader tool to fetch information from the extracted links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, deploy the KnowledgeEngine to summarize Batman's character evolution over time from the fetched data.
:evidence5: = KnowledgeEngine[How has the character of Batman evolved over time? Given context: :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a step-by-step plan to respond to the user query using the available tools. Each action in your plan should be associated with an evidence value, which will be the output of one of the provided functions given an input string that can either be the user's question, previous evidence values, or both.

Here are the tools you can use:
Bing[input]: A tool that lets users search for information via Bing search engine. This tool is helpful in finding relevant sites that may contain answers to the user's question. The function doesn't directly answer the question; it finds a list of sites that might have the answer.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, useful in answering questions based on an input passage of text.  The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The input to each function just needs to be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g. QAModel[What is the capital of France, given :evidence3:?]

Remember to include only one evidence output per plan step.

The output should follow this format:
Plan: [first action to take based on input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2018 and what was their most famous work?

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2018.
:evidence0: = Bing[Nobel Prize in Literature 2018 winner]
Plan: Use a language model to interpret the search results and identify the winner.
:evidence1: = QAModel[Who won the Nobel Prize in Literature in 2018, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = Bing[Most famous work of :evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the most famous work of the laureate from the extracted information.
:evidence5: = QAModel[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to address the following inquiry using the available resources. Each stage should have a corresponding piece of evidence, which is the output generated by executing the chosen function with the proper inputs.

Available Tools:
YahooSearch[input]: Allows users to conduct information searches through Yahoo. Useful for locating potential sources of answers.
PageLoader[input]: Takes a URL as input and retrieves the full text content of the page.
URLPicker[input]: Extracts all URLs from a given text and presents them as a simple list.
InfoAssistant[input]: Answers questions using either common sense, general world knowledge, or specific information provided in a context. To refer to previously obtained evidence, use #Evidence[index].

Output Format:
Plan: [First step based on the initial question]
#Evidence1 = [Function to be performed with suitable inputs]
Plan: [Next step based on the result of #Evidence1]
#Evidence2 = [Subsequent function to perform with required inputs, potentially referring back to previous evidence]
...
Final Response: #Evidence[n]

Question: What is quantum entanglement and how does it work?

Response:
Plan: Initiate a search for information on quantum entanglement.
#Evidence1 = YahooSearch[Quantum Entanglement]
Plan: Pick out the most pertinent links from the search results.
#Evidence2 = URLPicker[#Evidence1]
Plan: Load the text content of the selected pages.
#Evidence3 = PageLoader[#Evidence2]
Plan: Query InfoAssistant to describe quantum entanglement using the collected data.
#Evidence4 = InfoAssistant[What is quantum entanglement? Given context: #Evidence3]
Plan: Request InfoAssistant to explain how quantum entanglement works using the same context.
#Evidence5 = InfoAssistant[How does quantum entanglement work? Given context: #Evidence3]
Final Response: #Evidence4 and #Evidence5

System: A chat.


Instruction:
Please create a step-by-step plan to generate an answer to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the current population of Tokyo and what are some famous landmarks there?

Response:
Plan: Start by conducting a web search to find out the current population of Tokyo.
:evidence0: = Bing[Current population of Tokyo]
Plan: Use a language model to interpret the search results and find the population figure.
:evidence1: = QAModel[What is the current population of Tokyo, given :evidence0:?]
Plan: Conduct another web search to find the famous landmarks in Tokyo.
:evidence2: = Bing[Famous landmarks in Tokyo]
Plan: Extract the relevant links from the Bing search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the famous landmarks in Tokyo from the extracted information.
:evidence5: = QAModel[What are some famous landmarks in Tokyo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to answer the following query using the tools provided. Each part of your plan should generate an evidence value, which will be the outcome of one of the available functions given an input string that could be the user's question, earlier evidence values, or both.

Tools available:
FactFinder[input]: This tool lets you search for factual information online. It doesn't provide direct answers but generates a list of potentially helpful sites.
InfoExtractor[input]: This tool extracts links from plain text and provides a plain text, newline-delimited response of links.
DataDigger[input]: This tool loads one or more websites from the input string (containing newline-delimited links) and outputs plain text containing the site contents.
QuerySolver[input]: This is a question-answering language model that excels at providing answers based on an input text passage. The input should be a text question referencing an #E[index] variable.

Output format:
Plan: [initial action based on input question]
#E1 = [function to call with input parameter]
Plan: [subsequent action based on result of #E1]
#E2 = [next function to call and input parameter, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: Who designed the Sydney Opera House and what other notable buildings did they design?

Response:
Plan: Begin by searching for the designer of the Sydney Opera House.
#E1 = FactFinder[Designer of Sydney Opera House]
Plan: Use QuerySolver to interpret the search results and identify the designer.
#E2 = QuerySolver[Who designed the Sydney Opera House? Given context: #E1]
Plan: Conduct another search to find other notable buildings designed by the identified architect.
#E3 = FactFinder[Notable buildings designed by #E2]
Plan: Extract relevant links from the search results for more detailed information.
#E4 = InfoExtractor[#E3]
Plan: Use DataDigger to gather information from the relevant links.
#E5 = DataDigger[#E4]
Plan: Lastly, use QuerySolver to identify and summarize the other notable buildings designed by the architect from the gathered information.
#E6 = QuerySolver[What other notable buildings were designed by #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Develop a sequential plan to solve the problem below, making use of the tools provided. Each step in your plan should produce an evidence value, which is the output of one of the available functions when fed an input string that could be the user's question, previous evidence values, or a combination of both.

These are the tools you can use:

1. WebSearch[input]: This tool lets users search for information via a renowned search engine. It helps locate a range of sites that may hold the answer to the user's question. The function does not offer direct answers but locates potential sources of these answers.
2. SiteReader[input]: This tool reads one or more websites indicated by the input string containing newline separated links. The input consists of one or more URLs, and the output is plain text containing the contents of these sites.
3. URLCollector[input]: This tool extracts URLs from plain text and generates a plain text, newline-separated list of URLs.
4. QueryMaster[input]: This is a language model designed to answer questions based on a supplied passage of text. The input has to be a textual question that references a :evidence[n]: variable, such as "What is the dog's breed, given :evidence1:?"

Each function requires a simple string as input, without quotation marks or "+" to join a string with an evidence variable, like QueryMaster[What is the population of Brazil, given :evidence2:?]

Ensure that each plan step includes just one evidence output.

The output should follow this format:
Plan: [initial action derived from input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action derived from the outcome of :evidence0:]
:evidence1: = [next function to call and input parameter, possibly referring to prior evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the historical significance of the Rosetta Stone and where is it currently located?

Response:
Plan: Initiate a web search to find information about the historical significance of the Rosetta Stone.
:evidence0: = WebSearch[Rosetta Stone historical significance]
Plan: Utilize the language model to analyze the search results and outline the historical significance of the Rosetta Stone.
:evidence1: = QueryMaster[What is the historical significance of the Rosetta Stone, given :evidence0:?]
Plan: Perform another web search to determine the current location of the Rosetta Stone.
:evidence2: = WebSearch[Current location of the Rosetta Stone]
Plan: Extract pertinent links from the search results for further investigation.
:evidence3: = URLCollector[:evidence2:]
Plan: Employ the site reader tool to extract information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, use the language model to ascertain and state the current location of the Rosetta Stone from the gathered information.
:evidence5: = QueryMaster[Where is the Rosetta Stone currently located, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
ScraperTool[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractorTool[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some major accomplishments of Albert Einstein?

Response:
Plan: Start by conducting a web search to find out about Albert Einstein's major accomplishments.
:evidence0: = Bing[Major accomplishments of Albert Einstein]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence1: = LinkExtractorTool[:evidence0:]
Plan: Use ScraperTool to extract information from the relevant links.
:evidence2: = ScraperTool[:evidence1:]
Plan: Finally, utilize QAModel to identify and summarize the major accomplishments of Albert Einstein from the extracted information.
:evidence3: = QAModel[What are some major accomplishments of Albert Einstein, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Question: Who composed the music for the movie 'Inception' and what other movies has he/she worked on?

Here are the tools available to be called:
IMDb[input]: Tool that provides information about movies, TV shows, and celebrities.
ComposerFinder[input]: Finds the composer of a specified movie or show.
FilmographyExtractor[input]: Extracts the filmography of a specified person.

The output should be in format:
Plan: first action to take based on input question
#E1 = function to call with input parameter
Plan: next action to take, based on result of #E1
#E2 = next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"
...
Final answer: #E[n]

Response:
Plan: First, find the composer of the movie 'Inception'. Then, extract the filmography of that person.

#E1 = ComposerFinder['Inception']
Plan: Use the name of the composer from #E1 to find their other works.
#E2 = FilmographyExtractor[#E1]
Final answer: #E2

System: A chat.


Instruction:
Generate a step-by-step execution plan to solve the problem presented in the user instruction, using the tools provided. Each plan should be followed by exactly one evidence (#E[index]) value.

Available tools:
DuckDuckGo[input]: Tool that enables users to search for information via DuckDuckGo search engine. It finds a list of sites that might have the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline-delimited links. Input is one or more links, and it produces plain text output containing the link contents.
LinkCollector[input]: Extracts links from plain text and provides a plain text, newline-delimited response of links.
QuerySolver[input]: A question-answering language model. Particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

Output format:
Plan: [First action based on input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on result of #E1]
#E2 = [Next function to call and input parameter, possibly referring to previous evidence]
...
Final Answer: #E[n]

Question: What is the tallest building in New York City and when was it completed?

Response:
Plan: Begin by searching for the tallest building in New York City.
#E1 = DuckDuckGo[Tallest building in New York City]
Plan: Utilize QuerySolver to interpret the search results and identify the building.
#E2 = QuerySolver[What is the tallest building in New York City? Given context: #E1]
Plan: Search for the completion date of the identified building.
#E3 = DuckDuckGo[Completion date of #E2]
Plan: Extract the relevant links from the search results for detailed information.
#E4 = LinkCollector[#E3]
Plan: Use SiteLoader to extract information from the relevant links.
#E5 = SiteLoader[#E4]
Plan: Finally, utilize QuerySolver to determine the completion date of the building from the extracted information.
#E6 = QuerySolver[When was #E2 completed? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question using the available tools. Each tool will generate an evidence value that can be used in subsequent steps.

Available Tools:
SearchEngine[input]: This tool allows you to search for information on the internet. The input is a string query and the output is a list of websites that may contain relevant information.
TextExtractor[input]: Extracts text from a website given its URL. The input is a string containing the URL, and the output is plain text content of the webpage.
QA[input]: Can answer questions based on common sense, general world knowledge or given context. The input should be a question string which may reference previous evidence variables as context.
DataAnalyzer[input]: Analyzes data and extracts key points. Particularly useful when dealing with large amounts of text or data. Input must be a text string referencing an evidence variable.

The output format should be:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action based on #E1]
#E2 = [next function call with input parameter, possibly referencing #E1]
...
Final Answer: #E[n]

Question: What are some of the main tourist attractions in Paris?

Response:
Plan: Start by searching for information about tourist attractions in Paris.
#E1 = SearchEngine[Tourist attractions in Paris]
Plan: Extract the text from the most relevant link found.
#E2 = TextExtractor[#E1]
Plan: Use the QA tool to identify the main tourist attractions mentioned in the extracted text.
#E3 = QA[What are the main tourist attractions in Paris? Given context: #E2]
Plan: Analyze the response to extract key points.
#E4 = DataAnalyzer[#E3]
Final Answer: #E4

System: A chat.


Instruction:
Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
SiteLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the history of the Eiffel Tower and who was its architect?

Response:
Plan: Start by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = Bing[History of the Eiffel Tower]
Plan: Use a language model to interpret the search results and summarize the history of the Eiffel Tower.
:evidence1: = QAModel[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find out who the architect of the Eiffel Tower was.
:evidence2: = Bing[Architect of the Eiffel Tower]
Plan: Utilize the language model to identify the architect of the Eiffel Tower from the search results.
:evidence3: = QAModel[Who was the architect of the Eiffel Tower, given :evidence2:?]
Answer: :evidence1: and :evidence3:

System: A chat.


Instruction:
Develop a step-by-step execution plan to solve the user's problem using the provided tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user's question, previous evidence values, or both.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables the user to search for information using the DuckDuckGo search engine. It helps in finding suitable sites that might contain the answer to the user's question.
PageLoader[input]: Loads one or more websites from the input string containing newline separated links. The input is one or more links, and it generates plain text output containing the content of the pages.
LinkPicker[input]: Picks links from plain text and gives a plain text, newline-separated response of links.
NLPModel[input]: Natural Language Processing Model, particularly useful in answering questions based on an input text passage. The input should be a text question that refers to a :evidence[n]: variable, e.g., What is the weather like, given :evidence1:?

Each function's input should simply be a plain string, without quotes or "+" to join a string with an evidence variable, e.g., NLPModel[What is the population of New York City, given :evidence3:?]

Only include one evidence output per plan step.

The output should be in format:
Plan: [first action to take based on input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who was awarded the Nobel Prize in Literature in 2021 and what is their most famous work?

Response:
Plan: Begin by conducting a web search to find out who won the 2021 Nobel Prize in Literature.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2021 winner]
Plan: Utilize the NLP model to interpret the search results and find the name of the laureate.
:evidence1: = NLPModel[Who won the Nobel Prize in Literature in 2021, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = DuckDuckGo[Most famous work of :evidence1:]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use the PageLoader tool to extract information from the relevant links.
:evidence4: = PageLoader[:evidence3:]
Plan: Finally, utilize the NLP model to identify and summarize the most famous work of the laureate from the extracted information.
:evidence5: = NLPModel[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to answer the following question using these tools: WikiSearch[input], QASystem[input], GoogleMaps[input], WebScraper[input], LinkCollector[input] and TextAnalyzer[input]. Each tool must be used at least once, and one of them should be a question answering system similar to "QA". The output format should include an execution plan followed by exactly one evidence variable.

Here are the descriptions for each tool:

WikiSearch[input]: This tool allows you to search for information from Wikipedia. It is particularly useful in gaining knowledge about people, places, companies, historical events, etc.

QASystem[input]: A tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

GoogleMaps[input]: Tool that provides geographical data based on the input string. Useful for finding locations or getting geographical details about a place.

WebScraper[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.

LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.

TextAnalyzer[input]: Analyzes a piece of text and extracts key pieces of information such as names, dates, locations, etc.

The output should be in this format:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action]
#E2 = [next function call with input parameter]
...
Final Answer: #En

Question: What is the history of the Eiffel Tower and how far is it from the Louvre Museum?

Response:
Plan: Search for information about the Eiffel Tower.
#E1 = WikiSearch[Eiffel Tower]
Plan: Extract key historical facts about the Eiffel Tower.
#E2 = TextAnalyzer[#E1]
Plan: Use the question answering system to summarize the history of the Eiffel Tower.
#E3 = QASystem[What is the history of the Eiffel Tower? Given context: #E2]
Plan: Find out the distance between the Eiffel Tower and the Louvre Museum.
#E4 = GoogleMaps[Distance from Eiffel Tower to Louvre Museum]
Plan: Summarize the distance information.
#E5 = QASystem[How far is the Eiffel Tower from the Louvre Museum? Given context: #E4]
Final Answer: History: #E3; Distance: #E5

System: A chat.


Instruction:
Create a step-by-step plan to address the user query, making use of the available tools. Each plan should have a corresponding evidence value.

Here are the tools available to be called:
DuckDuckGo[input]: Allows the user to search for information using DuckDuckGo. Useful in finding potential sources of answers.
WebReader[input]: Loads one or more websites from the input string containing newline delimited links, producing plain text output containing the content of the links.
LinkHarvester[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
JLM[input]: A question-answering language model, particularly useful in answering questions based on an input passage of text.

Output Format:
Plan: [first action to take based in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: Who was the architect behind the design of the Sydney Opera House and what were his other major works?

Response:
Plan: Begin by searching for the architect of the Sydney Opera House.
#E1 = DuckDuckGo[Architect of Sydney Opera House]
Plan: Use JLM to interpret the search results and find the name of the architect.
#E2 = JLM[Who was the architect of the Sydney Opera House? Given context: #E1]
Plan: Conduct another search to find the other major works of the identified architect.
#E3 = DuckDuckGo[Major works of #E2]
Plan: Extract the relevant links from the search results for a detailed search.
#E4 = LinkHarvester[#E3]
Plan: Use WebReader to extract information from the relevant links.
#E5 = WebReader[#E4]
Plan: Lastly, use JLM to identify and summarize the other major works of the architect from the extracted information.
#E6 = JLM[What are the other major works of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.