Instruction:
A chat. Develop a systematic plan to address the query using the tools at your disposal. For each plan, indicate the corresponding evidence value which would be the outcome of calling one of the available functions with an appropriate input string.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables the user to conduct searches using the DuckDuckGo search engine. It helps locate potential sites that might hold answers to the user's question.
TextExtractor[input]: Retrieves plain text from one or more websites specified in the input string (newline separated links). Input includes one or more links and outputs plain text containing the site contents.
URLFetcher[input]: Pulls out URLs from plain text and generates a plain text response of newline-separated links.
InfoBot[input]: An AI model capable of answering queries based on an input text excerpt. The input needs to be a textual question referencing 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: Who invented the first airplane and what was their inspiration?


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

Here are the tools available to be called:
Bing[input]: A tool that allows users to search for information using Bing's search engine. This tool is useful in finding relevant sites that may contain the answer to the user's query.
WebCrawler[input]: Loads websites from the input string containing newline delimited 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 effective at 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 historical significance of the Battle of Waterloo and who were the key figures involved?


Instruction:
A chat. Create a step-by-step plan to answer the following question using the available tools. Each tool should be called with an appropriate input and its output stored in a variable named :evidence[n]:, where n is a number starting from 0. The final answer should reference the last evidence.

Available Tools:
1. Bing[input]: A tool that allows you to search for information on the internet using the Bing search engine.
2. TextAnalyzer[input]: Analyzes a block of text and extracts key details such as names, dates, places etc.
3. DocReader[input]: Reads documents provided in the form of links and outputs their content as plain text.
4. QnAMaker[input]: Answers questions based on given context. The input must include a question and a reference to an evidence variable for context.

Question: Who won the Nobel Prize in Literature in 2005 and what are some of his/her most famous works?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
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.
URLCollector[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
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 2022 Nobel Prize in Physics and what was their contribution?


Instruction:
A chat. Please provide a step-by-step plan to solve the following problem using the provided tools. For each step, indicate the external tool along with its input to retrieve evidence. Store the evidence into a variable :evidence[index]:

Available Tools:
Britannica[input]: A tool that fetches information from Britannica Encyclopedia. It's useful for gaining knowledge about historical events, people, places, etc.
AskJeeves[input]: A tool that answers questions directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Output Format:
Plan: [First action]
:evidence0: = [Function call with input]
Plan: [Next action based on :evidence0:]
:evidence1: = [Next function call with input possibly referencing :evidence0:]
...
Final Answer: [:evidencen:]

Question: How did the Industrial Revolution impact society and economy?


Instruction:
A chat. Question: What is the history of the English language?

Here are the tools available to be called:
HistoryArchive[input]: This tool provides access to historical archives and documents.
LinguisticsDB[input]: This tool provides linguistic information related to various languages.
Wikipedia[input]: Tool that allows the user to search for information from Wikipedia.
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.
LanguageEvolution[input]: This tool provides information about the evolution of languages over time.

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]


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine. This tool is useful in finding an appropriate list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites provided as newline separated links. The input should be one or more links and it produces plain text output containing the content of the links.
LinkParser[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAEngine[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Ensure to only include one evidence output per plan step.

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

Question: What are some notable achievements of the current president of Harvard University?


Instruction:
A chat. Construct a step-by-step plan to solve the problem using the tools provided. Each plan needs to have an associated evidence value.

Tools available:
PubMed[input]: Tool that searches for scientific articles and abstracts.
ChemSpider[input]: Tool that provides information about different chemical compounds.
MathSolver[input]: Tool that solves mathematical equations.
ScienceDirect[input]: Tool that provides access to full-text scientific studies.
SciAnswer[input]: Tool that answers science-based questions using a large database of scientific knowledge.

Question: What is the molecular structure of caffeine, find recent research papers about its effects on human health, and calculate the molar mass of caffeine.


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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"?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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]


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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]


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. 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?


Instruction:
A chat. Please generate a step-by-step plan to answer the user query using the following tools. Each tool will have an output, which is stored in a variable :evidence[n]:.

Here are the available tools:
SearchEngine[input]: This tool allows you to search for information from various sources on the internet. The input should be a string related to the query.
ArticleExtractor[input]: Extracts full text of articles from the provided links. The input must be one or more newline separated URLs.
LinkParser[input]: Parses plain text and extracts all URL links present in it.
QAEngine[input]: A question answering tool that can provide answers based on common knowledge or given context.

The output format should be as follows:
Plan: [first action]
:evidence0: = [function call with input]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with input possibly referencing previous evidence]
...
Answer: [:evidence[n]: containing final answer]

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


Instruction:
A chat. Please generate a plan to solve the following problem using the listed tools. Each plan will correspond to an evidence value which will be the result of a function called with an input string.

Available Tools:
AskJeeves[input]: A tool that searches for information online via Ask Jeeves. It returns a list of sites related to the input query.
PageReader[input]: Reads the contents of a page at a given URL. Input is a URL and output is the plain text content of the page.
LinkCollector[input]: Collects links from a block of text. Input is a block of text and output is a list of URLs found within the text.
InfoMaster[input]: Answers questions based on provided context. Input is a question and optionally a reference to previous evidence.

Output Format:
Plan: [First action based on input question]
:Evidence0: = [Function to call with input parameter]
Plan: [Next action based on :Evidence0:]
:Evidence1: = [Next function to call with input parameters, potentially including :Evidence0:]
...
Answer: [:EvidenceN:, containing final answer]

Question: What year did Queen Elizabeth II ascend to the throne and how long has she reigned?


Instruction:
A chat. Generate a step-by-step plan to answer the question: "What is the history and significance of the Eiffel Tower in Paris?"

Here are the tools available:
HistoricalData[input]: A tool that provides historical data about various topics.
CulturalSignificance[input]: A tool that gives information on the cultural importance of different places, events, or people.
Translate[input]: Translates text from one language to another.
QA[input]: Answers questions based on common sense and general world knowledge.
GoogleMaps[input]: Provides geographical information and location details.

Output format:
Plan: first action
#E1 = function with input parameter
Plan: next action
#E2 = next function with input parameter
...
Final Answer: #E[n]


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine.
PageLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkRetriever[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: An artificial intelligence-based question-answering model, particularly useful in answering questions based on an input passage of text.

The output should be in format:
Plan: [first action to take based in input question]
#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 designed the Sydney Opera House and what was his inspiration?


Instruction:
A chat. For the following tasks, create a detailed plan to solve the problem step-by-step. For each step in your plan, specify which external tool will be used along with its input to gather evidence. The gathered evidence can be stored into a variable #E[index] that can be referenced by subsequent tools.

Here are the available tools:
Bing[input]: A tool that allows you to search for information using the Bing search engine. This tool is useful for finding a list of sites that may contain the answer to your question. However, it doesn't directly provide an answer; instead, it provides a list of sites that might have the answer.
WebScraper[input]: Loads one or more websites from the input string containing newline-delimited links. The input should be one or more links and produces plain text output containing the content of these links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, 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 on input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context #E1"]
...
Final answer: #E[n]

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what book did they write about their experience?


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

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

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

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


Instruction:
A chat. Develop a plan to answer the following question using the tools provided. 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 be either the user's query, previous evidence values, or both.

Here are the tools you have at your disposal:
SearchEngine[input]: This tool allows users to search for information on the internet. 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 answers; it finds websites that might.
TextExtractor[input]: Extracts text from one or more websites from the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkParser[input]: Extracts links from plain text and generates 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 that references a :data[n]: variable, e.g., What color is the cat, given :data1:?

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

Ensure there is only one evidence output per plan step.

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 is the author of the book 'To Kill a Mockingbird' and what other books did they write?


Instruction:
A chat. Generate a solution plan for the user query using the tools at disposal. Each plan will correspond to an evidence value which will be the result of a function call.

Tools Available:
1. Yahoo[input]: Tool that uses Yahoo search engine to find relevant sites. The input is a string containing the search query.
2. LinkExtractor[input]: Extracts links from the plain text. The input is plain text with newline delimited links.
3. Scraper[input]: Scrapes websites mentioned in the input links and produces plain text content.
4. QAModel[input]: A language model that answers questions based on the input passage of text. The input must reference an :evidence[n]: variable.

Output Format:
Plan: [First action]
:evidence0: = [Function call with input]
Plan: [Next action]
:evidence1: = [Next function call with input]
...
Final Answer: :evidence[n]:

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


Instruction:
A chat. Provide a step-by-step plan to generate an appropriate response to the user's query, utilizing the following tools. Each plan should correspond to an evidence value, which would be the output of a specific function given an input string.

Tools available:
BingSearch[input]: A tool that enables users to conduct a Bing search. It provides a list of potential sites that might contain the answer to the user's query.
URLExtractor[input]: A tool that extracts URLs from a provided piece of text.
SiteReader[input]: Reads the contents of a website provided as a URL.
QAModel[input]: A question-answering model that can answer queries based on a given context. For instance, it could answer "What is the main theme of the article?" given ":evidence1:".

Output format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameters]
Plan: [Next action based on #E1]
#E2 = [Next function to call with input parameters (can refer to previous evidence)]
...
Final Answer: #En

Question: Who wrote the novel '1984' and what are some major themes discussed in the book?


Instruction:
A chat. 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.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What are some of the most popular dishes in French cuisine?


Instruction:
A chat. Please provide a plan to find out who the founder of Microsoft is and what was their first product? Make use of the tools below and store each result in a variable #E[index].

Tools Available:
DuckDuckGo[input]: This tool uses DuckDuckGo search engine to fetch information.
DataMiner[input]: Extracts specific information like names, products, dates etc., from a given text.
WebPageLoader[input]: Loads webpages from provided links and returns their textual content.
AIQA[input]: AI-powered Question Answering system that can answer queries given an input context.


Instruction:
A chat. Generate a step-by-step plan to respond to the following user request:

Question: What are the main causes of the Great Depression and its impact on global economy?

Here are the tools available to be called:
HistoricalDB[input]: A tool that allows you to search for historical data and events.
EconomicIndicator[input]: Provides economic indicators for a specific period.
GlobalImpact[input]: Assesses the global impact of a particular event or phenomenon.
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.
TextSummarizer[input]: Summarizes long texts into shorter versions.

Follow the same planning and output format as TSK 1.


Instruction:
A chat. Create a plan to solve the following problem using the tools at your disposal. For each step in your plan, indicate which tool you would use along with the necessary inputs. You can store the outputs into a variable #E[index] that can be referenced later.

Here are the tools you can use:
DuckDuckGo[input]: A tool that lets you perform searches using DuckDuckGo. Useful for finding lists of websites that might have the required information.
SiteReader[input]: Reads the content of one or more websites specified by newline-separated links in the input string.
URLExtractor[input]: Extracts URLs from plain text and returns them as newline-separated strings.
InfoModel[input]: An AI model that can answer questions based on a given context. The input should be a textual question that references a #E[n] variable, like "What is the population of Paris, given #E1?"

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

The output should look like this:
Plan: [first action based on the input question]
#E1 = [function call with input parameter]
Plan: [next action based on the result of #E1]
#E2 = [next function call and input parameter, possibly referencing previous evidence, e.g., "Given context #E1"]
...
Final Answer: #E[n]

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


Instruction:
A chat. Create a step-by-step plan to answer the following user question using the available tools. Each tool execution will generate 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 or previous evidence values.

Here are the tools you can use:
Bing[input]: A search engine tool that allows users to find information from various websites across the internet.
PageReader[input]: Loads a website from the input URL and produces plain text containing the content of the webpage.
LinkCollector[input]: Extracts links from plain text and generates a list of URLs.
TextAnalyzer[input]: Analyzes a passage of text and answers questions based on it. The input must be a question referencing an :evidence[n]: variable.

Each function takes a plain string as input without quotes or "+" for concatenation with an evidence variable (for example, TextAnalyzer[What is the capital of France, given :evidence2:?]).

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

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


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

Question: Who composed the music for the film 'Inception' and what other notable films have they worked on?

Here are the tools available to be called:
IMDbSearch[input]: Search for movie-related information using IMDb database.
ComposerInfo[input]: Get detailed information about a specific composer.
Filmography[input]: Get a list of all films a person has worked on.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.

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


Instruction:
A chat. Please create a plan to solve the following user query using the tools provided. Each step of the 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 question, previous evidence values, or a mixture of both.

Available tools:
WikiSearch[input]: Tool that allows the user to search for information from Wikipedia.
PageScraper[input]: Load a website from the input link and produces plain text output containing the content of the link.
QAEngine[input]: Answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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


Instruction:
A chat. Design a systematic plan to provide an optimal response to the user's command, leveraging the following tools. Each step in the plan will yield an evidence value that represents the output of one of the accessible functions. The inputs to these functions could either be the user's question, preceding evidence values, or a blend of both.

Tools Available:
YahooSearch[input]: Allows the user to conduct searches via the Yahoo search engine. This tool generates a list of potential websites that may hold the answer to the user's inquiry.
SiteScanner[input]: Fetches one or more websites from the input string, which contains newline-separated links. Produces a plain-text output comprising the contents of the links.
HyperlinkExtractor[input]: Gleans hyperlinks from plain text and delivers a plain-text, newline-separated list of links.
AIQA[input]: Artificial Intelligence Question-Answering model adept at responding to queries based on an input text passage. The input needs to be a textual question that refers to a #E[index] variable (e.g., What is the population of New York City, given #E1?)

Output Format:
Plan: [First action derived from the user's question]
#E0 = [Function to invoke with its input]
Plan: [Following action, based on the outcome of #E0]
#E1 = [Subsequent function to invoke with its input, possibly referring to earlier evidence (e.g., "Given context #E0")]
...
Answer: [#E[n] containing the final answer]

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


Instruction:
A chat. Create a sequential plan to generate a response to the user instruction, utilizing the set of available tools. Each plan will have a corresponding evidence value, which is the output of one of the functions given an input string - this could be the user's question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
Bing[input]: Tool that enables the user to perform a Bing search. Useful for finding a range of sites that might include the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string (containing newline-delimited links), producing plain text output containing the website content.
URLPicker[input]: Picks URLs from plain text and generates a plain text, newline-delimited list of URLs.
NLPModel[input]: Language model for answering questions based on an input text passage. The input must be a textual question that references an :evidence[n]: variable, e.g., What is the population of Tokyo, given :evidence1:?

Only one evidence output should be included 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, possibly referring to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

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


Instruction:
A chat. Create a detailed plan to answer the following query using the set of tools at your disposal. Each step of the plan should yield an evidence value, produced by calling a function with an input string that could be the original question, previously obtained evidence, or a combination of both.

Available tools:
WikiLookup[input]: Searches Wikipedia for information related to the input string. While it may not always give direct answers, it often provides valuable context.
TextAnalyzer[input]: Analyzes a body of text and summarizes key points. Particularly useful when dealing with large amounts of information.
QAHelper[input]: Answers questions using general knowledge or specific context provided through previous evidence.

Each function requires a simple string as input, without the need for quotes or concatenation symbols. For instance, QAHelper[Who won the 2020 presidential election, given :evidence2:?].

Ensure each plan step has exactly one corresponding evidence output.

Output format:
Plan: [initial action based on the question]
:evidence0: = [call to function with input parameter]
Plan: [subsequent action, considering the outcome of :evidence0:]
:evidence1: = [call to next function with input parameter, possibly referring to earlier evidence such as "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

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


Instruction:
A chat. Generate a plan to answer the following question using these available tools. Each tool should be used with an input and will produce an output that can be stored in a variable :evidence[n]: for further use.

Available Tools:
Bing[input]: A search engine tool useful for finding relevant websites based on the input query.
WebReader[input]: This tool takes one or more URLs as input, reads the content of the webpage(s), and produces plain text output containing the information from the page(s).
LinkPicker[input]: Extracts links from plain text and outputs them in a list format.
AskAI[input]: An AI model capable of answering questions based on given context (text). The input must be a text question referencing an :evidence[n]: variable.

The output should follow this format:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with possible reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some notable accomplishments of Elon Musk?


Instruction:
A chat. Generate a step-by-step plan to answer the user's question, using the following tools at your disposal. Each plan should be followed by an evidence value that will be the output of one of the available functions given an input string.

Here are the tools you can use:

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

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

Question: Who was the first woman to win a Nobel Prize and what was her contribution to science?


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

Here are the tools available to be called:
NewsAggregator[input]: Tool that collects news articles related to a particular topic.
SocialMediaMonitor[input]: Tool that monitors social media posts related to a specific keyword or hashtag.
SentimentAnalyzer[input]: Tool that analyzes the sentiment (positive, negative, neutral) of a piece of text.
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.
WebCrawler[input]: Tool that visits websites to collect information.

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: How is the latest iPhone model being received by the public?