Instruction:
Generate a plan to answer the following question using the provided tools. Each plan should correspond to an evidence value, which will be the output of a specific function given an input string that could be the user question, previous evidence values, or a mix of both.

Available tools:
DuckDuckGo[input]: A tool that enables users to search for information using the DuckDuckGo search engine. It helps locate potential websites that might contain answers to the user's query.
WebReader[input]: Reads content from one or more websites specified in the input string (newline-separated links) and outputs the plain text content.
URLCollector[input]: Collects URLs from plain text and generates a plain text, newline-separated list of links.
BERT[input]: A question-answering language model effective at providing answers based on an input text passage. The input should be a text question referencing 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 :evidence0:'s result]
:evidence1: = [Next function to call and input parameter, potentially referring to prior evidence]
...
Final Answer: [:evidence[n]: with the final answer]

Question: Who invented the telephone and what were their other significant contributions?

Response:
Plan: Begin with a web search to determine who invented the telephone.
:evidence0: = DuckDuckGo[Who invented the telephone]
Plan: Use BERT to interpret the search results and identify the inventor.
:evidence1: = BERT[Who invented the telephone, given :evidence0:?]
Plan: Perform another web search to discover the other significant contributions made by this individual.
:evidence2: = DuckDuckGo[Other contributions by :evidence1:]
Plan: Collect the relevant links from the DuckDuckGo search results for detailed examination.
:evidence3: = URLCollector[:evidence2:]
Plan: Utilize WebReader to extract information from the collected links.
:evidence4: = WebReader[:evidence3:]
Plan: Lastly, employ BERT to summarize the other significant contributions made by the inventor from the gathered information.
:evidence5: = BERT[What are the other contributions by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Generate a plan to solve the following problem using the provided tools. Every plan should have an associated evidence value, which is the output of the chosen function after it has been executed with the correct parameters.

Tools you can use:
BingSearch[input]: A tool that lets users search for information via Bing. It's great for finding websites that might contain answers to your queries.
SiteReader[input]: Loads a website from the input URL and outputs its textual content.
LinkSelector[input]: Picks out URLs from a block of text and returns them as a plain-text list.
KnowledgeBot[input]: Can answer questions using general knowledge or specific information from a given context. To refer to prior evidence, simply use #E[index] in your query.

Output format:
Plan: [the first step based on the input question]
#E1 = [function to execute with the right parameters]
Plan: [the next step, informed by the outcome of #E1]
#E2 = [the subsequent function to run with the necessary parameters, possibly referencing earlier evidence]
...
Final Answer: #E[n]

Question: What is the process of photosynthesis and why is it important?

Response:
Plan: Begin by searching for information on photosynthesis.
#E1 = BingSearch[Photosynthesis]
Plan: Select the most relevant links from the search results.
#E2 = LinkSelector[#E1]
Plan: Read the contents of the selected websites.
#E3 = SiteReader[#E2]
Plan: Ask KnowledgeBot to explain the process of photosynthesis using the gathered information.
#E4 = KnowledgeBot[What is the process of photosynthesis? Given context: #E3]
Plan: Ask KnowledgeBot to explain the importance of photosynthesis using the same context.
#E5 = KnowledgeBot[Why is photosynthesis important? Given context: #E3]
Final Answer: #E4 and #E5

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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
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 notable works by the author who wrote "To Kill a Mockingbird"?

Response:
Plan: Start by conducting a web search to find out who the author of "To Kill a Mockingbird" is.
:evidence0: = DuckDuckGo[Author of To Kill a Mockingbird]
Plan: Use the QAModel to interpret the search results and identify the name of the author.
:evidence1: = QAModel[Who is the author of "To Kill a Mockingbird", given :evidence0:?]
Plan: Conduct another web search to find the notable works by the identified author.
:evidence2: = DuckDuckGo[Notable works by :evidence1:]
Plan: Extract the relevant links from the DuckDuckGo search results for a deeper search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use the WebReader tool to extract information from the relevant links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, use the QAModel to identify and summarize the notable works by the author from the extracted information.
:evidence5: = QAModel[What are the notable works by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Available Tools:
DuckDuckGo[input]: Allows users to search for information via the DuckDuckGo search engine. Useful for locating a range of sites that might contain the answer to the user's question.
PageScraper[input]: Loads one or more websites from an input string that contains newline separated links. Outputs plain text containing the link content.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and outputs a plain text, newline-separated list of links.
GPT-3[input]: A language model adept at answering questions based on an input text passage. The input must be a textual question referencing a #E[n] variable.

Output Format:
Plan: [Initial action]
#E1 = [Function to call with input]
Plan: [Subsequent action]
#E2 = [Next function to call with input]
...
Final Answer: #E[n]

Question: What are the main ingredients in a traditional French ratatouille?

Response:
Plan: Initiate a web search to find the main ingredients in a traditional French ratatouille.
#E1 = DuckDuckGo[Traditional French ratatouille ingredients]
Plan: Use GPT-3 to parse the search results and identify the main ingredients.
#E2 = GPT-3[What are the main ingredients in a traditional French ratatouille? Given context: #E1]
Plan: Conduct a second web search to confirm and get more details about these ingredients.
#E3 = DuckDuckGo[#E2]
Plan: Extract the pertinent links from the search results for a deeper investigation.
#E4 = HyperlinkExtractor[#E3]
Plan: Scrape the content from the chosen links.
#E5 = PageScraper[#E4]
Plan: Lastly, use GPT-3 to consolidate the information about the ingredients from the scraped page contents.
#E6 = GPT-3[Tell me more about the ingredients :#E2:. Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. For each step in your plan, provide an evidence variable that can be referenced later.

The available tools are:
WebSearch[input]: This tool allows you to search for information on the internet. The input should be a query string.
TextExtractor[input]: Extracts text from web pages given one or more URLs as input.
QA[input]: Can answer questions based on general knowledge and specific context given as input.
ImageFinder[input]: Finds images related to the input query.
ImageAnalyzer[input]: Analyzes an image and provides descriptive text about it.

The output format should be:
Plan: [action]
#E[index] = [function call with input]
...
Final Answer: #E[n]

Question: What is the main diet of snow leopards and where do they usually live?

Response:
Plan: Search for information about the diet of snow leopards.
#E1 = WebSearch[Snow leopard diet]
Plan: Use QA tool to find out the main diet from the search results.
#E2 = QA[What is the main diet of snow leopards? Given context: #E1]
Plan: Search for information about the habitat of snow leopards.
#E3 = WebSearch[Snow leopard habitat]
Plan: Use QA tool to find out their usual living area from the search results.
#E4 = QA[Where do snow leopards usually live? Given context: #E3]
Final Answer: Snow leopards mainly eat #E2 and usually live in #E4.

System: A chat.


Instruction:
Design a step-by-step solution to the following problem using the provided tools. Each step should correspond to an evidence value, which represents the output of a specific function given an input string (which could be the original question, earlier evidence values, or a combination).

Available Tools:
DuckDuckGo[input]: Allows users to search for information via DuckDuckGo. This tool returns a list of potential sources but does not directly answer the question.
HyperlinkHarvester[input]: Harvests hyperlinks from a given block of text.
WebsiteScanner[input]: Scans the content of websites provided through their URLs.
QueryMaster[input]: Answers questions based on a given piece of text. The input needs to be a question referencing a *E[n]* variable, such as "What is the population of Tokyo, given *E1*?"

Output Format:
Plan: [First action based on the input question]
*E1* = [Function to call with its input parameter]
Plan: [Next action based on the outcome of *E1*]
*E2* = [Next function to call with its input parameter, which might refer to previous evidence, such as "Given context *E1*"]
...
Final Answer: *E[n]*

Question: Who invented the World Wide Web and what was his motivation?

Response:
Plan: Start by searching DuckDuckGo to find out who invented the World Wide Web.
*E1* = DuckDuckGo[Inventor of the World Wide Web]
Plan: Use QueryMaster to process the search results and identify the inventor.
*E2* = QueryMaster[Who invented the World Wide Web? Given context: *E1*]
Plan: Perform another DuckDuckGo search to determine the inventor's motivation.
*E3* = DuckDuckGo[Motivation of *E2* for inventing the World Wide Web]
Plan: Use HyperlinkHarvester to collect the relevant links from the search results.
*E4* = HyperlinkHarvester[*E3*]
Plan: Use WebsiteScanner to gather information from the harvested links.
*E5* = WebsiteScanner[*E4*]
Plan: Finally, use QueryMaster to summarize the inventor's motivation for creating the World Wide Web from the gathered information.
*E6* = QueryMaster[What was the motivation of *E2* for inventing the World Wide Web? Given context: *E5*]
Final Answer: *E6*

System: A chat.


Instruction:
Create a detailed plan to respond to the following user query utilizing the provided tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more prior evidence values, or a combination of both.

Available tools include:
Bing[input]: This tool enables users to perform information searches using the Bing search engine.
URLGrabber[input]: This function extracts URLs from plain text and returns a plain text list of URLs.
WebReader[input]: This tool loads one or more websites from an input string containing newline-separated links, where the input is one or more links, and outputs plain text content from those links.
Encyclopedia[input]: This tool performs a search on Encyclopedia Britannica for pertinent articles based on the input string.
QAModel[input]: This is a question-answering language model that excels at answering queries based on an input text passage. The input must be a textual question referencing a #E[index] variable.

Output format:
Plan: [Initial action based on input question]
#E1 = [Function to invoke with input parameter]
Plan: [Subsequent action based on the outcome of #E1]
...
Final Answer: #E[n]

Question: Who designed the Eiffel Tower and what were their other significant architectural contributions?

Response:
Plan: Begin by conducting an encyclopedia search to determine who designed the Eiffel Tower.
#E1 = Encyclopedia[Eiffel Tower]
Plan: Utilize QAModel to ascertain the designer's name from the Encyclopedia Britannica article.
#E2 = QAModel[Who designed the Eiffel Tower? Given context: #E1]
Plan: Execute another Bing search to discover other significant architectural contributions made by the identified designer.
#E3 = Bing[#E2 + ' architectural contributions']
Plan: Extract the relevant URLs from the Bing search results for a more focused investigation.
#E4 = URLGrabber[#E3]
Plan: Employ WebReader to retrieve information from the relevant URLs.
#E5 = WebReader[#E4]
Plan: Lastly, utilize QAModel to identify and summarize the key architectural contributions made by the designer from the retrieved information.
#E6 = QAModel[What are the significant architectural contributions of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a step-by-step plan to generate an answer for the user query using the available tools. Each step in your plan should be followed by exactly one evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a combination of both.

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

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

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

Response:
Plan: 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 AIML to interpret the search results and identify the winner.
:evidence1: = AIML[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = Bing[Most famous work of :evidence1:]
Plan: Extract relevant links from the Bing search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Utilize WebScraper to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use AIML to summarize the most famous work of the laureate from the extracted information.
:evidence5: = AIML[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to answer the following question using these available tools. Each step in your plan should have an associated evidence variable that stores the output of one of the tools.

Here are the tools you can use:
1. WebSearch[input]: This tool allows you to search for information on the web. The input is a string query, and the output is a list of websites that may contain relevant information.
2. TextExtractor[input]: This tool extracts all text from a given website URL. The input is a single URL, and the output is the plain text content of the webpage.
3. FactChecker[input]: This tool verifies facts by cross-referencing multiple sources. The input is a fact statement, and the output is a confirmation or denial of the fact's validity.
4. KnowledgeBaseQA[input]: This tool answers questions based on a vast knowledge base. The input is a question, and the output is the answer to the question.

The format of your response should be as follows:
Plan: [describe the first action]
#E1 = [tool to call with input parameter]
Plan: [describe the next action, referencing #E1 if necessary]
#E2 = [next tool to call with input parameter, possibly referring to #E1]
...
Final Answer: #En

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

Response:
Plan: Use a web search to find out who won the Nobel Prize in Literature in 2005.
#E1 = WebSearch[Nobel Prize in Literature 2005 winner]
Plan: Extract the name of the laureate from the search results.
#E2 = KnowledgeBaseQA[Who won the Nobel Prize in Literature in 2005? Given context: #E1]
Plan: Search for more information about the laureate's works.
#E3 = WebSearch[#E2 + ' most famous work']
Plan: Identify the most famous work of the laureate from the search results.
#E4 = KnowledgeBaseQA[What is the most famous work of #E2? Given context: #E3]
Plan: Verify the obtained information.
#E5 = FactChecker[#E2 won the Nobel Prize in Literature in 2005 and their most famous work is #E4]
Final Answer: #E5

System: A chat.


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

Here are the tools you can use:
Bing[input]: This tool allows users to search for information using Bing search engine. It helps in finding relevant websites that may contain answers to the user's question.
TextExtractor[input]: Extracts text from web pages provided as newline-separated links in the input string and produces plain text output containing the content of these pages.
LinkFilter[input]: Filters out irrelevant links from a list of newline-separated links and outputs a clean list of useful links.
KnowledgeBase[input]: A tool that uses AI to answer questions based on general knowledge and common sense.
DocReader[input]: Reads documents and extracts key points. The input must be a text question referencing an :evidence[n]: variable.

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

Each plan step should only include one evidence output.

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

Question: What are some notable achievements of the current Prime Minister of Canada?

Response:
Plan: Start by conducting a web search to find out who the current Prime Minister of Canada is.
:evidence0: = Bing[Current Prime Minister of Canada]
Plan: Use KnowledgeBase to interpret the search results and identify the name of the Prime Minister.
:evidence1: = KnowledgeBase[Who is the current Prime Minister of Canada, given :evidence0:?]
Plan: Conduct another web search to find the notable achievements of the identified Prime Minister.
:evidence2: = Bing[Notable achievements of :evidence1:]
Plan: Filter out irrelevant links from the Bing search results.
:evidence3: = LinkFilter[:evidence2:]
Plan: Use TextExtractor to extract information from the filtered links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use DocReader to summarize the notable achievements of the Prime Minister from the extracted information.
:evidence5: = DocReader[What are the notable achievements of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step plan to respond to the following user query using the tools provided. Each plan should correspond to an evidence value produced by one of the available functions.

Available Tools:
Encyclopedia[input]: A tool that searches an online encyclopedia for information related to the input query.
FactChecker[input]: A tool that verifies the accuracy of statements using various sources.
TextAnalyzer[input]: A tool that extracts key points from a large body of text.
KnowledgeBaseQA[input]: A tool that answers questions based on general knowledge and context provided.

Output Format:
Plan: [First action based on input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next function to call with input parameter, possibly referencing #E1]
...
Final Answer: #En

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

Response:
Plan: Start by searching the encyclopedia for information on Nikola Tesla.
#E1 = Encyclopedia[Nikola Tesla]
Plan: Analyze the retrieved text to extract key points about Nikola Tesla.
#E2 = TextAnalyzer[#E1]
Plan: Check the facts obtained from the analysis for accuracy.
#E3 = FactChecker[#E2]
Plan: Query the KnowledgeBaseQA for Tesla's major contributions to science.
#E4 = KnowledgeBaseQA[What were Nikola Tesla's major contributions to science? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Please create a step-by-step plan to generate an optimal response to the user query, using the set of tools provided. Each plan will be followed by an evidence value, which is the output of one of the available functions given an input string that can be either the user's question, one or more previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: A tool that allows users to search for information using the Bing search engine. This tool helps in finding relevant sites that may contain the answer to the user's question.
WebReader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references 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: Who won the Nobel Prize in Literature in 2019 and what was their most famous work?

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

System: A chat.


Instruction:
Make a plan to explain how a rainbow forms.

Available tools:
ScienceExplainer[input]: Explains scientific phenomena based on the input.
VisualAidFinder[input]: Finds visual aids related to the input.
DetailedQA[input]: Provides detailed answers to questions based on the input.
InformationGatherer[input]: Gathers information from multiple sources.
ReportGenerator[input]: Generates a report based on the input context.

Output format:
Plan: First step
#Proof1 = Function with input parameter
Plan: Second step
#Proof2 = Next function with input parameter
...
Final Explanation: #Proof[n]

Response:
Plan: First step - Gather information about how a rainbow forms.
#Proof1 = InformationGatherer["How does a rainbow form?"]

Plan: Second step - Explain the scientific phenomena behind the formation of a rainbow.
#Proof2 = ScienceExplainer[#Proof1]

Plan: Third step - Find visual aids to support the explanation of how a rainbow forms.
#Proof3 = VisualAidFinder["Rainbow formation"]

Plan: Fourth step - Prepare detailed answers for potential questions about the process of rainbow formation.
#Proof4 = DetailedQA["Questions about rainbow formation"]

Plan: Fifth step - Generate a report that integrates all the gathered information, explanations, visual aids and Q&A.
Final Explanation: #Proof5 = ReportGenerator[{"Information": #Proof1, "Explanation": #Proof2, "Visual Aids": #Proof3, "Q&A": #Proof4}]

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:
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.
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.
NLPModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references 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 wrote the book 'To Kill a Mockingbird' and what awards did it win?

Response:
Plan: Start by conducting a web search to find out who wrote 'To Kill a Mockingbird'.
:evidence0: = DuckDuckGo[Author of To Kill a Mockingbird]
Plan: Use a language model to interpret the search results and identify the author.
:evidence1: = NLPModel[Who wrote the book 'To Kill a Mockingbird', given :evidence0:?]
Plan: Conduct another web search to find the awards won by 'To Kill a Mockingbird'.
:evidence2: = DuckDuckGo[Awards won by To Kill a Mockingbird]
Plan: Extract the relevant links from the search results for a more detailed 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 awards won by 'To Kill a Mockingbird' from the extracted information.
:evidence5: = NLPModel[What awards did 'To Kill a Mockingbird' win, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a sequential plan to respond to the inquiry below utilizing the listed resources. For every step, specify the tool to be used along with the input needed to gather evidence. Store the gathered evidence in a variable named @Evidence[index] that can be referred to later.

Tools Available:
WikiSearch[input]: Searches Wikipedia for information related to the input query.
LinkHarvester[input]: Harvests all the URLs present in the input text.
PageReader[input]: Reads the text from the pages whose URLs are provided as input.
QuerySolver[input]: Solves queries using the context provided in the input.

Each plan should be accompanied by exactly one evidence (@Evidence[index]) value.

Output Format:
Plan: [Initial action based on input question]
@Evidence1 = [Function to call with input parameter]
Plan: [Subsequent action based on result of @Evidence1]
@Evidence2 = [Next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context @Evidence1"]
...
Final Answer: @Evidence[n]

Question: What is the population of Tokyo and what is its GDP?

Response:
Plan: Start by searching Wikipedia for the population of Tokyo.
@Evidence1 = WikiSearch[Tokyo population]
Plan: Use QuerySolver to extract the population figure from the Wikipedia data.
@Evidence2 = QuerySolver[What is the population of Tokyo? Given context: @Evidence1]
Plan: Next, search Wikipedia for the GDP of Tokyo.
@Evidence3 = WikiSearch[Tokyo GDP]
Plan: Use QuerySolver to extract the GDP figure from the Wikipedia data.
@Evidence4 = QuerySolver[What is the GDP of Tokyo? Given context: @Evidence3]
Final Answer: @Evidence2 and @Evidence4

System: A chat.


Instruction:
Create a systematic plan to solve the following query utilizing the provided tools. For each plan, indicate which external tool along with its input would retrieve the required evidence. Store this evidence into a variable #E[index] that can be referred to later.

Available tools:
DuckDuckGo[input]: A tool allowing users to search for information via DuckDuckGo search engine. Useful for obtaining a list of potential sources that might contain the answer to the user's query.
SiteReader[input]: Loads one or more websites from the input string (containing newline separated links) and outputs plain text content of these links.
URLPicker[input]: Extracts URLs from plain text and returns a plain text response of newline-separated links.
QAModel[input]: A question-answering language model capable of answering queries based on a provided text passage. The input must be a text-based question referencing a #E[n] variable.

Output Format:
Plan: [first action based on input question]
#E1 = [function to call with input parameter]
Plan: [subsequent action based on result of #E1]
#E2 = [next function to call and input parameter, possibly referring to previous evidence like "Given context #E1"]
...
Final Answer: #E[n]

Question: What is the highest peak in the Andes and what is its elevation?

Response:
Plan: Initiate a web search to find the highest peak in the Andes.
#E1 = DuckDuckGo[Highest peak in the Andes]
Plan: Employ the language model to decipher the search results and identify the peak's name.
#E2 = QAModel[What is the highest peak in the Andes? Given context: #E1]
Plan: Carry out another web search to discover the elevation of the identified peak.
#E3 = DuckDuckGo[Elevation of #E2]
Plan: Extract the pertinent links from the search results for a detailed investigation.
#E4 = URLPicker[#E3]
Plan: Utilize the SiteReader tool to obtain information from the selected links.
#E5 = SiteReader[#E4]
Plan: Lastly, employ the language model to determine and summarize the elevation of the peak from the obtained data.
#E6 = QAModel[What is the elevation of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


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

Available tools:
BingSearch[input]: A tool that enables users to search for information using Bing. It helps locate suitable websites that might contain answers to the user's query.
SiteReader[input]: Loads one or more websites from the input string containing newline-separated links. The input is one or more links, and it generates plain text output containing the link contents.
HyperlinkFinder[input]: Extracts hyperlinks from plain text and generates a plain text, newline-separated list of links.
LanguageModelQnA[input]: A question-answering language model that excels at 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 the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, potentially referencing previous evidence]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

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

Response:
Plan: Start by performing a web search to discover who designed the Sydney Opera House.
:evidence0: = BingSearch[Sydney Opera House architect]
Plan: Use the language model to parse the search results and determine the architect's name.
:evidence1: = LanguageModelQnA[Who designed the Sydney Opera House, given :evidence0:?]
Plan: Carry out another web search to uncover other significant buildings designed by the identified architect.
:evidence2: = BingSearch[:evidence1: notable designs]
Plan: Extract pertinent links from the Bing search results for a more targeted investigation.
:evidence3: = HyperlinkFinder[:evidence2:]
Plan: Employ the SiteReader tool to glean information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, employ the language model to identify and summarise the architect's other notable designs from the retrieved data.
:evidence5: = LanguageModelQnA[What other notable structures did :evidence1: design, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools you can use:
Bing[input]: This tool allows users to search for information on Bing. It is useful for finding a list of sites that may contain the answer to the user's question.
TextScraper[input]: This function loads websites from the input string containing newline delimited links and produces plain text output with the content of these links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

Question: What are some major accomplishments of the scientist Marie Curie?

Response:
Plan: Begin by conducting a web search to find out about Marie Curie's accomplishments.
:evidence0: = Bing[Marie Curie accomplishments]
Plan: Extract relevant links from the Bing search results for further investigation.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Use the TextScraper tool to extract information from the selected links.
:evidence2: = TextScraper[:evidence1:]
Plan: Finally, utilize the QAModel to identify and summarize the major accomplishments of Marie Curie from the extracted information.
:evidence3: = QAModel[What are some major accomplishments of Marie Curie? Given :evidence2:]
Answer: :evidence3:

System: A chat.


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

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

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

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

Response:
Plan: Start by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = Bing[Eiffel Tower History]
Plan: Use a language model to interpret the search results and summarize the history of the Eiffel Tower.
:evidence1: = AnswerBot[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find the main architects of the Eiffel Tower.
:evidence2: = Bing[Main architects of Eiffel Tower]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the language model to identify and name the main architects of the Eiffel Tower from the extracted information.
:evidence5: = AnswerBot[Who were the main architects of the Eiffel Tower, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[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 input to each function just just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g. NLP[What is the capital of Michigan, given :evidence3:?]

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

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

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

Response:
Plan: Start by conducting a web search to find out who the architect of the Sydney Opera House is.
:evidence0: = Bing[Architect of Sydney Opera House]
Plan: Use the natural language processing model to interpret the search results and identify the architect.
:evidence1: = NLP[Who was the architect of the Sydney Opera House, given :evidence0:?]
Plan: Conduct another web search to find the other notable works by the identified architect.
:evidence2: = Bing[Notable works by :evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkFinder[: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 other notable works by the architect from the extracted information.
:evidence5: = NLP[What are the other notable works by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a systematic plan to address the following question. Each step should specify a function to invoke along with its input. Store the outcome of each function in a :Data[index]: variable, which can be referenced in subsequent steps.

Functions Available:
YahooSearch[input]: Executes a Yahoo search for the input term and returns a list of potential resources.
UrlGatherer[input]: Given a piece of text (like the output of a YahooSearch), this function extracts all URLs contained within the text.
WebsiteReader[input]: Fetches the page at the specified URL and returns its contents as plain text.
DeepMind[input]: An advanced AI question-answering system capable of providing direct responses to various types of queries. It can also generate answers based on supplied context (e.g., the text of a website).

Output Structure:
Plan: [First step description]
:Data0: = [First step function call]
Plan: [Second step description]
:Data1: = [Second step function call]
... Continue this pattern until ...
Final Answer: :DataN:

Question: Who invented the telephone and what other inventions do they have to their name?

Response:
Plan: Initiate a Yahoo search to discover who invented the telephone.
:Data0: = YahooSearch[inventor of the telephone]
Plan: Utilize DeepMind to analyze the search results and identify the inventor.
:Data1: = DeepMind[Who invented the telephone? Given context: :Data0:]
Plan: Carry out another Yahoo search to uncover other inventions credited to the identified individual.
:Data2: = YahooSearch[:Data1: other inventions]
Plan: Gather the URLs from the search results for further exploration.
:Data3: = UrlGatherer[:Data2:]
Plan: Retrieve the contents of the first URL from the list.
:Data4: = WebsiteReader[:Data3[0]]
Plan: Finally, employ DeepMind to scrutinize the webpage text and pinpoint the other inventions of the inventor.
:Data5: = DeepMind[What other inventions does :Data1: have? Given context: :Data4:]
Final Answer: :Data5:

System: A chat.


Instruction:
Please create a step-by-step execution plan for the following question using these tools:
WikiLookup[input]: Searches Wikipedia for information related to the input.
WebCrawler[input]: Crawls the web for relevant pages related to the input.
TextAnalyzer[input]: Analyzes a block of text and extracts key points.
QAModel[input]: Answers questions given an input context.

Question: How does photosynthesis work in plants?

Response:
Step 1: WikiLookup["Photosynthesis in plants"]
Use the WikiLookup tool to search Wikipedia for information related to "Photosynthesis in plants". This will provide a broad overview of the topic and likely include details on how photosynthesis works.

Step 2: TextAnalyzer[WikiLookup Result]
Take the result from the WikiLookup and input it into the TextAnalyzer. This will extract key points from the Wikipedia article, providing a summarized version of how photosynthesis works in plants.

Step 3: WebCrawler["Photosynthesis in plants"]
To gather more detailed or additional information, use the WebCrawler tool with the input "Photosynthesis in plants". This will crawl the web for relevant pages that contain further information about the process of photosynthesis in plants.

Step 4: TextAnalyzer[WebCrawler Result]
Analyze the results obtained from the WebCrawler using the TextAnalyzer. This will help condense the information found across various web pages into key points, making it easier to understand and digest.

Step 5: QAModel["How does photosynthesis work in plants?"]
Finally, input the question "How does photosynthesis work in plants?" into the QAModel. Use the context gathered from the previous steps (the key points extracted by the TextAnalyzer from both the WikiLookup and WebCrawler results) as the input context for the QAModel. The model should then be able to generate a concise and accurate answer to the question based on this context.

System: A chat.


Instruction:
Generate a step-by-step plan to answer the following question, making use of the available tools. Each step in your plan should correspond to an evidence value, which will be the output of one of the available functions given an input string that can be the user's question, previous evidence values, or both.

Here are the tools you can call:
WebSearch[input]: A tool that allows the user to search for information using a general web search engine. This tool is useful for finding a list of sites that may contain the answer to the user's question.
ReadPage[input]: Load a website from the input string and produces plain text output containing the content of the page.
LinkFinder[input]: Extract links from plain text and produces a plain text response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?

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

Ensure to include only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who the architect of the Eiffel Tower was.
#E0 = WebSearch[Eiffel Tower architect]
Plan: Use the question answering model to interpret the search results and identify the architect.
#E1 = QAModel[Who was the architect of the Eiffel Tower, given #E0?]
Plan: Conduct another web search to find other notable structures designed by the identified architect.
#E2 = WebSearch[:Notable structures designed by #E1:]
Plan: Extract relevant links from the web search results for more detailed information.
#E3 = LinkFinder[#E2]
Plan: Use the ReadPage tool to extract information from the relevant links.
#E4 = ReadPage[#E3]
Plan: Finally, use the question answering model to identify and summarize the other notable structures designed by the architect from the extracted information.
#E5 = QAModel[What are the other notable structures designed by #E1?, given #E4?]
Final Answer: #E5

System: A chat.


Instruction:
Generate a stepwise execution plan to respond to the query below, using the listed tools. Each step should have an associated evidence value derived from the output of a specified tool and input string.

Tools Available:
InternetSearch[input]: Allows users to search for information online.
LinkGatherer[input]: Collects all the URLs present in a piece of text.
PageReader[input]: Reads the contents of a webpage and outputs them as text.
QnA[input]: Answers questions based on supplied context.

Output Format:
Plan: [Action based on input question]
#Evidence1 = [Tool with input]
Plan: [Next action based on #Evidence1]
#Evidence2 = [Next tool with input, possibly referring to #Evidence1]
...
Final Answer: #Evidence[n]

Question: How does photosynthesis work and what role do chloroplasts play in it?

Response:
Plan: Start by searching online for how photosynthesis works.
#Evidence1 = InternetSearch[How does photosynthesis work]
Plan: Gather the URLs found in the search results.
#Evidence2 = LinkGatherer[#Evidence1]
Plan: Read the contents of the pages linked in the search results.
#Evidence3 = PageReader[#Evidence2]
Plan: Using the page contents as context, answer the question about how photosynthesis works.
#Evidence4 = QnA[How does photosynthesis work? Given context: #Evidence3]
Plan: Search online again, but this time for the role of chloroplasts in photosynthesis.
#Evidence5 = InternetSearch[Role of chloroplasts in photosynthesis]
Plan: Gather the URLs found in the new search results.
#Evidence6 = LinkGatherer[#Evidence5]
Plan: Read the contents of the pages linked in the new search results.
#Evidence7 = PageReader[#Evidence6]
Plan: Using the new page contents as context, answer the question about the role of chloroplasts in photosynthesis.
#Evidence8 = QnA[What role do chloroplasts play in photosynthesis? Given context: #Evidence7]
Final Answer: #Evidence4 and #Evidence8

System: A chat.


Instruction:
Please create a sequential plan to respond to the user instruction using the provided tools. Every plan will correspond to an evidence value, which will be the outcome of one of the available functions given an input string that could be the user question, prior evidence values, or both.

Here are the tools available to be used:
DuckDuckGo[input]: A tool that lets the user search for information through DuckDuckGo. It helps in locating a list of websites that might contain the answer to the user's question.
WebScraper[input]: Loads one or more websites from the input string containing newline-delimited links, where input is one or more links, and outputs plain text containing the content of the links.
URLCollector[input]: Collects URLs from plain text and returns a plain text, newline-separated list of links.
NLPQA[input]: Natural Language Processing Question Answering model, especially helpful in answering questions based on an input text passage. The input must be a text question referencing a :info[n]: variable, like What is the height of Mount Everest, given :info1:?

Each function input should just be a plain string, without quotes or "+" to join a string with an evidence variable, e.g., NLPQA[What is the population of China, given :info2:?]

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

The output should follow this format:
Plan: [initial action based on input question]
:info0: = [function to call with input parameter]
Plan: [subsequent action based on the result of :info0:]
:info1: = [next function to call and input parameter, which may refer to previous evidence, e.g., "Given context :info0"]
...
Final Answer: [:info[n]: containing the ultimate answer.]

Question: What are some famous paintings by Vincent van Gogh and where are they currently located?

Response:
Plan: Initiate a web search to find famous paintings by Vincent van Gogh.
:info0: = DuckDuckGo[Famous paintings by Vincent van Gogh]
Plan: Utilize the NLPQA model to extract the names of the paintings from the search results.
:info1: = NLPQA[What are some famous paintings by Vincent van Gogh, given :info0:?]
Plan: Perform another web search to locate where these paintings are currently held.
:info2: = DuckDuckGo[Current location of :info1: paintings]
Plan: Collect relevant links from the DuckDuckGo search results for further investigation.
:info3: = URLCollector[:info2:]
Plan: Use the WebScraper tool to gather information from the collected links.
:info4: = WebScraper[:info3:]
Plan: Lastly, employ the NLPQA model to determine and summarize the current locations of the paintings from the scraped data.
:info5: = NLPQA[Where are the paintings :info1: currently located, given :info4:?]
Final Answer: :info5:

System: A chat.


Instruction:
Please generate a plan to solve the problem presented in the user's question using the following tools. Each step should correspond to an evidence value (#E[index]), which will be the output of one of the available functions given an input string that could be the user's question, previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: A tool that allows users to conduct a web search using Bing. It helps in finding potential sources that might contain answers to the user's query.
PageReader[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 returns a plain text, newline delimited list of links.
AIQA[input]: An artificial intelligence-powered question-answering model, especially adept at answering queries based on an input text passage. The input must be a textual question referencing a #E[n] variable, such as "What is the population of New York City, given #E1?"

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

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

Response:
Plan: Initiate a web search to find information about Batman's origin story.
#E1 = Bing[Batman origin story]
Plan: Use AIQA to analyze the search results and provide a summary of Batman's original backstory.
#E2 = AIQA[What is the origin story of Batman? Given context: #E1]
Plan: Conduct another web search to find how Batman's origin story has changed over time.
#E3 = Bing[Batman origin story evolution]
Plan: Extract relevant links from the search results for detailed examination.
#E4 = HyperlinkExtractor[#E3]
Plan: Use PageReader to gather information from the selected links.
#E5 = PageReader[#E4]
Plan: Lastly, use AIQA to summarize how Batman's origin story has evolved over time from the gathered information.
#E6 = AIQA[How has Batman's origin story evolved over time? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a plan to answer the following question using the available tools. Each step of your plan should be associated with an evidence variable that stores the output from one of the functions.

Here are the tools you can use:
SearchEngine[input]: This tool allows you to search for information on the internet. The input is a query string, and the output is a list of web pages that may contain the answer.
WebScraper[input]: This tool extracts text content from a given URL. It takes as input a URL and returns the plain text content of the page.
LinkExtractor[input]: This tool extracts all URLs from a given piece of text. The input is a block of text, and the output is a list of URLs found in that text.
AnswerBot[input]: This tool answers questions based on a provided context. The input is a question and a context (the latter being optional), and the output is the answer to the question.

The output format should be:
Plan: [description of the first action]
#E1 = [function call with input parameter]
Plan: [description of the next action, based on #E1]
#E2 = [next function call with input parameter, which might reference #E1]
...
Final Answer: #En

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

Response:
Plan: Use a search engine to find out who won the Nobel Prize in Literature in 2010.
#E1 = SearchEngine[Nobel Prize in Literature 2010 winner]
Plan: Extract the name of the laureate from the search results.
#E2 = AnswerBot[Who won the Nobel Prize in Literature in 2010? Given context: #E1]
Plan: Conduct another search to find the most famous work of the identified laureate.
#E3 = SearchEngine[Most famous work of #E2]
Plan: Extract the title of the work from the search results.
#E4 = AnswerBot[What is the most famous work of #E2? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Generate a detailed execution plan to respond to the user's inquiry using the set of available tools. Each plan must correspond to an evidence value, which is the outcome of one of the accessible functions given an input string that could be the user's question, one or multiple prior evidence values, or both.

Here are the tools available to be called:
Bing[input]: A tool that enables the user to perform a Bing search. It finds a list of sites that might have the answer to the user's question but doesn't provide a direct answer.
SiteLoader[input]: Loads one or more websites from the input string containing newline-separated links. Input is one or more links, and the output contains the content of the links in plain text.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and generates a plain text, newline-delimited response of links.
LMQ[input]: Language model for question answering, particularly effective in 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 in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020 and what is known about their works?

Response:
Plan: Begin by conducting a Bing search to find out who won the Nobel Prize in Literature in 2020.
:evidence0: = Bing[Nobel Prize in Literature 2020 winner]
Plan: Utilize LMQ to interpret the search results and find the name of the laureate.
:evidence1: = LMQ[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Conduct another Bing search to find information about the laureate's works.
:evidence2: = Bing[:evidence1: works]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use SiteLoader to load information from the relevant links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, utilize LMQ to summarize the key points about the laureate's works from the loaded information.
:evidence5: = LMQ[What are the key points about :evidence1:'s works, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Question: What are the health benefits of regular exercise?

Here are the tools available to be called:
Healthline[input]: This tool provides health-related information and advice.
MedicalJournal[input]: This tool gives access to medical journals and research papers.
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.
FitnessTracker[input]: This tool provides data related to fitness activities and their impact on health.
NutritionData[input]: This tool provides nutritional information and its impacts on health.

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

Response:
Plan: Start by using the Healthline tool to get general health-related information about regular exercise. Then, use the MedicalJournal tool to access more detailed and scientific data on the benefits of regular exercise.

#E1 = Healthline[input]: "What are the health benefits of regular exercise?"

Plan: Use the information from Healthline to provide a general answer.

Final answer: #E1

Plan: Use the MedicalJournal tool for more in-depth information based on research papers.

#E2 = MedicalJournal[input]: "Health benefits of regular exercise"

Plan: Combine the general knowledge from Healthline with the specific findings from medical journals to give a comprehensive answer.

Final answer: Given context #E1 and #E2

System: A chat.


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

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

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

Question: What is the history of Bitcoin and who was its creator?

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

System: A chat.


Instruction:
Design a systematic plan to respond to the user's inquiry using the listed tools. Each stage in your plan should generate an evidence value, representing the output of the invoked function given an input string that could be the user's question, prior evidence values, or a combination of both.

Tools Available:
YahooSearch[input]: Enables users to perform a web search using Yahoo. Useful for identifying possible sources that might contain the answer.
SiteReader[input]: Reads one or more websites from an input string consisting of newline separated URLs and provides plain text output comprising the website contents.
HyperlinkExtractor[input]: Pulls out hyperlinks from a chunk of plain text and delivers them as a newline-separated list.
QueryBot[input]: A bot proficient in answering queries based on an input text passage. The input needs to be a question referring to an :evidence[n]: variable.

Output Structure:
Plan: [First action based on the input question]
:evidence0: = [Function to invoke with its input]
Plan: [Next action contingent on the result of :evidence0:]
:evidence1: = [Following function to invoke with its input, potentially citing prior evidence]
...
Final Response: [:evidence[n]: Carrying the final resolution]

Question: What was the impact of the Industrial Revolution on society and economy?

Response:
Plan: Kick off with a web search to explore the impact of the Industrial Revolution on society and economy.
:evidence0: = YahooSearch[Impact of the Industrial Revolution on society and economy]
Plan: Leverage HyperlinkExtractor to derive pertinent links from the search results.
:evidence1: = HyperlinkExtractor[:evidence0:]
Plan: Utilize SiteReader to pull information from these derived links.
:evidence2: = SiteReader[:evidence1:]
Plan: Finally, engage QueryBot to examine the pulled information and summarize the impact of the Industrial Revolution on society and economy.
:evidence3: = QueryBot[What was the impact of the Industrial Revolution on society and economy, given :evidence2:?]
Final Response: :evidence3:

System: A chat.


Instruction:
Develop a step-by-step execution plan to solve the user's query. Each step will have a corresponding evidence value which is the result of a function call.

Here are the tools available:
Bing[input]: A tool that performs a Bing search and returns a list of relevant links.
PageReader[input]: Loads a webpage from the input URL and produces plain text output containing the content of the page.
LinkCollector[input]: Collects all the links from the input text.
QAModel[input]: Answers questions based on an input passage of text.

Output Format:
Plan: [Action]
:EvidenceN: = [Function Call]
...
Answer: :EvidenceN:

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

Response:
Plan: Perform a Bing search to find out who was the first person to climb Mount Everest without supplemental oxygen.
:Evidence0: = Bing[First person to climb Mount Everest without supplemental oxygen]
Plan: Use QAModel to identify the name of the person from the search results.
:Evidence1: = QAModel[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: :Evidence0:]
Plan: Perform another Bing search to find out when this person climbed Mount Everest without supplemental oxygen.
:Evidence2: = Bing[:Evidence1: climb Mount Everest without supplemental oxygen date]
Plan: Use QAModel to identify the date from the search results.
:Evidence3: = QAModel[When did :Evidence1: climb Mount Everest without supplemental oxygen? Given context: :Evidence2:]
Answer: :Evidence1: was the first person to climb Mount Everest without supplemental oxygen and this happened on :Evidence3:.

System: A chat.


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

Here are the tools you can use:
Bing[input]: This tool allows the user to search for information on Bing. It provides a list of sites that may contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
LMQA[input]: Language model for answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

Ensure there is only one evidence output per plan step.

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, 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 and what challenges did they face?

Response:
Plan: Start by conducting a web search to find out who was the first person to climb Mount Everest.
:evidence0: = Bing[First person to climb Mount Everest]
Plan: Use a language model to interpret the search results and identify the name of the climber.
:evidence1: = LMQA[Who was the first person to climb Mount Everest, 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: climbing Mount Everest]
Plan: Extract the relevant links from the Bing search results for a more detailed search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the challenges faced by the climber from the extracted information.
:evidence5: = LMQA[What were the challenges faced by :evidence1: while climbing Mount Everest, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step plan to respond to the user instruction, making use of the provided tools. Each plan should correspond to an evidence value, which is the output of one of the available functions given an input string that could be the user's question, prior evidence values, or both.

Available tools:
Bing[input]: Allows the user to search for information using Bing search engine. It helps in locating appropriate sites that might contain the answer to the user's query.
SiteLoader[input]: Loads one or multiple websites from the input string containing newline separated links. Input is one or more links, and it generates plain text output containing the content of the links.
URLGrabber[input]: Grabs links from plain text and provides a plain text, newline separated list of links.
QuerySolver[input]: Answers questions based on an input text passage. The input needs to be a textual question referencing an #E[index] variable, like What is the population of New York, given #E1?

Inputs to these functions should be plain strings, without quotes or "+" to concatenate a string with an evidence variable. For instance, QuerySolver[What is the GDP of India, given #E3?]

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

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

Question: Who is the current president of Microsoft and what are some significant contributions they've made to the company?

Response:
Plan: Begin by performing a web search to find out who the current president of Microsoft is.
#E1 = Bing[Current president of Microsoft]
Plan: Use the QuerySolver to interpret the search results and find the name of the president.
#E2 = QuerySolver[Who is the current president of Microsoft, given #E1?]
Plan: Conduct another web search to find the key contributions made by the identified president of Microsoft.
#E3 = Bing[Key contributions made by #E2 at Microsoft]
Plan: Extract the relevant links from the Bing search results for a more focused search.
#E4 = URLGrabber[#E3]
Plan: Use the SiteLoader tool to extract information from the relevant links.
#E5 = SiteLoader[#E4]
Plan: Finally, utilize the QuerySolver to identify and summarize the key contributions made by the president of Microsoft from the extracted information.
#E6 = QuerySolver[What are the key contributions made by #E2 at Microsoft, 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:
GoogleBooks[input]: Tool that allows the user to search for information from Google Books. This tool is particularly useful in gaining knowledge about published works, authors, and other types of factual information related to books.
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, e.g. "Given context #E1"]
...
Final answer: #E[n]

Question: What is the plot summary of the book '1984' by George Orwell?

Response:
Plan: Search for more information about the book '1984' by George Orwell.
#E1 = GoogleBooks['1984' George Orwell]
Plan: Find out the plot summary of the book.
#E2 = QAEngine[What is the plot summary of the book '1984'? Given context: #E1]
Final answer: #E2

System: A chat.


Instruction:
Create a systematic plan to respond to the user instruction, making use of a range 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.
TextExtractor[input]: Extracts main text from the input string containing multiple paragraphs, where input is a long text, and produces plain text output containing the main points.
URLPicker[input]: Picks up URLs from plain text and produces a plain text, newline delimited response of URLs.
AIQA[input]: AI-based question answering system, particularly useful in answering questions based on an input passage of text.

The output should be in format:
Plan: [first action to take based in input question]
#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 Tokyo and how has it changed over the last decade?

Response:
Plan: Begin by conducting a web search to find out the current population of Tokyo.
#E1 = DuckDuckGo[Current population of Tokyo]
Plan: Utilize the AI-based QA system to interpret the search results and find the population figure.
#E2 = AIQA[What is the current population of Tokyo? Given context: #E1]
Plan: Conduct another web search to find information about the change in Tokyo's population over the last decade.
#E3 = DuckDuckGo[Tokyo population change over the last decade]
Plan: Pick up the relevant URLs from the DuckDuckGo search results for a more detailed search.
#E4 = URLPicker[#E3]
Plan: Use the TextExtractor tool to extract important information from the picked URLs.
#E5 = TextExtractor[#E4]
Plan: Finally, utilize the AIQA system to identify and summarize the changes in Tokyo's population over the last decade from the extracted information.
#E6 = AIQA[How has the population of Tokyo changed over the last decade? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Create a step-by-step plan to respond to the user query utilizing the following tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user query, one or more previous evidence values, or a combination of both.

Available tools:
BingSearch[input]: A tool allowing users to perform searches via Bing. Useful for locating potential sources of answers.
WebReader[input]: Loads a website specified in the input string and outputs its textual contents.
LinkSelector[input]: Takes in a plain text string and outputs a list of hyperlinks found within it.
AnswerBot[input]: An AI model capable of answering questions when provided with context. It requires a text-based question referencing a #E[index] variable.

Output format:
Plan: [First action]
#E1 = [Function to call with input]
Plan: [Subsequent action based on #E1's result]
#E2 = [Next function to call with input, potentially referencing #E1]
...
Final Answer: #E[n]

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

Response:
Plan: Search for the winner of the 2020 Nobel Prize in Literature.
#E1 = BingSearch[2020 Nobel Prize in Literature winner]
Plan: Identify the winner from the search results.
#E2 = AnswerBot[Who won the 2020 Nobel Prize in Literature? Given context: #E1]
Plan: Search for the most famous work of the identified laureate.
#E3 = BingSearch[Most famous work of #E2]
Plan: Extract relevant links from the search results.
#E4 = LinkSelector[#E3]
Plan: Extract text from the selected links.
#E5 = WebReader[#E4]
Plan: Identify the most famous work from the extracted texts.
#E6 = AnswerBot[What is the most famous work of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a systematic plan to solve the user query making use of the provided tools. Each step in your plan should correspond to an evidence value, which would be the output of one of the available functions when fed an input string. This input string could either be the user question, one or more prior evidence values, or a mix of both.

Available tools:
BingSearch[input]: Tool allowing users to search for information via Bing search engine. It helps in locating a suitable list of sites that might contain the answer to the user's query. Note that this function does not provide direct answers but aids in identifying potential sources of information.
SiteLoader[input]: Loads one or more websites from the input string consisting of newline separated links. Input is one or more links and output is plain text content of these links.
HyperlinkFinder[input]: Pulls out hyperlinks from plain text and generates a plain text, newline separated list of links.
TextAnalyzer[input]: Language model for answering queries based on a given passage of text. Input has to be a textual question referencing an :evidence[n]: variable, e.g., What is the population of Tokyo, given :evidence2:?

Each function requires a simple string as input, without any need for quotes or "+" to join a string with an evidence variable, e.g., TextAnalyzer[What is the GDP of India, given :evidence4:?]

Remember to associate only one evidence output with each plan step.

Output should follow this format:
Plan: [initial action based on input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action based on outcome of :evidence0:]
:evidence1: = [following function to call and input parameter, possibly referring to earlier evidence, e.g., "Considering context :evidence0"]
...
Final Answer: [:evidence[n]: holding the ultimate answer.]

Question: Who is the author of the book '1984' and what other books have they written?

Response:
Plan: Initiate a web search to identify the author of the book '1984'.
:evidence0: = BingSearch['1984' book author]
Plan: Apply the language model to decipher the search results and determine the author's name.
:evidence1: = TextAnalyzer[Who is the author of the book '1984', given :evidence0:?]
Plan: Carry out another web search to discover other books written by the determined author.
:evidence2: = BingSearch[Other books written by :evidence1:]
Plan: From the Bing search results, pull out the pertinent links for a more focused exploration.
:evidence3: = HyperlinkFinder[:evidence2:]
Plan: Employ the website loader tool to gather information from the selected links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Lastly, use the language model to identify and summarise the other books written by the author from the gathered information.
:evidence5: = TextAnalyzer[What other books has :evidence1: written, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

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

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

Each plan step should only include one evidence output.

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

Question: Who invented the World Wide Web and what were some of their major contributions to its development?

Response:
Plan: Start by conducting a web search to find out who invented the World Wide Web.
:data0: = Bing[Who invented the World Wide Web]
Plan: Use a language model to interpret the search results and identify the inventor.
:data1: = QAModel[Who invented the World Wide Web, given :data0:?]
Plan: Conduct another web search to find the major contributions made by the identified inventor to the development of the World Wide Web.
:data2: = Bing[Major contributions of :data1: to the development of the World Wide Web]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:data3: = LinkPicker[:data2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:data4: = WebScraper[:data3:]
Plan: Finally, use the language model to identify and summarize the key contributions made by the inventor to the development of the World Wide Web from the extracted information.
:data5: = QAModel[What were the major contributions of :data1: to the development of the World Wide Web, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
Please develop a plan to generate an ideal response for the following user instruction, making use of the available tools. Each step in your plan should correspond with an evidence value, which will be the output of one of the available functions given an input string that can either be the user question, previous evidence values, or both.

Here are the tools you can call upon:
Bing[input]: This tool allows the user to search for information using the Bing search engine. It is useful for finding relevant sites that may contain the answer to the user's query. The function doesn't directly provide answers; it finds websites that might have them.
WebScraper[input]: Loads 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.
LinkHarvester[input]: Extracts links from plain text and generates a plain text, newline delimited list of links.
SAM[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Ensure only one evidence output per plan step.

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

Question: Who won the 2020 NBA Finals MVP award and what were their season stats?

Response:
Plan: Start by conducting a web search to find out who won the 2020 NBA Finals MVP award.
:evidence0: = Bing[2020 NBA Finals MVP winner]
Plan: Use the language model to interpret the search results and identify the name of the MVP.
:evidence1: = SAM[Who won the 2020 NBA Finals MVP award, given :evidence0:?]
Plan: Conduct another web search to find the season stats for the identified MVP.
:evidence2: = Bing[:evidence1: 2020 season stats]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkHarvester[:evidence2:]
Plan: Use the WebScraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the season stats of the 2020 NBA Finals MVP from the extracted information.
:evidence5: = SAM[What were the 2020 season stats for :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a step-by-step plan to respond to the user query, utilizing the following tools at your disposal. Each step in the plan will produce an evidence value which corresponds to the output of one of the available functions. The input to these functions could be the user's question, previous evidence values, or a combination of both.

Available Tools:
DuckDuckGo[input]: A tool that enables users to perform searches using the DuckDuckGo search engine. It returns a list of potential sources that might contain answers to the user's query.
PageLoader[input]: Loads one or more websites provided as newline separated links in the input string. Outputs the plain text content of these pages.
URLGrabber[input]: Extracts URLs from a plain text input and provides them as a newline-separated plain text output.
NLPModel[input]: A natural language processing model designed to answer questions based on a provided text passage. The input should be a question referencing an :evidence[n]: variable (e.g., What is the capital of France, given :evidence1:?).

Output Format:
Plan: [Initial action based on the user's question]
:evidence0: = [Function to execute with its input]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to execute with its input, potentially referencing prior evidence (e.g., "Considering :evidence0")]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

Question: Who is the current Prime Minister of Japan and what political party do they belong to?

Response:
Plan: Start by performing a web search to identify the current Prime Minister of Japan.
:evidence0: = DuckDuckGo[Current Prime Minister of Japan]
Plan: Utilize the NLP Model to analyze the search results and determine the name of the Prime Minister.
:evidence1: = NLPModel[Who is the current Prime Minister of Japan, given :evidence0:?]
Plan: Execute another web search to ascertain the political party of the identified Prime Minister.
:evidence2: = DuckDuckGo[Political party of :evidence1:]
Plan: Extract pertinent links from the search results for a more detailed examination.
:evidence3: = URLGrabber[:evidence2:]
Plan: Deploy the PageLoader tool to retrieve information from the selected links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, employ the NLP Model to discern and summarize the political party affiliation of the Prime Minister from the retrieved data.
:evidence5: = NLPModel[What political party does :evidence1: belong to, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a comprehensive plan to address the user instruction, leveraging the available tools. Each plan will correspond to an evidence value, being the output of one of the available functions given an input string that could be the user question, one or multiple prior evidence values, or a combination thereof.

Available tools:
DuckDuckGo[input]: Tool enabling users to search for information through DuckDuckGo's search engine. It helps in identifying potential sites that might contain the answer to the user's question.
WebScraper[input]: Loads one or more websites from the input string containing newline-separated links, where input is one or more links, producing plain text output with the content of the links.
HyperlinkHarvester[input]: Harvests hyperlinks from plain text and outputs a plain text, newline-separated response of links.
BotQA[input]: Question-answering bot particularly adept at answering queries based on an input text passage. The input needs to be a textual question referencing a :info[n]: variable.

Each function requires a plain string as input, devoid of quotes or "+" used to concatenate a string with an info variable, e.g., BotQA[Who won the 2020 US Presidential Election, given :info2:?]

Ensure each plan step includes just one evidence output.

Output format should be:
Plan: [initial action based on input question]
:info0: = [function to call with input parameter]
Plan: [subsequent action based on outcome of :info0:]
:info1: = [next function to call and input parameter, possibly referring to previous evidence]
...
Answer: [:info[n]: holding the final answer.]

Question: Who is the current President of Microsoft and what major contributions have they made to the company?

Response:
Plan: Initiate a web search to discover who the current President of Microsoft is.
:info0: = DuckDuckGo[Current President of Microsoft]
Plan: Deploy the BotQA model to interpret the search results and ascertain the name of the President.
:info1: = BotQA[Who is the current President of Microsoft, given :info0:?]
Plan: Conduct another web search to unearth the significant contributions made by the identified President of Microsoft.
:info2: = DuckDuckGo[Major contributions by :info1: to Microsoft]
Plan: Extract the pertinent links from the DuckDuckGo search results for a deeper investigation.
:info3: = HyperlinkHarvester[:info2:]
Plan: Utilize the WebScraper tool to glean information from the harvested links.
:info4: = WebScraper[:info3:]
Plan: Lastly, employ the BotQA model to pinpoint and summarize the major contributions made by the President of Microsoft using the scraped information.
:info5: = BotQA[What are the major contributions made by :info1: to Microsoft, given :info4:?]
Answer: :info5:

System: A chat.


Instruction:
Create a plan to solve the following problem step-by-step. For each step in your plan, indicate which external tool along with its input will be used to gather evidence. Store this evidence into a variable #E[index] that can be referenced later.

Here are the tools at your disposal:
DuckDuckGo[input]: A tool that enables users to search for information through DuckDuckGo. This tool generates a list of sites that might contain the answer to the user's query.
TextExtractor[input]: Extracts key pieces of information from plain text and produces a summarized version of the text.
URLFinder[input]: Finds URLs from plain text and outputs a plain text, newline delimited list of URLs.
QAModel[input]: A question-answering language model that answers questions based on an input text passage. The input must be a text question that references a #E[n] variable, e.g., What is the population of New York City, given #E1?

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

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

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

Question: Who invented the telephone and what was their motivation behind it?

Response:
Plan: Begin by searching for information about who invented the telephone.
#E1 = DuckDuckGo[Who invented the telephone]
Plan: Utilize the TextExtractor to pull out the inventor's name from the search results.
#E2 = TextExtractor[#E1]
Plan: Search for information about the inventor's motivation behind inventing the telephone.
#E3 = DuckDuckGo[Motivation behind inventing the telephone by #E2]
Plan: Find useful URLs from the search results for further investigation.
#E4 = URLFinder[#E3]
Plan: Extract key details about the inventor's motivation from these URLs.
#E5 = TextExtractor[#E4]
Plan: Use the QAModel to understand and summarize the inventor's motivation behind inventing the telephone.
#E6 = QAModel[What was the motivation of #E2 for inventing the telephone? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a step-by-step execution plan for the following task, making use of the available tools. For each plan, indicate which external tool together with tool input to retrieve evidence. You can store the evidence into a variable #E[index] that can be called by later tools.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables users to search for information via the DuckDuckGo search engine. It is effective in generating a list of sites that might contain answers to the user's query.
PageReader[input]: This tool loads one or more websites from an input string containing newline-delimited links. The input is one or more links, and it outputs plain text containing the content of the links.
URLCollector[input]: This tool extracts URLs from plain text and generates a plain text, newline-delimited response of URLs.
AIQA[input]: An AI-powered Question Answering tool capable of answering queries based on an input text passage. The input must be a text question referencing a #E[n] variable, e.g., 'What is the population of New York City, given #E1?'

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

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

Question: Who invented the telephone and what were some of the initial reactions to this invention?

Response:
Plan: Search for more information about who invented the telephone.
#E1 = DuckDuckGo[Who invented the telephone]
Plan: Identify the inventor of the telephone.
#E2 = AIQA[Who invented the telephone? Given context: #E1]
Plan: Search for more information about the initial reactions to the invention of the telephone.
#E3 = DuckDuckGo[Initial reactions to the invention of the telephone]
Plan: Extract the relevant links from the search results for a more detailed investigation.
#E4 = URLCollector[#E3]
Plan: Read the content of the extracted links.
#E5 = PageReader[#E4]
Plan: Find out the initial reactions to the invention of the telephone.
#E6 = AIQA[What were the initial reactions to the invention of the telephone? Given context: #E5]
Final answer: #E6

System: A chat.