Instruction:
Generate a detailed execution plan to solve the user's query using the following tools. For each step, indicate the corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user's question, prior evidence values, or both.

Here are the tools available to use:
WebSearch[input]: A tool that allows the user to conduct an internet search. This tool is helpful in finding potential sites that might contain the answer to the user's question.
PageScraper[input]: Loads one or more webpages from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the pages.
LinkGrabber[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerAI[input]: A question-answering AI model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, 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., AnswerAI[What is the population of Brazil, given #E3?]

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

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

Question: What are some of the most critically acclaimed films directed by Christopher Nolan and what awards have they won?

Response:
Plan: Start by conducting a web search to find out the most critically acclaimed films directed by Christopher Nolan.
#E1 = WebSearch[Critically acclaimed films directed by Christopher Nolan]
Plan: Use the AnswerAI to interpret the search results and list the films.
#E2 = AnswerAI[What are the critically acclaimed films directed by Christopher Nolan, given #E1?]
Plan: Conduct another web search to find the awards won by these films.
#E3 = WebSearch[Awards won by #E2]
Plan: Extract the relevant links from the search results for more focused research.
#E4 = LinkGrabber[#E3]
Plan: Use the PageScraper tool to extract information from the relevant links.
#E5 = PageScraper[#E4]
Plan: Lastly, use the AnswerAI to identify and summarize the awards won by the films from the extracted information.
#E6 = AnswerAI[What awards have the films #E2 won, given #E5?]
Final Answer: #E6

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:
GoogleScholar[input]: Tool that allows the user to search for academic articles and papers. This tool is particularly useful in gaining knowledge about scientific topics, theories, and research findings.
PubMed[input]: Tool that allows the user to search for biomedical literature. It is especially useful when looking for specific medical conditions, treatments, and research.
QAEngine[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: What is the latest research on Alzheimer's disease treatment?

Response:
Plan: Search for recent academic articles on Alzheimer's disease treatment.
#E1 = GoogleScholar[Latest research on Alzheimer's disease treatment]
Plan: Find out the key points from the most relevant article.
#E2 = QAEngine[What are the key points from the latest research on Alzheimer's disease treatment? Given context: #E1]
Plan: Search for more detailed information about the treatment mentioned in the key points.
#E3 = PubMed[#E2]
Plan: Summarize the details of the treatment.
#E4 = QAEngine[What are the details of the treatment #E2? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Make a plan to discover what the primary diet of an African elephant is.

Available tools:
AnimalDiet[input]: Provides information about the diet of specified animals.
ZooDB[input]: Database of zoological information.
QA[input]: Can answer questions using common sense or given context.
NationalGeographic[input]: Provides wildlife and geographic information.
Wikipedia[input]: Allows searching for information from Wikipedia.

Output format:
Plan: First action
:Evidence0: = function with input parameter
Plan: Next action based on :Evidence0:
:Evidence1: = next function with input parameter referencing previous evidence if necessary
...
Answer: [:Evidence[n]: containing the final answer.]

Response:
Plan: First action
:Evidence0: = AnimalDiet["African elephant"]
Plan: If :Evidence0: is not conclusive, use the ZooDB to find more information.
:Evidence1: = ZooDB["African elephant diet"]
Plan: If :Evidence1: is still not conclusive, ask QA for a common sense answer.
:Evidence2: = QA["What do African elephants eat?"]
Plan: If :Evidence2: does not provide a satisfactory answer, refer to NationalGeographic.
:Evidence3: = NationalGeographic["African elephant diet"]
Plan: If all else fails, search Wikipedia for comprehensive information.
:Evidence4: = Wikipedia["African elephant diet"]
Answer: [:Evidence[n]: containing the final answer.]

System: A chat.


Instruction:
Design a sequential plan to address the following query using the designated tools. Each stage should correspond to an evidence value, which represents the outcome of one of the available operations given an input string that could be the user's inquiry, one or multiple prior evidence values, or a blend of both.

Here are the tools available to be called:
BingSearch[input]: Allows the user to perform an online search for data using Bing. This tool helps locate potential sites that might contain the answer to the user's query.
PDFReader[input]: Reads PDF files from the URL(s) supplied as input and generates a textual output containing the file's contents.
URLFinder[input]: Finds URLs embedded within a block of text provided as input and returns them as a list.
AIQA[input]: An AI-based question-answering model that provides answers to queries based on an input text fragment. The input should be a text question referencing an #E[index] variable, e.g., What is the name of the dog, given #E1?

Each function's input should be a simple string, without quotation marks or "+" to combine a string with an evidence variable, e.g., AIQA[What is the population of New York City, given #E3?]

Ensure that there is only one evidence output for each plan step.

The output should follow this format:
Plan: [First action based on the input question]
#E1 = [Function to call with its input parameter]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call and its input parameter, possibly referring to previous evidence, e.g., "Given context #E1"]
...
Final Answer: #E[n], where n is the index of the last evidence

Question: What were the main findings of the latest climate change report published by the United Nations?

Response:
Plan: Begin by performing a Bing search to find the latest UN climate change report.
#E1 = BingSearch[Latest UN climate change report]
Plan: Utilize the URLFinder to collect the URLs of the report from the search results.
#E2 = URLFinder[#E1]
Plan: Use the PDFReader to extract the text from the located PDF report.
#E3 = PDFReader[#E2]
Plan: Lastly, employ the AIQA model to determine the main findings of the report from the extracted text.
#E4 = AIQA[What were the main findings of the latest UN climate change report, given #E3?]
Final Answer: #E4

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a general web search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
KnowledgeBaseQA[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, 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 2020 US Presidential Election and what were some key issues during their campaign?

Response:
Plan: Start by conducting a web search to find out who won the 2020 US Presidential Election.
:evidence0: = WebSearch[2020 US Presidential Election winner]
Plan: Use a language model to interpret the search results and find the name of the winner.
:evidence1: = KnowledgeBaseQA[Who won the 2020 US Presidential Election, given :evidence0:?]
Plan: Conduct another web search to find the key issues during the identified winner's campaign.
:evidence2: = WebSearch[Key issues during :evidence1:'s 2020 presidential campaign]
Plan: Extract the relevant links from the web search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the key issues during the winner's campaign from the extracted information.
:evidence5: = KnowledgeBaseQA[What were the key issues during :evidence1:'s 2020 presidential campaign, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a step-by-step plan to solve the user instruction, making use of the 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]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What are some popular dishes in Vietnamese cuisine and what ingredients do they typically contain?

Response:
Plan: Begin by conducting a web search to find out about popular dishes in Vietnamese cuisine.
:evidence0: = Bing[Popular dishes in Vietnamese cuisine]
Plan: Utilize a language model to interpret the search results and identify some popular dishes.
:evidence1: = QAModel[What are some popular dishes in Vietnamese cuisine, given :evidence0:?]
Plan: Conduct another web search to find the typical ingredients of these identified dishes.
:evidence2: = Bing[Ingredients of :evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use a web reader tool to extract information from the relevant links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the typical ingredients of the Vietnamese dishes from the extracted information.
:evidence5: = QAModel[What are the typical ingredients of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Design a systematic plan to respond to the user's inquiry utilizing the following tools. Every plan should correspond to an evidence value, representing the output of a function when provided with an input string that could be the user's question, earlier evidence values, or both.

These are the tools you can use:
YahooSearch[input]: Allows users to look up information using Yahoo's search engine. It's handy for locating websites that might contain answers to the user's question.
PageLoader[input]: Loads a webpage from an input URL and returns the page's content in plain text.
URLGatherer[input]: Gathers all URLs found on a webpage. The input is a single URL and the output is a list of URLs found on the page.
AskBot[input]: A bot that can answer questions based on an input text passage. The input should be a text question that refers to an :evidence[n]: variable.

The output should follow this structure:
Plan: [First action based on the user's question]
:evidence0: = [Function call with input parameter]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Subsequent function call and input parameter, possibly referring to prior evidence]
...
Final Answer: [:evidence[n]: Containing the final answer.]

Question: How did Amazon.com start and who founded it?

Response:
Plan: Start by searching the web for information on how Amazon.com started.
:evidence0: = YahooSearch[Amazon.com origin]
Plan: Use AskBot to analyze the search results and provide details on how Amazon.com began.
:evidence1: = AskBot[How did Amazon.com start? Given context: :evidence0:]
Plan: Search the web again to find out who founded Amazon.com.
:evidence2: = YahooSearch[Founder of Amazon.com]
Plan: Use AskBot once more to determine who founded Amazon.com based on the new search results.
:evidence3: = AskBot[Who founded Amazon.com? Given context: :evidence2:]
Final Answer: :evidence1: and :evidence3:

System: A chat.


Instruction:
Construct a step-by-step plan to address the following inquiry using the tools provided. Each tool should be used at least once and each plan must 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:
AskJeeves[input]: Allows the user to search for information using the Ask Jeeves search engine.
PageReader[input]: Loads one or more websites from the input string containing newline delimited links, producing plain text output containing the content of the links.
URLCollector[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of links.
QAMachine[input]: Machine Learning based Question Answering tool, useful in answering questions based on an input passage of text.

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

Question: Who is the director of the movie 'Inception' and what other popular movies have they directed?

Response:
Plan: Begin by conducting a web search to find out who the director of 'Inception' is.
$E1 = AskJeeves[Director of Inception]
Plan: Use QAMachine to interpret the search results and identify the director.
$E2 = QAMachine[Who is the director of the movie 'Inception', given context: $E1]
Plan: Conduct another web search to find other popular movies directed by the identified director.
$E3 = AskJeeves[Popular movies directed by $E2]
Plan: Extract the relevant links from the search results for further exploration.
$E4 = URLCollector[$E3]
Plan: Use PageReader to gather detailed information from the selected links.
$E5 = PageReader[$E4]
Plan: Lastly, use QAMachine to identify and summarize the popular movies directed by the director from the gathered information.
$E6 = QAMachine[What are the popular movies directed by $E2? Given context: $E5]
Final answer: $E6

System: A chat.


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

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

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

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

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

System: A chat.


Instruction:
Create a plan to find out: "Who was Nikola Tesla and what were his major contributions to science?"

Available tools:
Biography[input]: Provides biographical information about individuals.
ScientificContributions[input]: Gives details about scientific discoveries and contributions made by individuals.
Wikipedia[input]: Allows for search of information from Wikipedia.
QA[input]: Can answer questions using common sense and general world knowledge.
TimeLine[input]: Provides a timeline of important events related to the input topic.

Output format:
Plan: initial action
:Evidence0: = function with input parameter
Plan: subsequent action
:Evidence1: = next function with input parameter
...
Answer: [:Evidence[n]: containing the final answer.]

Response:
Plan: Start by gathering general information about Nikola Tesla.
:Evidence0: = Biography[input: "Nikola Tesla"]

Plan: Next, delve into his scientific contributions.
:Evidence1: = ScientificContributions[input: "Nikola Tesla"]

Plan: To get a comprehensive understanding of his life and work, check Wikipedia for additional details.
:Evidence2: = Wikipedia[input: "Nikola Tesla"]

Plan: If there are any unclear or ambiguous points in the collected data, use QA to clarify them.
:Evidence3: = QA[input: specific questions based on gathered data]

Plan: Finally, create a timeline of Tesla's life and major accomplishments.
:Evidence4: = TimeLine[input: "Nikola Tesla"]

Answer: [:Evidence0:, :Evidence1:, :Evidence2:, :Evidence3:, :Evidence4:] will provide a detailed overview of who Nikola Tesla was and what his major contributions to science were.

System: A chat.


Instruction:
Generate a step-by-step plan to solve the following problem using the provided tools.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that uses DuckDuckGo's search engine to find information online.
WebsiteReader[input]: Reads the content of a website and provides it as plain text.
AIAnswerer[input]: An AI tool that answers questions based on the context provided.

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: When did the first manned mission land on Mars and who were the astronauts involved?

Response:
Plan: Start by searching for when the first manned mission landed on Mars.
:E1: = DuckDuckGo[first manned mission to Mars]
Plan: Use the AIAnswerer to determine the date of the landing from the search results.
:E2: = AIAnswerer[When did the first manned mission land on Mars? Given context: :E1]
Plan: Search again to find out who the astronauts involved in the mission were.
:E3: = DuckDuckGo[astronauts of the first manned mission to Mars]
Plan: Use the AIAnswerer to identify the astronauts from the search results.
:E4: = AIAnswerer[Who were the astronauts involved in the first manned mission to Mars? Given context: :E3]
Final Answer: :E4:

System: A chat.


Instruction:
Formulate a step-by-step solution plan to address the query below. Use the tools provided, and for each step, specify the tool along with the required input. Store the outcome as evidence, which you can refer back to in later steps.

Available Tools:
DuckDuckGo[input]: This tool conducts a DuckDuckGo search using the supplied input and yields a collection of potentially informative resources.
ContentExtractor[input]: This tool retrieves key details from a large amount of text.
KnowledgeModel[input]: This tool provides answers to queries based on the context supplied in the input.

Format of Output:
Plan: [outline of the initial step]
:Evidence1: = [selected tool and its input]
Plan: [outline of the succeeding step]
:Evidence2: = [subsequent tool chosen and its input, possibly referring to :Evidence1:]
...
Final Response: [:EvidenceN:]

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

Response:
Plan: Begin by searching for the architect of the Sydney Opera House.
:Evidence1: = DuckDuckGo[Architect of Sydney Opera House]
Plan: Utilize the ContentExtractor to pinpoint the architect's name from the search findings.
:Evidence2: = ContentExtractor[:Evidence1:]
Plan: Carry out another search to discover other notable structures designed by the identified architect.
:Evidence3: = DuckDuckGo[Notable structures designed by :Evidence2:]
Plan: Apply the ContentExtractor again to pull out the names of these structures from the search results.
:Evidence4: = ContentExtractor[:Evidence3:]
Final Response: :Evidence4:

System: A chat.


Instruction:
Create a step-by-step plan to solve the user's question using the following 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 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 internet. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from HTML content and produces a plain text response.
QAEngine[input]: Answers questions based on common sense, general world knowledge, and given context. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?
LinkCollector[input]: Collects all URLs from a given text and outputs them as a newline-delimited string.

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

Remember to include only one evidence output per plan step.

The output format should be:
Plan: [first action based on the input question]
#E0 = [function to call with input parameter]
Plan: [next action based on the result of #E0]
#E1 = [next function to call and input parameter, which may reference previous evidence, e.g., "Given context #E0"]
...
Answer: [#En 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.
#E0 = WebSearch[Nobel Prize in Literature 2020 winner]
Plan: Use the QAEngine to identify the winner from the search results.
#E1 = QAEngine[Who won the Nobel Prize in Literature in 2020, given #E0?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E2 = WebSearch[Most famous work of #E1]
Plan: Extract the relevant links from the search results for more focused research.
#E3 = LinkCollector[#E2]
Plan: Extract text from the relevant links.
#E4 = TextExtractor[#E3]
Plan: Finally, use the QAEngine to identify and summarize the most famous work of the laureate from the extracted information.
#E5 = QAEngine[What is the most famous work of #E1, given #E4?]
Answer: #E5

System: A chat.


Instruction:
Generate a sequential plan to respond to the user's query using the tools provided. Each step should include the use of a tool and its corresponding input. Store the output of each tool in a variable :evidence[n]:

Available tools:
Bing[input]: Tool that allows you to perform searches on Bing.
LinkExtractor[input]: Extracts links from plain text.
Scraper[input]: Loads websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
LLM[input]: Language model that answers questions based on an input passage of text.

Output format:
Plan: [First action]
:evidence0: = [Function call with input]
Plan: [Next action]
:evidence1: = [Function call with input]
...
Answer: [:evidence[n:] containing the final answer.]

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

Response:
Plan: Start by conducting a search to find out who won the 2020 Nobel Prize in Physics.
:evidence0: = Bing[2020 Nobel Prize in Physics winner]
Plan: Use LLM to interpret the search results and identify the winner.
:evidence1: = LLM[Who won the 2020 Nobel Prize in Physics, given :evidence0:?]
Plan: Conduct another search to find out the contributions of the identified laureate.
:evidence2: = Bing[:evidence1: + "Nobel Prize contribution"]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Scrape the content of the most relevant link.
:evidence4: = Scraper[:evidence3:]
Plan: Finally, use LLM to summarize the laureate's contribution from the scraped content.
:evidence5: = LLM[What was the contribution of :evidence1: for which they received the Nobel Prize in Physics, given :evidence4:?]
Answer: :evidence5:

Please continue this process to generate 8 more unique instruction/response pairs.

System: A chat.


Instruction:
Please generate a plan to solve the following question using 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 given an input string that can be the user question, previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information from Bing. This tool is useful in finding relevant websites and articles related to the user's query.
TextParser[input]: Extracts key details from a text passage. The input must be a plain text passage.
URLCollector[input]: Collects URLs from a list of sites. The input must be a plain text, newline delimited response of links.
QAEngine[input]: A language model 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 color is the cat, given #E1?

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

Question: Who won the Nobel Prize in Literature in 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 = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the QAEngine to extract the name of the winner from the search results.
#E2 = QAEngine[Who won the Nobel Prize in Literature in 2020? Given context: #E1]
Plan: Conduct another web search to find the most famous work of the identified author.
#E3 = Bing[Most famous work of #E2]
Plan: Extract the relevant URLs from the Bing search results for more detailed information.
#E4 = URLCollector[#E3]
Plan: Parse the content of the collected URLs to extract information about the author's most famous work.
#E5 = TextParser[#E4]
Plan: Finally, use the QAEngine to identify and summarize the most famous work of the author from the parsed information.
#E6 = QAEngine[What is the most famous work of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Construct a plan to learn about the nutritional value of a medium-sized apple.

Tools available:
- NutritionDB[input]: Database providing detailed nutritional information about food items.
- QA[input]: Answers questions using general world knowledge or provided context.
- FoodAnalyzer[input]: Analyzes food items to determine their nutritional composition.
- ComparisonTool[input1, input2]: Compares two or more things based on specified criteria.
- ValidationTool[input]: Validates the accuracy of a given piece of information.

Follow the same output format as described in TSK 1 and TSK 2.

Response:
1. **Task**: Use the NutritionDB tool to find detailed nutritional information about a medium-sized apple.
    - **Input to NutritionDB**: "Medium-sized apple"
    - **Expected Output**: Detailed nutritional information about a medium-sized apple.

2. **Task**: Ask QA for general knowledge about the nutritional value of a medium-sized apple.
    - **Input to QA**: "What is the nutritional value of a medium-sized apple?"
    - **Expected Output**: General information about the nutritional value of a medium-sized apple.

3. **Task**: Use the FoodAnalyzer tool to analyze a medium-sized apple and determine its nutritional composition.
    - **Input to FoodAnalyzer**: "Medium-sized apple"
    - **Expected Output**: Nutritional composition of a medium-sized apple.

4. **Task**: Compare the results from the NutritionDB, QA, and FoodAnalyzer using the ComparisonTool.
    - **Input to ComparisonTool**: [Output from NutritionDB, Output from QA, Output from FoodAnalyzer]
    - **Expected Output**: A comparison of the nutritional values obtained from each source.

5. **Task**: Validate the accuracy of the comparison result using the ValidationTool.
    - **Input to ValidationTool**: [Output from ComparisonTool]
    - **Expected Output**: Confirmation of the accuracy of the comparison result or indication of any discrepancies.

6. **Task**: If there are discrepancies in the validation output, repeat steps 1-5 with more specific queries (e.g., specifying the type of apple).

7. **Task**: Summarize the final validated nutritional value information for a medium-sized apple.
    - **Input to QA**: "Summarize the nutritional value of a medium-sized apple based on the validated data."
    - **Expected Output**: A summary of the nutritional value of a medium-sized apple.

System: A chat.


Instruction:
Please provide a step-by-step plan to generate an ideal response to the user instruction, 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:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.
URLReader[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.
HyperlinkFinder[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
LanguageUnderstandingModel[input]: Question answering language model, useful in answering questions based on an input passage of text.

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

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

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2018.
#E1 = DuckDuckGo[Nobel Prize in Literature 2018 winner]
Plan: Use the Language Understanding Model to determine the winner from the search results.
#E2 = LanguageUnderstandingModel[Who won the Nobel Prize in Literature in 2018? Given context: #E1]
Plan: Perform another web search to find the most acclaimed work of the identified author.
#E3 = DuckDuckGo[Most acclaimed work of #E2]
Plan: Extract the relevant links from the search results for deeper examination.
#E4 = HyperlinkFinder[#E3]
Plan: Use URL Reader to gather detailed information from the selected links.
#E5 = URLReader[#E4]
Plan: Lastly, use the Language Understanding Model to identify and summarize the most acclaimed work of the author from the gathered information.
#E6 = LanguageUnderstandingModel[What is the most acclaimed work of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Please provide a detailed plan to answer the following question using the tools available. For each step, identify the tool and its input parameters that will be used to gather evidence. You can store the results of each step in a variable #E[index] for use in subsequent steps.

Here are the tools you have at your disposal:
SearchEngine[input]: This tool allows you to perform an internet search with the given input string. It returns a list of websites that may contain relevant information.
TextExtractor[input]: This tool extracts all text from a given website URL. The input should be one or more URLs separated by commas.
LinkPicker[input]: This tool picks out specific links from a block of text based on relevance to the input query.
AIAnswerer[input]: This is a sophisticated AI model capable of answering questions when provided with a context. The input should be a question, optionally followed by "Given context: #E[n]", where n refers to previous evidence.

The output format should be as follows:
Plan: [first action to take based on the 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 historical significance of the Rosetta Stone and where is it currently located?

Response:
Plan: Start by searching the internet for information about the Rosetta Stone.
#E1 = SearchEngine[Rosetta Stone]
Plan: Extract useful links from the search results related to the historical significance of the Rosetta Stone.
#E2 = LinkPicker[Historical significance of the Rosetta Stone Given context: #E1]
Plan: Extract textual content from the selected links.
#E3 = TextExtractor[#E2]
Plan: Use the AI model to determine the historical significance of the Rosetta Stone from the extracted text.
#E4 = AIAnswerer[What is the historical significance of the Rosetta Stone? Given context: #E3]
Plan: Conduct another internet search to find out where the Rosetta Stone is currently located.
#E5 = SearchEngine[Current location of the Rosetta Stone]
Plan: Extract useful links from the search results related to the current location of the Rosetta Stone.
#E6 = LinkPicker[Current location of the Rosetta Stone Given context: #E5]
Plan: Extract textual content from the selected links.
#E7 = TextExtractor[#E6]
Plan: Use the AI model to determine the current location of the Rosetta Stone from the extracted text.
#E8 = AIAnswerer[Where is the Rosetta Stone currently located? Given context: #E7]
Final Answer: The historical significance of the Rosetta Stone is #E4 and it is currently located at #E8.

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
TextExtractor[input]: Extracts text from plain HTML and produces a plain text, newline delimited response.
LinkFinder[input]: Finds 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 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 architect behind the design of Sydney Opera House and what were his other notable works?

Response:
Plan: Begin by conducting a web search to find out who was the architect of Sydney Opera House.
:evidence0: = Bing[Architect of Sydney Opera House]
Plan: Utilize AIQA to interpret the search results and find the name of the architect.
:evidence1: = AIQA[Who was the architect of Sydney Opera House, given :evidence0:?]
Plan: Conduct another web search to find the other notable works of the identified architect.
:evidence2: = Bing[Notable works of :evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use TextExtractor tool to extract information from the relevant links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, utilize AIQA to identify and summarize the other notable works of the architect from the extracted information.
:evidence5: = AIQA[What are the other notable works of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please formulate a sequential plan to tackle the user's inquiry using the designated tools. Each stage of the plan should produce an evidence value.

Tools available:
YouTube[input]: Tool that finds videos related to a specific topic.
LyricsFinder[input]: Tool that searches for song lyrics.
Spotify[input]: Tool that streams music and provides information about songs and artists.
MusicCharts[input]: Tool that provides information about top-charting songs and albums.
SongTrivia[input]: Tool that answers trivia questions about songs and artists.

Question: Find the official video of the song "Bohemian Rhapsody" by Queen, get its lyrics, play the song on Spotify, tell me its chart history, and give some trivia about the song.

Response:
1. Use the YouTube tool to search for the official video of "Bohemian Rhapsody" by Queen. The evidence value would be the link to the official music video.

2. Utilize the LyricsFinder tool to look up the lyrics for "Bohemian Rhapsody". The evidence value will be the full set of lyrics for the song.

3. Open Spotify and use its search function to find "Bohemian Rhapsody" by Queen. Play the song. The evidence value is the confirmation that the song is playing on Spotify.

4. Access the MusicCharts tool to get information about the chart history of "Bohemian Rhapsody". The evidence value would be the positions it held on various music charts, and how long it stayed there.

5. Finally, use the SongTrivia tool to gather some trivia about "Bohemian Rhapsody". The evidence value would be interesting facts or anecdotes related to the song or its creation.

System: A chat.


Instruction:
Develop a sequential plan to generate a suitable response to the user instruction, utilizing the provided set of tools. Every plan will correspond to an evidence value, which is the outcome of one of the accessible functions with an input string that could be the user question, one or more preceding evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: Tool that lets the user search for information via DuckDuckGo search engine. It aids in locating a list of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from the input string comprising newline separated links. Input is one or more links, and it generates plain text output containing the link contents.
HyperlinkCollector[input]: Gathers links from plain text and yields a plain text, newline-separated list of links.
QAModel[input]: Question-answering language model, especially helpful in answering queries based on an input text passage. The input needs to be a textual question that refers to an :evidence[n]: variable.

Output format:
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, possibly referencing prior evidence, e.g., "Given context :evidence0:"]
...
Final Answer: [:evidence[n]: holding the ultimate answer]

Question: Who is the author of the book 'To Kill a Mockingbird' and what other books did they write?

Response:
Plan: Begin by searching the web to find out who wrote 'To Kill a Mockingbird'.
:evidence0: = DuckDuckGo['To Kill a Mockingbird' author]
Plan: Utilize QAModel to interpret the search results and identify the author.
:evidence1: = QAModel[Who is the author of 'To Kill a Mockingbird', given :evidence0:?]
Plan: Carry out another web search to find other books written by the identified author.
:evidence2: = DuckDuckGo[Other books written by :evidence1:]
Plan: Collect the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = HyperlinkCollector[:evidence2:]
Plan: Use SiteReader to extract information from the chosen links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, employ QAModel to identify and summarize the other books written by the author from the gathered information.
:evidence5: = QAModel[What other books were written by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a sequential plan to answer the following query using the provided tools. Each plan should correspond to an evidence value which is the output of a function given its input.

Tools Available:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to gather information related to the input query.
WebScraper[input]: Loads multiple websites from the input string which contains newline separated links. It then outputs plain text content of these links.
URLExtractor[input]: Extracts URLs from plain text and returns them as newline separated strings.
AIQA[input]: An AI-based question-answering tool that takes in a question referencing an :evidence[n]: variable.

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

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

Response:
Plan: Initiate a web search to determine who won the Nobel Prize in Literature in 2018.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2018 winner]
Plan: Utilize AIQA to interpret the search results and find the name of the laureate.
:evidence1: = AIQA[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: = DuckDuckGo[Most famous work of :evidence1:]
Plan: Extract the relevant links from the DuckDuckGo search results for detailed information.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use WebScraper to extract information from the selected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Lastly, employ AIQA to identify and summarize the most famous work of the laureate from the scraped data.
:evidence5: = AIQA[What is the most famous work of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step plan to solve the user's query making use of the available tools: BingSearch[input], InfoExtractor[input], QAEngine[input], SiteCrawler[input], HyperlinkGatherer[input] and GeoLocator[input]. Each tool has to be utilized at least once, and there should be a question answering tool like "QA".

Descriptions of the tools are as follows:

BingSearch[input]: Allows users to find information using the Bing search engine. Finds appropriate sites that might have the answer to the user's question.

InfoExtractor[input]: Extracts important information from a block of text. Can identify names, dates, locations, etc.

QAEngine[input]: Answers questions based on common sense, general world knowledge, or given input context that contains the answer.

SiteCrawler[input]: Visits one or more websites from the input string (newline separated links) and outputs plain text content of those sites.

HyperlinkGatherer[input]: Extracts hyperlinks from a plain text and gives a newline-separated list of links.

GeoLocator[input]: Provides geographic data about a location based on the input string.

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

Question: Who was Albert Einstein and what were his major contributions to science? Also, locate his birthplace.

Response:
Plan: Start by searching for information about Albert Einstein.
#Evidence1 = BingSearch[Albert Einstein]
Plan: Extract relevant links from the search results.
#Evidence2 = HyperlinkGatherer[#Evidence1]
Plan: Visit the extracted links to gather more detailed information.
#Evidence3 = SiteCrawler[#Evidence2]
Plan: Extract key information about Albert Einstein from the gathered text.
#Evidence4 = InfoExtractor[#Evidence3]
Plan: Use the question answering engine to get a summary of who Albert Einstein was and his major scientific contributions.
#Evidence5 = QAEngine[Who was Albert Einstein and what were his major contributions to science? Given context: #Evidence4]
Plan: Locate Albert Einstein's birthplace.
#Evidence6 = GeoLocator[Birthplace of Albert Einstein]
Answer: #Evidence5; Birthplace: #Evidence6

System: A chat.


Instruction:
Create a plan to respond to the user instruction below using the tools provided. For each step in your plan, assign an evidence value that corresponds to the output of one of the available functions. The input string for these functions can be the user question, prior evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: Allows users to search for information via DuckDuckGo. Useful for finding websites and articles pertinent to the user's query.
InfoExtractor[input]: Pulls out crucial details from a block of text. Input must be a simple text passage.
LinkGatherer[input]: Gathers links from a set of sites. Input must be a plain text, newline separated list of links.
QAModel[input]: Language model capable of answering queries based on an input text. The input needs to be a textual question referencing a :evidence[n]: variable, such as What is the dog's breed, given :evidence1:?

Output format:
Plan: [First action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action, considering the outcome of :evidence0:]
:evidence1: = [Subsequent function to call and its input parameter, potentially referring to earlier evidence like "Considering context :evidence0"]
...
Answer: [:evidence[n]: containing the final solution.]

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

Response:
Plan: Initiate a web search to determine the director of the movie 'Inception'.
:evidence0: = DuckDuckGo[Director of Inception]
Plan: Utilize QAModel to discern the director's name from the search results.
:evidence1: = QAModel[Who directed the movie Inception? Considering context :evidence0:?]
Plan: Carry out another web search to discover other movies directed by the identified individual.
:evidence2: = DuckDuckGo[Movies directed by :evidence1:]
Plan: Compile the relevant links from the DuckDuckGo search results for further investigation.
:evidence3: = LinkGatherer[:evidence2:]
Plan: Apply InfoExtractor to pull information about the director's other movies from the gathered links.
:evidence4: = InfoExtractor[:evidence3:]
Plan: Lastly, employ QAModel to recognize and summarize the other movies directed by the person from the extracted data.
:evidence5: = QAModel[What other movies has :evidence1: directed? Considering context :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.
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.
LinkCollector[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
LMQA[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the history of the Louvre Museum and who were its key architects?

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

System: A chat.


Instruction:
Construct a step-by-step plan to respond to the user instruction, making use of the 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.

Tools available:
NetSearch[input]: Allows the user to search for information online. This tool is useful in finding a list of sites that may or may not contain the answer to the user's question.
PageLoader[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.
LinkGrabber[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Language model for answering questions, especially effective when answering 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 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 founded SpaceX and what were their motivations?

Response:
Plan: Begin by conducting a web search to find out who founded SpaceX.
:evidence0: = NetSearch[Founder of SpaceX]
Plan: Utilize QAModel to interpret the search results and find the founder's name.
:evidence1: = QAModel[Who founded SpaceX, given :evidence0:?]
Plan: Conduct another web search to find the motivations behind founding SpaceX.
:evidence2: = NetSearch[Motivations of :evidence1: for founding SpaceX]
Plan: Extract the relevant links from the Google search results for a more focused search.
:evidence3: = LinkGrabber[:evidence2:]
Plan: Use PageLoader to extract information from the relevant links.
:evidence4: = PageLoader[:evidence3:]
Plan: Finally, utilize QAModel to identify and summarize the motivations of the SpaceX founder from the extracted information.
:evidence5: = QAModel[What were the motivations of :evidence1: for founding SpaceX, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools you can use:
Bing[input]: A tool that allows users to search for information via Bing. It helps find a list of websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from web pages. The input is one or more URLs and it outputs plain text containing the content of the links.
LinkHarvester[input]: Extracts links from plain text and produces a plain text response of newline-separated links.
AIQA[input]: An AI-powered Question Answering model. Useful in answering questions based on an input passage of text.

The format of each function's input should be a simple string. There's no need for quotes or "+" to concatenate a string with an evidence variable (e.g., AIQA[What is the capital of France, given :evidence3:?]).

Remember to include only one evidence output per plan step.

Output format:
Plan: [first action]
:evidence1: = [function call with input parameter]
Plan: [next action, based on result of :evidence1:]
:evidence2: = [next function call and input parameter, referencing previous evidence if necessary]
...
Answer: [:evidence[n]: contains the final answer.]

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

Response:
Plan: Start by searching for the author of "To Kill a Mockingbird".
:evidence1: = Bing[Author of To Kill a Mockingbird]
Plan: Use the AIQA tool to extract the name of the author from the search results.
:evidence2: = AIQA[Who is the author of To Kill a Mockingbird, given :evidence1:?]
Plan: Conduct another search to find other books written by this author.
:evidence3: = Bing[Books written by :evidence2:]
Plan: Extract relevant links from the search results for further investigation.
:evidence4: = LinkHarvester[:evidence3:]
Plan: Extract textual data from these links.
:evidence5: = TextExtractor[:evidence4:]
Plan: Finally, use the AIQA tool to identify and summarize the other books written by the author.
:evidence6: = AIQA[What other books were written by :evidence2:, given :evidence5:?]
Answer: :evidence6:

System: A chat.


Instruction:
Develop a plan to generate a response to the user's instruction using the 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.

Available tools:
Bing[input]: Allows the user to search for information using Bing. It finds a list of sites that may contain the answer to the user's question.
LinkParser[input]: Extracts links from plain text and produces a newline delimited response of links.
WebReader[input]: Loads websites from the input string containing newline-delimited links and produces plain text output containing the content of the links.
AIAnswerer[input]: 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]
:evidence0: = [function call with input parameter]
Plan: [next action based on :evidence0:]
:evidence1: = [next function call with input parameter, referencing previous evidence if necessary]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the 2020 US Presidential Election and what were their main campaign promises?

Response:
Plan: Conduct a web search to find out who won the 2020 US Presidential Election.
:evidence0: = Bing[2020 US Presidential Election winner]
Plan: Use AIAnswerer to identify the winner from the search results.
:evidence1: = AIAnswerer[Who won the 2020 US Presidential Election, given :evidence0:?]
Plan: Conduct another web search to find the main campaign promises of the identified winner.
:evidence2: = Bing[Main campaign promises of :evidence1:]
Plan: Extract relevant links from the search results.
:evidence3: = LinkParser[:evidence2:]
Plan: Load the content of the extracted links.
:evidence4: = WebReader[:evidence3:]
Plan: Use AIAnswerer to summarize the main campaign promises from the loaded content.
:evidence5: = AIAnswerer[What were the main campaign promises of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
Google[input]: Tool that allows the user to search for information using the Google search engine.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
Scraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
WikiSearch[input]: A tool that searches Wikipedia for relevant articles based on the input string.
AnswerBot[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:]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some of the most notable works by the author who wrote "To Kill a Mockingbird"?

Response:
Plan: Start by searching for the author of "To Kill a Mockingbird".
:evidence0: = WikiSearch[To Kill a Mockingbird]
Plan: Use AnswerBot to identify the author's name from the Wikipedia page.
:evidence1: = AnswerBot[Who is the author of To Kill a Mockingbird? Given context: :evidence0:]
Plan: Conduct a Google search to find other notable works by this author.
:evidence2: = Google[:evidence1: + ' notable works']
Plan: Extract the relevant links from the Google search results.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use Scraper to extract information from these links.
:evidence4: = Scraper[:evidence3:]
Plan: Finally, use AnswerBot to summarize the most notable works by this author from the extracted information.
:evidence5: = AnswerBot[What are the most notable works by :evidence1:? Given context: :evidence4:]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using any popular web search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a webpage link provided as input and produces a plain text output containing the content of the page.
LinkParser[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.

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

Question: What are some major accomplishments of Elon Musk?

Response:
Plan: Start by conducting a web search to find out about Elon Musk's major accomplishments.
:evidence0: = WebSearch[Major accomplishments of Elon Musk]
Plan: Extract the relevant links from the search results for a more focused search.
:evidence1: = LinkParser[:evidence0:]
Plan: Use TextExtractor tool to extract information from the relevant links.
:evidence2: = TextExtractor[:evidence1:]
Plan: Finally, utilize the AIQA model to identify and summarize the major accomplishments of Elon Musk from the extracted information.
:evidence3: = AIQA[What are some major accomplishments of Elon Musk, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Please construct a step-by-step strategy to address the following inquiry, making use of the tools supplied. Every stage in your strategy should correlate with an evidence value, which represents the output of a function given an input string. This string might be the user's question, previous evidence values, or a blend of both.

Here are the tools you can utilize:
NetResearcher[input]: This tool enables the user to conduct a broad internet search for information. It's handy for locating websites that might contain the answer to the user's question.
SiteReader[input]: Retrieves the textual content from a specified website URL.
HyperlinkGatherer[input]: Extracts URLs from a block of text, producing a list of links separated by newlines.
DataQA[input]: An AI-powered question-answering tool capable of providing responses based on a specific text passage. The input needs to be a question that refers to an :evidence[n]: variable, for instance, "What is the GDP of Japan, given :evidence1:?"

Inputs to these functions should be straightforward strings, devoid of quotation marks or "+" signs used to combine a string with an evidence variable, like DataQA[Who won the 2020 US Presidential Election, given :evidence3:?].

Ensure that each plan step corresponds to exactly one evidence output.

Your output should adhere to the following structure:
Plan: [the initial action based on the input question]
:evidence0: = [the function to invoke with the appropriate input parameter]
Plan: [the subsequent action based on the outcome of :evidence0:]
:evidence1: = [the next function to call along with its input parameter, potentially referencing prior evidence, e.g., "In light of :evidence0"]
...
Final Response: [:evidence[n]: containing the conclusive answer.]

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

Response:
Plan: Initiate a broad internet search to gather information about the significance of the Rosetta Stone.
:evidence0: = NetResearcher[Rosetta Stone significance]
Plan: Deploy the DataQA tool to discern the importance of the Rosetta Stone from the gathered data.
:evidence1: = DataQA[What is the significance of the Rosetta Stone, given :evidence0:?]
Plan: Conduct another internet search to ascertain the current location of the Rosetta Stone.
:evidence2: = NetResearcher[Current location of Rosetta Stone]
Plan: Extract pertinent links from the search results for a more focused analysis.
:evidence3: = HyperlinkGatherer[:evidence2:]
Plan: Leverage the SiteReader tool to obtain information from the collected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, apply the DataQA tool to pinpoint the current location of the Rosetta Stone from the obtained information.
:evidence5: = DataQA[Where is the Rosetta Stone currently located, given :evidence4:?]
Final Response: The Rosetta Stone, significant because :evidence1:, is currently located at :evidence5:.

System: A chat.


Instruction:
Design a detailed plan to solve the following problem step-by-step. For each plan, specify which external tool along with its input to gather evidence. You can store the gathered evidence into a variable #E[index] that can be referenced later.

Available tools:
GoogleScholar[input]: Tool that enables searching for academic articles, papers, and publications. The input should be a research-related query.
PDFParser[input]: Load PDF files from the input URL(s) and produce plain text output containing the content of the file(s).
CitationTracker[input]: Track citations made in academic papers. Input is a link to an academic paper.
QAExpert[input]: Answer questions based on common sense, world knowledge, or given input context that may contain the answer.

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

Output format:
Plan: [First action based on input question]
#E1 = [Function call with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next function call and input parameter, potentially referring to previous evidence, e.g., "Given context #E1"]
...
Final answer: #E[n]

Question: How has the theory of relativity been used in recent astrophysics research?

Response:
Plan: Search for recent astrophysics research related to the theory of relativity.
#E1 = GoogleScholar[Recent astrophysics research theory of relativity]
Plan: Parse the most relevant academic papers found in the search.
#E2 = PDFParser[#E1]
Plan: Track the citations made in these papers to understand how they reference the theory of relativity.
#E3 = CitationTracker[#E1]
Plan: Analyze the parsed texts and citation tracking data to determine how the theory of relativity has been applied in recent research.
#E4 = QAExpert[How has the theory of relativity been used in these papers? Given context: #E2 and #E3]
Final answer: #E4

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo 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.
ContentExtractor[input]: Extracts text content from plain text and produces a plain text, newline delimited response of links.
TextSummarizer[input]: Summarizes large chunks of text into concise summaries.
QAEngine[input]: 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: Start by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = DuckDuckGo[Nobel Prize in Physics 2020 winner]
Plan: Use the QAEngine to interpret the search results and identify the winner.
:evidence1: = QAEngine[Who won the Nobel Prize in Physics in 2020, given :evidence0:?]
Plan: Conduct another web search to find the contributions made by the identified laureate.
:evidence2: = DuckDuckGo[:evidence1: Nobel Prize contribution]
Plan: Extract the relevant text from the search results for further analysis.
:evidence3: = ContentExtractor[:evidence2:]
Plan: Summarize the extracted information to get a brief overview of the laureate's contribution.
:evidence4: = TextSummarizer[:evidence3:]
Plan: Finally, utilize the QAEngine to extract the key details about the laureate's contribution from the summarized information.
:evidence5: = QAEngine[What was the contribution of :evidence1: for which they received the Nobel Prize in Physics in 2020, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a detailed execution plan for solving the following query. Each step of your plan should involve invoking one of the listed functions with a specific input. Store the output of each function invocation in a numbered :Evidence[index]: variable, which you can refer back to in subsequent steps.

Available Functions:
DuckDuckGo[input]: Searches DuckDuckGo for the provided input and returns a list of potential sources.
ExtractLinks[input]: Given a block of text (such as the output of a DuckDuckGo search), this function will return a list of all URLs found within the text.
ReadURL[input]: Given a URL, this function will fetch the page at that URL and return its contents as plain text.
AIQA[input]: A powerful AI-based question-answering system. Can provide direct answers to many types of questions, and can also generate answers based on provided context (for example, the text of a webpage).

Output Format:
Plan: [Description of the first step]
:Evidence0: = [Function call for the first step]
Plan: [Description of the second step]
:Evidence1: = [Function call for the second step]
... and so forth until ...
Final Answer: :EvidenceN:

Question: Who won the Nobel Prize in Literature in 1954 and what were their most significant works?

Response:
Plan: Begin by searching DuckDuckGo for the winner of the 1954 Nobel Prize in Literature.
:Evidence0: = DuckDuckGo[Nobel Prize in Literature 1954 winner]
Plan: Use AIQA to parse the search results and determine the winner.
:Evidence1: = AIQA[Who won the Nobel Prize in Literature in 1954? Given context: :Evidence0:]
Plan: Perform another DuckDuckGo search to find the most significant works of the identified author.
:Evidence2: = DuckDuckGo[:Evidence1: most significant works]
Plan: Extract the URLs from the search results for further investigation.
:Evidence3: = ExtractLinks[:Evidence2:]
Plan: Read the contents of the first URL in the list.
:Evidence4: = ReadURL[:Evidence3[0]]
Plan: Lastly, use AIQA to parse the webpage text and identify the most significant works of the author.
:Evidence5: = AIQA[What are the most significant works of :Evidence1:? Given context: :Evidence4:]
Final Answer: :Evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
SiteLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLGrabber[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
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 invented the light bulb and what were some of their other inventions?

Response:
Plan: Start by conducting a web search to find out who invented the light bulb.
:evidence0: = Bing[Who invented the light bulb]
Plan: Use a language model to interpret the search results and identify the inventor.
:evidence1: = SAM[Who invented the light bulb, given :evidence0:?]
Plan: Conduct another web search to find other inventions by the identified inventor.
:evidence2: = Bing[Other inventions by :evidence1:]
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:evidence3: = URLGrabber[:evidence2:]
Plan: Use a site loader tool to extract information from the relevant URLs.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the other inventions by the inventor from the extracted information.
:evidence5: = SAM[What are the other inventions by :evidence1:, given :evidence4:?]
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:
Britannica[input]: Tool that allows the user to search for information from Britannica Encyclopedia. This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
FAQSolver[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: Who was Alexander Hamilton and what were his major contributions to American history?

Response:
Plan: Search for more information about Alexander Hamilton.
#E1 = Britannica[Alexander Hamilton]
Plan: Find out who Alexander Hamilton was.
#E2 = FAQSolver[Who was Alexander Hamilton? Given context: #E1]
Plan: Search for more information about Alexander Hamilton's contributions to American history.
#E3 = Britannica[Alexander Hamilton's contributions]
Plan: Find out the major contributions of Alexander Hamilton to American history.
#E4 = FAQSolver[What were the major contributions of Alexander Hamilton to American history? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the following user query, using the tools provided. Each step in your plan should have a corresponding evidence value that will be the output of one of the available functions given an input string which could be the user question, previous evidence values or both.

Here are the tools you can use:
WebSearch[input]: This tool allows users to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
TextScraper[input]: This tool extracts text from one or more websites from the input string containing newline delimited links. 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.
AIQA[input]: An artificial intelligence question answering model, useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output format should be as follows:
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]
...
Answer: [:evidence[n]: containing the final answer.]

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

Response:
Plan: Begin by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = WebSearch[Eiffel Tower History]
Plan: Use AIQA to interpret the search results and extract key points about the history of the Eiffel Tower.
:evidence1: = AIQA[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find out who the main architects of the Eiffel Tower were.
:evidence2: = WebSearch[Main architects of Eiffel Tower]
Plan: Use AIQA again to identify the main architects from the search results.
:evidence3: = AIQA[Who were the main architects of the Eiffel Tower, given :evidence2:?]
Answer: :evidence1:, :evidence3:

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 that will be the output of one of the available functions given an input string, which can be the user's question, previous evidence values, or both.

Here are the tools available to you:
Bing[input]: This tool allows the user to search for information using the Bing search engine. It is useful in finding sites that may contain the answer to the user's question.
HTMLParser[input]: This tool extracts plain text from HTML content. The input must be HTML content and it produces plain text as output.
URLCollector[input]: This tool collects URLs from plain text and produces a list of newline delimited links.
DeepQA[input]: A deep learning based question answering model. Useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should follow this format:
Plan: [first action to take based on input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
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 DeepQA to interpret the search results and identify the winner.
:evidence1: = DeepQA[Who won the Nobel Prize in Literature in 2020? Given context: :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 further exploration.
:evidence3: = URLCollector[:evidence2:]
Plan: Parse the HTML content of the relevant links to extract information.
:evidence4: = HTMLParser[:evidence3:]
Plan: Finally, use DeepQA to identify and summarize the most famous work of the laureate from the extracted information.
:evidence5: = DeepQA[What is the most famous work of :evidence1:? Given context: :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
For the following task, create a plan 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:
GoogleMaps[input]: Tool that allows the user to search for geographical information using Google Maps.
IMDb[input]: Tool that allows the user to search for information about movies and TV shows from IMDb.
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.
YouTube[input]: Tool that allows the user to search for videos on YouTube.
Dictionary[input]: Tool that provides definitions of words.

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 location of the filming of the movie 'Inception' and what does the word 'inception' mean?

Response:
Plan: First, find the filming location of the movie 'Inception'.
#E1 = IMDb['Inception']

Plan: Next, extract the filming location from the information retrieved.
#E2 = QA['Where was the movie Inception filmed?', context=#E1]

Plan: Then, find the meaning of the word 'inception'.
#E3 = Dictionary['inception']

Final answer: The movie 'Inception' was filmed at #E2. The word 'inception' means #E3.

System: A chat.


Instruction:
Please develop a systematic plan to answer the user's query utilizing the provided tools. Each phase of the plan will produce an evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
YahooSearch[input]: A tool that enables the user to look up information using the Yahoo search engine. This tool is handy for locating a list of sites that may hold the answer to the user's question. It does not provide a direct answer to the question but identifies potential sources of answers.
WebScraper[input]: Loads one or more websites from the input string containing newline-delimited links, where input is one or more links, and generates 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.
MLQA[input]: Machine Learning Question Answering model, particularly effective at answering questions based on an input passage of text. The input must be a text question that refers to an :evidence[n]: variable, e.g., What is the height of Mount Everest, given :evidence1:?

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

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

Response:
Plan: Start by conducting a web search to find out who wrote 'To Kill a Mockingbird'.
:evidence0: = YahooSearch[Author of To Kill a Mockingbird]
Plan: Use MLQA to interpret the search results and identify the author.
:evidence1: = MLQA[Who is the author of 'To Kill a Mockingbird', given :evidence0:?]
Plan: Conduct another web search to find other books written by the identified author.
:evidence2: = YahooSearch[Other books written by :evidence1:]
Plan: Extract the relevant hyperlinks from the Yahoo search results for a more detailed search.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use WebScraper to extract information from the relevant hyperlinks.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use MLQA to summarize the other books written by the author from the extracted information.
:evidence5: = MLQA[What other books has :evidence1: written, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to answer the following question using the available tools. For each step of the plan, specify which tool you would use and what input you would give it. Store the output of each tool in a variable #E[index] that can be used as input for subsequent steps.

Here are the tools available to be called:
SearchEngine[input]: A tool that allows the user to search for information on the internet. The input should be a string containing the query.
DocumentReader[input]: This tool reads documents and extracts relevant information based on the given input.
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.
LinkExtractor[input]: Extracts links from plain text and produces a list of links.
Scraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.

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 largest city in France?

Response:
Plan: Use SearchEngine to find out the largest city in France.
#E1 = SearchEngine[Largest city in France]
Plan: Use QA tool to extract the name of the largest city from the search results.
#E2 = QA[What is the largest city in France? Given context: #E1]
Plan: Use SearchEngine again to find out the population of the identified city.
#E3 = SearchEngine[Population of #E2]
Plan: Finally, use QA tool to extract the population figure from the search results.
#E4 = QA[What is the population of #E2? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Generate a detailed execution plan to address the following user instruction, making use of the provided set of tools. Each plan will correspond to an evidence value, which will be the outcome of one of the accessible functions given an input string that could be the user's question, one or more preceding evidence values, or a combination of both.

Available tools to be used:
DuckDuckGo[input]: A tool that enables the user to search for information via the DuckDuckGo search engine. It assists in locating a suitable list of sites that might have the answer to the user's inquiry.
WebReader[input]: Loads one or more websites from the input string consisting of newline separated links. The input is one or more links, and it generates a plain text output containing the link contents.
HyperlinkFinder[input]: Extracts hyperlinks from plain text and delivers a plain text, newline-separated response of links.
ASKER[input]: A question-answering language model, especially effective at answering queries based on an input text passage. The input has to be a textual question that refers to an :evidence[n]: variable, like 'What is the population of Tokyo, given :evidence1:?'.

Output format:
Plan: [First action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action based on the result of :evidence0:]
:evidence1: = [Next function to call and input parameter, possibly referencing previous evidence, such as "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the final answer]

Question: What is the current market capitalization of Amazon and how did it change over the last year?

Response:
Plan: Start by conducting a web search to determine the current market capitalization of Amazon.
:evidence0: = DuckDuckGo[Current market capitalization of Amazon]
Plan: Use the ASKER language model to analyze the search results and ascertain the current market capitalization.
:evidence1: = ASKER[What is the current market capitalization of Amazon, given :evidence0:?]
Plan: Perform another web search to discover how Amazon's market capitalization changed over the past year.
:evidence2: = DuckDuckGo[Amazon market capitalization change over the last year]
Plan: Extract the pertinent links from the DuckDuckGo search results for a more targeted investigation.
:evidence3: = HyperlinkFinder[:evidence2:]
Plan: Employ the WebReader tool to extract data from the selected links.
:evidence4: = WebReader[:evidence3:]
Plan: Lastly, use the ASKER language model to identify and summarize the changes in Amazon's market capitalization over the past year from the retrieved information.
:evidence5: = ASKER[How did the market capitalization of Amazon change over the last year, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Provide a detailed plan to solve the following problem using the tools at your disposal. Each tool execution will provide an evidence value which can be utilized in subsequent steps.

Tools Available:
WebSearch[input]: A tool that searches the web for information related to the input query.
LinkCollector[input]: Collects all links present in the provided text.
ContentScraper[input]: Scrapes the content of the provided URLs.
InfoProcessor[input]: Processes the scraped content and provides concise information.
QueryAnswerer[input]: Answers queries based on the processed information.

Output Format:
Step: [Action to take]
:Evidence1: = [Tool to use with input parameters]
Step: [Next action based on :Evidence1:]
:Evidence2: = [Next tool to use with input parameters, potentially referencing :Evidence1:]
...
Final Response: [:EvidenceN:]

Question: Who won the Nobel Prize in Literature in 2019?

Response:
Step: Initiate a web search to find out who won the Nobel Prize in Literature in 2019.
:Evidence1: = WebSearch[Nobel Prize in Literature 2019 winner]
Step: Collect all the links from the search results.
:Evidence2: = LinkCollector[:Evidence1:]
Step: Scrape the content from the collected links.
:Evidence3: = ContentScraper[:Evidence2:]
Step: Process the scraped content to obtain concise information.
:Evidence4: = InfoProcessor[:Evidence3:]
Step: Answer the query based on the processed information.
:Evidence5: = QueryAnswerer[Who won the Nobel Prize in Literature in 2019? Given :Evidence4:]
Final Response: :Evidence5:

Continue this process for additional 8 unique instruction/response pairs.

System: A chat.


Instruction:
Create a plan to answer the following question: "What is the main diet of the Giant Panda and where can they be found in the wild?" using these tools:

1. WebSearch[input]: A tool that performs an internet search based on the input string.
2. Extractor[input]: This tool extracts key information from a large amount of text, such as the results of a web search.
3. Atlas[input]: A tool that provides geographical information about specific places or regions.
4. QandA[input]: A tool that answers questions based on provided context.

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

Response:
Plan: Conduct a web search to find out what the main diet of the Giant Panda is.
#E1 = WebSearch[Giant Panda Diet]
Plan: Use the extractor tool to pull out the relevant information from the search results.
#E2 = Extractor[#E1]
Plan: Formulate a response to the first part of the question using the QandA tool.
#E3 = QandA[What is the main diet of the Giant Panda? Given context: #E2]
Plan: Perform another web search to find out where Giant Pandas can be found in the wild.
#E4 = WebSearch[Giant Panda Habitat]
Plan: Use the Atlas tool to get more detailed geographic information.
#E5 = Atlas[#E4]
Plan: Use the QandA tool again to formulate a response to the second part of the question.
#E6 = QandA[Where can Giant Pandas be found in the wild? Given context: #E5]
Final Answer: #E3 and #E6

System: A chat.


Instruction:
Create a sequential plan to answer the following question using the provided tools. Each step in your plan should correspond to an evidence variable.

Tools Available:
Encyclopedia[input]: Searches for detailed information about the input topic from an online encyclopedia.
FactChecker[input]: Verifies the truthfulness of a statement or fact.
NewsArchive[input]: Searches through archived news articles related to the input topic.
AIQA[input]: AI Question Answering system that answers questions based on the input context.

Output Format:
Plan: [action to take]
#E[index] = [tool to use with input]
...
Final Answer: #E[n]

Question: Did Albert Einstein win a Nobel Prize and if so, what was it for?

Response:
Plan: Look up Albert Einstein in the online encyclopedia.
#E1 = Encyclopedia[Albert Einstein]
Plan: Use the AIQA system to determine if Albert Einstein won a Nobel Prize.
#E2 = AIQA[Did Albert Einstein win a Nobel Prize? Given context: #E1]
Plan: If #E2 indicates that Albert Einstein did win a Nobel Prize, find out what it was for.
#E3 = AIQA[What did Albert Einstein win a Nobel Prize for? Given context: #E1]
Plan: Verify the obtained information using the Fact Checker.
#E4 = FactChecker[#E3]
Final Answer: #E4

System: A chat.