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

Here are the tools you have at your disposal:
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.
TextExtractor[input]: Extracts plain text from web pages given one or more links as input.
LinkFinder[input]: Extracts links from plain text and returns them as a newline-separated list.
QAEngine[input]: A question-answering model that answers questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

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

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


Instruction:
A chat. Create a step-by-step plan to answer the user's question using the available tools. Each tool will generate an evidence value, which is 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 available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool helps in finding a list of sites that may contain 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.
AIM[input]: An artificial intelligence model that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?

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

Include only one evidence output per plan step.

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

Question: Who won the 2022 FIFA World Cup and what were some key moments of their journey?


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

Here are the tools you can use:
WebSearch[input]: A tool that allows users to search for information on the web. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
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.
LinkExtractor[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 a :evidence[n]: variable.

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

Question: What are some significant accomplishments of Albert Einstein?


Instruction:
A chat. Develop a sequential plan to address the user query utilizing the provided tools. Each step will yield an evidence value which is the output of the selected function given an input string that could be the user question, preceding evidence values, or a combination of both.

Available tools are:
WebCrawler[input]: A tool that enables users to search for data on the web. It's handy for locating potential sites that might have answers to the user's query.
TextExtractor[input]: Loads a webpage from the supplied URL and generates a plain text output containing the page's content.
URLPicker[input]: Extracts URLs from plain text and produces a list of URLs.
QuerySolver[input]: An AI model adept at answering queries based on an input text passage. The input has to be a text query referencing a #Evidence[n] variable, such as What is the dog's breed, given #Evidence1?

Output format should be:
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, potentially referring to prior evidence like "Given context #Evidence1"]
...
Final Answer: #Evidence[n]

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


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.
TextExtractor[input]: Extracts plain text from websites provided as newline delimited links in the input string.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the history behind the creation of Google?


Instruction:
A chat. Please provide a step-by-step plan to answer the user's question, making use of available tools. Each step will have an associated evidence value, which is the output from 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 available to be called:
SearchEngine[input]: Tool that allows the user to search for information using a general 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.
LinkGrabber[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

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

Only include one evidence output per plan step.

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

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


Instruction:
A chat. Formulate a sequential plan to solve the following user query using the provided tools. Each tool operation will yield an evidence value, which corresponds to the output of one of the functions when supplied with an input string that could be the user's question or prior evidence values.

Tools at your disposal include:
DuckDuckGo[input]: This tool uses the DuckDuckGo search engine to gather information from numerous online sources.
URLLoader[input]: This loads a webpage from the given URL and outputs its textual content in plain form.
HyperlinkExtractor[input]: From a block of text, this extracts hyperlinks and provides a list of URLs.
InfoProcessor[input]: This analyzes a section of text and responds to queries based on it. An :evidence[n]: variable must be referenced in the input.

For each function, simply provide a plain string as input without quotation marks or "+" symbols for concatenating with an evidence variable (like InfoProcessor[What is the population of Tokyo, given :evidence1:?]).

The output should adhere to the following structure:
Plan: [initial action]
:evidence0: = [call to function with input parameter]
Plan: [subsequent action influenced by outcome of :evidence0:]
:evidence1: = [call to next function with input parameter, possibly referring to earlier evidence]
...
Answer: [:evidence[n]: where n represents the final answer]

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


Instruction:
A chat. Formulate a plan to find out the height of Mount Everest and which country it's in.

Available tools:
MountainStats[input]: Provides statistics about mountains worldwide.
CountryLocator[input]: Identifies the country a specified landmark is in.
QA[input]: Can answer questions using common sense or given context.
GoogleEarth[input]: Provides geographical data about a place.
Wikipedia[input]: Allows searching for information from Wikipedia.

Output format:
Plan: First action
#E1 = function with input parameter
Plan: Next action based on #E1
#E2 = next function with input parameter referencing previous evidence if necessary
...
Final Answer: #E[n]


Instruction:
A chat. Create a step-by-step plan to answer the user query, making use of the following 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 either the user question or previous evidence values.

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

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

Question: What is the history behind the construction of Eiffel Tower?


Instruction:
A chat. Create an execution plan to solve the following problem using the provided tools. Each step must include one action, one tool call with inputs, and store the result into a variable #E[index] for later reference.

Tools Available:
WebSearch[input]: Searches the web for information related to the input string.
QAEngine[input]: Answers questions using common sense, world knowledge, or given context.
CompanyDatabase[input]: Retrieves data about a specified company.
StockMarketAPI[input]: Fetches real-time stock market data for a specified company.

Format:
Plan: [Action to be performed]
#E1 = [Tool to be used with its input]
...
Final Answer: #E[n]

Question: What is the current market capitalization of Microsoft Corporation and who is their CEO?


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:
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.
TextExtractor[input]: Extracts text from websites provided as input and produces plain text output containing the content of the site.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the history behind the creation of Bitcoin and who was involved?


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

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information from various sources on the internet.
FactChecker[input]: Tool that verifies the accuracy of facts and figures.
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.
DatabaseLookup[input]: Tool that searches a database for specific information.
ImageAnalyzer[input]: Tool that analyzes images and provides details about them.

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 highest peak in the Alps and what is its elevation?


Instruction:
A chat. Create a plan to answer the following question using the available tools. Each step in your plan should have an associated evidence variable that will be used as input for subsequent steps.

Available Tools:
WebSearch[input]: This tool allows you to search the web for information related to the input string.
TextAnalyzer[input]: Analyzes a block of text and extracts key pieces of information such as names, dates, places, etc.
QA[input]: A tool that can answer questions based on common sense, general world knowledge, or given context.
ImageFinder[input]: Searches the web for images related to the input string.
ImageAnalyzer[input]: Analyzes an image and provides a description of what it contains.

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

Question: Who won the 2019 Tour de France and where is he from?


Instruction:
A chat. Question: How does the process of photosynthesis work in plants?

Here are the tools available to be called:
BiologyTextbook[input]: Tool that provides detailed explanations of biological processes.
DiagramGenerator[input]: Tool that generates diagrams or flowcharts to visually represent complex processes.
QA[input]: Tool that can answer questions based on common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
VideoFinder[input]: Tool that finds educational videos related to a specified topic.
SummaryMaker[input]: Tool that summarizes lengthy texts into concise summaries.

Plan: First action to take based on input question
#E1 = BiologyTextbook["photosynthesis"]
Plan: Next action to take, based on result of #E1
#E2 = DiagramGenerator[#E1]
Plan: Find an educational video for better understanding
#E3 = VideoFinder["photosynthesis"]
Plan: Summarize all the gathered information
#E4 = SummaryMaker[#E1 + " " + #E2 + " " + #E3]
Final Answer: #E4


Instruction:
A chat. Generate a plan to respond to the user's query using the provided tools. Each step of the plan will have a corresponding evidence variable.

Here are the tools available to be called:
BingSearch[input]: A tool that uses Bing search engine to find relevant information online.
PageParser[input]: A tool that extracts text from a webpage.
QueryResponder[input]: A tool that answers questions based on an input passage of text.

The output should be in format:
Plan: [first action to take based on input question]
@Evidence1 = [function to call with input parameter]
Plan: [next action to take, based on result of @Evidence1]
...
Final answer: @Evidence[n]

Question: What is the population of Tokyo and what is it known for?


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

Here are the tools you can use:
Bing[input]: A tool that allows users to search for information on Bing. This tool is useful in finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KnowledgeModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the dog, given #E1?

The output format should be as follows:
Plan: [first action]
#E0 = [function with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function with input parameter referencing previous evidence if necessary]
...
Answer: [#En containing the final answer]

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


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

Here are the tools available to be called:
Britannica[input]: Tool that allows the user to search for information from Britannica Encyclopedia. This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
AIQA[input]: AI Question Answering tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Each plan should be followed by exactly one evidence (#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: When was the Eiffel Tower built and who was its architect?


Instruction:
A chat. Create 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 the chosen function given its input parameters.

Available Tools:
GoogleScholar[input]: A tool that searches academic papers and articles related to the input query.
PDFReader[input]: A tool that reads PDF files from the input link(s) and provides a plain text output.
HyperlinkExtractor[input]: A tool that extracts hyperlinks from the input text.
BERT[input]: A language model tool that answers questions based on an input context. The input must be a text question referencing a #E[index] variable.

Output Format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call with input parameter, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: What were the main findings of the research paper titled "Artificial Intelligence in Healthcare"?


Instruction:
A chat. Develop a plan to answer the following query using the tools provided. Each step should specify the tool used and its input. Store the outputs in variables named :evidenceN:, where N is the index number.

Available Tools:
1. DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to gather information. It provides a list of potential sources but does not directly answer the question.
2. SiteLoader[input]: Loads the content of specified websites into plain text. Input is one or more URLs separated by newlines.
3. URLExtractor[input]: Extracts URLs from plain text and returns them as a newline-separated list.
4. AskIt[input]: A tool that answers questions based on provided context. The input is a question that refers to an :evidenceN: variable.

Output Format:
Plan: [First Action]
:evidence0: = [Function Call with Input Parameter]
Plan: [Next Action Based on Result of :evidence0:]
:evidence1: = [Next Function Call with Input Parameter Referencing Previous Evidence]
...
Answer: [:evidenceN: Containing Final Answer]

Question: Who was the first woman to win a Nobel Prize and what field was it in?


Instruction:
A chat. Design a plan to respond to the user instruction utilizing the set of tools provided. For each plan, indicate the corresponding evidence value, which will be the output of one of the available functions given an input string - this could be the user's question, previous evidence values, or a combination of both.

Available tools:
Bing[input]: This tool enables users to perform searches on Bing. It doesn't directly answer queries; instead, it finds a list of sites that might contain the answer.
ContentParser[input]: This tool extracts text from a list of URLs (newline-separated). The input is one or multiple links, and the output is plain text containing the content of those links.
URLSelector[input]: This tool selects relevant links from a plaintext list of links and generates a plaintext response consisting of selected links.
Oracle[input]: This is a question-answering model that responds to queries based on common sense, world knowledge, or given context. The input should be a question referencing an :evidence[n]: variable, such as 'What is the tallest mountain, given :evidence1:?'.

Remember, each function's input should be a simple string, without quotation marks or '+' to concatenate a string with an evidence 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, possibly referring to prior evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n]: that contains the ultimate answer.]

Question: What is the significance of the Battle of Waterloo and how did it impact Europe?


Instruction:
A chat. Generate a step-by-step plan to respond to the user query utilizing the available tools. For each step, indicate the corresponding evidence value, which would be the output of one of the available functions given an input string that could be the user's question, prior evidence values, or a combination of both.

Available tools are as follows:
WebSearch[input]: A tool that enables users to perform a search on the web. It locates a list of sites that might contain the answer but does not directly provide the answer.
SiteReader[input]: Load one or multiple websites from the input string containing newline separated links, where input is one or several links, and generates plain text output containing the link contents.
UrlCollector[input]: Extracts URLs from plain text and returns a plain text, newline separated response of URLs.
KnowledgeBot[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.

Output should be formatted 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]
...
Final 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 the tools provided. Each step of your plan should be followed by an evidence value, which will be the output of one of the available functions given an input string that can be either the user's question or one or more previous evidence values.

Here are the tools available for use:
SearchEngine[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.
TextExtractor[input]: Extracts plain 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.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should follow this format:
Plan: [first action to take based 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"]
...
Final Answer: [:evidence[n]: containing the final answer.]

Question: Who wrote the book 'To Kill a Mockingbird' and what other works they have written?


Instruction:
A chat. Create a detailed execution plan to solve the following problem. You have several tools at your disposal. For each step, indicate which tool you would use and how you would use it. Store the output of each tool into a variable #E[index] that can be used as input for subsequent steps.

Available Tools:
GoogleSearch[input]: A tool that uses Google's search algorithm to find relevant web pages based on the input query.
SiteReader[input]: A tool that extracts all text from a specified website URL.
QAModel[input]: A tool that answers questions based on provided context. The input should be a question and some context that might contain the answer.

Output Format:
Plan: [First action]
#E1 = [Tool and its input]
Plan: [Second action]
#E2 = [Next tool and its input, possibly referencing #E1]
...
Final Answer: #En

Question: How many languages does Pope Francis speak fluently?


Instruction:
A chat. Question: How many books has Stephen King written and what are their average ratings?

Here are the tools available to be called:
AuthorWorks[input]: Lists all works by a specified author.
BookRatings[input]: Provides average ratings for a list of books.
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.

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 plan to respond to the user instruction using the set of tools below. Each tool can be used with an input string and provides an output that can be stored as #E[index] for later use.

Available tools:
DuckDuckGo[input]: Searches for information on DuckDuckGo, including web pages, news articles, images, etc.
SummaryMaker[input]: Summarizes long pieces of text into concise key points.
URLExtractor[input]: Extracts URLs from a given piece of text.
SiteLoader[input]: Loads one or more websites from the input string (newline separated links) and outputs the text content of these sites.
KnowledgeBase[input]: A question-answering tool that can provide answers based on common knowledge or given context (previous evidence).

Your output should look like this:
Plan: [First step]
#E1 = [Function call with input]
Plan: [Next step based on #E1]
#E2 = [Next function call with input, potentially referring to #E1]
...
Final Answer: #E[n]

Question: How does nuclear fusion work and what are its applications?


Instruction:
A chat. Develop a plan to respond to the following question using the listed tools. For each step in your plan, provide an evidence value which corresponds to the output of one of the available functions.

Available Tools:
AskJeeves[input]: A tool that allows you to ask direct questions and receive succinct answers. Useful for obtaining quick facts and figures.
DeepDive[input]: A tool that delves into comprehensive resources to retrieve detailed information on a topic. Input is a search term or phrase.
TextAnalyzer[input]: Analyzes a body of text and extracts key points and summaries.
QAModel[input]: Question answering language model that provides answers based on a provided text passage. It uses an :evidence[n]: variable as input.

Output Format:
Plan: [First action to take based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action to take, based on result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which may refer to previous evidence, e.g., "Given context :evidence0:"]
...
Answer: [:evidence[n]: Containing the final answer.]

Question: How did Amazon get its start and what were some early challenges it faced?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding 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.
Parser[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkHarvester[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, 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. QAModel[What is the capital of Michigan, given :evidence3:?]

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

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

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


Instruction:
A chat. Construct a systematic plan to address the following query. Make use of the tools provided and save the output of each tool into a variable $Evidence[index] that can be referred to later.

Tools Available:
YahooSearch[input]: A search engine tool used to gather information from the internet.
TextCleaner[input]: Takes a block of text as input and removes any irrelevant information or noise, leaving only important details.
HyperlinkGatherer[input]: Gathers all hyperlinks present within a block of text.
InfoBot[input]: A tool designed to answer questions based on common knowledge or specific context provided to it.

Format your response as follows:
Plan: [Initial action based on input question]
$Evidence1 = [Call to function with appropriate input]
Plan: [Subsequent action based on $Evidence1]
$Evidence2 = [Next function call with suitable input, potentially referring back to $Evidence1]
...
Final Answer: $Evidence[n]

Question: Who is the current president of Brazil and what are some significant policies they have implemented?


Instruction:
A chat. Develop a sequential plan to address the user's query, making use of the provided tools. Each plan should have a corresponding evidence value, which is the output of one of the functions given an input string.

Here are the tools available to be called:
YahooSearch[input]: A tool that lets the user search for information through the Yahoo search engine. It's useful for locating a variety of sites that could hold the answer to the user's question.
HyperlinkFinder[input]: Finds hyperlinks from plain text and delivers a plain text, newline separated response of links.
SiteLoader[input]: Loads one or more websites from the input string containing newline-separated links, where input is one or more links, and yields plain text output containing the content of the links.
QAModel[input]: A question-answering model powered by artificial intelligence, highly efficient at answering questions based on an input passage of text. The input has to be a text question that refers to a :evidence[n]: variable.

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

Question: How did the Great Depression impact the global economy?


Instruction:
A chat. Generate a step-by-step plan to answer the following question using the tools provided. Assign an evidence variable to each step.

Tools Available:
NetSearch[input]: Searches the internet for websites containing information related to the input.
SiteScraper[input]: Scrapes the website at the provided URL and returns its text content.
LinkCollector[input]: Collects all URLs contained within the provided text.
InfoAssistant[input]: Answers questions using the context provided in the input.

Output Format:
Plan: [first action]
$Evidence1 = [tool with input]
Plan: [next action]
$Evidence2 = [next tool with input]
...
Final Answer: $EvidenceN

Question: What are some famous paintings by Vincent van Gogh?


Instruction:
A chat. Generate a step-by-step plan to solve the following problem using the provided tools. Each step should have a corresponding evidence variable (#E[index]), which will be the output of a specific function given an input string (which could be the user's question, previous evidence variables, or a mix).

Available tools:
Bing[input]: Allows users to search for information on the internet via Bing. Useful for locating sites potentially containing the answer.
Readability[input]: Takes a URL as input and returns a simplified version of the webpage’s text.
LinkCollector[input]: From a block of text, extracts URLs and provides them as newline-separated output.
FactoidQA[input]: Answers factual questions based on an input passage of text. The input should be a text question referencing a #E[n] variable, like “What is the tallest mountain, given #E1?”

Ensure only one evidence output per plan step.

Output format:
Plan: [First action based on input question]
#E1 = [Function to call with input]
Plan: [Next action, based on #E1]
#E2 = [Next function to call with input, possibly referencing prior evidence]
…
Final Answer: #E[n]

Question: Where was Nikola Tesla born and what notable inventions did he make?


Instruction:
A chat. Create a comprehensive plan to solve the user query using the provided tools. For each step in the plan, assign an evidence value corresponding to the output of the called function.

Available Tools:
DuckDuckGo[input]: Allows users to conduct a web search using DuckDuckGo search engine. Useful for generating a list of potential sources containing answers.
PageLoader[input]: Loads one or more webpages from an input string containing newline separated URLs and returns plain text output containing the webpage contents.
URLGrabber[input]: Extracts URLs from a block of plain text and outputs them as a newline-separated list.
AskAI[input]: An AI-powered tool capable of answering questions based on a supplied context. The input should be a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Initial action based on the input question]
:evidence0: = [Function to call with its input]
Plan: [Subsequent action depending on the outcome of :evidence0:]
:evidence1: = [Next function to call with its input, possibly referencing earlier evidence]
...
Final Answer: [:evidence[n]: Containing the ultimate solution]

Question: Who invented the telephone and what were the key developments leading to its invention?


Instruction:
A chat. Please develop a step-by-step plan to answer the following user 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 the user's question, previous evidence values, or both.

Here are the tools you have at your disposal:

Bing[input]: A tool that allows users to search for information via Bing's search engine. This tool is useful for finding a list of sites that may contain the answer to the user's query. The function doesn't directly provide answers; it finds a list of websites that might contain the necessary information.
WebReader[input]: Load one or more websites from the input string containing newline delimited links. The input should consist of one or more links and produces plain text output containing the content of these 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 in providing answers 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 dog, 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., SAM[What is the capital of France, given :data2:?]

Ensure only one evidence output per plan step.

The output format should be as follows:
Plan: [first action to take based on 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 was the architect behind the design of the Sydney Opera House and what were some of his other notable works?


Instruction:
A chat. Create a plan to find out: "Who composed the music for the movie 'Inception' and list some other movies they have worked on."

Available tools:
IMDbLookup[input]: Tool that retrieves data about films, including cast, crew, and trivia.
ComposerFilmography[input]: Tool that lists all the movies a certain composer has worked on.
QA[input]: Tool that answers questions using general world knowledge.

Output format:
Plan: initial action
:Evidence0: = function with input
Plan: subsequent action, referencing :Evidence0:
:Evidence1: = next function with input (can refer to prior evidence)
...
Answer: [:Evidence[n]: containing final answer.]


Instruction:
A chat. Create a plan to answer the following question using the tools provided. Each step of your plan should be followed by an evidence variable, which will contain the output from one of the available functions given an input string that can either be the user's question, previous evidence values or both.

The tools you have at your disposal are as follows:
1. Bing[input]: This tool allows users to search for information on the internet using the Bing search engine. It provides a list of websites that may contain the answer to the user's query.
2. TextParser[input]: This function takes in text and extracts key pieces of information such as names, dates, locations etc.
3. URLReader[input]: This tool loads the content of a website from a given URL and produces plain text output.
4. QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a question referencing an :evidence[n]: variable.

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

Question: What is the history behind the creation of Microsoft Corporation?


Instruction:
A chat. Create a detailed execution plan to respond to the following user query using the tools provided. Every plan should be associated with an evidence value generated by one of the tools provided as per the input string which could be the user query itself, any prior evidence value or a combination of both.

Available Tools:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to find potential answers to the user's query.
LinkHarvester[input]: A tool that extracts all URLs from a given piece of text.
PageReader[input]: A tool that fetches the contents of a webpage given its URL.
NLPModel[input]: A natural language processing model that can answer questions based on an input text. The input should be a question referencing a #info[n] variable, like "What is the population of Tokyo, given #info1?"

Output Format:
Plan: [First step based on the user query]
#info0 = [Tool to use with input parameters]
Plan: [Next step based on the outcome of #info0]
#info1 = [Next tool to use with input parameters possibly including reference to previous info like "#info0"]
...
Final Answer: [#info[n] that contains the final answer]

Question: When was the Eiffel Tower built and what materials were used in its construction?


Instruction:
A chat. Please generate a step-by-step plan to answer the user's question using the available tools. Each tool should be used at least once and each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information on the internet. This tool is useful in finding websites that may contain the answer to the user's question.
WebsiteScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an #E[n] variable, e.g. What color is the cat, given #E1?

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

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


Instruction:
A chat. Generate a step-by-step plan to answer the user query using the following tools. Each tool can be called with an input string and will return an output that can be stored in a variable :evidence[n]: for future reference.

The available tools are:
Bing[input]: This function allows you to search for information on Bing, which may include websites, articles, images, etc.
TextAnalyzer[input]: This tool extracts key points from a large amount of text.
LinkCollector[input]: Extracts all links from a given piece of text.
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.
QAEngine[input]: A question answering tool that can provide answers based on general knowledge or specific context provided in the form of previous evidence variables.

Output should follow this format:
Plan: [first action]
:evidence0: = [function call with input]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with input, possibly referencing :evidence0:]
...
Answer: [:evidence[n]: containing final answer]

Question: What's the history behind the creation of Bitcoin and who was involved?


Instruction:
A chat. Create a plan to answer the following question using these available tools. For each step, indicate which tool you will use and what input you will provide it with. You can store the results of each tool in a variable :evidence[n]: that can be used as input for subsequent steps.

Here are the tools available to be called:
Bing[input]: A search engine tool that provides a list of websites related to the input query.
TextExtractor[input]: Extracts plain text from one or more websites provided as newline delimited links.
LinkCollector[input]: Collects all links present in the given plain text.
AskJeeves[input]: A language model tool capable of answering questions based on an input passage of text. The input must be a question that references an :evidence[n]: variable.

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

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


Instruction:
A chat. Create a step-by-step plan to solve the user's query using the following tools. Each tool will provide an evidence value which can be used in subsequent steps.

Available Tools:
1. WikiSearch[input]: This tool allows you to search for information on Wikipedia. The input should be a string that would help find the appropriate page.
2. QAEngine[input]: A question answering tool that uses common sense and general world knowledge, as well as context from previous evidences to answer questions.
3. GoogleMaps[input]: Tool that provides geographical information about places around the world.
4. WeatherAPI[input]: Provides current weather conditions of a given location.

The output format should be:
Plan: [First action based on the input]
#E1 = [Function call with input parameter]
Plan: [Next action based on result of #E1]
#E2 = [Next function call with input parameter referencing previous evidence if necessary]
...
Final Answer: #E[n]

Question: What is the historical significance of London Bridge and what is the current weather there?


Instruction:
A chat. Create a comprehensive plan to respond to the user query, making use of the provided tools. For every plan, there should be corresponding evidence which would be the output of a function taking an input string that could be the user query, previous evidence values, or both.

Available tools:
DuckDuckGo[input]: Tool allowing users to search for information via DuckDuckGo search engine. It helps in locating potential sites having answers to the user's query. The function does not directly answer but locates possible sources.
TextParser[input]: Parses one or more websites from the input string comprising newline separated links. Input includes one or more links, and the output contains the textual content of these links.
URLExtractor[input]: Pulls out URLs from plain text and gives a plain text, newline-separated list of URLs.
BrainyQA[input]: Language model for answering queries based on a text passage. The input has to be a question referencing an :evidence[n]: variable, like What is the dog's breed, given :evidence1:?

Inputs to functions should be simple strings, devoid of quotes or "+" for concatenating a string with an evidence variable, like BrainyQA[What is New York's population, given :evidence3:?]

Remember to include only one evidence output per plan step.

Output format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action, based on :evidence0:'s outcome]
:evidence1: = [Next function to call and its input parameter, possibly referring to prior evidence, like "Considering context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

Question: What are some notable works of J.K. Rowling besides Harry Potter and how were they received?


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

Here are the tools available to be called:
GoogleSearch[input]: Tool that allows the user to search for information using Google. This tool is useful in finding websites 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.
KnowledgeBaseQA[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

Question: Who won the 2018 FIFA World Cup and who was their top scorer?


Instruction:
A chat. Please provide a detailed plan to generate an answer for the user's question using the following tools. Each step of your plan should have corresponding evidence, which will be the output of one of the available functions given an input string that can be the user's query, previous evidence values, or both.

Here are the tools available to use:
SearchEngine[input]: A tool that allows you to search for information on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a webpage link provided as input and produces a plain text output containing the content of the page.
LinkLister[input]: Extracts links from plain text and produces a plain text response of links.
InfoBot[input]: A question answering model that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What is the capital of France, given #E1?

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

Remember to include only one evidence output per plan step.

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

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


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:
GoogleSearch[input]: Allows the user to search for information using Google.
TextParser[input]: Parses a large body of text into smaller, more manageable chunks.
LinkCollector[input]: Collects all URLs from a given piece of text.
InfoFinder[input]: A tool that answers questions when provided with a specific piece of text as context.

Output 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 did Apple Inc. become successful and what were some major obstacles they faced?


Instruction:
A chat. Develop a plan to answer the following question using the available tools. For each step in your plan, provide an evidence variable that will store the output of the tool you use.

Here are the tools at your disposal:

1. SearchEngine[input]: This tool allows you to search for information on the internet. The input should be a string containing the query.
2. TextAnalyzer[input]: Analyzes text and extracts key points from it. It can be used with the context provided by previous steps as input.
3. KnowledgeBase[input]: A tool that answers questions based on a large database of general knowledge. The input must be a question.
4. WebScraper[input]: Extracts text content from websites given their URLs. The input is one or more URLs separated by newlines.
5. LinkFinder[input]: Finds relevant links within a piece of text. The input is any text that may contain URLs.

Your response should follow this format:
Plan: [describe the first action]
#E1 = [tool to use with its input]
Plan: [describe the next action based on #E1's result]
#E2 = [next tool to use with its input, which could include reference to #E1]
...
Final Answer: #En

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


Instruction:
A chat. Create a step-by-step execution plan to respond to the following user query, utilizing the available tools. Each step should produce an evidence value which corresponds to the output of a tool function given an appropriate input string. This input could be the original user query, a prior evidence value, or a combination of these.

Available Tools:
BingSearch[input]: A tool allowing users to find information via Bing's search engine.
PageReader[input]: Loads one or more webpages specified by newline separated URLs in the input string, returning plain text content from those pages.
URLCollector[input]: Gathers URLs from provided plain text, producing a newline-separated list of URLs.
KnowledgeBase[input]: A tool for retrieving factual information from a large database of common knowledge.
InferenceEngine[input]: A tool capable of answering questions based on provided textual context. Input should be a question referencing an :evidenceN: variable, such as 'What is the main ingredient in :evidence3:?'

Output Format:
Plan: [First action based on user query]
:evidence0: = [Tool function call with relevant input]
Plan: [Subsequent action, considering outcome of :evidence0:]
:evidence1: = [Next tool function call, potentially referencing earlier evidence]
...
Answer: [:evidenceN:, containing final response.]

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


Instruction:
A chat. Construct a plan to find out the height of Mount Everest and compare it to the height of K2.

Tools available:
MountainHeight[input]: Tool that provides the height of a specified mountain.
CompareNumbers[input]: Tool that compares two numbers and provides a comparison statement.
QA[input]: Tool that answers questions using general world knowledge.

Output format:
Plan: First action to take based on input question
#E1 = Function to call with input parameter
Plan: Next action to take, based on result of #E1
#E2 = Next function to call and input parameter, referencing previous evidence if necessary
...
Final Answer: #E[n]


Instruction:
A chat. Develop a plan to find out when the Eiffel Tower was built and who designed it.

Available tools:
HistoricalEvents[input]: Provides information about historical events.
ArchitectInfo[input]: Provides information about architects and their works.
QA[input]: Can answer questions using common sense or given context.
LandmarkFacts[input]: Provides facts about famous landmarks.
Wikipedia[input]: Allows searching for information from Wikipedia.

Output format:
Plan: First action
#E1 = function with input parameter
Plan: Next action based on #E1
#E2 = next function with input parameter referencing previous evidence if necessary
...
Final Answer: #E[n]


Instruction:
A chat. Create a step-by-step plan to respond to the user's query using the following tools. Every plan should correspond to an evidence value.

Available tools:

1. DuckDuckGo[input]: Allows users to search for information using the DuckDuckGo search engine.
2. TextExtractor[input]: Extracts plain text from a list of newline-separated links.
3. LinkParser[input]: Parses plain text to extract newline-separated links.
4. AnswerBot[input]: Can answer questions using general knowledge or context from previously generated evidence.

Output format:
Plan: [First action]
#E1 = [Function with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next function with input parameter, which may refer to previous evidence]
...
Final answer: #E[n]

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


Instruction:
A chat. Develop a detailed plan to address the user's query utilizing the tools at your disposal. For each step, provide the corresponding evidence value.

Tools Available:
WikiLookup[input]: Searches Wikipedia for information related to the input string.
QAEngine[input]: Answers questions based on common knowledge or given context. The input must be a question that references a #E[index] variable.
GoogleMaps[input]: Provides geographical data related to the input location.
WeatherAPI[input]: Gives current weather conditions for the input location.

Output Format:
Plan: [Initial action]
#E1 = [Tool with input parameters]
Plan: [Subsequent action, based on outcome of #E1]
#E2 = [Next tool with input parameters, possibly referencing prior evidence]
...
Final Answer: #E[n]

Question: What is the population of the capital city of France and what is its current weather condition?


Instruction:
A chat. Design a step-by-step plan to answer the following user query using the tools provided. Each tool can be invoked with an input string and provides an output that can be stored in a variable #E[index]. Subsequent tools can reference these variables.

Here are the tools available:
DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to find potential sources of information.
URLPicker[input]: This tool extracts URLs from a block of text and returns them as a newline-separated list.
SiteLoader[input]: This tool loads the content of one or more websites specified by newline-separated URLs.
InfoExtractor[input]: A question-answering tool that generates answers based on a given context. The input should be a question that refers to a #E[index] variable.

The output should follow this format:
Plan: [First action]
#E1 = [Function to call with input]
Plan: [Next action based on #E1]
#E2 = [Next function to call with input, possibly referring to #E1]
...
Final Answer: #E[n]

Question: Who was the first woman to win a Nobel Prize and what did she discover?


Instruction:
A chat. Develop a plan to determine the life cycle of a butterfly.

Tools at your disposal:
Encyclopedia[input]: Searches for detailed information about the input topic.
IllustrationLocator[input]: Locates illustrations related to the input.
LifecycleDescriber[input]: Describes the lifecycle of an organism based on the input context.
KnowledgeBaseQA[input]: Answers questions using a vast database of knowledge.
DataCompiler[input]: Compiles data into a comprehensive report.

Output format:
Plan: Starting action
#Fact1 = Function with input parameter
Plan: Following action
#Fact2 = Next function with input parameter
...
Final Conclusion: #Fact[n]


Instruction:
A chat. Construct a detailed plan to tackle the user inquiry employing the given tools. Each stage should align with an evidence value, which is the output of one of the accessible functions given an input string that might be the user question, earlier evidence values, or a blend of both.

Available tools are:
NetSearch[input]: Enables the user to search for information using a generic internet search engine. It helps in locating a variety of sites that may hold the answer to the user's query.
TextScrape[input]: Loads one or several websites from the input string holding newline separated links, where input comprises one or multiple links, and yields plain text including the content of the links.
URLExtractor[input]: Extracts URLs from plain text and delivers a plain text, newline separated response of URLs.
QuerySolver[input]: A question-answering language model, handy for answering queries based on an input text passage. The input needs to be a text question referring to an :evidence[n]: variable, e.g., What is the population of Tokyo, given :evidence1:?

The output should adhere to this structure:
Plan: [initial action to undertake based on input question]
:evidence0: = [function to invoke with input parameter]
Plan: [subsequent action to undertake, hinged on the outcome of :evidence0:]
:evidence1: = [following function to invoke and input parameter, which may allude to preceding evidence, e.g., "Considering context :evidence0"]
...
Answer: [:evidence[n]: carrying the ultimate answer.]

Question: What are the causes and effects of climate change according to recent studies?


Instruction:
A chat. Generate a step-by-step plan to solve the user's problem using the following tools. Each plan should produce an evidence value, which will be the output of a specific function given an input string.

Tools available:
YahooSearch[input]: Allows users to search for information through Yahoo. It helps in identifying a list of sites that could contain the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline separated links. The input is one or more links, and the output includes the content of those links.
HyperlinkCollector[input]: Collects hyperlinks from plain text and gives a plain text, newline separated list of links.
QuerySolver[input]: A language model used to answer questions based on an input text passage. The input must be a text question that refers to a $Evidence[n]$ variable, e.g., 'What is the capital of Italy, given $Evidence1$?'

Output format:
Plan: [Initial action]
$Evidence0$ = [Function call with input parameter]
Plan: [Next action, based on result of $Evidence0$]
$Evidence1$ = [Next function call with input parameter, which may reference previous evidence, e.g., "Given context $Evidence0$"]
...
Final Answer: $Evidence[n]$

Question: What is the history behind the Eiffel Tower and how tall is it?


Instruction:
A chat. Create a sequential plan to address the following question using the tools provided. Ensure each step has an associated evidence value.

Available Tools:
GoogleScholar[input]: Searches academic papers and scholarly articles related to the input query.
ArticleReader[input]: Reads and summarizes the content of academic articles.
DataAnalyzer[input]: Analyzes data sets and extracts meaningful insights.
QASystem[input]: Provides answers to questions based on the context provided in the input.

Output Format:
Plan: [First action based on the input question]
:Evidence1: = [Function to call with appropriate input]
Plan: [Subsequent action based on the outcome of :Evidence1:]
:Evidence2: = [Next function to call with appropriate input, referencing previous evidence if necessary]
...
Answer: [:EvidenceN:]

Question: What are the recent advancements in quantum computing?


Instruction:
A chat. Generate a plan to solve the following problem using the available tools. For each step, provide an evidence value corresponding to the output of a specific function, given an input string that could be the user's query, previous evidence values, or a combination of both.

Available tools include:
DuckDuckGo[input]: Allows users to conduct searches via DuckDuckGo. Useful for identifying potential sources of answers.
SiteReader[input]: Takes one or more website URLs (newline separated) from the input string and outputs plain text content from these sites.
URLExtractor[input]: Pulls out URLs from a block of plain text, providing a newline-separated list of links.
InfoProcessor[input]: A question-answering language model that uses an input text passage to answer queries. The input should be a textual question that refers to a #E[n] variable, such as "What's the population of Rome, given #E1?"

Your output should follow this structure:
Plan: [initial action]
#E0 = [function call with input parameters]
Plan: [subsequent action based on #E0's outcome]
#E1 = [following function call and input parameters, possibly referring back to prior evidence like "Given context #E0"]
...
Final Answer: [#En containing the ultimate solution]

Question: What is the history behind the creation of the Eiffel Tower and who were the key people involved?


Instruction:
A chat. Formulate a systematic plan to respond to the user query making use of the set of available tools. Each plan will correspond to an evidence value which will be the output of one of the available functions given an input string that could be the user question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that enables the user to search for information using DuckDuckGo search engine. It finds a list of sites that might contain the answer to the user's question.
WebCrawler[input]: Loads one or more websites from the input string containing newline separated links, where input is one or more links, and generates plain text output containing the content of the links.
URLPicker[input]: Picks out links from plain text and generates a plain text, newline separated response of links.
SAM[input]: Question answering language model, particularly helpful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the dog, given :evidence1:?

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

Ensure to include only one evidence output per plan step.

The output should be in format:
Plan: [first action to take based on input question]
: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 Albert Einstein and when did he receive the Nobel Prize in Physics?


Instruction:
A chat. Construct a systematic approach to answer the user query utilizing the below mentioned tools. Each step in the plan should correspond to an evidence value which will be the output of the invoked function. The function's input could be either the user query, prior evidence values, or a combination of both.

Tools at disposal:
YahooSearch[input]: This tool lets the user perform a search operation via Yahoo's search engine. It provides a list of potential sources that might contain the answer to the user's query.
PageScraper[input]: This tool fetches the content of one or more webpages whose URLs are supplied as the input.
HyperlinkExtractor[input]: This tool extracts hyperlinks from a given chunk of text.
JARVIS[input]: An AI-based language model adept at answering queries given a context. The input should be a question that refers to an :evidence[n]: variable, such as 'What is the capital of country Y, given :evidence1:?'.

Output Format:
Plan: [Initial step based on the user query]
:evidence0: = [Function invocation with suitable input]
Plan: [Following step(s), depending upon the outcome of :evidence0:]
:evidence1: = [Next function invocation with suitable input, potentially referring to prior evidence]
...
Answer: [:evidence[n]: encapsulating the final answer.]

Question: Who is the author of the book '1984' and what are his other notable works?


Instruction:
A chat. Develop a systematic plan to respond to the following query using the provided tools. For each plan, indicate the associated evidence value which will be the outcome of one of the accessible functions considering an input string that could be the user's question, prior evidence values, or both.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that lets you search for data using the DuckDuckGo search engine. It aids in locating pertinent sites that might hold the answer to your inquiry.
SiteLoader[input]: Loads one or more websites from the input string consisting of newline separated links, where input comprises one or more links, and yields plain text output encompassing the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and generates a plain text, newline-separated list of links.
ELM[input]: An AI-powered question-answering model that excels at answering queries based on a supplied text passage. The input has to be a textual question referencing an :evidence[n]: variable, such as What is the height of the Eiffel Tower, given :evidence1:?

The output should follow this format:
Plan: [initial action to undertake based on the input question]
:evidence0: = [function to invoke with input parameter]
Plan: [subsequent action to undertake, depending on the outcome of :evidence0:]
:evidence1: = [next function to invoke and input parameter, which may refer to earlier evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the ultimate answer.]

Question: Who invented the World Wide Web and what were the primary reasons behind its creation?


Instruction:
A chat. Create a plan to answer the following question: "What is the history of the Eiffel Tower and how was it constructed?" Use the available tools as necessary.

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 can find relevant websites that may contain the answer to the user's query.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KnowledgeEngine[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

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


Instruction:
A chat. Create a sequential plan to respond to the user instruction, utilizing the available tools. Each 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, one or more previous evidence values, or a mix of both.

Available tools to be used:
DuckDuckGo[input]: A tool that enables the user to search for information using the DuckDuckGo search engine. It helps in locating a suitable list of sites that might contain the answer to the user's query.
WebScraper[input]: Loads one or more websites from the input string containing newline separated links, where input is one or more links, and generates plain text output containing the link contents.
URLCollector[input]: Gathers links from plain text and produces a plain text, newline separated response of links.
QAModel[input]: Question answering language model, especially useful in answering questions based on an input text passage. The input must be a text question that refers to an :evidence[n]: variable, e.g., What is the dog's breed, given :evidence1:?

The input to each function should simply be a plain string, without quotation marks or "+" to join a string with an evidence variable, e.g., QAModel[What is the tallest building in the world, given :evidence3:?]

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

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

Question: What is the population of Tokyo and how has it changed over the past decade?


Instruction:
A chat. Please generate a plan to solve the following problem using the tools at your disposal. For each step of the plan, indicate the corresponding evidence value, which would be the output of one of the available functions given an input string.

Here are the tools you can use:
WebCrawler[input]: Tool that searches the internet for information. It provides a list of sites that might contain the answer but does not provide direct answers.
DataMiner[input]: Extracts text from one or multiple websites from the input string containing newline separated links.
LinkHarvester[input]: Finds links within plain text and outputs them as a newline-separated list.
InfoAI[input]: Language model designed to answer questions based on a given text. The input must be a question referencing an :info[n]: variable.

The output should look like this:
Plan: [first action based on input question]
:info0: = [function to call with input parameter]
Plan: [next action, 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"]
...
Final Answer: [:info[n]: containing the final answer.]

Question: When was the Eiffel Tower built and who were the architects involved?


Instruction:
A chat. Develop a plan to answer: "How does the stock market work and how can I get started investing?"

Tools available:
FinancialBasics[input]: Provides basic financial concepts and explanations.
InvestmentGuide[input]: Offers guidance on investment strategies and getting started.
StockMarketOverview[input]: Gives an overview of how the stock market works.
QA[input]: Answers questions based on common sense and general world knowledge.
WebSearch[input]: Searches the web for relevant information.

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. Formulate a plan to discover when the Great Wall of China was built and who ordered its construction.

Tools available:
HistoricalEventInfo[input]: Tool that provides information about a specific historical event or landmark.
EntityExtractor[input]: Tool that extracts key entities from a text passage.
TimelineGenerator[input]: Tool that generates a timeline of events related to a specific entity or topic.
QA[input]: Tool that answers questions using general world knowledge.

Output format:
Plan: First action to take based on input question
#E1 = Function to call with input parameter
Plan: Next action to take, based on result of #E1
#E2 = Next function to call and input parameter, referencing previous evidence if necessary
...
Final Answer: #E[n]


Instruction:
A chat. Create a step-by-step plan to solve the following problem using the available tools. Each tool should be used with an input parameter that can either be a user question, one or more previous evidence values, or a combination of both.

Here are the tools you can use:
1. Bing[input]: A search engine tool that allows users to find information online. This tool is useful for finding a list of websites that may contain answers to the user's questions.
2. SiteReader[input]: A tool that loads and reads the content from the website links provided in the input string.
3. LinkLister[input]: A tool that extracts links from plain text and produces a plain text response containing these links.
4. QAModel[input]: A language model tool designed to answer questions based on an input passage of text. The input must be a text question referencing a #E[n] variable.

Each step in your plan should have a corresponding evidence value which will be the output of one of the functions given an input string.

The output format should be as follows:
Plan: [First action]
#E1 = [Function call with input parameter]
Plan: [Next action based on result of #E1]
#E2 = [Next function call with input parameter, possibly referring to previous evidence]
...
Final Answer: #E[n]

Question: Who is the author of the book "War and Peace" and what other books has he written?


Instruction:
A chat. Formulate a plan to discover when the Eiffel Tower was constructed. You can use these tools:
- HistoricalEventsDatabase[input]: Searches for historical events.
- WebSearchEngine[input]: Searches the web for information.
- DateExtractor[input]: Extracts dates from text.
- LandmarkInfo[input]: Provides information about landmarks.
- GeneralKnowledgeQA[input]: Answers questions based on general knowledge or context.

Please provide output in this format:
Plan: [first action]
#E1 = [function call with input]
Plan: [next action]
#E2 = [next function call and input, perhaps citing previous evidence]
...
Final Answer: #E[n]


Instruction:
A chat. Create a step-by-step plan to answer the following question using the tools provided. Each tool should be used at least once and each plan must have a corresponding evidence value, which will be the output of one of the available functions given an input string 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]: A tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
NLPModel[input]: Natural Language Processing model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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


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

Available Tools:
WebSearch[input]: This tool allows you to search for information on the web. The input is a string and it returns a list of websites that may contain the answer.
TextExtractor[input]: Extracts plain text from one or more websites provided as newline delimited links.
LinkParser[input]: Parses plain text and produces a list of links.
QAModel[input]: A question answering model that answers questions based on given context. The input should be a question referencing an :evidence[n]: variable, e.g., "What color is the cat, given :evidence1:?"

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

Question: What are some notable works by the author who wrote 'Pride and Prejudice'?


Instruction:
A chat. Generate a step-by-step plan to find out the population of New York City in 1920 and how it compares to its current population.

Here are the tools available to be called:
HistoricalData[input]: Tool that allows the user to search for historical data about cities, countries, etc.
CurrentPopulation[input]: Tool that provides the current population of a given city or country.
CompareNumbers[input]: Tool that compares two numbers and gives an output as to which is larger/smaller and by what percentage.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge.

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. Formulate a comprehensive plan to resolve the user request using the provided tools. Each phase should match with an evidence value, which is the return of one of the usable functions given an input string that can be the user question, earlier evidence values, or a combination of both.

You can use these tools:
InfoSeek[input]: Allows the user to search for information from a broad database of resources. Useful for gathering diverse information.
DataHarvester[input]: Loads one or multiple websites from the input string featuring newline separated links, where input includes one or more links, and gives plain text output containing the content of the links.
LinkRetriever[input]: Retrieves links from plain text and produces a plain text, newline separated response of links.
QueryHandler[input]: A question-answering language model, effective for handling queries based on an input text passage. The input must be a text question indicating an :evidence[n]: variable, e.g., What is the height of Mount Everest, given :evidence1:?

The output should follow this layout:
Plan: [initial action to perform based on input question]
:evidence0: = [function to apply with input parameter]
Plan: [subsequent action to perform, based on the effect of :evidence0:]
:evidence1: = [next function to apply and input parameter, which may suggest previous evidence, e.g., "Bearing in mind context :evidence0"]
...
Answer: [:evidence[n]: containing the conclusive answer.]

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


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

Here are the tools you can use:
Bing[input]: A tool that enables users to search for information using Bing search engine. This tool is handy in finding a list of sites that may contain the answer to the user's question. The function doesn't directly provide the answer; it finds a list of sites that might have the solution.
TextExtractor[input]: Extracts plain text from websites provided in the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkGrabber[input]: Extracts links from plain text and provides a plain text, newline delimited response of links.
NLP[input]: Natural Language Processing model useful in 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 dog, given :data1:?

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

Remember to include only one evidence output per plan step.

The output format should be:
Plan: [first action to take based on 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 '1984' and what other notable works have they written?


Instruction:
A chat. Generate a detailed plan to solve the following query using the described tools. Each step should involve executing a command with one of the tools and storing the result in an Evidence variable (#E[index]).

Tools Available:
NetSearch[input]: Executes a broad internet search based on the input string.
URLExtractor[input]: Pulls all URLs from a block of text.
PageParser[input]: Retrieves the full text of a webpage given its URL.
AIQA[input]: Uses AI to answer questions based on a provided context.

Format your plan as follows:
Plan: [description of first step]
#E1 = [execution command for one of the tools]
Plan: [description of next step]
#E2 = [execution command for one of the tools, potentially referencing #E1]
...
Answer: [#E[n], which contains the final answer]

Question: How did Apple Inc. get its name and who were its founders?


Instruction:
A chat. Create a step-by-step plan to solve the user's query, making use of 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 its input string.

Here are the tools you can call upon:
1. Bing[input]: A tool that lets users search for information using the Bing search engine. It is useful for finding sites that may contain answers to the user's question.
2. WebReader[input]: This function loads websites from the input string containing newline delimited links and produces plain text output containing the content of those links.
3. LinkPicker[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
4. SAM[input]: Question answering language model. The input must be a text question that references a :data[n]: variable, e.g., What color is the dog, 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., SAM[What is the capital of France, given :data2:?]

Each plan should only include one evidence output.

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

Question: Who is the current president of Microsoft and what are their major achievements?


Instruction:
A chat. Create a detailed execution plan to respond to the following query, using the tools provided. For each plan, specify the tool you would use along with its input to gather evidence. Store the gathered evidence into a variable #E[index] that can be referenced later.

Tools available:
GoogleScholar[input]: A tool that searches Google Scholar for academic papers and articles related to the input query.
AbstractReader[input]: Reads the abstracts of academic papers and generates a summary.
LinkCollector[input]: Collects all the links present in the input text.
QAModel[input]: A question-answering tool that uses machine learning to provide answers based on the context provided.

Output Format:
Plan: [First action]
#E1 = [Tool to use with input]
Plan: [Next action based on #E1]
#E2 = [Next tool to use with input, possibly referencing #E1]
...
Final Answer: #E[n]

Question: How does climate change affect biodiversity?


Instruction:
A chat. Develop a systematic plan to respond to the following user query utilizing the listed tools. Each plan should result in an evidence value, derived from the output of a function call.

Tools Available:
NetSearch[input]: Executes an internet search based on the input query.
DocParser[input]: Parses documents or webpages and extracts key points.
QueryMaster[input]: Answers questions based on a mix of general knowledge and specific context provided as input.
URLHarvester[input]: Gathers all URLs from a specified text.

Output Format:
Strategy: [Initial action]
#Fact1 = [Function invocation with input]
Strategy: [Subsequent action based on #Fact1]
#Fact2 = [Next function invocation with input, potentially referring to #Fact1]
...
Solution: [#FactN containing the ultimate answer.]

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


Instruction:
A chat. Create a plan to solve the following problem using the available tools. Each plan should correspond to an evidence value, which will be the output of one of the available functions.

Available Tools:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to retrieve information related to the input query.
SiteReader[input]: Loads one or more websites provided as newline-delimited links in the input string and returns the textual content of these sites.
LinkSelector[input]: Extracts links from a block of plain text and returns them as a newline-separated list.
KnowledgeModel[input]: Language model designed to answer questions based on a provided context. It requires a question referencing an :evidence[n]: variable.

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

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


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

Here are the tools you can use:
SearchEngine[input]: This tool allows the user to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
TextScraper[input]: This tool 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]: This tool extracts links from plain text and produces a plain text, newline delimited response of links.
AIAnswerer[input]: This is a question answering AI model, useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

Question: What is the history behind the creation of Bitcoin and who was involved?


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

Here are the tools you can use:
Bing[input]: A tool that allows users to search for information using Bing search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
TextParser[input]: Extracts key details from plain text and produces a structured response containing the extracted details.
LinkCollector[input]: Collects links from plain text and generates a list of links.
WebReader[input]: Loads one or more websites from the input string (containing newline delimited links) and produces plain text output with the content of these links.
AskMe[input]: Question answering language model that answers questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

Ensure only one evidence output per plan step.

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

Question: What is the history behind the Eiffel Tower and who designed it?