Instruction:
Please construct a methodical plan to address the following question, utilizing the resources listed. Each phase of your plan should yield an evidence value, which represents the output of one of the available functions after being provided an input string that can either be the user's inquiry, earlier evidence values, or both.

You have access to the following tools:

1. NetSearch[input]: This tool enables users to look up information through a widely-used search engine. It aids in locating various sites that might contain the answer to the user's question. The function doesn't provide a direct answer; instead, it identifies possible sources of the answer.
2. PageParser[input]: This tool pulls plain text from one or more websites designated by the input string containing newline separated links. The input comprises one or more URLs, and the output is plain text encapsulating the contents of the linked pages.
3. HyperlinkHarvester[input]: This tool extracts hyperlinks from plain text and returns a plain text, newline-separated array of links.
4. FactoidAI[input]: This is a language model built to answer queries based on a given piece of text. The input needs to be a text-based question that refers to a #E[n] variable, for example, "How tall is the Eiffel Tower, given #E1?"

The input to each function should simply be a string without quotes or "+" to concatenate a string with an evidence variable, for instance, FactoidAI[Who wrote War and Peace, given #E2?]

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

The output should adhere to the following structure:
Plan: [first action based on input question]
#E0 = [function to call with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function to call and input parameter, which may refer to previous evidence, e.g., "Given context #E0"]
...
Final Answer: #E[n]

Question: Who was Galileo Galilei and what were his major contributions to science?

Response:
Plan: Begin by performing a web search to gather information about Galileo Galilei.
#E0 = NetSearch[Galileo Galilei]
Plan: Use the language model to analyze the search results and define who Galileo Galilei was.
#E1 = FactoidAI[Who was Galileo Galilei, given #E0?]
Plan: Carry out another web search to discover the major scientific contributions made by Galileo Galilei.
#E2 = NetSearch[Major scientific contributions of Galileo Galilei]
Plan: Harvest relevant links from the search results for deeper exploration.
#E3 = HyperlinkHarvester[#E2]
Plan: Apply the page parser tool to pull information from the harvested links.
#E4 = PageParser[#E3]
Plan: Finally, utilize the language model to identify and summarize the major scientific contributions made by Galileo Galilei from the parsed information.
#E5 = FactoidAI[What were the major scientific contributions of Galileo Galilei, given #E4?]
Final Answer: #E5

System: A chat.


Instruction:
Create a step-by-step plan to solve the user's query using the following tools. Each tool must be used in one or more steps of your plan, and each step should have an associated evidence value.

Here are the available tools:
Bing[input]: This function allows you to search for information using Bing. It can find relevant websites that may contain the answer to the question.
TextScraper[input]: This tool extracts text from the given website links. The input is a string containing newline-separated URLs.
LinkExtractor[input]: This tool extracts all the links present in the plain text provided as input.
GPT3[input]: A language model that answers 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 output format should be:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with input parameter, which might reference previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the history of the Eiffel Tower and what were some controversies surrounding its construction?

Response:
Plan: Begin by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = Bing[History of the Eiffel Tower]
Plan: Extract the relevant links from the Bing search results for detailed information.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Use TextScraper to extract information from the relevant links.
:evidence2: = TextScraper[:evidence1:]
Plan: Utilize GPT3 to interpret the extracted text and summarize the history of the Eiffel Tower.
:evidence3: = GPT3[What is the history of the Eiffel Tower, given :evidence2:?]
Plan: Conduct another web search to find any controversies surrounding the construction of the Eiffel Tower.
:evidence4: = Bing[Controversies during the construction of the Eiffel Tower]
Plan: Extract the relevant links from the Bing search results.
:evidence5: = LinkExtractor[:evidence4:]
Plan: Use TextScraper to extract information from these links.
:evidence6: = TextScraper[:evidence5:]
Plan: Finally, utilize GPT3 to interpret the extracted text and summarize the controversies surrounding the construction of the Eiffel Tower.
:evidence7: = GPT3[What were the controversies during the construction of the Eiffel Tower, given :evidence6:?]
Answer: :evidence3: and :evidence7:

System: A chat.


Instruction:
Please create a 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. This tool is useful in finding appropriate sites that may 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.
LMQA[input]: Language model question answering tool, 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: Begin by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = GoogleSearch[Nobel Prize in Physics 2020 winner]
Plan: Utilize a language model to interpret the search results and find the name of the laureate.
:evidence1: = LMQA[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: = GoogleSearch[:evidence1: Nobel Prize contribution]
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: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the key contributions made by the laureate from the extracted information.
:evidence5: = LMQA[What were the key contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please provide a step-by-step plan to answer the user's question using the available tools. Each step 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 question, previous evidence values, or both.

Here are the tools you can use:
SearchEngine[input]: A tool that allows users to search for information on the internet. This function is useful in finding a list of websites that may contain the answer to the user's query.
ContentExtractor[input]: Extracts text content from a website URL provided as input and produces plain text output containing the content of the link.
LinkFinder[input]: Extracts links from plain text and produces a plain text response of newline-separated links.
AnswerBot[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., "What is the capital of France, given #E1?"

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

Each plan step should include only one evidence output.

The output format should be:
Plan: [first action based on input question]
#E0 = [function to call with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function to call and input parameter, including reference to previous evidence if necessary, e.g., "Given context #E0"]
...
Final Answer: #E[n]

Question: What is the history of the Eiffel Tower and who were its main architects?

Response:
Plan: Start by conducting an online search about the history of the Eiffel Tower.
#E0 = SearchEngine[Eiffel Tower history]
Plan: Use the LinkFinder tool to extract relevant links from the search results.
#E1 = LinkFinder[#E0]
Plan: Extract the textual content from the most relevant link found.
#E2 = ContentExtractor[#E1]
Plan: Use the AnswerBot to find out about the history of the Eiffel Tower from the extracted content.
#E3 = AnswerBot[What is the history of the Eiffel Tower, given #E2?]
Plan: Conduct another online search to find out who the main architects of the Eiffel Tower were.
#E4 = SearchEngine[Main architects of the Eiffel Tower]
Plan: Extract the textual content from the most relevant link found.
#E5 = ContentExtractor[#E4]
Plan: Finally, use the AnswerBot to identify the main architects of the Eiffel Tower from the extracted content.
#E6 = AnswerBot[Who were the main architects of the Eiffel Tower, given #E5?]
Final Answer: #E3 and #E6

System: A chat.


Instruction:
Create a step-by-step plan to answer the following user query using the available tools. Each tool can be used multiple times but should not be used consecutively and each plan must have an associated evidence value.

Here are the tools that can be called:

WebSearch[input]: A tool that allows users to search for information on the internet. This tool is useful in finding relevant websites or pages that may contain the answer to the user's question.
TextAnalyzer[input]: Analyzes a given text and provides a summary of its content. The input should be a string containing the text to analyze.
QAEngine[input]: Can answer questions based on common sense, general world knowledge, and specific context provided as input.
LinkCollector[input]: Extracts all links from a given text. The input should be a string containing the text with links.
SiteReader[input]: Reads the content of one or more websites from the input string which contains newline delimited links.

The output format should be:
Plan: [first action]
#Evidence1 = [function call with input parameter]
Plan: [next action based on #Evidence1]
#Evidence2 = [next function call with input parameter, referencing previous evidence if necessary]
...
Final Answer: #Evidence[n]

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

Response:
Plan: Start by conducting a web search to find out who invented the first electric car.
#Evidence1 = WebSearch[First electric car inventor]
Plan: Use the QAEngine to interpret the search results and identify the inventor.
#Evidence2 = QAEngine[Who invented the first electric car? Given context: #Evidence1]
Plan: Conduct another web search to find out when the first electric car was invented.
#Evidence3 = WebSearch[When was the first electric car invented]
Plan: Use the QAEngine again to interpret these new search results and determine the date of invention.
#Evidence4 = QAEngine[When was the first electric car invented? Given context: #Evidence3]
Final Answer: #Evidence2 and #Evidence4

System: A chat.


Instruction:
Design a stepwise strategy to respond to the user's inquiry using the tools provided. Each step should correspond to an evidence value, which is the product of a function given its input.

Tools at Disposal:
AskJeeves[input]: A tool that utilizes Ask Jeeves search engine to amass information associated with the input query.
WebsiteLoader[input]: Takes multiple websites from the input string comprising newline separated links and yields plain text content of these links.
LinkPicker[input]: Picks out links from plain text and renders them as newline separated strings.
SmartAnswer[input]: An AI-driven question-answering tool that needs a question referencing an :evidence[n]: variable.

Output Format:
Plan: [First move based on input question]
:evidence0: = [Function to invoke with input parameters]
Plan: [Following move based on the effect of :evidence0:]
:evidence1: = [Upcoming function to summon with input parameters potentially citing prior evidence]
...
Final Answer: :evidence[n]:

Question: Who invented the telephone and where were they born?

Response:
Plan: Commence with a web search to identify the inventor of the telephone.
:evidence0: = AskJeeves[Inventor of the telephone]
Plan: Apply SmartAnswer to decipher the search results and pinpoint the name of the inventor.
:evidence1: = SmartAnswer[Who invented the telephone, given :evidence0:?]
Plan: Carry out another web search to learn where the identified inventor was born.
:evidence2: = AskJeeves[Birthplace of :evidence1:]
Plan: Pick out the relevant links from the AskJeeves search results for deeper investigation.
:evidence3: = LinkPicker[:evidence2:]
Plan: Deploy WebsiteLoader to extract information from the selected links.
:evidence4: = WebsiteLoader[:evidence3:]
Plan: In the end, apply SmartAnswer to recognize and summarize the birthplace of the inventor from the extracted data.
:evidence5: = SmartAnswer[Where was :evidence1: born, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to answer the following question using the tools provided. Each step of your plan should correspond with an evidence variable, 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 you have at your disposal:
1. Bing[input]: This tool allows the user to search for information using the Bing search engine. It is useful in finding a list of sites that may contain the answer to the user's question.
2. TextParser[input]: This tool extracts key pieces of information from a block of text and produces a plain text response containing this information.
3. LinkCollector[input]: This tool extracts links from plain text and provides a newline delimited list of these links.
4. KnowledgeModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

The function inputs should be plain strings without quotes or "+" to concatenate a string with an evidence variable, e.g., KnowledgeModel[What is the capital of France, given :evidence1:?]

Ensure each plan step includes only one evidence output.

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 include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what 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.
:evidence0: = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the KnowledgeModel to interpret the search results and identify the winner.
:evidence1: = KnowledgeModel[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = Bing[Most famous work of :evidence1:]
Plan: Extract relevant links from the Bing search results for more detailed information.
:evidence3: = LinkCollector[:evidence2:]
Plan: Parse the extracted information to find the name of the laureate's most famous work.
:evidence4: = TextParser[:evidence3:]
Plan: Finally, use the KnowledgeModel to summarize the most famous work of the laureate from the parsed information.
:evidence5: = KnowledgeModel[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a detailed plan to respond to the following user query, making use of the provided tools. For each step in your plan, provide an associated piece of evidence, which would be the output of a specific function given its input. Inputs could be either the user's original question, previously generated evidence, or a mix of both.

These are the tools you can use:
DuckDuckGo[input]: A tool that enables users to conduct searches via DuckDuckGo. It returns a list of potential sites that might contain answers but does not provide direct answers itself.
SiteLoader[input]: Takes one or more URLs (separated by newlines) as input and outputs the plaintext contents of those sites.
URLExtractor[input]: Extracts URLs from plaintext and provides them as newline-separated plaintext.
KnowledgeModel[input]: A language model capable of answering questions when provided with a text passage as context. The input must be a question referencing an :evidence[n]: variable, such as "What is the height of Mount Everest, given :evidence1:?"

Inputs to these functions should be simple strings without quotation marks or '+' signs for concatenating strings with evidence variables. For instance, KnowledgeModel[What is the capital of France, given :evidence2:?].

Ensure there's only one piece of evidence per plan step.

Output format should be:
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 with input parameter, potentially referencing prior evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n]: contains the ultimate answer.]

Question: What is the history behind the Eiffel Tower and why was it built?

Response:
Plan: Begin by searching online for information about the history of the Eiffel Tower.
:evidence0: = DuckDuckGo[Eiffel Tower history]
Plan: Extract pertinent URLs from the search results for further investigation.
:evidence1: = URLExtractor[:evidence0:]
Plan: Load the contents of the selected websites for detailed examination.
:evidence2: = SiteLoader[:evidence1:]
Plan: Utilize the knowledge model to determine the history of the Eiffel Tower based on the loaded website contents.
:evidence3: = KnowledgeModel[What is the history of the Eiffel Tower, given :evidence2:?]
Plan: Next, search online for reasons why the Eiffel Tower was built.
:evidence4: = DuckDuckGo[Why was the Eiffel Tower built]
Plan: Extract relevant URLs from this new set of search results.
:evidence5: = URLExtractor[:evidence4:]
Plan: Load the contents of these newly-selected websites.
:evidence6: = SiteLoader[:evidence5:]
Plan: Finally, utilize the knowledge model to establish why the Eiffel Tower was constructed based on the contents of these websites.
:evidence7: = KnowledgeModel[Why was the Eiffel Tower built, given :evidence6:?]
Final Answer: :evidence3: and :evidence7:

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:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine.
InfoExtractor[input]: Extracts key details from a block of text, such as names, dates, locations etc.
SiteLoader[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.
URLFinder[input]: Finds URLs within a body of text and outputs them as a list.
AnswerBot[input]: Answers 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 Microsoft Corporation and who were its founders?

Response:
Plan: Begin by conducting a web search to find out about the history of Microsoft Corporation.
:evidence0: = YahooSearch[History of Microsoft Corporation]
Plan: Extract the relevant details about the history and founders of Microsoft Corporation from the search results.
:evidence1: = InfoExtractor[:evidence0:]
Plan: Conduct another web search to find more detailed information about the founders of Microsoft Corporation.
:evidence2: = YahooSearch[Founders of Microsoft Corporation]
Plan: Find the relevant links from the search results for further exploration.
:evidence3: = URLFinder[:evidence2:]
Plan: Load the content of the found URLs for more detailed information.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, utilize AnswerBot to summarize the history and founders of Microsoft Corporation from the loaded information.
:evidence5: = AnswerBot[Who founded Microsoft Corporation and what is its history? Given :evidence4:]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a detailed plan to solve the following problem, using the provided tools. Each step in your plan should produce an evidence value.

Tools Available:
DuckDuckGo[input]: A function that uses the DuckDuckGo search engine to retrieve potentially relevant information.
ParseHTML[input]: Takes a list of URLs (newline-separated) and returns the full HTML content of those pages as plain text.
ExtractLinks[input]: Given some text, this function extracts any URLs present in the text.
AskJeeves[input]: A question-answering AI model that takes a question and context as input and provides an answer.

Output Format:
Plan: [description of first step]
#E1 = [tool used and its input]
Plan: [description of next step]
...
Final Answer: #En

Question: Who won the 2018 FIFA World Cup and where was it held?

Response:
Plan: Search for the winner of the 2018 FIFA World Cup.
#E1 = DuckDuckGo[2018 FIFA World Cup winner]
Plan: Use AskJeeves to extract the winner from the search results.
#E2 = AskJeeves[Who won the 2018 FIFA World Cup? Given context: #E1]
Plan: Now search for the location of the 2018 FIFA World Cup.
#E3 = DuckDuckGo[2018 FIFA World Cup location]
Plan: Use AskJeeves to determine the location from the search results.
#E4 = AskJeeves[Where was the 2018 FIFA World Cup held? Given context: #E3]
Final Answer: #E2 and #E4

System: A chat.


Instruction:
Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine.
URLScraper[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.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A question-answering language model that answers questions based on an input passage of text. The input must be a text question that references a #E[index] variable.

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

Question: Who invented the internet and what was their motivation?

Response:
Plan: Begin by conducting a web search to find out who invented the internet.
#E1 = DuckDuckGo[Who invented the internet]
Plan: Utilize a language model to interpret the search results and find the name of the inventor.
#E2 = QAModel[Who invented the internet? Given context: #E1]
Plan: Conduct another web search to find the motivation behind inventing the internet.
#E3 = DuckDuckGo[Motivation behind inventing the internet by #E2]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
#E4 = HyperlinkExtractor[#E3]
Plan: Use a URL scraper tool to extract information from the relevant links.
#E5 = URLScraper[#E4]
Plan: Finally, utilize the language model to identify and summarize the motivation behind inventing the internet from the extracted information.
#E6 = QAModel[What was the motivation behind inventing the internet by #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a detailed plan to answer the user's question using the tools provided below. For each step in your plan, store the outcome in a variable #E[index].

Available Tools:
WikiSearch[input]: Searches Wikipedia for information based on the input string.
PageReader[input]: Reads the entire page of a given URL and outputs the text.
QAExpert[input]: Answers questions using general world knowledge or specific context provided.

Output Format:
Plan: [First Action]
#E1 = [Function Call with Input]
Plan: [Next Action Based on Result of #E1]
#E2 = [Next Function Call with Input Possibly Referencing Previous Evidence]
...
Final Answer: #E[n]

Question: Who was the first person to climb Mount Everest without supplemental oxygen and when did this happen?

Response:
Plan: Begin by searching Wikipedia for information about the first person to climb Mount Everest without supplemental oxygen.
#E1 = WikiSearch[First person to climb Mount Everest without supplemental oxygen]
Plan: Use the QAExpert tool to extract the name of the person and the date of the event from the Wikipedia data.
#E2 = QAExpert[Who was the first person to climb Mount Everest without supplemental oxygen and when did this happen? Given context: #E1]
Final Answer: #E2

System: A chat.


Instruction:
Create a step-by-step execution plan to solve the following problem using the provided tools. Each step should correspond to an evidence value, which will be the output of a specific function given an input string. This string could be the user's query, a previous evidence value, or a combination of both.

Here are the tools you can use:
DuckDuckGo[input]: A tool that lets users search for information via the DuckDuckGo search engine. It helps locate a range of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from an input string (containing newline-separated links). Input is one or more links, and it outputs plain text content from these links.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-separated list of URLs.
InfoQA[input]: A question-answering language model that answers queries based on an input text passage. The input should be a text-based question referencing an :evidence[n]: variable.

Output should follow this format:
Plan: [First action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action, based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameter, possibly referring to previous evidence]
...
Final Answer: [:evidence[n]: containing the final answer]

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

Response:
Plan: Start by searching for the winner of the 2019 Nobel Prize in Literature.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2019 winner]
Plan: Use the InfoQA model to determine the winner from the search results.
:evidence1: = InfoQA[Who won the Nobel Prize in Literature in 2019? Given context: :evidence0:]
Plan: Search for the most famous work of the identified laureate.
:evidence2: = DuckDuckGo[Most famous work of :evidence1:]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use SiteReader to gather information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, use the InfoQA model to identify the most famous work of the laureate from the gathered information.
:evidence5: = InfoQA[What is the most famous work of :evidence1:, given context: :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Develop a systematic approach to respond to the user inquiry utilizing the following resources. Each resource must be utilized at least once and every plan should correspond to an evidence variable.

Tools available:

DuckDuckGo[input]: Allows users to find information via DuckDuckGo. Useful for identifying potential sources containing the answer.
SiteReader[input]: Loads content from one or more websites supplied in the input string (links separated by newlines). Outputs the plain text content of these sites.
URLCollector[input]: Extracts URLs from plain text and provides them as newline-separated strings.
AnswerBot[input]: Can answer questions using common sense, world knowledge, or given context. The input should be a question that may refer to prior evidence variables.

Output Format:
Plan: [Initial Action]
#Evidence1 = [Call to function with input parameter]
Plan: [Subsequent action depending on #Evidence1]
#Evidence2 = [Following function call with input parameters possibly referring to #Evidence1]
...
Final Response: #Evidence[n]

Question: What is the tallest mountain in Australia and how was it formed?

Response:
Plan: Begin by searching for the tallest mountain in Australia.
#Evidence1 = DuckDuckGo[Tallest mountain in Australia]
Plan: Utilize AnswerBot to determine the name of the mountain from the search results.
#Evidence2 = AnswerBot[What is the tallest mountain in Australia? Given context: #Evidence1]
Plan: Conduct another search to find out how this mountain was formed.
#Evidence3 = DuckDuckGo[How was #Evidence2 formed]
Plan: Extract relevant links from the search results for detailed analysis.
#Evidence4 = URLCollector[#Evidence3]
Plan: Extract information from the chosen links.
#Evidence5 = SiteReader[#Evidence4]
Plan: Finally, use AnswerBot to understand and summarize how the mountain was formed from the extracted data.
#Evidence6 = AnswerBot[How was #Evidence2 formed? Given context: #Evidence5]
Final Response: #Evidence6

System: A chat.


Instruction:
Generate a plan to solve the following problem using the specified tools. For each step of the plan, indicate the corresponding evidence variable.

Tools Available:
DuckDuckGo[input]: Search engine tool for general queries.
SiteScraper[input]: Tool that retrieves content from specific websites given a link.
LinkPicker[input]: Tool that selects pertinent links from a set of URLs.
FactFinder[input]: Question-answering tool that uses a knowledge base to provide answers based on input context.

Output Format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameters]
Plan: [Next action based on #E1's outcome]
#E2 = [Next function to call with input parameters (may refer to prior evidence)]
...
Final Answer: #En

Question: What is the population of New York City and when was it founded?

Response:
Plan: Begin by searching for the current population of New York City.
#E1 = DuckDuckGo[Current population of New York City]
Plan: Use FactFinder to extract the population data from the search results.
#E2 = FactFinder[What is the current population of New York City? Given context: #E1]
Plan: Now, search for the founding date of New York City.
#E3 = DuckDuckGo[Founding date of New York City]
Plan: Use FactFinder to determine the founding date from the search results.
#E4 = FactFinder[When was New York City founded? Given context: #E3]
Final Answer: #E2 and #E4

System: A chat.


Instruction:
Create a sequential plan to generate an optimal response to the user instruction, making use of a 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 can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is helpful in finding a list of sites that may or may not contain the answer to the user's question. The function does not directly answer the question; instead, it finds a list of sites that may have the answer.
SiteLoader[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.
LinkFinder[input]: Extracts 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, e.g. What color is the dog, 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: What is the population of Tokyo and how has it changed over the last decade?

Response:
Plan: Begin by conducting a web search to find out the current population of Tokyo.
:evidence0: = DuckDuckGo[Current population of Tokyo]
Plan: Utilize AIQA to interpret the search results and find the population figure.
:evidence1: = AIQA[What is the current population of Tokyo, given :evidence0:?]
Plan: Conduct another web search to find how the population of Tokyo has changed over the last decade.
:evidence2: = DuckDuckGo[Tokyo population change over the last decade]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use SiteLoader to extract information from the relevant links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, utilize AIQA to identify and summarize the changes in Tokyo's population over the last decade from the extracted information.
:evidence5: = AIQA[How has the population of Tokyo changed over the last decade, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a solution strategy for the problem below utilizing the tools listed. For each plan, indicate the associated evidence variable resulting from the execution of a tool.

Here are the tools available to be called:
WikiSearch[input]: Tool that enables users to search Wikipedia for information.
PageParser[input]: Parses a webpage and extracts the main body of text.
QAHelper[input]: Provides answers to questions using either general world knowledge or specific context provided.
HyperlinkCollector[input]: Collects hyperlinks from a given piece of text.

Output should adhere to the following structure:
Plan: [first action to take based on 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]
...
Final Answer: #Evidence[n]

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

Response:
Plan: Begin by searching Wikipedia for the winner of the 2020 Nobel Prize in Literature.
#Evidence1 = WikiSearch[Nobel Prize in Literature 2020]
Plan: Use QAHelper to determine the winner from the Wikipedia page.
#Evidence2 = QAHelper[Who won the Nobel Prize in Literature in 2020? Given context: #Evidence1]
Plan: Search Wikipedia again for more details about the winner.
#Evidence3 = WikiSearch[#Evidence2]
Plan: Parse the Wikipedia page to extract the main body of text.
#Evidence4 = PageParser[#Evidence3]
Plan: Determine the author's most famous work using QAHelper.
#Evidence5 = QAHelper[What is the most famous work of #Evidence2? Given context: #Evidence4]
Final Answer: #Evidence5

System: A chat.


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

Here are the tools available to be called:
Encyclopedia[input]: Tool that allows the user to search for information from Encyclopedia. This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information. The input to this function should be a search string that would help find the appropriate page. The output may be quite verbose and noisy, but often contains the correct piece of information related to the input query.
AIQA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: What is the population of the city where Microsoft headquarters is located?

Response:
Plan: Search for more information about Microsoft headquarters.
#E1 = Encyclopedia[Microsoft headquarters]
Plan: Find out the city where Microsoft headquarters is located.
#E2 = AIQA[Where is Microsoft headquarters located? Given context: #E1]
Plan: Search for more information about the city.
#E3 = Encyclopedia[#E2]
Plan: Find out the population of the city.
#E4 = AIQA[What is the population of the city #E2? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Develop a sequential plan to address the following query. Indicate the specific tool to be utilized at each stage, along with the necessary inputs. Store any obtained evidence in a variable #E[index], which can be recalled in subsequent steps.

Tools Available:
GoogleScholar[input]: This tool facilitates academic searches on Google Scholar. The input should be a keyword or phrase related to the desired topic.
TextAnalyzer[input]: This tool analyzes a block of text and answers questions based on the analysis.

Output Structure:
Plan: [Initial course of action]
#E1 = [First tool to use with its respective input]
Plan: [Subsequent action, dependent on the outcome of #E1]
#E2 = [Following tool to employ with its input, potentially referring back to prior evidence]
...
Final Answer: #E[n]

Question: What are the primary causes of climate change according to recent scientific studies?

Response:
Plan: Initiate a scholarly search for recent research on the causes of climate change.
#E1 = GoogleScholar[Cause of climate change recent research]
Plan: Analyze the search results to determine the main causes of climate change according to recent studies.
#E2 = TextAnalyzer[What are the primary causes of climate change according to these sources? Given context: #E1]
Final Answer: #E2

System: A chat.


Instruction:
Create a step-by-step plan to solve the following user instruction using the available tools. Each plan will have an associated evidence value, which is 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 using the Bing search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
URLParser[input]: Extracts URLs from plain text and produces a list of URLs.
WebReader[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.
Querier[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 #E[n] variable, e.g. What color is the dog, given #E1?

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

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]
#E0 = [function to call with input parameter]
Plan: [next action to take, based on result of #E0]
#E1 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E0"]
...
Answer: [#E[n] containing the final answer.]

Question: Who is the current president of Microsoft and what major projects have they overseen?

Response:
Plan: Start by conducting a web search to find out who the current president of Microsoft is.
#E0 = Bing[Current president of Microsoft]
Plan: Use the question answering model to interpret the search results and find the name of the president.
#E1 = Querier[Who is the current president of Microsoft, given #E0?]
Plan: Conduct another web search to find the major projects overseen by the identified president of Microsoft.
#E2 = Bing[Major projects overseen by #E1]
Plan: Extract the relevant URLs from the Bing search results for a more detailed search.
#E3 = URLParser[#E2]
Plan: Use the WebReader tool to extract information from the relevant URLs.
#E4 = WebReader[#E3]
Plan: Finally, use the question answering model to identify and summarize the major projects overseen by the president of Microsoft from the extracted information.
#E5 = Querier[What are the major projects overseen by #E1, given #E4?]
Answer: #E5

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 the Google search engine.
WebsiteLoader[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.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
KnowledgeModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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

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

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

Response:
Plan: Begin by conducting a web search to find out who Albert Einstein was.
#E1 = GoogleSearch[Albert Einstein]
Plan: Utilize the knowledge model to interpret the search results and provide a summary of who Albert Einstein was.
#E2 = KnowledgeModel[Who was Albert Einstein? Given context: #E1]
Plan: Conduct another web search to find the main scientific contributions made by Albert Einstein.
#E3 = GoogleSearch[Main scientific contributions of Albert Einstein]
Plan: Extract the relevant links from the Google search results for a more focused search.
#E4 = LinkFinder[#E3]
Plan: Use the website loader tool to extract information from the relevant links.
#E5 = WebsiteLoader[#E4]
Plan: Finally, utilize the knowledge model to identify and summarize the main scientific contributions made by Albert Einstein from the extracted information.
#E6 = KnowledgeModel[What were the main scientific contributions of Albert Einstein? Given context: #E5]
Final answer: #E6

Continue this process until you've generated 10 unique instruction/response pairs.

System: A chat.


Instruction:
Develop a sequence of steps to answer the user's query utilizing the tools provided. Every step should have a corresponding evidence value, which would be the output of a function given its input.

Available Tools:
YahooSearch[input]: A tool that employs Yahoo Search engine to collect information pertaining to the input query.
SiteReader[input]: Loads several websites from the input string consisting of newline separated links and provides plain text content of these links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and presents them as newline separated strings.
IntelligentQA[input]: An AI-powered question-answering tool that requires a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Initial step based on input question]
:evidence0: = [Function to call with input parameters]
Plan: [Subsequent step based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameters possibly referring to previous evidence]
...
Final Answer: :evidence[n]:

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

Response:
Plan: Begin with a web search to find out the tallest building in New York City.
:evidence0: = YahooSearch[Tallest building in New York City]
Plan: Use IntelligentQA to analyze the search results and identify the name of the building.
:evidence1: = IntelligentQA[What is the tallest building in New York City, given :evidence0:?]
Plan: Perform another web search to discover when the identified building was completed.
:evidence2: = YahooSearch[Completion date of :evidence1:]
Plan: Extract the pertinent links from the YahooSearch results for further exploration.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Employ SiteReader to extract information from the chosen links.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, use IntelligentQA to identify and summarize the completion date of the building from the gathered data.
:evidence5: = IntelligentQA[When was :evidence1: completed, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Formulate a detailed plan to respond to the user's inquiry utilizing the available tools. Each tool should be employed at least once, and every plan stage should correspond to an evidence value.

Tools Available:
GoogleSearch[input]: Allows the user to conduct a Google search based on the input string.
PageReader[input]: Reads and extracts the textual content from a webpage.
HyperlinkFinder[input]: Finds hyperlinks within a body of text.
QuerySolver[input]: Solves queries based on a provided piece of text.

Output Format:
Plan: [Initial action based on the input question]
#E1 = [Function to execute with its parameters]
Plan: [Subsequent action based on the outcome of #E1]
#E2 = [Following function to execute with its parameters]
...
Final Answer: #E[last]

Question: What is the significance of the Rosetta Stone in understanding ancient Egyptian hieroglyphics?

Response:
Plan: Start by conducting a Google search about the Rosetta Stone.
#E1 = GoogleSearch[Rosetta Stone]
Plan: Use HyperlinkFinder to locate any relevant links in the search results.
#E2 = HyperlinkFinder[#E1]
Plan: Utilize PageReader to extract textual content from the found webpages.
#E3 = PageReader[#E2]
Plan: Employ QuerySolver to determine the significance of the Rosetta Stone in deciphering ancient Egyptian hieroglyphics.
#E4 = QuerySolver[What is the significance of the Rosetta Stone in understanding ancient Egyptian hieroglyphics? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Create a plan to respond to the user instruction below, making use of the 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:
WebSearch[input]: Tool that enables users to search for information online.
TextExtractor[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.
HyperlinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
KnowledgeEngine[input]: Language model that answers questions based on an input passage of text.  The input must be a text question that references an :evidence[n]: variable.

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

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

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

System: A chat.


Instruction:
Formulate a plan to address the user's request below using the available tools. Each plan will generate an evidence variable, which is the output of a specific tool given an input string.

Available tools:
DuckDuckGo[input]: Tool that allows users to search for information using DuckDuckGo search engine.
WebReader[input]: Reads the content of web pages given their URLs.
URLSelector[input]: Selects relevant URLs from a list of URLs.
InfoGenie[input]: A question-answering model capable of generating answers based on general knowledge or given context.

Output format:
Plan: [initial action based on input question]
$Evidence1 = [tool to call with input parameters]
Plan: [subsequent action based on $Evidence1]
$Evidence2 = [next tool to call with input parameters, possibly referencing $Evidence1]
...
Answer: [$EvidenceN containing final answer]

Question: What is the history of Bitcoin and who invented it?

Response:
Plan: Begin by conducting a search about the history of Bitcoin.
$Evidence1 = DuckDuckGo[History of Bitcoin]
Plan: Use InfoGenie to extract information about the inventor of Bitcoin from the search results.
$Evidence2 = InfoGenie[Who invented Bitcoin? Given context: $Evidence1]
Plan: Conduct another search focusing on the inventor of Bitcoin.
$Evidence3 = DuckDuckGo[#Evidence2 + Bitcoin]
Plan: Select relevant URLs from the search results for further investigation.
$Evidence4 = URLSelector[$Evidence3]
Plan: Read the content of the selected web pages.
$Evidence5 = WebReader[$Evidence4]
Plan: Finally, use InfoGenie to compile a summary of the history of Bitcoin and its inventor.
$Evidence6 = InfoGenie[What is the history of Bitcoin and who invented it? Given context: $Evidence5]
Answer: $Evidence6

System: A chat.


Instruction:
Develop a detailed plan to respond to the user's instruction using the provided tools. Each plan should correspond to an evidence value, which will be the output of a function given a certain input string. This could be the user's question, one or more previous evidence values, or a combination of both.

These are the tools at your disposal:
BingSearch[input]: Allows the user to search for information using Bing. It does not provide direct answers but generates a list of sites that might contain the required information.
URLLoader[input]: Loads one or more websites from an input string containing newline separated links. The input is one or more links, and the output is plain text containing the contents of the links.
HyperlinkHarvester[input]: Extracts hyperlinks from plain text and provides a plain text, newline-separated response of links.
AIQA[input]: An AI-based question-answering model that excels at answering queries based on an input text passage. The input must be a textual question referencing an :evidence[n]: variable.

The output should adhere to the following structure:
Plan: [First action based on the input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to invoke and input parameter, possibly referring to prior evidence]
...
Final Answer: [:evidence[n]: that contains the ultimate answer]

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

Response:
Plan: Initiate a Bing search to discover who won the 2019 Nobel Prize in Literature.
:evidence0: = BingSearch[Nobel Prize in Literature 2019 winner]
Plan: Utilize AIQA to interpret the search results and determine the winner's name.
:evidence1: = AIQA[Who won the Nobel Prize in Literature in 2019, given :evidence0:?]
Plan: Conduct another Bing search to find the most acclaimed work of the identified laureate.
:evidence2: = BingSearch[Most acclaimed work of :evidence1:]
Plan: Extract the pertinent links from the Bing search results for a more focused investigation.
:evidence3: = HyperlinkHarvester[:evidence2:]
Plan: Employ the URLLoader tool to fetch information from the relevant links.
:evidence4: = URLLoader[:evidence3:]
Plan: Lastly, employ the AIQA to identify and summarize the most acclaimed work of the laureate from the fetched data.
:evidence5: = AIQA[What is the most acclaimed work of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Formulate a plan to answer the question: "When was the last solar eclipse visible from New York City?"

Here are the tools available:
AstroEvents[input]: Tool that provides information about astronomical events.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
DateFinder[input]: Finds dates associated with specific events.
EventTracker[input]: Tracks past events based on a provided context.
LLM[input]: Question answering language model.

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

Response:
Plan: Use the AstroEvents tool to find information about solar eclipses.
#E1 = AstroEvents["solar eclipse in New York City"]

Plan: Extract date from the result of #E1
#E2 = DateFinder[#E1]

Final answer: #E2

System: A chat.


Instruction:
Create a step-by-step plan to generate an ideal response to the user instruction, using the following 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 a list of sites that may contain the answer to the user's question.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIM[input]: An artificial intelligence model capable of 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]
#E0 = [function to call with input parameter]
Plan: [next action to take, based on result of #E0]
#E1 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E0"]
...
Answer: [#E[n] containing the final answer.]

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

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
#E0 = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the AI model to interpret the search results and find the name of the laureate.
#E1 = AIM[Who won the Nobel Prize in Literature in 2020? Given context: #E0]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E2 = Bing[Most famous work of #E1]
Plan: Extract the relevant links from the Bing search results for a more focused search.
#E3 = LinkPicker[#E2]
Plan: Use the WebReader tool to extract information from the relevant links.
#E4 = WebReader[#E3]
Plan: Finally, use the AI model to identify and summarize the most famous work of the laureate from the extracted information.
#E5 = AIM[What is the most famous work of #E1? Given context: #E4]
Answer: #E5

System: A chat.


Instruction:
Formulate a plan to answer the following question using the tools provided. Each step in your plan should be accompanied by an evidence variable, which will hold the output of one of the available functions given its input string.

Available tools:
YahooSearch[input]: A tool that uses Yahoo's search engine to find potentially useful websites. It does not directly answer queries but provides a list of sites that could contain the answer.
SiteReader[input]: Reads and extracts plain text from one or more websites based on the input string containing newline-separated links. The input can be one or several links, and the output is plain text content of these links.
HyperlinkGatherer[input]: Gathers hyperlinks from plain text and produces a plain text response with newline-separated links.
InfoBot[input]: A language model designed to answer questions based on a text passage. The input must be a text question referencing an :evidence[n]: variable, e.g., When was America discovered, given :evidence1:?

Each function requires a simple string as input without quotes or "+" to concatenate a string with an evidence variable, e.g., InfoBot[When did World War II end, given :evidence3:?]

Ensure only one evidence output per plan step.

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 include reference to previous evidence, e.g., "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the final answer.]

Question: Who invented the telephone and where were they born?

Response:
Plan: Initiate a web search to discover who invented the telephone.
:evidence0: = YahooSearch[inventor of the telephone]
Plan: Deploy the language model to interpret the search results and identify the inventor.
:evidence1: = InfoBot[Who invented the telephone, given :evidence0:?]
Plan: Execute another web search to find out where the identified inventor was born.
:evidence2: = YahooSearch[Birthplace of :evidence1:]
Plan: Gather relevant links from the search results for deeper exploration.
:evidence3: = HyperlinkGatherer[:evidence2:]
Plan: Employ the SiteReader tool to extract information from the chosen links.
:evidence4: = SiteReader[:evidence3:]
Plan: Ultimately, use the language model to pinpoint and summarize the birthplace of the inventor from the extracted information.
:evidence5: = InfoBot[Where was :evidence1: born, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to answer the following question using the available tools. Each step in your plan should be followed by an evidence variable that will store the output of one of the functions given its input string.

Here are the tools available to be called:
GoogleSearch[input]: This tool allows you to search for information using Google's search engine. It can find a list of sites related to the user's query.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A question answering model that answers 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 behind the creation of the Eiffel Tower and who were the key people involved?

Response:
Plan: Start by conducting a web search about the history of the Eiffel Tower.
:evidence0: = GoogleSearch[History of the Eiffel Tower]
Plan: Use a language model to interpret the search results and summarize the history of the Eiffel Tower.
:evidence1: = QAModel[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to identify the key people involved in the creation of the Eiffel Tower.
:evidence2: = GoogleSearch[Key people involved in the creation of the Eiffel Tower]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Scrape the contents of the extracted links for detailed information.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the language model to identify and summarize the key people involved in the creation of the Eiffel Tower from the scraped information.
:evidence5: = QAModel[Who were the key people involved in the creation of the Eiffel Tower, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. For each step in your plan, provide an evidence value that corresponds to the output of one of the available functions given an input string. This could be either the user's question, previous evidence values, or both.

Here are the tools you can use:
WebSearch[input]: A tool that allows the user to search for information on the web. It is useful for finding sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from a webpage given its URL. The input should be a single link and the output will be plain text content of the page.
LinkPicker[input]: Picks the most relevant links from a list of URLs based on the input query.
AnswerBot[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, e.g., What is the capital of France, given #E1?

Each function takes a plain string as input without quotes or "+" to concatenate a string with an evidence variable, e.g., AnswerBot[What is the population of Tokyo, given #E2?]

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

Question: Who won the Nobel Prize in Literature in 2020 and what 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.
#E1 = WebSearch[Nobel Prize in Literature 2020 winner]
Plan: Use AnswerBot to interpret the search results and identify the winner.
#E2 = AnswerBot[Who won the Nobel Prize in Literature in 2020, given #E1?]
Plan: Conduct another web search to find the most famous work of the identified author.
#E3 = WebSearch[Most famous work of #E2]
Plan: Pick the most relevant links from the search results for detailed analysis.
#E4 = LinkPicker[#E3]
Plan: Extract text from the selected link(s) for more information about the author's work.
#E5 = TextExtractor[#E4]
Plan: Finally, use AnswerBot to summarize the most famous work of the author from the extracted text.
#E6 = AnswerBot[What is the most famous work of #E2, given #E5?]
Final Answer: #E6

System: A chat.


Instruction:
Generate a step-by-step plan to answer the user query using the following tools. Each tool should be used at least once and every plan must have an associated evidence value.

Here are the available tools:

1. Bing[input]: This function allows users to search for information on the Bing search engine. It is useful in finding websites that may contain answers to the user's question.
2. Extractor[input]: A tool that extracts text from web pages given one or more URLs as input.
3. URLFinder[input]: A tool that finds URLs within a body of text.
4. QAModel[input]: A language model that can answer questions based on a provided context. The input should be a question referencing an :evidence[n]: variable.

The output format should be:
Plan: [First action]
:evidence0: = [Function with input parameter]
Plan: [Next action based on result of :evidence0:]
:evidence1: = [Next function with input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the significance of the Battle of Waterloo?

Response:
Plan: Start by searching for information about the Battle of Waterloo using Bing.
:evidence0: = Bing[Battle of Waterloo]
Plan: Extract URLs from the search results for detailed information.
:evidence1: = URLFinder[:evidence0:]
Plan: Use the Extractor tool to get the content of the identified URLs.
:evidence2: = Extractor[:evidence1:]
Plan: Finally, use the QAModel to understand the significance of the Battle of Waterloo from the extracted information.
:evidence3: = QAModel[What is the significance of the Battle of Waterloo? Given :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Create a plan to answer the following question using the available tools. Each step in your plan should 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 on Bing. It is useful for finding lists of sites that may contain answers to the user's questions.
TextExtractor[input]: Extracts text from websites provided as newline-separated links in the input string. The output is plain text containing the content of the linked pages.
LinkParser[input]: Parses plain text and produces a list of links separated by newlines.
AIQA[input]: An AI-based question answering model capable of providing answers based on an input passage of text. The input must be a textual question referencing an :evidence[n]: variable.

Each function takes a simple string as input without quotes or "+" for concatenating strings with evidence variables (e.g., AIQA[What is the capital of France, given :evidence2:?]).

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

Question: What is the significance of Leonardo da Vinci's painting 'The Last Supper'?

Response:
Plan: Start by searching the web to find out about the significance of 'The Last Supper'.
:evidence0: = Bing[Significance of The Last Supper by Leonardo da Vinci]
Plan: Parse the search results to extract relevant links.
:evidence1: = LinkParser[:evidence0:]
Plan: Scrape the extracted links to gather more detailed information.
:evidence2: = TextExtractor[:evidence1:]
Plan: Use the AI-based QA system to interpret the scraped text and provide a summary of the painting's significance.
:evidence3: = AIQA[What is the significance of The Last Supper by Leonardo da Vinci, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Using the available tools, create a detailed plan to answer the user's question. Each plan should correspond to an evidence value.

Available Tools:
1. WebCrawler[input]: A tool that scans the web for information relevant to the input.
2. QAEngine[input]: A question answering tool that uses AI to answer questions based on common sense, world knowledge, or provided context.
3. DocumentAnalyzer[input]: Analyzes documents to extract important details and summaries.

Output Format:
Plan: [First Action]
:Evidence0: = [Function with Input Parameter]
Plan: [Next Action]
:Evidence1: = [Next Function with Input Parameter]
...
Answer: :EvidenceN:

Question: What are the main features of the Eiffel Tower and when was it last renovated?

Response:
Plan: Start by gathering information about the Eiffel Tower.
:Evidence0: = WebCrawler[Eiffel Tower]
Plan: Use the QAEngine to identify the main features of the Eiffel Tower.
:Evidence1: = QAEngine[What are the main features of the Eiffel Tower? Given context: :Evidence0:]
Plan: Find out when the Eiffel Tower was last renovated.
:Evidence2: = QAEngine[When was the Eiffel Tower last renovated? Given context: :Evidence0:]
Plan: Analyze the collected data to provide a concise response.
:Evidence3: = DocumentAnalyzer[:Evidence1: and :Evidence2:]
Answer: :Evidence3:

System: A chat.


Instruction:
Please develop a plan to answer the following question using the listed tools. Each step should correspond to an evidence variable, which represents the output of a function given an input string (the user's question, prior evidence variables, or both).

Available tools:
YahooSearch[input]: Allows users to search for information via Yahoo. It provides a list of potentially helpful sites but does not directly answer the question.
WebCrawler[input]: Retrieves the content of one or more websites specified by newline-separated links in the input string.
HyperlinkHarvester[input]: Extracts hyperlinks from plain text and delivers them as newline-separated strings.
QueryBot[input]: A language model designed to answer questions based on a supplied passage of text. The input should be a text question that refers to an :evidence[n]: variable, such as "How tall is Mount Everest, given :evidence1:?"

Input to each function should be a simple string, no need for quotes or "+" to concatenate a string with an evidence variable, e.g., QueryBot[What is the capital of Italy, given :evidence2:?]

Ensure to provide only one evidence output per plan step.

Output format should be:
Plan: [first action based on the input question]
:evidence0: = [function call with input parameter]
Plan: [subsequent action based on the outcome of :evidence0:]
:evidence1: = [next function call and input parameter, perhaps referencing previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who directed the movie Inception and what other movies have they directed?

Response:
Plan: Initiate a web search to discover who directed the movie Inception.
:evidence0: = YahooSearch[Director of Inception]
Plan: Employ QueryBot to interpret the search results and identify the director.
:evidence1: = QueryBot[Who directed the movie Inception, given :evidence0:?]
Plan: Carry out another web search to find other movies directed by the identified individual.
:evidence2: = YahooSearch[Movies directed by :evidence1:]
Plan: Harvest the pertinent links from the Yahoo search results for deeper exploration.
:evidence3: = HyperlinkHarvester[:evidence2:]
Plan: Deploy WebCrawler to retrieve information from the harvested links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Lastly, utilize QueryBot to identify and list the other movies directed by the individual from the retrieved information.
:evidence5: = QueryBot[What other movies has :evidence1: directed, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
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.
LinkHarvester[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 historical significance of the Rosetta Stone and where is it currently located?

Response:
Plan: Start by conducting a web search to find out about the historical significance of the Rosetta Stone.
:evidence0: = Bing[Rosetta Stone historical significance]
Plan: Use the QAModel to interpret the search results and summarize the historical significance of the Rosetta Stone.
:evidence1: = QAModel[What is the historical significance of the Rosetta Stone? Given context: :evidence0:]
Plan: Conduct another web search to find out where the Rosetta Stone is currently located.
:evidence2: = Bing[Current location of Rosetta Stone]
Plan: Use the QAModel again to determine the current location of the Rosetta Stone from the search results.
:evidence3: = QAModel[Where is the Rosetta Stone currently located? Given context: :evidence2:]
Answer: :evidence1: and :evidence3:

System: A chat.


Instruction:
Create a step-by-step plan to solve the following user query using the available tools. Each plan will be followed by an evidence value which is the output of one of the available functions given an input string that can be either 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 using the Bing search engine. This tool is useful in finding relevant websites that may contain the answer to the user's question.
HTMLParser[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.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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

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

System: A chat.


Instruction:
Create a plan to solve the following problem step-by-step. Each step should use one of the available tools and produce an evidence value that can be used in subsequent steps.

Here are the tools available to be called:
Bing[input]: A tool that uses Bing search engine to find information related to the input query.
TextExtractor[input]: Extracts plain text from websites given as input links, newline delimited.
LinkPicker[input]: Picks out relevant links from a large set of links provided as input.
KnowledgeBot[input]: This is a question answering bot that can answer questions based on common knowledge or using context provided by previous evidence values.

The output should follow this 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]
...
Final Answer: #E[n]

Question: Who was the architect behind the Sydney Opera House and what other famous buildings did they design?

Response:
Plan: Start by searching for the architect of the Sydney Opera House.
#E1 = Bing[Architect of Sydney Opera House]
Plan: Use KnowledgeBot to identify the name of the architect from the search results.
#E2 = KnowledgeBot[Who designed the Sydney Opera House? Given context: #E1]
Plan: Search for other famous buildings designed by the identified architect.
#E3 = Bing[Famous buildings designed by #E2]
Plan: Extract relevant links from the search results for more detailed information.
#E4 = LinkPicker[#E3]
Plan: Extract textual content from the selected links.
#E5 = TextExtractor[#E4]
Plan: Use KnowledgeBot to summarize the key buildings designed by the architect.
#E6 = KnowledgeBot[What are some famous buildings designed by #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Generate a plan to respond to the following query utilizing the tools provided. Each step in your plan should correspond to an evidence value which will be the output of one of the available functions.

Available Tools:
DuckDuckGo[input]: Allows users to conduct a web search using DuckDuckGo search engine.
PageReader[input]: Reads the contents of a webpage from a link and provides a textual summary.
URLCollector[input]: Gathers all URLs present within a block of text.
KnowledgeEngine[input]: Answers questions using a pre-existing knowledge base. It requires a question referencing an :evidence[n]:

Output Format:
Plan: [First Action]
:evidence0: = [Function with Input Parameter]
Plan: [Subsequent Actions]
:evidence[n]: = [Function with Input Parameter including possible references to prior evidences]
Final Answer: :evidence[n]:

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what other significant achievements do they have?

Response:
Plan: Begin with a web search to identify the first person to climb Mount Everest without supplemental oxygen.
:evidence0: = DuckDuckGo[First person to climb Mount Everest without supplemental oxygen]
Plan: Utilize KnowledgeEngine to extract the name of the climber from the search results.
:evidence1: = KnowledgeEngine[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: :evidence0:]
Plan: Perform another web search to gather more information about this individual's significant achievements.
:evidence2: = DuckDuckGo[Significant achievements of :evidence1:]
Plan: Collect relevant URLs from the search results for further investigation.
:evidence3: = URLCollector[:evidence2:]
Plan: Read the contents of the collected pages to get detailed information.
:evidence4: = PageReader[:evidence3:]
Plan: Finally, use KnowledgeEngine to summarize the significant achievements of the individual from the gathered information.
:evidence5: = KnowledgeEngine[What are the significant achievements of :evidence1:? Given context: :evidence4:]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: Allows the user to search for information using DuckDuckGo search engine.
PDFReader[input]: Load a PDF file from the input link and produces plain text output containing the content of the PDF.
HTMLParser[input]: Parse HTML from a website and produces plain text output containing the content of the site.
ALICE[input]: A language model that answers questions based on an input passage of text.

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

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

Question: Who wrote the book "1984" and what is its main theme?

Response:
Plan: Search for the author of the book "1984".
#E1 = DuckDuckGo["1984" book author]
Plan: Find out who wrote the book "1984".
#E2 = ALICE[Who wrote the book "1984"? Given context: #E1]
Plan: Search for the main theme of the book "1984".
#E3 = DuckDuckGo["1984" book main theme]
Plan: Extract the main theme of the book "1984".
#E4 = ALICE[What is the main theme of the book "1984"? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Create a step-by-step plan to answer the following user question, making use of available tools. Each plan will have an associated evidence value, which is 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 you can call:
Bing[input]: A tool that allows users to search for information using Bing. This tool is useful in finding appropriate sites that may contain the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that might have the answer.
WebReader[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 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 a :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., SAM[What is the capital of Michigan, given :evidence3:?]

Remember to include only one evidence output per plan step.

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

Question: Who won the 2020 NBA Finals MVP award and what college did they attend?

Response:
Plan: Start by conducting a web search to find out who won the 2020 NBA Finals MVP award.
:evidence0: = Bing[2020 NBA Finals MVP winner]
Plan: Use a language model to interpret the search results and identify the MVP winner.
:evidence1: = SAM[Who won the 2020 NBA Finals MVP award, given :evidence0:?]
Plan: Conduct another web search to find out which college the identified MVP attended.
:evidence2: = Bing[:evidence1: + ' college']
Plan: Extract relevant links from the Bing search results for a more focused search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use the WebReader tool to extract information from the relevant links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, utilize the language model to identify the college attended by the MVP from the extracted information.
:evidence5: = SAM[What college did :evidence1: attend, given :evidence4:?]
Answer: :evidence5:

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 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.
LinkMiner[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

Question: Who was the first person to walk on the moon and what were some major challenges they faced during the mission?

Response:
Plan: Begin by conducting a web search to find out who the first person to walk on the moon was.
:evidence0: = Bing[First person to walk on the moon]
Plan: Utilize a language model to interpret the search results and find the name of the astronaut.
:evidence1: = SAM[Who was the first person to walk on the moon, given :evidence0:?]
Plan: Conduct another web search to find the major challenges faced by the identified astronaut during the mission.
:evidence2: = Bing[Major challenges faced by :evidence1: during moon landing]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkMiner[: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 major challenges faced by the astronaut during the mission from the extracted information.
:evidence5: = SAM[What were the major challenges faced by :evidence1: during the moon landing, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Question: What is the history and cultural significance of the Eiffel Tower?

Here are the tools available to be called:
HistoricalDatabase[input]: Tool that provides historical information about a specific topic.
CulturalSignificanceChecker[input]: Tool that provides details on the cultural importance of a particular entity.
QA[input]: Tool that can answer questions based on common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
GoogleTranslate[input]: Tool that translates text from one language to another.
WebSearch[input]: Tool that allows the user to search for information using a web search engine.

Plan: First action to take based on input question
#E1 = HistoricalDatabase["Eiffel Tower"]
Plan: Next action to take, based on result of #E1
#E2 = CulturalSignificanceChecker["Eiffel Tower"]
Plan: Final step, translate the results if necessary
#E3 = GoogleTranslate[#E1 + " " + #E2]
Final Answer: #E3

Response:
The plan seems to be flawed. There is no need for translation unless the information retrieved from HistoricalDatabase and CulturalSignificanceChecker are in a different language, which isn't mentioned in the question.

Here's an improved version:

Plan: First action to take based on input question
#E1 = HistoricalDatabase["Eiffel Tower"]
Plan: Next action to take, based on result of #E1
#E2 = CulturalSignificanceChecker["Eiffel Tower"]
Final Answer: Combine results from #E1 and #E2

Please note that we might have to use QA tool if any further clarification or elaboration is needed based on the outputs of #E1 and #E2.

System: A chat.


Instruction:
Question: What is the primary diet of the Australian saltwater crocodile?

Here are the tools available to be called:
WikiSearch[input]: Tool that allows the user to search for information from Wikipedia.
AskJeeves[input]: A tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
GoogleMaps[input]: This tool provides geographical data about a specific location.
NatGeoData[input]: This tool provides access to National Geographic's database of animal facts and figures.
ZooDB[input]: This tool gives access to a comprehensive database of zoological information.

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

Response:
Plan: The first action is to use the NatGeoData tool which provides animal facts and figures.
#E1 = NatGeoData["Australian saltwater crocodile diet"]

Final answer: #E1

System: A chat.


Instruction:
Create a plan to answer 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 the user question, previous evidence values, or both.

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information from various websites on the internet. The input is a search string and the output is a list of website links related to the query.
ReadPage[input]: This tool takes a URL as input and returns the text content of the webpage.
LinkFilter[input]: Extracts relevant links from a plain text containing multiple URLs.
AIAnswerer[input]: An AI model that answers questions based on an input passage of text. The input must be a text question that references an #E[n] variable.

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's the history behind the creation of Google?

Response:
Plan: Start by searching the web for information about the creation of Google.
#E1 = WebSearch[History of Google creation]
Plan: Filter out irrelevant links from the search results.
#E2 = LinkFilter[#E1]
Plan: Read the contents of the filtered pages.
#E3 = ReadPage[#E2]
Plan: Use the AI Answerer to extract specific details about the creation of Google from the page contents.
#E4 = AIAnswerer[What's the history behind the creation of Google? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Create a plan to answer the following question using these available tools. Each step in your plan should be associated with an evidence variable, which will store the output of the tool used in that step.

Here are the tools you can use:

1. BingSearch[input]: This tool uses the Bing search engine to find information related to the input query. It returns a list of websites that might contain the required information.
2. WebScraper[input]: This tool takes one or more URLs as input and retrieves plain text content from those pages.
3. URLExtractor[input]: This tool extracts all URLs from the provided plain text.
4. WikiInfo[input]: This tool searches Wikipedia for information on the input topic.
5. QAModel[input]: This is a question answering model that can provide answers based on given context (from previous evidence variables).

Remember, each function's input must be a plain string without quotes or concatenation operators. The final format should look like this:

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

Question: What is the history behind the Eiffel Tower and who were its main architects?

Response:
Plan: Search for basic information about the Eiffel Tower on Wikipedia.
#E1 = WikiInfo[Eiffel Tower]
Plan: Use the QA model to extract the names of the main architects of the Eiffel Tower from the Wikipedia information.
#E2 = QAModel[Who were the main architects of the Eiffel Tower? Given context: #E1]
Plan: Conduct a Bing search to find more detailed information about the history of the Eiffel Tower.
#E3 = BingSearch[History of the Eiffel Tower]
Plan: Extract URLs from the Bing search results for further investigation.
#E4 = URLExtractor[#E3]
Plan: Scrape the webpages found during the Bing search for their textual content.
#E5 = WebScraper[#E4]
Plan: Finally, use the QA model to summarize the history of the Eiffel Tower based on the scraped webpage contents.
#E6 = QAModel[What is the history of the Eiffel Tower? Given context: #E5]
Final Answer: #E6

System: A chat.