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:
Google[input]: Tool that allows the user to search for information using the Google search engine.
Scraper[input]: Load one or more websites from the input string containing newline delimited 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.
LLM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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:]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the history of the Eiffel Tower and how was it constructed?

Response:
Plan: Begin by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = Google[History of the Eiffel Tower]
Plan: Utilize a language model to interpret the search results and summarize the history of the Eiffel Tower.
:evidence1: = LLM[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find out how the Eiffel Tower was constructed.
:evidence2: = Google[Construction of the Eiffel Tower]
Plan: Extract the relevant links from the Google search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = Scraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize how the Eiffel Tower was constructed from the extracted information.
:evidence5: = LLM[How was the Eiffel Tower constructed, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a plan to answer the following query using the tools provided. Each step in the plan should correspond to a piece of evidence generated by one of the tools.

Tools Available:
YahooSearch[input]: Uses Yahoo's search engine to gather information related to the input query.
PageLoader[input]: Loads webpage content from one or multiple URLs provided in the input.
HyperlinkFinder[input]: Extracts hyperlinks from a block of text.
ALICE[input]: An AI-driven question-answering tool. It requires a question and a context (which can be a previous #E[index]) to provide an answer.

Output Format:
Plan: [description of the first step]
#E1 = [tool to use with input]
Plan: [description of the subsequent step based on the result of #E1]
#E2 = [next tool to use with input, potentially referring to #E1]
...
Final Answer: #E[n]

Question: What were the main causes of World War I and what countries were primarily involved?

Response:
Plan: Initiate a search for information regarding the main causes of World War I.
#E1 = YahooSearch[Main causes of World War I]
Plan: Employ the AI question-answering tool to determine the main causes of World War I.
#E2 = ALICE[What were the main causes of World War I? Given context: #E1]
Plan: Execute a new search for information about the primary countries involved in World War I.
#E3 = YahooSearch[Countries involved in World War I]
Plan: Extract hyperlinks from the search results for additional exploration.
#E4 = HyperlinkFinder[#E3]
Plan: Load the webpage content from the extracted hyperlinks.
#E5 = PageLoader[#E4]
Plan: Use the AI question-answering tool to identify the primary countries involved in World War I.
#E6 = ALICE[What countries were primarily involved in World War I? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Develop a detailed execution plan to respond to the following query using the below mentioned tools. Each plan will correspond to an evidence value which will be the output of a particular function when supplied with an appropriate input string.

Tools available:
WikiSearch[input]: A tool that searches Wikipedia for information related to the input string.
PageScraper[input]: Scrapes all the text from a webpage whose URL is provided as the input.
URLCollector[input]: Collects all URLs embedded within a piece of text provided as the input.
AIAnswerer[input]: An AI model that answers questions based on a piece of text provided as the input. The input should be a question referencing a :evidence[n]: variable.

Output format:
Plan: [First action]
:evidence0: = [Function to execute with input parameters]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Next function to execute with input parameters, possibly referring to prior evidence]
...
Final Answer: [:evidencen:]

Question: What is the significance of the Battle of Waterloo and who were the key figures involved?

Response:
Plan: Search Wikipedia for information about the Battle of Waterloo.
:evidence0: = WikiSearch[Battle of Waterloo]
Plan: Use the AIAnswerer to identify the significance of the Battle of Waterloo from the obtained information.
:evidence1: = AIAnswerer[What is the significance of the Battle of Waterloo, given :evidence0:?]
Plan: Use the AIAnswerer again to identify the key figures involved in the Battle of Waterloo.
:evidence2: = AIAnswerer[Who were the key figures in the Battle of Waterloo, given :evidence0:?]
Final Answer: :evidence1:, :evidence2:

System: A chat.


Instruction:
Please create a step-by-step plan to generate an optimal 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 combination 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. The function doesn't directly answer the question; it finds a list of sites that may 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]: 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, e.g. What color is the cat, given :evidence1:?

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

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 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 an AI model to interpret the search results and find the name of the laureate.
:evidence1: = AIQA[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: Nobel Prize Contribution]
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 AI model to identify and summarize the key contributions made by the laureate from the extracted information.
:evidence5: = AIQA[What were the key contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools you have at your disposal:

1. Bing[input]: This tool allows users to search for information using the Bing search engine. It doesn't directly answer questions but provides a list of sites that might contain the desired information.
2. SiteReader[input]: This function loads one or more websites from the input string containing newline-delimited links and produces plain text output with the content of those links.
3. LinkPicker[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
4. QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

The output format should look like this:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call and input parameter, possibly referring to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the history of Microsoft Corporation and who is its current CEO?

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

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:
WebSearch[input]: Tool that allows the user to search for information using a general web 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.
PageReader[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 pages.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering 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 notable accomplishments of the scientist Marie Curie?

Response:
Plan: Start by conducting a web search to find out about Marie Curie's accomplishments.
:evidence0: = WebSearch[Marie Curie accomplishments]
Plan: Use the link extractor to get relevant links from the search results.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Utilize the page reader to extract information from these links.
:evidence2: = PageReader[:evidence1:]
Plan: Finally, utilize the QAModel to identify and summarize the notable accomplishments of Marie Curie from the extracted information.
:evidence3: = QAModel[What are some notable accomplishments of Marie Curie? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Generate a step-by-step plan to address the user query, utilizing the provided tools. Each plan will correspond to an evidence value, derived from the output of a function given an input string that could be the user's question, prior evidence values, or a combination thereof.

Available tools:
DuckDuckGo[input]: A tool allowing users to search for information via the DuckDuckGo search engine. Useful for locating potential sources that might hold answers to the user's question.
SiteLoader[input]: Loads one or more websites from an input string comprising newline-separated links. Input is one or more links; output is plain text containing link contents.
HyperlinkExtractor[input]: Pulls out hyperlinks from plain text, returning a plain-text, newline-separated list of links.
InfoModel[input]: A question-answering language model adept at providing answers based on an input text passage. The input needs to be a textual question referencing an :evidence[n]: variable.

Output format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on :evidence0:'s outcome]
:evidence1: = [Next function to call and its input parameter, potentially referring back to earlier evidence]
...
Answer: [:evidence[n]: - contains the final answer]

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what was their motivation?

Response:
Plan: Start with a web search to determine who first climbed Mount Everest without supplemental oxygen.
:evidence0: = DuckDuckGo[First person to climb Mount Everest without supplemental oxygen]
Plan: Use the language model to parse the search results and ascertain the climber's name.
:evidence1: = InfoModel[Who was the first person to climb Mount Everest without supplemental oxygen, given :evidence0:?]
Plan: Perform another web search to uncover the climber's motivations.
:evidence2: = DuckDuckGo[Motivation of :evidence1: to climb Mount Everest without supplemental oxygen]
Plan: Extract pertinent links from the DuckDuckGo search results for further examination.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Employ the SiteLoader tool to pull information from the selected links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Lastly, apply the language model to discern and summarize the climber's motivations from the retrieved data.
:evidence5: = InfoModel[What motivated :evidence1: to climb Mount Everest without supplemental oxygen, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a methodical plan to address the user instruction utilizing the given tools. Each plan will correspond to an evidence value, which will be the result of one of the available functions given an input string that can be the user question, preceding evidence values, or both.

These are the tools you can use:
YahooSearch[input]: Tool that enables the user to look up information via Yahoo Search. This tool is handy in identifying a suitable list of sites that may hold the answer to the user's question.
HTMLParser[input]: Parses HTML from a webpage link and produces plain text containing the content of the link.
HyperlinkHarvester[input]: Harvests hyperlinks from plain text and yields a plain text response of links.
DeepQA[input]: Deep learning-based Question Answering model, particularly effective in answering queries based on an input text passage. The input must be a text question referring to a :knowledge[n]: variable, e.g., Who won the Nobel Prize in Literature in 2019, given :knowledge1:?

Function inputs should be simple strings without quotes or "+" to concatenate a string with an evidence variable, e.g., DeepQA[Who was the first person to walk on the moon, given :knowledge3:?]

Ensure only one evidence output per plan step.

The output should adhere to this format:
Plan: [first action predicated on input question]
:knowledge0: = [function to call with input parameter]
Plan: [following action based on the outcome of :knowledge0:]
:knowledge1: = [next function to call and input parameter, which may reference earlier evidence, e.g., "Given context :knowledge0"]
...
Answer: [:knowledge[n]: containing the final resolution.]

Question: What are the main ingredients in a traditional Italian lasagna and how is it prepared?

Response:
Plan: Begin with a web search to find the main ingredients in a traditional Italian lasagna.
:knowledge0: = YahooSearch[Traditional Italian lasagna ingredients]
Plan: Use the DeepQA model to parse the search results and identify the main ingredients.
:knowledge1: = DeepQA[What are the main ingredients in a traditional Italian lasagna, given :knowledge0:?]
Plan: Conduct another web search to find the preparation method for a traditional Italian lasagna.
:knowledge2: = YahooSearch[How to prepare traditional Italian lasagna]
Plan: Harvest relevant links from the Yahoo search results for deeper exploration.
:knowledge3: = HyperlinkHarvester[:knowledge2:]
Plan: Parse the HTML from the harvested links to obtain the necessary information.
:knowledge4: = HTMLParser[:knowledge3:]
Plan: Finally, use the DeepQA model to identify and summarize the preparation method for a traditional Italian lasagna from the parsed information.
:knowledge5: = DeepQA[How is a traditional Italian lasagna prepared, given :knowledge4:?]
Answer: :knowledge5:

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:
GoogleSearch[input]: Tool that allows the user to search for information using Google's 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.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
WikiSearch[input]: Searches Wikipedia for information related to the input string.
QAModel[input]: Question answering 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, e.g. What color is the cat, given #E1?

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: What are some of the major works of art located at the Louvre Museum?

Response:
Plan: Start by searching for information about the Louvre Museum on Wikipedia.
#E1 = WikiSearch[Louvre Museum]
Plan: Use the QAModel to identify some of the major works of art located at the Louvre Museum.
#E2 = QAModel[What are some of the major works of art located at the Louvre Museum? Given context: #E1]
Final answer: #E2

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.
Scraper[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.
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:]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who wrote the book "To Kill a Mockingbird" and what awards did it win?

Response:
Plan: Start by conducting a web search to find out who wrote "To Kill a Mockingbird".
:evidence0: = Bing[Author of To Kill a Mockingbird]
Plan: Use SAM to interpret the search results and identify the author.
:evidence1: = SAM[Who wrote To Kill a Mockingbird, given :evidence0:?]
Plan: Conduct another web search to find the awards won by "To Kill a Mockingbird".
:evidence2: = Bing[Awards won by To Kill a Mockingbird]
Plan: Extract relevant links from the Bing search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use Scraper to extract information from the extracted links.
:evidence4: = Scraper[:evidence3:]
Plan: Finally, use SAM to summarize the awards won by "To Kill a Mockingbird" from the scraped information.
:evidence5: = SAM[What awards did To Kill a Mockingbird win, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please create a step-by-step plan to generate an optimal response to the user query, using 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 combination 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 a list of sites that may contain 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.
LinkCollector[input]: Extracts 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, 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: = QAModel[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: Nobel Prize Contribution]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkCollector[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the language model to identify and summarize the key contributions made by the laureate from the extracted information.
:evidence5: = QAModel[What were the key contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to answer the following question: "What is the main diet of the African elephant and where can they be found in the wild?" Use the tools provided below:

1. SearchEngine[input]: This tool allows you to search for information using an online search engine. The input should be a string that represents your query.
2. TextParser[input]: This tool extracts key pieces of information from a large body of text. It's useful when you have a lot of data and need to find specific details.
3. MapLocator[input]: This tool helps locate places on a map based on the input string.
4. QA_Tool[input]: A tool that answers questions based on common sense, general world knowledge or given context.

Remember, each step in your plan should correspond with one evidence value (#E[index]). Your final output should follow this format:

Plan: [first action]
#E1 = [function call with input]
Plan: [next action]
#E2 = [function call with input, possibly referencing previous evidence]
...
Final Answer: #E[n]

Response:
Plan: Begin by searching for information about the diet of the African elephant.
#E1 = SearchEngine[African elephant diet]
Plan: Extract key details about the diet from the search results.
#E2 = TextParser[#E1]
Plan: Now, search for locations where African elephants can be found in the wild.
#E3 = SearchEngine[African elephant habitat]
Plan: Use the map locator tool to identify these locations more precisely.
#E4 = MapLocator[#E3]
Plan: Finally, combine all the gathered information to answer the original question.
#E5 = QA_Tool[What is the main diet of the African elephant and where can they be found in the wild? Given context: #E2 and #E4]
Final Answer: #E5

System: A chat.


Instruction:
Generate a comprehensive plan to answer the following query making use of the provided tools. For each step, indicate the corresponding evidence output.

Available Tools:
WikiSearch[input]: Allows users to retrieve information from Wikipedia.
InfoScraper[input]: Scrapes data from specified URL(s) producing plain text output.
LinkGatherer[input]: Extracts links from a given text and returns them as a list.
AnswerBot[input]: Answers questions based on context provided. It requires a text question referencing an #E[index] variable.

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

Question: Who invented the first electric car and when was it made?

Response:
Plan: Begin by searching Wikipedia for information on the first electric car.
#E1 = WikiSearch[first electric car]
Plan: Use AnswerBot to determine who invented the first electric car.
#E2 = AnswerBot[Who invented the first electric car? Given context: #E1]
Plan: Again, use AnswerBot to determine when the first electric car was made.
#E3 = AnswerBot[When was the first electric car made? Given context: #E1]
Final Response: #E2 and #E3

System: A chat.


Instruction:
Create a strategy to respond to the following query using the available tools. Each stage of your strategy should correspond to 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, previous evidence values, or both.

Available Tools:
AskJeeves[input]: This tool lets users perform a search using the Ask Jeeves search engine.
DataExtractor[input]: This tool pulls out important details from a large amount of text.
HyperlinkHarvester[input]: This tool collects hyperlinks from plain text and returns them in a list.
InfoAnalyzer[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should follow this format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on the result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which might reference previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: Containing the final answer.]

Question: Who is the author of War and Peace and what other books did they write?

Response:
Plan: Initiate a web search to identify the author of War and Peace.
:evidence0: = AskJeeves[Author of War and Peace]
Plan: Use InfoAnalyzer to interpret the search results and identify the author.
:evidence1: = InfoAnalyzer[Who is the author of War and Peace, given :evidence0:?]
Plan: Conduct another web search to find other books written by the identified author.
:evidence2: = AskJeeves[Other books written by :evidence1:]
Plan: Harvest relevant links from the search results for further investigation.
:evidence3: = HyperlinkHarvester[:evidence2:]
Plan: Extract information from the harvested links about the author's other works.
:evidence4: = DataExtractor[:evidence3:]
Plan: Lastly, use InfoAnalyzer to summarize the other books written by the author from the extracted information.
:evidence5: = InfoAnalyzer[What other books were written by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a detailed plan to generate a response to the following query using the resources listed below. For each step, assign an evidence value corresponding to the output of a specific function, which could be derived from the initial question or previous evidence variables.

Tools at your disposal include:
BingSearch[input]: Enables users to perform a search using Bing. It provides a list of potentially relevant websites but does not offer direct answers.
UrlGrabber[input]: Retrieves URLs from any given plaintext input, producing a list of newline-separated URLs.
WebsiteReader[input]: Fetches and presents the textual content of any URL(s) provided as newline-separated inputs.
KnowledgeBot[input]: Answers queries based on common knowledge and context obtained from prior evidence.

Your output should follow this structure:
Plan: [Initial action]
:Evidence0: = [Function invocation with appropriate input]
Plan: [Subsequent action dependent on :Evidence0:]
:Evidence1: = [Next function invocation with suitable input, possibly referring to :Evidence0:]
...
Answer: [:EvidenceN:, where N represents the final piece of evidence]

Question: Who was Albert Einstein and what were his major contributions to science?

Response:
Plan: Initiate a Bing search to gather information about Albert Einstein.
:Evidence0: = BingSearch[Albert Einstein]
Plan: Retrieve useful URLs from the search results.
:Evidence1: = UrlGrabber[:Evidence0:]
Plan: Read the contents of the identified URLs.
:Evidence2: = WebsiteReader[:Evidence1:]
Plan: Utilize KnowledgeBot to determine who Albert Einstein was.
:Evidence3: = KnowledgeBot[Who was Albert Einstein? Given context: :Evidence2:]
Plan: Employ KnowledgeBot once more to identify Einstein's major scientific contributions.
:Evidence4: = KnowledgeBot[What were Albert Einstein's major contributions to science? Given context: :Evidence2:]
Answer: :Evidence3: and :Evidence4:

System: A chat.


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

Here are the tools you can use:
Bing[input]: This tool allows users to search for information using Bing search engine. It is useful in finding websites that may contain answers to the user's questions.
PageReader[input]: This function loads one or more web pages from the input string containing newline separated links. The input is one or more URLs and it produces plain text output with the content of the pages.
LinkCollector[input]: Extracts links from plain text and produces a plain text response with newline-separated links.
QAModel[input]: A language model for answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Remember to include only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who the architect of the Sydney Opera House is.
:evidence0: = Bing[Architect of Sydney Opera House]
Plan: Use the question-answering model to interpret the search results and identify the architect.
:evidence1: = QAModel[Who is the architect of the Sydney Opera House, given :evidence0:?]
Plan: Conduct another web search to find the other notable works of the identified architect.
:evidence2: = Bing[Notable works of :evidence1:]
Plan: Extract relevant links from the Bing search results for a more detailed search.
:evidence3: = LinkCollector[:evidence2:]
Plan: Use the PageReader tool to extract information from the relevant links.
:evidence4: = PageReader[:evidence3:]
Plan: Finally, use the question-answering model to identify and summarize the other notable works of the architect from the extracted information.
:evidence5: = QAModel[What are the other notable works 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.
WebCrawler[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 IBM and who were its key founders?

Response:
Plan: Start by conducting a web search to find out about the history of IBM.
:evidence0: = Bing[History of IBM]
Plan: Use a language model to interpret the search results and summarize the history of IBM.
:evidence1: = QAModel[What is the history of IBM, given :evidence0:?]
Plan: Conduct another web search to find the key founders of IBM.
:evidence2: = Bing[Key founders of IBM]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use a web crawler tool to extract information from the relevant links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the key founders of IBM from the extracted information.
:evidence5: = QAModel[Who were the key founders of IBM, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to solve the following problem using these tools. Each tool can be called with an input string and will produce some output which you can store in a variable :evidence[n]: for later use.

Here are the available tools:
1. WikiSearch[input]: This tool allows you to search Wikipedia for information on a specific topic. The input should be a search term or phrase.
2. QandA[input]: This is a question answering tool that uses general knowledge and context from previous evidence to answer questions.
3. MapTool[input]: A tool that provides geographical information about a place when given its name as input.
4. Translate[input]: This tool translates text from one language to another, given the input text and target language.

The output format should be as follows:
Plan: [description of first action]
:evidence0: = [first function call]
Plan: [description of second action based on result of :evidence0:]
:evidence1: = [second function call referencing :evidence0:, if necessary]
...
Final Answer: [:evidence[n]: containing the final answer]

Question: What is the history of the Eiffel Tower and what does "Eiffel Tower" translate to in Spanish?

Response:
Plan: Search for information about the history of the Eiffel Tower.
:evidence0: = WikiSearch[Eiffel Tower]
Plan: Extract historical details about the Eiffel Tower.
:evidence1: = QandA[What is the history of the Eiffel Tower? Given context: :evidence0:]
Plan: Translate 'Eiffel Tower' into Spanish.
:evidence2: = Translate[Eiffel Tower, Spanish]
Final Answer: :evidence1:, :evidence2:

System: A chat.


Instruction:
Please develop a detailed plan to respond to the user's inquiry, utilizing the set of available tools. For each plan, indicate the corresponding evidence value, which would be the output of one of the available functions given an input string.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables the user to search for information via the DuckDuckGo search engine. This tool is beneficial for identifying a range of sites that might contain the answer to the user's question.
LinkGrabber[input]: Grabs links from plain text and generates a plain text, newline separated response of links.
WebReader[input]: Loads one or more websites from the input string containing newline-separated links, where input is one or more links, and produces plain text output containing the content of the links.
AIQA[input]: An artificial intelligence-based question-answering model, especially effective at answering questions based on an input passage of text. The input must be a text question that references a :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: Who was Nikola Tesla and what were his major contributions to science?

Response:
Plan: Begin by conducting a web search to gather information about Nikola Tesla.
:evidence0: = DuckDuckGo[Nikola Tesla]
Plan: Use LinkGrabber to extract pertinent links from the search results.
:evidence1: = LinkGrabber[:evidence0:]
Plan: Employ WebReader to retrieve information from the selected links.
:evidence2: = WebReader[:evidence1:]
Plan: Lastly, utilize AIQA to process the retrieved information and identify Nikola Tesla's major contributions to science.
:evidence3: = AIQA[What were Nikola Tesla's major contributions to science, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Develop a systematic plan to tackle this question using these tools:
ScholarlyArticleSearch[input]: Searches scholarly articles for relevant information.
PubMedLookup[input]: Looks up medical research papers on PubMed.
ResearchSummarizer[input]: Summarizes research papers into key points.
FactVerifier[input]: Verifies factual statements.
KnowledgeEngine[input]: AI model that answers questions based on input context.

Question: What is the role of serotonin in human brain function?

Response:
Plan:

1. Use ScholarlyArticleSearch["serotonin in human brain function"] to find relevant scholarly articles on the role of serotonin in human brain function.

2. Simultaneously, use PubMedLookup["serotonin and brain function"] to look up medical research papers related to the topic on PubMed. This will provide a more medically-focused perspective.

3. After gathering several papers from both sources, utilize ResearchSummarizer[input] on each paper to condense them into key points. This step will help in understanding the main findings without having to read through every single paper in detail.

4. Compile all the summarized points together and then run FactVerifier[input] to verify the factual accuracy of these statements. This is important to ensure that the information gathered is correct and reliable.

5. Finally, input all verified facts into KnowledgeEngine[input]. The AI model should be able to synthesize this information and provide a comprehensive answer to the question about the role of serotonin in human brain function.

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.

Here are the tools available to be called:
BookSummary[input]: Tool that provides summaries of books.
AuthorInfo[input]: Tool that provides information about authors.
GenreClassifier[input]: Tool that classifies books into genres.
ReviewAnalyzer[input]: Tool that analyzes book reviews.
LLM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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 wrote the book 'To Kill a Mockingbird' and what genre does it belong to?

Response:
Plan: Identify the author of the book 'To Kill a Mockingbird'
:evidence0: = AuthorInfo['To Kill a Mockingbird']
Plan: Determine the genre of the book 'To Kill a Mockingbird'
:evidence1: = GenreClassifier['To Kill a Mockingbird']
Answer: [:evidence0: containing the author's name, :evidence1: containing the genre of the book.]

System: A chat.


Instruction:
Construct a methodical plan to tackle the user's inquiry utilizing the provided tools. Make sure to label each step of your plan with an evidence marker.

Tools Accessible:
SportsStats[input]: Offers statistics for various sports.
ConcertFinder[input]: Locates concerts based on artist and location.
RecipeSearch[input]: Searches for recipes based on ingredients.
FitnessTracker[input]: Tracks physical activity and health data.
KnowledgeBot[input]: Answers queries using general knowledge or supplied context.

Output Format:
Plan: Preliminary step guided by the input question
#Evidence1 = Operation to carry out with suitable input
Plan: Ensuing step dictated by the outcome of #Evidence1
#Evidence2 = Subsequent operation to undertake with its input, perhaps referring to past evidence like "In light of #Evidence1"
...
Final Answer: #EvidenceN

Question: Who won the last NBA championship, when is the next concert of Coldplay, can you give me a recipe for a high protein meal, and how many calories do I burn running for 30 minutes?

Response:
Plan: First, identify the winner of the last NBA championship.
#Evidence1 = SportsStats["NBA Championship Winner"]

Plan: Next, find out when and where Coldplay's next concert is.
#Evidence2 = ConcertFinder["Coldplay"]

Plan: Then, search for a high protein meal recipe.
#Evidence3 = RecipeSearch["High Protein Meal"]

Plan: Lastly, calculate how many calories are burned running for 30 minutes.
#Evidence4 = FitnessTracker["Running", "30 minutes"]

Final Answer: #Evidence1, #Evidence2, #Evidence3, #Evidence4

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question using the available tools. Each tool should be used with an input string that can be the user's query, one or more previous evidence values, or both.

Here are the tools available to be called:
GoogleSearch[input]: A tool that allows you to search for information using Google. This tool is useful in finding a list of sites that may contain the answer to your question.
WebScraper[input]: Loads one or more websites from the input string containing newline delimited 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.
QA_Tool[input]: Question answering tool that can answer questions based on common sense, general world knowledge, as well as given input context that may contain the answer.

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: What are some of the most significant contributions made by Nikola Tesla?

Response:
Plan: Begin by conducting a web search to find out about Nikola Tesla's contributions.
#E1 = GoogleSearch[Nikola Tesla Contributions]
Plan: Extract the relevant links from the Google search results for detailed information.
#E2 = LinkExtractor[#E1]
Plan: Use a web scraper tool to extract information from the relevant links.
#E3 = WebScraper[#E2]
Plan: Finally, utilize the QA_Tool to identify and summarize the significant contributions made by Nikola Tesla from the extracted information.
#E4 = QA_Tool[What are some of the most significant contributions made by Nikola Tesla? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Construct a detailed plan to respond to the following user question using the listed tools. Each plan will align with 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, one or more former evidence values, or a combination of both.

Here are the tools you can use:
AskJeeves[input]: This tool allows users to search for information using the Ask Jeeves search engine.
URLUnearther[input]: This function extracts URLs from plain text and delivers a plain text list of URLs.
WebFetcher[input]: This tool loads one or more websites from an input string containing newline-separated links, where the input is one or more links, and yields plain text content from those links.
WorldBook[input]: This tool carries out a search on World Book for applicable articles based on the input string.
QuestionCracker[input]: This is a question-answering language model that excels at responding to questions based on an input text passage. The input must be a text question that cites a #H[index] variable.

Output format:
Plan: [First action based on input question]
#H1 = [Function to call with input parameter]
Plan: [Subsequent action based on the result of #H1]
...
Final Reply: #H[n]

Question: What is photosynthesis and why is it important to life on Earth?

Response:
Plan: Commence by executing a World Book search to comprehend photosynthesis.
#H1 = WorldBook[photosynthesis]
Plan: Utilize QuestionCracker to describe photosynthesis from the World Book article.
#H2 = QuestionCracker[What is photosynthesis? Given context: #H1]
Plan: Run an Ask Jeeves search to grasp why photosynthesis is crucial to life on Earth.
#H3 = AskJeeves[Why is photosynthesis important to life on Earth?]
Plan: Unearth the relevant URLs from the Ask Jeeves search results for a more specialized probe.
#H4 = URLUnearther[#H3]
Plan: Deploy WebFetcher to obtain information from these URLs.
#H5 = WebFetcher[#H4]
Plan: In conclusion, apply QuestionCracker to summarize why photosynthesis is vital to life on Earth from the obtained information.
#H6 = QuestionCracker[Why is photosynthesis important to life on Earth? Given context: #H5]
Final Reply: #H6

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:
SearchEngine[input]: Tool that allows the user to search for information using any popular 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]: Artificial Intelligence Question Answering 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 most recent archaeological discovery in Egypt and what significance does it hold?

Response:
Plan: Begin by conducting a web search to find out about the most recent archaeological discovery in Egypt.
:evidence0: = SearchEngine[Most recent archaeological discovery in Egypt]
Plan: Utilize AIQA to interpret the search results and identify the most recent discovery.
:evidence1: = AIQA[What is the most recent archaeological discovery in Egypt, given :evidence0:?]
Plan: Conduct another web search to find the significance of the identified archaeological discovery.
:evidence2: = SearchEngine[Significance of :evidence1: in Egypt]
Plan: Extract the relevant links from the search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use WebScraper to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize AIQA to summarize the significance of the discovery from the extracted information.
:evidence5: = AIQA[What is the significance of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a systematic plan to generate an ideal response to the user instruction, making use of the set of available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could 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. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
URLLoader[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.
HyperlinkParser[input]: Extract hyperlinks from plain text and produces a plain text, newline delimited response of links.
DeepQA[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 input to each function just just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g., DeepQA[What is the capital of France, given :evidence3:?]

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: What is the significance of the Battle of Hastings and how did it impact England?

Response:
Plan: Begin by conducting a web search to find out about the Battle of Hastings.
:evidence0: = Bing[Battle of Hastings]
Plan: Utilize a language model to interpret the search results and understand the significance of the battle.
:evidence1: = DeepQA[What is the significance of the Battle of Hastings, given :evidence0:?]
Plan: Conduct another web search to find the impact of the Battle of Hastings on England.
:evidence2: = Bing[Impact of Battle of Hastings on England]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = HyperlinkParser[:evidence2:]
Plan: Use a URL loader tool to extract information from the relevant links.
:evidence4: = URLLoader[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the impact of the Battle of Hastings on England from the extracted information.
:evidence5: = DeepQA[How did the Battle of Hastings impact England, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Formulate a plan to answer the following query using the specified tools. Each phase of your plan should correlate with an evidence variable, which will be the output of one of the accessible functions given an input string, which can be the user's question, earlier evidence values, or both.

Tools at your disposal:
YahooSearch[input]: Tool that enables the user to look for information via the Yahoo search engine. It helps in locating websites that may possess the answer to the user's inquiry.
TextScraper[input]: Retrieves plaintext from a website given its URL.
HyperlinkHarvester[input]: Gathers hyperlinks from plaintext and returns a list of newline-separated links.
NeuralNetQA[input]: A neural network-based question-answering model. Especially handy in responding to queries based on an input passage of text. The input has to be a textual question mentioning an :evidence[n]: variable.

Output structure:
Plan: [Initial action predicated on input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action predicated on the outcome of :evidence0:]
:evidence1: = [Following function to invoke and input parameter, potentially alluding to preceding evidence]
...
Answer: [:evidence[n]: Carrying the ultimate response]

Question: Who is the author of "War and Peace" and where were they born?

Response:
Plan: Initiate by performing a web search to discover the author of "War and Peace".
:evidence0: = YahooSearch[Author of War and Peace]
Plan: Employ NeuralNetQA to parse the search results and pinpoint the author.
:evidence1: = NeuralNetQA[Who is the author of "War and Peace"? Given context: :evidence0:]
Plan: Execute another web search to ascertain the birthplace of the identified author.
:evidence2: = YahooSearch[Birthplace of :evidence1:]
Plan: Harvest the pertinent links from the Yahoo search results for additional investigation.
:evidence3: = HyperlinkHarvester[:evidence2:]
Plan: Scrape plaintext from the chosen links to amass more information.
:evidence4: = TextScraper[:evidence3:]
Plan: Ultimately, utilize NeuralNetQA to identify and encapsulate the birthplace of the author from the amassed information.
:evidence5: = NeuralNetQA[Where was :evidence1: born? Given context: :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a methodical plan to resolve the following user inquiry using the given tools. Each stage of your plan should correspond to an evidence value which signifies the outcome of a function when supplied with its input.

Available Tools:
DataMiner[input]: Uses a broad search engine to gather potential data sources.
ContentReader[input]: Reads through a text and extracts crucial details.
HyperlinkGatherer[input]: Collects all hyperlinks embedded within a specific text.
QuerySolver[input]: Solves queries based on a given context.

Required Output Format:
Step: [Initial action derived from input]
@Evidence1 = [Called function with input]
Step: [Following action derived from @Evidence1]
@Evidence2 = [Next called function with input, could refer to @Evidence1]
...
Final Response: @Evidence[n]

Question: Who was the director of the movie 'Inception' and what other movies has he directed?

Response:
Step: Begin a search to find the director of the movie 'Inception'.
@Evidence1 = DataMiner[Director of Inception]
Step: Use QuerySolver to ascertain the director from the search results.
@Evidence2 = QuerySolver[Who directed the movie Inception? Context: @Evidence1]
Step: Perform another search to discover other movies directed by the identified individual.
@Evidence3 = DataMiner[Movies directed by @Evidence2]
Step: Gather the URLs from the search results for deeper investigation.
@Evidence4 = HyperlinkGatherer[@Evidence3]
Step: Read the contents of the URLs for comprehensive information.
@Evidence5 = ContentReader[@Evidence4]
Step: Identify the other movies directed by the same person from the read content.
@Evidence6 = QuerySolver[What other movies were directed by @Evidence2? Context: @Evidence5]
Final Response: @Evidence6

System: A chat.


Instruction:
Generate a plan to answer the following query using the provided tools. Each tool should be used at least once and each step of the plan should correspond to an evidence value.

Available Tools:
WikiLookup[input]: Searches Wikipedia for information related to the input string.
WebCrawler[input]: Crawls the web for additional sources of information based on the input string.
TextAnalyzer[input]: Analyzes a block of text and extracts key points and summaries.
QAAssistant[input]: Answers questions based on the input text.

Output Format:
Plan: [First step based on the input question]
#E1 = [Function to call with input parameters]
Plan: [Next step based on the result of #E1]
#E2 = [Next function to call with input parameters]
...
Final Answer: #E[last]

Question: How did the Battle of Waterloo impact Europe's political landscape?

Response:
Plan: Begin by looking up information about the Battle of Waterloo on Wikipedia.
#E1 = WikiLookup[Battle of Waterloo]
Plan: Analyze the retrieved text to extract key points about the battle.
#E2 = TextAnalyzer[#E1]
Plan: Use the QAAssistant to determine how the Battle of Waterloo ended.
#E3 = QAAssistant[How did the Battle of Waterloo end? Given context: #E2]
Plan: Crawl the web for more sources discussing the aftermath of the Battle of Waterloo.
#E4 = WebCrawler[Aftermath of the Battle of Waterloo]
Plan: Analyze the crawled text to summarize the impacts on Europe's political landscape.
#E5 = TextAnalyzer[#E4]
Plan: Use the QAAssistant to clarify the main political changes in Europe after the Battle of Waterloo.
#E6 = QAAssistant[What were the main political changes in Europe after the Battle of Waterloo? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Please generate a plan to answer the following question using the available tools. Each step in your plan 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, previous evidence values, or both.

Here are the tools available to you:
1. SearchEngine[input]: This tool allows users to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
2. TextExtractor[input]: Extracts text from a webpage given its URL. Input is a link and produces plain text output containing the content of the link.
3. LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
4. AnswerBot[input]: A language model capable of 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 follow this 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 won the 2020 Nobel Prize in Literature and what is their most famous work?

Response:
Plan: Start by conducting a web search to find out who won the 2020 Nobel Prize in Literature.
:evidence0: = SearchEngine[2020 Nobel Prize in Literature winner]
Plan: Use AnswerBot to interpret the search results and identify the winner.
:evidence1: = AnswerBot[Who won the 2020 Nobel Prize in Literature, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = SearchEngine[Most famous work of :evidence1:]
Plan: Extract relevant links from the search results for more detailed information.
:evidence3: = LinkFinder[:evidence2:]
Plan: Extract textual information from the relevant links.
:evidence4: = TextExtractor[: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:?]
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:
WebSearch[input]: Tool that allows the user to search for information using a web 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.
SiteReader[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.
NLPModel[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 a #E[n] variable, e.g. What color is the cat, given #E1?

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 2019 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 2019.
#E1 = WebSearch[Nobel Prize in Literature 2019 winner]
Plan: Use the NLP Model to interpret the search results and find the name of the laureate.
#E2 = NLPModel[Who won the Nobel Prize in Literature in 2019? Given context: #E1]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E3 = WebSearch[Most famous work of #E2]
Plan: Extract the relevant links from the search results for a more focused search.
#E4 = LinkPicker[#E3]
Plan: Use SiteReader tool to extract information from the relevant links.
#E5 = SiteReader[#E4]
Plan: Finally, utilize the NLP Model to identify and summarize the most famous work of the laureate from the extracted information.
#E6 = NLPModel[What is the most famous work of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a step-by-step plan to solve the following problem using the provided tools. Each plan should correspond to an evidence value, which is the output of one of the available tools given an input string that could be the user's question, one or more prior evidence values, or a combination of both.

Here are the tools you can use:
GoogleScholar[input]: Allows users to search for scholarly literature such as articles, theses, books, conference papers, etc.
PubMed[input]: A free search engine accessing primarily the MEDLINE database of references and abstracts on life sciences and biomedical topics.
SemanticQA[input]: A tool that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable.
ArxivScraper[input]: Load one or more ArXiv preprints 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.

The output should follow this format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: What are the latest advancements in neurobiology research related to Alzheimer's disease?

Response:
Plan: Start by searching for scholarly articles related to recent advancements in neurobiology research on Alzheimer's disease.
#E1 = GoogleScholar[Latest advancements in neurobiology research on Alzheimer's disease]
Plan: Use SemanticQA to analyze the search results and provide a summary of the advancements.
#E2 = SemanticQA[What are the latest advancements in neurobiology research on Alzheimer's disease according to the articles? Given context: #E1]
Plan: Search PubMed for additional medical literature on the topic.
#E3 = PubMed[#E2]
Plan: Extract the relevant information from the PubMed search results.
#E4 = SemanticQA[What additional information does the PubMed search provide on the advancements? Given context: #E3]
Plan: Scrape ArXiv for any preprints related to the advancements.
#E5 = ArxivScraper[#E2]
Plan: Analyze the scraped preprints for further details on the advancements.
#E6 = SemanticQA[What do the preprints reveal about the advancements? Given context: #E5]
Final Answer: #E6

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:
SearchEngine[input]: Tool that allows the user to search for information using a generic 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.
NLPModel[input]: Natural Language Processing 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 was the director of the movie Inception and what other movies have they directed?

Response:
Plan: Start by conducting a web search to find out who the director of the movie Inception is.
:evidence0: = SearchEngine[Director of the movie Inception]
Plan: Use the NLP Model to interpret the search results and identify the name of the director.
:evidence1: = NLPModel[Who is the director of the movie Inception, given :evidence0:?]
Plan: Conduct another web search to find other movies directed by the identified director.
:evidence2: = SearchEngine[Movies directed by :evidence1:]
Plan: Extract the relevant links from the search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the Web Scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the NLP Model to identify and summarize the other movies directed by the same person from the extracted information.
:evidence5: = NLPModel[What are the other movies directed by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a systematic plan to solve the user instruction, utilizing a variety of available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user question, one or more previous evidence values, or a mixture of both.

Available tools:
YahooSearch[input]: Allows the user to search for information using Yahoo. Useful for finding lists of sites that might contain the answer to the user's query.
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.
LinkGatherer[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
InfoBot[input]: A question-answering bot capable of answering queries based on an input passage of text. The input must be a text question that references a #E[index] variable, e.g., What is the population of Tokyo, given #E1?

Output 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]

Question: What is the history behind the construction of the Eiffel Tower and how was it received by the public when it was built?

Response:
Plan: Begin by searching for information about the history of the Eiffel Tower's construction.
#E1 = YahooSearch[Eiffel Tower construction history]
Plan: Use InfoBot to interpret the search results and provide a summary of the tower's construction history.
#E2 = InfoBot[What is the history of the Eiffel Tower's construction, given #E1?]
Plan: Perform another web search to find out how the Eiffel Tower was received by the public when it was built.
#E3 = YahooSearch[Public reception of the Eiffel Tower when it was built]
Plan: Extract the relevant links from the Yahoo search results for a more detailed investigation.
#E4 = LinkGatherer[#E3]
Plan: Use WebScraper to extract information from the gathered links.
#E5 = WebScraper[#E4]
Plan: Lastly, use InfoBot to identify and summarize the public's reaction to the Eiffel Tower when it was constructed from the scraped information.
#E6 = InfoBot[How was the Eiffel Tower received by the public when it was built, given #E5?]
Final answer: #E6

System: A chat.


Instruction:
Create a sequential plan to solve the problem below using the described tools. Every step should have corresponding evidence which stores the result of the function used in that step.

Tools Available:
DuckDuckGo[input]: Uses DuckDuckGo search engine to fetch relevant data for the input string.
Parser[input]: Parses a webpage and extracts all the textual content.
WebCrawler[input]: Crawls through multiple pages of a website starting from the input URL.
InfoFinder[input]: Answers questions using common sense, world knowledge, or given context.

The output format should be:
Plan: [First action]
$Evi1 = [Function call with input]
Plan: [Next action]
$Evi2 = [Function call with input referring to $Evi1 if necessary]
...
Answer: [$Evin]

Question: Who was Nikola Tesla and what are his major contributions to science?

Response:
Plan: Search for information about Nikola Tesla using DuckDuckGo.
$Evi1 = DuckDuckGo[Nikola Tesla]
Plan: Parse the top results to extract the textual content.
$Evi2 = Parser[$Evi1]
Plan: Crawl through the pages linked in the parsed content for more detailed information.
$Evi3 = WebCrawler[$Evi2]
Plan: Find out who Nikola Tesla was using the crawled information.
$Evi4 = InfoFinder[Who was Nikola Tesla? Given context: $Evi3]
Plan: Identify Tesla's major contributions to science using the same context.
$Evi5 = InfoFinder[What are the major contributions of Nikola Tesla to science? Given context: $Evi3]
Answer: $Evi5

System: A chat.


Instruction:
Formulate a stepwise plan to generate an answer to the user query, utilizing a selection of available tools. Each step in the plan corresponds to an evidence value, which represents the output of a specific function when supplied with an input string. This input string can either be the user's question, one or more previously obtained evidence values, or a combination thereof.

Tools available for use:
YahooSearch[input]: A tool enabling users to conduct searches via the Yahoo search engine. This tool aids in identifying a range of websites that may hold the answer to the user's question.
SiteReader[input]: Loads one or more websites from an input string consisting of newline-separated links. The input consists of one or more links, yielding plain text output comprising the contents of these links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text, providing a plain text, newline-separated list of hyperlinks as output.
InfoBot[input]: A language model designed to answer questions based on a given passage of text. The input should be a textual question referring to an :evidence[n]: variable.

Output format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, potentially referring to earlier evidence]
...
Final Answer: [:evidence[n]: containing the final answer]

Question: Who is the author of the book "To Kill a Mockingbird" and what other works have they written?

Response:
Plan: Commence with a web search to identify the author of "To Kill a Mockingbird".
:evidence0: = YahooSearch[Author of To Kill a Mockingbird]
Plan: Deploy a language model to parse the search results and ascertain the author's name.
:evidence1: = InfoBot[Who is the author of To Kill a Mockingbird, given :evidence0:?]
Plan: Execute another web search to discover other works written by the identified author.
:evidence2: = YahooSearch[Other works by :evidence1:]
Plan: Extract relevant hyperlinks from the Yahoo search results for more detailed information.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use the SiteReader tool to retrieve information from the selected hyperlinks.
:evidence4: = SiteReader[:evidence3:]
Plan: Ultimately, employ the language model to pinpoint and summarise other works authored by the writer of "To Kill a Mockingbird" from the retrieved information.
:evidence5: = InfoBot[What other works has :evidence1: written, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Devise a stepwise plan to respond to the user's inquiry using the listed tools. Each step should produce an evidence value, which is the output of a function invoked with a particular input string - this could be the user's question, past evidence values, or a mix of both.

Tools at your disposal:
NetSearch[input]: Enables the user to look up information online. It yields a list of websites that might hold the answer to the user's question.
PageLoader[input]: Loads the webpage(s) from the supplied link(s) and delivers the content as plain text.
InquiryMaster[input]: Capable of answering questions based on common knowledge and given context. It refers to a *Evidence[index]* variable in its input.
HyperlinkGatherer[input]: Gathers all hyperlinks from the provided text and returns them as a newline-separated string.

Output should adhere to the following format:
Plan: [First action based on the input question]
*Evidence0* = [Function to call with input parameter]
Plan: [Next action, influenced by the result of *Evidence0*]
*Evidence1* = [Subsequent function to call and input parameter, possibly referring back to previous evidence, e.g., "Considering context *Evidence0*"]
...
Final Response: [*EvidenceN*, which includes the final answer.]

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

Response:
Plan: Begin with a web search to find out who designed the Sydney Opera House.
*Evidence0* = NetSearch[Sydney Opera House architect]
Plan: Utilize InquiryMaster to pinpoint the designer from the search results.
*Evidence1* = InquiryMaster[Who designed the Sydney Opera House, considering *Evidence0*?]
Plan: Perform another web search to find other notable buildings designed by the identified architect.
*Evidence2* = NetSearch[Notable buildings designed by *Evidence1*]
Plan: Gather the pertinent links from the search results for deeper exploration.
*Evidence3* = HyperlinkGatherer[*Evidence2*]
Plan: Load the content of the gathered links.
*Evidence4* = PageLoader[*Evidence3*]
Plan: Ultimately, employ InquiryMaster to recognize and summarize the other notable buildings designed by the architect from the loaded content.
*Evidence5* = InquiryMaster[What other notable buildings were designed by *Evidence1*, considering *Evidence4*?]
Final Response: *Evidence5*

System: A chat.


Instruction:
Please generate a comprehensive plan to solve the problem below, making use of the available tools. For each plan, indicate which external tool together with tool input to retrieve evidence. You can store the evidence into a variable #Evidence[index] that can be called by later tools.

Here are the tools available to be called:
BingSearch[input]: Tool that allows the user to search for information from Bing.  This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
ParseHTML[input]: Load one or more websites from the input string and produces plain text output containing the content of the site.
URLExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
AIQA[input]: Artificial Intelligence Question Answering 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 (#Evidence[index]) value.

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

Question: When was the first iPhone released and what were its key features?

Response:
Plan: Search for more information about the release date of the first iPhone.
#Evidence1 = BingSearch[first iPhone release date]
Plan: Find out when the first iPhone was released.
#Evidence2 = AIQA[When was the first iPhone released? Given context: #Evidence1]
Plan: Search for more information about the key features of the first iPhone.
#Evidence3 = BingSearch[key features of the first iPhone]
Plan: Extract the relevant URLs from the Bing search results.
#Evidence4 = URLExtractor[#Evidence3]
Plan: Parse the HTML of the relevant URLs to get the textual content.
#Evidence5 = ParseHTML[#Evidence4]
Plan: Find out the key features of the first iPhone.
#Evidence6 = AIQA[What were the key features of the first iPhone? Given context: #Evidence5]
Final answer: #Evidence6

System: A chat.


Instruction:
Formulate a systematic plan to address the subsequent user question, employing the specified tools. Every stage in your plan should yield a piece of evidence, signifying the output of a designated function upon receipt of its input. Such input could be the primary user question, any evidence produced earlier, or a blend of both.

You can use these tools:
AskJeeves[input]: Enables users to carry out searches via Ask Jeeves. It compiles a list of possible sites that may contain the answer, though it doesn't provide the answer itself.
PageRenderer[input]: Receives one or more URLs (split by newlines) as input and renders the plaintext contents of those pages.
LinkCollector[input]: Collects links from plaintext and presents them as newline-separated plaintext.
QueryEngine[input]: A machine learning language model adept at answering questions when presented with a text excerpt as context. The input needs to be a question pointing to an :evidence[n]: variable, such as "When was the Declaration of Independence signed, given :evidence1:?"

Inputs to these functions should be unadorned strings, free of quotation marks or '+' characters for merging strings with evidence variables. As an illustration, QueryEngine[Who is the President of the United States, given :evidence2:?].

Ensure each plan step incorporates just one piece of evidence.

Your output should adhere to this layout:
Plan: [Primary action derived from input question]
:evidence0: = [Function to execute with input parameter]
Plan: [Subsequent action, guided by the outcome of :evidence0:]
:evidence1: = [Next function to execute with input parameter, potentially alluding to preceding evidence like "Considering :evidence0"]
...
Final Solution: [:evidence[n]: encompassing the definitive answer.]

Question: What led to the fall of the Roman Empire and what impact did it have on Europe?

Response:
Plan: Kick off a web search to investigate what caused the fall of the Roman Empire.
:evidence0: = AskJeeves[Cause of the fall of the Roman Empire]
Plan: Accumulate applicable URLs from the search results for further scrutiny.
:evidence1: = LinkCollector[:evidence0:]
Plan: Render the contents of the selected websites for thorough review.
:evidence2: = PageRenderer[:evidence1:]
Plan: Employ the query engine to deduce what led to the fall of the Roman Empire based on the rendered website contents.
:evidence3: = QueryEngine[What caused the fall of the Roman Empire, given :evidence2:?]
Plan: Subsequently, commence a different web search to uncover the impact of the fall of the Roman Empire on Europe.
:evidence4: = AskJeeves[Impact of the fall of the Roman Empire on Europe]
Plan: Amass suitable URLs from this new group of search results.
:evidence5: = LinkCollector[:evidence4:]
Plan: Render the contents of these additional websites.
:evidence6: = PageRenderer[:evidence5:]
Plan: Ultimately, utilize the query engine to comprehend the impact of the fall of the Roman Empire on Europe based on the contents of these extra websites.
:evidence7: = QueryEngine[What was the impact of the fall of the Roman Empire on Europe, given :evidence6:?]
Final Solution: :evidence3: and :evidence7:

System: A chat.


Instruction:
Develop a plan to respond to the user's inquiry using the provided tools. For each stage of your plan, create an evidence variable to hold the output of a function call.

Available tools:
InternetSearch[input]: Searches the internet for information relevant to the input query.
SiteScraper[input]: Scrapes a website for textual content. Input is a URL, and output is the site's text content.
InfoExtractor[input]: Extracts key pieces of information from a text based on the input query.
QAModel[input]: Provides answers to questions either from common sense or given a context.

Output format:
Plan: [first action]
:Evidence0: = [first function call with input]
Plan: [subsequent action, based on :Evidence0:]
:Evidence1: = [next function call with input, potentially referring to :Evidence0:]
...
Answer: [:EvidenceN:, containing the final response.]

Question: Who was the director of the movie "Inception" and what other movies have they directed?

Response:
Plan: Start by searching the internet to find out who directed the movie "Inception".
:Evidence0: = InternetSearch[Director of Inception]
Plan: Use the QAModel to determine the director's name from the search results.
:Evidence1: = QAModel[Who directed the movie Inception? Given context: :Evidence0:?]
Plan: Carry out another internet search to find other movies directed by the person identified.
:Evidence2: = InternetSearch[Movies directed by :Evidence1:]
Plan: Finally, use InfoExtractor to list the other movies directed by this individual from the search results.
:Evidence3: = InfoExtractor[List of movies directed by :Evidence1:. Given context: :Evidence2:?]
Answer: :Evidence3:

System: A chat.


Instruction:
Generate a step-by-step execution plan to solve the user's query using the following tools. Each plan should correspond to an evidence value (#E[index]).

Tools:
DuckDuckGo[input]: Allows users to search for information via DuckDuckGo. Finds websites that might have the answer.
WebParser[input]: Loads websites from an input string (newline delimited links) and outputs the content in plain text.
URLExtractor[input]: Extracts URLs from plain text and provides a newline-delimited list of links.
AIQA[input]: AI-based question answering system. Can answer questions given context from prior evidence variables.

Output Format:
Plan: [First action]
#E1 = [Function call with input]
Plan: [Next action]
#E2 = [Next function call with input, possibly referencing #E1]
...
Final Answer: #E[n]

Question: Who invented the Python programming language and what were his motivations?

Response:
Plan: Search for the inventor of the Python programming language.
#E1 = DuckDuckGo[Inventor of Python programming language]
Plan: Use AIQA to parse the search results and identify the inventor.
#E2 = AIQA[Who invented the Python programming language? Given context: #E1]
Plan: Search for the motivations behind inventing Python.
#E3 = DuckDuckGo[Motivations of #E2 for inventing Python]
Plan: Extract useful links from the search results.
#E4 = URLExtractor[#E3]
Plan: Parse the content of the selected links.
#E5 = WebParser[#E4]
Plan: Use AIQA to summarize the motivations of the inventor from the parsed content.
#E6 = AIQA[What were the motivations of #E2 for inventing Python? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a step-by-step plan to answer the user's question: "Who was the first person to climb Mount Everest without supplemental oxygen and what were his reasons?" You have the following tools available:

WikiLookup[input]: Searches Wikipedia for a page matching the input query and returns the full text of the page.
LinkExtractor[input]: Extracts all links from a block of text.
DeepRead[input]: Reads a long passage of text and answers questions based on it.
InterviewSimulator[input]: Simulates an interview with a historical figure based on known facts about them.

Your output should look like this:
Plan: [first action]
:Evidence0: = [tool to use with input]
Plan: [next action]
:Evidence1: = [next tool to use with input, possibly referencing :Evidence0:]
...
Answer: [:EvidenceN:]

Response:
Plan: Look up information about the first person to climb Mount Everest without supplemental oxygen.
:Evidence0: = WikiLookup[First person to climb Mount Everest without supplemental oxygen]
Plan: Use DeepRead to extract the climber's name from the Wikipedia text.
:Evidence1: = DeepRead[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: :Evidence0:]
Plan: Simulate an interview with the climber to understand their motivations.
:Evidence2: = InterviewSimulator[:Evidence1:]
Plan: Use DeepRead again to summarize the climber's reasons for climbing without supplemental oxygen.
:Evidence3: = DeepRead[Why did :Evidence1: climb Mount Everest without supplemental oxygen? Given context: :Evidence2:]
Answer: :Evidence3:

System: A chat.


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

Available Tools:
Bing[input]: A tool for searching information on Bing search engine. This function does not directly answer questions but provides a list of websites which may contain the answers.
WebCrawler[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.
LinkPicker[input]: Extracts links from plain text and generates a plain text, newline delimited response of links.
AIQA[input]: An AI-based question answering tool that can provide direct answers based on general knowledge or given context (input passage of text).

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, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: What are some notable works by the author who wrote "The Old Man and The Sea"?

Response:
Plan: Start by conducting a web search to find out who the author of "The Old Man and The Sea" is.
#E1 = Bing[Author of The Old Man and The Sea]
Plan: Use the AIQA tool to interpret the search results and identify the author's name.
#E2 = AIQA[Who is the author of "The Old Man and The Sea"? Given context: #E1]
Plan: Conduct another web search to find the notable works by the identified author.
#E3 = Bing[Notable works by #E2]
Plan: Extract relevant links from the Bing search results for detailed information.
#E4 = LinkPicker[#E3]
Plan: Use the WebCrawler tool to extract information from the relevant links.
#E5 = WebCrawler[#E4]
Plan: Finally, use the AIQA tool to summarize the notable works by the author from the extracted information.
#E6 = AIQA[What are the notable works by #E2? Given context: #E5]
Final Answer: #E6

---

System: A chat.


Instruction:
Please generate a step-by-step execution plan to solve the problem using the provided tools. Each tool should produce an evidence value, which is the output of a function given an input string (which could be the user's question, previous evidence values, or both).

Available tools:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to find information. It provides a list of sites that might contain the answer to the user's question.
WebScraper[input]: Loads one or more websites from the input string, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: An AI-powered question answering model. It 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 car, given :evidence1:?

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

Question: Who invented the World Wide Web and what were its initial purposes?

Response:
Plan: Begin by conducting a web search to find out who invented the World Wide Web.
:evidence0: = DuckDuckGo[Inventor of the World Wide Web]
Plan: Utilize the AIQA model to interpret the search results and find the name of the inventor.
:evidence1: = AIQA[Who invented the World Wide Web, given :evidence0:?]
Plan: Conduct another web search to find the initial purposes of the World Wide Web.
:evidence2: = DuckDuckGo[Initial purposes of the World Wide Web]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = URLExtractor[: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 initial purposes of the World Wide Web from the extracted information.
:evidence5: = AIQA[What were the initial purposes of the World Wide Web, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a step-by-step plan to solve the user instruction, using the available tools. Each plan should be associated with an evidence value, which will be the output of one of the functions given an input string that can be the user question, previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information from Bing search engine. This tool is useful in finding relevant websites that may contain the answer to the user's query.
SiteReader[input]: Loads and reads the content of a website provided as input and produces plain text output containing the content of the site.
LinkPicker[input]: Extracts links from plain text and provides a list of links.
LMQA[input]: Language model question answering tool, useful in answering questions based on an input passage of text. The input must be a text question that references a :proof[n]: variable, e.g., What color is the dog, given :proof1:?

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

Ensure to include only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
:proof0: = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the language model question answering tool to interpret the search results and identify the winner.
:proof1: = LMQA[Who won the Nobel Prize in Literature in 2020, given :proof0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:proof2: = Bing[Most famous work of :proof1:]
Plan: Extract the relevant links from the Bing search results for detailed information.
:proof3: = LinkPicker[:proof2:]
Plan: Use the SiteReader tool to extract information from the selected links.
:proof4: = SiteReader[:proof3:]
Plan: Finally, use the language model question answering tool to identify and summarize the most famous work of the laureate from the extracted information.
:proof5: = LMQA[What is the most famous work of :proof1:, given :proof4:?]
Answer: :proof5:

System: A chat.