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

Here are the tools available to be called:
GoogleScholar[input]: Tool that allows the user to search for academic articles and papers. This tool is particularly useful in gaining knowledge about scientific studies, historical research, and other types of scholarly information.
PubMed[input]: Tool that allows the user to search for biomedical literature. This tool is especially useful when looking for medical and health-related information.
QAExpert[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: What are the latest advancements in cancer treatment?


Instruction:
A chat. Create a systematic plan to solve the following problem, utilizing the provided tools. For each step, specify the tool to be used along with its input. You can store the output into a variable #E[index] that can be referenced later.

Available Tools:
WikiLookup[input]: A tool that retrieves information from Wikipedia. Input should be a keyword or phrase related to the desired information.
DataExtractor[input]: Extracts specific data points from a larger body of text.
QueryMaster[input]: Can answer questions based on previously gathered evidence.

Output Format:
Plan: [action based on input question]
#E1 = [tool with input]
Plan: [next action based on #E1]
#E2 = [next tool with input, referencing #E1 if necessary]
...
Final Answer: #E[n]

Question: Who was involved in the signing of the Treaty of Versailles and what were their roles?


Instruction:
A chat. Develop a step-by-step plan to respond to the following query using the tools provided. Each tool should be used at least once and each plan must correspond to an evidence value, which will be the output of one of the available functions given an input string.

Here are the tools available to be called:
YahooSearch[input]: Allows the user to search for information using the Yahoo search engine.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, producing 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.
AIQA[input]: Artificial Intelligence Question Answering tool, useful in answering questions based on an input passage of text.

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

Question: What is the capital city of Bhutan and what notable landmarks does it contain?


Instruction:
A chat. Create a step-by-step plan to answer the following question using the available tools. Each tool can be used with an input parameter, and its output will be stored in a variable :evidence[n]: for further use.

Here are the tools you can call:
WebSearch[input]: This tool allows you to search the web for information related to the input string.
TextAnalyzer[input]: Analyzes text from the given context and answers questions based on it.
ImageFinder[input]: Finds images related to the input string.
ImageAnalyzer[input]: Analyzes an image and provides descriptive information about it.
QA[input]: A tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Each plan should have exactly one evidence (:evidence[n]:) value.

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

Question: What is the significance of the painting 'Starry Night' by Vincent Van Gogh?


Instruction:
A chat. Create 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 mixture of both.

Here are the tools available to be called:
GoogleMaps[input]: Tool that allows the user to search for geographical information and location-based data.
WikiSearch[input]: A tool that searches Wikipedia for relevant articles based on the input query.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
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.
AIQA[input]: An artificial intelligence tool that answers 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 in input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context #E1"]
...
Final answer: #E[n]

Question: What is the population density of the capital city of Japan?


Instruction:
A chat. Develop a step-by-step execution plan to respond to the user query utilizing the provided tools. Each plan should include an evidence variable, representing the output of a function call.

Available tools:
IMDb[input]: A tool for retrieving movie-related information.
RottenTomatoes[input]: A tool for obtaining movie ratings and reviews.
BoxOfficeMojo[input]: A tool for getting box office data about movies.
Twitter[input]: A tool for searching tweets related to a particular topic.
AskAI[input]: A question-answering AI model that uses its vast knowledge base to provide answers.

Question: Who directed the movie "Inception", how was it rated on Rotten Tomatoes, how much did it earn at the box office, and what are people saying about it on Twitter?


Instruction:
A chat. Develop a detailed execution plan to solve the following problem, making use of the available tools. For each step in the plan, indicate the tool you would use along with its input to gather evidence. You can store this evidence into a variable #E[index] that can be referenced later.

Here are the tools available to be called:
BingSearch[input]: A tool that lets users search for information via Bing. It helps locate potential sites that might hold answers to the user's query.
SiteReader[input]: Loads one or more websites from an input string (containing newline separated links), producing plain text output with the content of those links.
LinkPicker[input]: Picks out links from plain text, generating a plain text, newline-separated list of links.
InfoAnalyzer[input]: A language model capable of answering questions based on an input text passage. The input should be a question referencing a #E[n] variable, like 'What is the capital of France, given #E1?'

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

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

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


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

Here are the tools you can use:
WebSearch[input]: This tool 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.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response with newline-separated links.
SiteScraper[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and the output is plain text content from these links.
InfoQA[input]: A question-answering tool that answers questions based on general knowledge as well as context from previously gathered evidence.

The output format should be:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action, based on #E1]
#E2 = [next function call with input parameter, possibly referencing #E1]
...
Final Answer: #En

Question: What is the significance of the Battle of Hastings and who were the key figures involved?


Instruction:
A chat. Draft a meticulous scheme to resolve the forthcoming question. Each phase should prescribe a function to trigger with its corresponding input. Preserve the yield of each function in a defined :Result[index]: variable, which can subsequently be invoked in future phases.

On-hand Functions:
BaiduSearch[input]: Runs a Baidu search for the input keyword and procures a compilation of potential leads.
LinkIsolator[input]: Given a chunk of text (like the output of a BaiduSearch), this function spots all URLs housed within the text.
SiteFetcher[input]: Visits the page at the stipulated URL and transcribes its contents into plain text.
Cerebro[input]: An advanced AI-centric question-answering entity adept at furnishing direct solutions to a multitude of queries. It can also devise answers drawing upon background info (e.g., the text from a webpage).

Output Scheme:
Plan: [Sketch of the primary step]
:Result0: = [Primary step function activation]
Plan: [Sketch of the succeeding step]
:Result1: = [Succeeding step function activation]
... Sustain this progression until ...
Final Answer: :ResultN:

Question: Who composed 'Fur Elise' and what other compositions are they celebrated for?


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:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
MLM[input]: Machine learning model for 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 was the architect behind the design of the Eiffel Tower and what other notable structures did they design?


Instruction:
A chat. Create a step-by-step plan to solve the user instruction using 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 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 on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
PageReader[input]: Load a website from the input URL and produces plain text output containing the content of the page.
LinkCollector[input]: Extract links from plain text and produces a list of URLs.
AIAnswerer[input]: AI model capable of answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

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

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


Instruction:
A chat. Question: What is the nutritional value of an apple and how does it compare to a banana?

Here are the tools available to be called:
NutritionData[input]: Provides nutrition facts for a specified food item.
FoodComparer[input]: Compares the nutritional values of two specified food items.
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. Create a step-by-step plan to answer the following question using the available tools. Each plan should have a corresponding evidence value, which will be the output of one of the functions given an input string that can be the user question, previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: A tool that allows you to search for information using the Bing search engine. This tool is useful in finding relevant sites that may contain the answer to your question.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the dog, given :evidence1:?

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

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what were their motivations?


Instruction:
A chat. Create a plan to answer the following question using these available tools. Each step in your plan should correspond with 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 function is useful for finding a list of sites that may contain the answer to the user's query.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links. The 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 provides a plain text, newline separated response of links.
QAModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

Ensure there is only one evidence output per plan step.

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

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


Instruction:
A chat. Construct a step-by-step plan to address the following user query:

Question: What are some popular dishes in Japanese cuisine and how are they typically prepared?

Here are the tools available to be called:
CuisineExplorer[input]: Provides information about various cuisines around the world.
RecipeFinder[input]: Finds recipes based on the input dish name.
IngredientLister[input]: Lists ingredients used in a particular dish.
CookingInstructions[input]: Provides cooking instructions for a specified dish.
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.

Follow the same planning and output format as TSK 2.


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

Here are the tools you have at your disposal:
Bing[input]: This tool allows the user to search for information using Bing search engine. It is useful in finding relevant sites that may contain the answer to the user's query.
TextExtractor[input]: Extracts plain text from a webpage given its URL. The input must be a link and the output will be the content of the page in plain text.
LinkCollector[input]: Collects all links present on a web page. Input is a single URL and output is a list of URLs found on the page.
QAModel[input]: A 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.

The function inputs should be simple strings without quotes or "+" for concatenation. For example: QAModel[What is the capital of France, given :evidence1:?]

Each plan step should only include one evidence output.

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

Question: What is the history behind the construction of the Eiffel Tower and who were the main architects involved?


Instruction:
A chat. Formulate a comprehensive plan to address the following user inquiry, employing the listed tools. Every plan should correlate to an evidence value, which would be the output of one of the accessible functions given an input string. This could be the user's question, prior evidence values, or a blend of both.

Tools available:
YahooSearch[input]: Allows users to seek information through Yahoo Search. It aids in identifying possible sites that may contain responses to the user's question. It does not offer direct answers but compiles a list of sites that might possess the answer.
PageLoader[input]: Takes one or more websites from an input string comprising newline-separated links. The input includes one or more links, and the output provides the plain text content of these links.
URLGatherer[input]: Collects links from plain text and returns a plain text, newline-separated compilation of links.
QuerySolver[input]: An AI-based question-solving model proficient in supplying answers derived from a specified text passage. The input needs to be a text question referencing an :evidence[n]: variable, such as 'Who wrote Pride and Prejudice, given :evidence1:'?

Each function's inputs should be simple strings, devoid of quotation marks or '+' symbols used to concatenate a string with an evidence variable, like QuerySolver[Who directed Titanic, given :evidence3:?].

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

The output should adhere to this format:
Plan: [First action based on the input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Following action based on the result of :evidence0:]
:evidence1: = [Subsequent function to invoke with input parameter, possibly referring to earlier evidence, i.e., 'Given context :evidence0']
...
Final Answer: [:evidence[n]: containing the definitive answer.]

Question: How has climate change affected the Great Barrier Reef over the past decade?


Instruction:
A chat. Concoct a complete game plan to unravel the impending query. Each division should designate a function to kick-start with its allied input. Safeguard the dividend of each function in a labeled :Clue[index]: variable, which can thereafter be summoned in ensuing divisions.

Ready-to-use Functions:
ExciteSearch[input]: Triggers an Excite search for the input idiom and collects an accumulation of plausible sources.
UrlDivider[input]: Supplied a volume of text (like the output from an ExciteSearch), this function locates all URLs ensconced within the text.
PageHarvester[input]: Routes to the page at the specified URL and transposes its contents into plain text.
OmegaThinker[input]: A state-of-the-art AI-oriented question-answering unit skilled at dispensing instant solutions to a diverse range of inquiries. It can also fabricate answers relying on auxiliary specifics (e.g., the text from a webpage).

Output Sketch:
Plan: [Portrayal of the inaugural step]
:Clue0: = [Inaugural step function kick-start]
Plan: [Portrayal of the sequential step]
:Clue1: = [Sequential step function kick-start]
... Persist this chain until ...
Final Answer: :ClueN:

Question: Who discovered penicillin and what other scientific breakthroughs are they hailed for?


Instruction:
A chat. Create a methodical plan to respond to the user request, making use of the provided toolkit. Each plan will associate with an evidence value, which is the product of one of the available functions given an input string that could be the user's question, earlier evidence values, or both.

Tools at disposal:
YahooSearch[input]: A tool enabling the user to seek information through Yahoo Search. This tool assists in identifying appropriate sites that may hold the answer to the user's inquiry.
PageLoader[input]: Fetches one or more websites from the input string containing newline-separated links. The input consists of one or more links, producing plain text output encompassing the content of these links.
URLGatherer[input]: Retrieves links from plain text, generating a plain text, newline-separated response of links.
QAEngine[input]: A question-answering language model, adept at answering inquiries based on an input text passage. The input has to be a text-based question referring to an :evidence[n]: variable.

Output format:
Plan: [Initial action predicated on input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action contingent upon result of :evidence0:]
:evidence1: = [Following function to invoke and input parameter, potentially citing prior evidence, e.g., "In light of :evidence0:"]
...
Ultimate Response: [:evidence[n]: carrying the final answer]

Question: Who invented the telephone and what patents do they hold?


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 combination of both.

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information using a generic search engine. This tool is useful 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.
LinkExtractor[input]: Extract 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 an :evidence[n]: variable.

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

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


Instruction:
A chat. Create a plan to solve the following question using the available tools. For each step of your plan, provide an evidence variable that will be used in subsequent steps or as the final answer.

Here are the tools you can use:
Bing[input]: This tool allows users to search for information using Bing's search engine. It is useful for finding a list of sites that may contain answers to the user's query.
WebReader[input]: Load one or more websites from the input string containing newline delimited links. The 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 provides a plain text, newline separated 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 a :data[n]: variable, e.g., What is the capital of France, given :data1:?

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

Ensure there is only one evidence output per plan step.

The output format should be:
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 include reference to previous data, e.g., "Given context :data0"]
...
Final Answer: [:data[n]: containing the final answer.]

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


Instruction:
A chat. Develop a step-by-step plan to answer the user query using the available tools. Each step in 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 question, one or more previous evidence values, or a combination of both.

Here are the tools you can use:
DuckDuckGo[input]: A tool that allows users to search for information using the DuckDuckGo search engine. This tool is useful for finding a list of sites that may contain the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that might have the answer.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: 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 needs to be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g. QAModel[What is the capital of France, given :evidence3:?]

Ensure only 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 Nobel Prize in Physics in 2020 and what was their contribution?


Instruction:
A chat. Create a step-by-step plan to answer the user's question using the tools provided. Each step should have a corresponding evidence value which is the output of the tool used.

Available Tools:
WikiSearch[input]: Searches Wikipedia for information related to the input string.
PageParser[input]: Parses a webpage and produces plain text content.
URLExtractor[input]: Extracts URLs from plain text.
AnswerBot[input]: Answers questions based on the context provided in the input.

Output Format:
Plan: [first action]
#Evidence0 = [function call with input]
Plan: [next action]
#Evidence1 = [next function call with input]
...
Final Answer: #EvidenceN

Question: What is the main diet of the Blue Whale?


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:
SearchEngine[input]: Tool that allows the user to search for information using a generic 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.
LinkFinder[input]: Extract 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 an :evidence[n]: variable.

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

Question: What are some major accomplishments of Albert Einstein?


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

Here are the tools you can use:
WebSearch[input]: A tool that allows the user to search for information on the web. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextExtractor[input]: Extracts text from a webpage given its URL. The input is a link and the output is plain text containing the content of the page.
QAEngine[input]: Answers questions based on common sense, general world knowledge, and given context that may contain the answer. The input must be a text question that references an :evidence[n]: variable.
LinkPicker[input]: Picks the most relevant links from a set of URLs. The input is a newline-delimited string of URLs and the output is a single URL that seems most likely to contain the answer to the user's question.

The 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, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What was the cause of death of the famous painter Vincent van Gogh?


Instruction:
A chat. Construct a comprehensive plan to respond to this query using these tools:
QuoraSearch[input]: Searches Quora for relevant discussions.
BlogFinder[input]: Finds blogs related to the input topic.
TextCondenser[input]: Condenses large amounts of text into key points.
TruthAssessor[input]: Assesses the truthfulness of a statement.
QuerySolver[input]: Solves queries based on input context.

Question: What are the main theories about the construction of the pyramids of Egypt?


Instruction:
A chat. Develop a plan to answer the following question: "What is the process of photosynthesis and what are its main components?" using the tools provided. The tools available include:

1. Bing[input]: A tool that allows you to search for information on the internet via the Bing search engine.
2. TextSummarizer[input]: This tool can summarize large chunks of text, making it easier to extract relevant information.
3. QA[input]: A tool capable of answering questions based on common sense, general world knowledge or given input context.
4. DocumentReader[input]: Reads documents from the specified URL and outputs plain text.

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

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


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.
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.
URLExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text.

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

Question: Who is the current Prime Minister of Japan and what are some major policies they implemented?


Instruction:
A chat. Please create a detailed plan to generate an ideal response to the user query, making use of the set of tools provided. 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 prior evidence values, or a mixture of both.

Here are the tools available to be used:
DuckDuckGo[input]: A tool that enables the user to search for information via the DuckDuckGo search engine. This tool helps in locating a suitable list of sites that might contain the answer to the user's query.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-separated response of URLs.
SiteReader[input]: Loads one or more websites from the input string containing newline-delimited links, where input is one or more links, and outputs plain text containing the content of the links.
QAModel[input]: Question-answering model, especially effective at answering queries based on an input text passage. The input needs to be a text question that refers to an :evidence[n]: variable, e.g., What is the height of the Eiffel Tower, given :evidence1:?

The output should follow this format:
Plan: [first action to take based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action to take, based on the 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: What is the tallest building in Dubai and how many floors does it have?


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

Here are the tools you can call:
SearchEngine[input]: A tool that allows users to search for information using a generic search engine. This tool helps in finding relevant sites that may contain the answer to the user's question.
WebScraper[input]: Load websites from the input string containing newline separated links. The input is one or more links and produces plain text output with the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response of links separated by newlines.
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 an :evidence[n]: variable.

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

Include only one evidence output per plan step.

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

Question: What are some major accomplishments of Elon Musk?


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information from DuckDuckGo. This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
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.

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

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

Question: What is the average temperature in July for the city that hosts the largest annual jazz festival?


Instruction:
A chat. Formulate a systematic plan to address the user's inquiry, employing the following tools. Every stage in your strategy should correspond to an evidence value, which represents the output of one of the provided functions when supplied with an appropriate input string.

Tools at your disposal:
1. DuckDuckGo[input]: Allows users to search for information via the DuckDuckGo search engine. Useful for locating potential sources of information related to the user's query.
2. SiteParser[input]: Takes as input a string containing newline-separated URLs and returns plain text content from these sites.
3. URLSelector[input]: Extracts URLs from plain text and outputs them as newline-separated strings.
4. ALICE[input]: A language model designed to answer questions based on a passage of text. The input should be a question referencing a :fact[n]: variable, e.g., How tall is the Eiffel Tower, given :fact1:?

Input to each function should simply be a plain string without any special characters used to concatenate it with a fact variable, e.g., ALICE[What is the population of Tokyo, given :fact3:?]

Only one evidence output should be included per plan step.

Output format:
Plan: [initial action based on input question]
:fact0: = [function to call with input parameter]
Plan: [subsequent action based on outcome of :fact0:]
:fact1: = [next function to call with input parameter, possibly referring to earlier facts, e.g., "Given context :fact0"]
...
Final Answer: [:fact[n]: contains the ultimate answer.]

Question: Who is the founder of SpaceX and what notable missions has the company accomplished?


Instruction:
A chat. Develop a plan to answer the following question: "What is the main diet of an adult Bengal tiger and where can they be found in the wild?" Here are some tools that you can use:

WebSearch[input]: A tool that allows users to search for information using a web-based search engine. The input should be a query string, and the output will be a list of websites that may contain relevant information.
PageScraper[input]: This tool takes one or more URLs as input and outputs plain text content from those pages.
QAEngine[input]: This tool can answer questions based on common knowledge or given context. It requires a question string as input, which may reference previous evidence variables.
MapInfo[input]: This tool provides geographical information about a specific location when provided with a place name.

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


Instruction:
A chat. Create a step-by-step plan to solve the user's question, using any of the following tools. Each tool should be used at least once and each plan will have an associated evidence value, which is the output from one of the available functions given an input string.

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 can find 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.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
ALM[input]: An advanced 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 be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

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


Instruction:
A chat. Please generate a detailed plan to address the user's query, making use of the following tools. Each plan should have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Available Tools:
DuckDuckGo[input]: Allows the user to search for information using the DuckDuckGo search engine. It provides a list of sites that could potentially hold the answer to the user's question.
PageReader[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.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of URLs.
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 an #E[n] variable, e.g. What is the capital of France, given #E1?

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

Question: What was the highest grossing movie of 2019 and who directed it?


Instruction:
A chat. Please outline a methodical plan to respond to the following user request utilizing the available resources. Every step in the plan should generate an evidence value that corresponds to the output of one of the provided functions.

These are the tools you can use:
DuckDuckGo[input]: An online search engine that can be utilized to search for any type of information.
PageScraper[input]: Tool that loads one or multiple websites from the input string (containing newline-separated links) and produces plain text output with the content of these pages.
URLCollector[input]: Extracts URLs from a chunk of text and generates a plain text output with newline-separated links.
InfoProcessor[input]: A powerful AI tool that can answer queries based on an input text passage. The input needs to be a question referencing an :info[n]: variable.

Your output should follow this structure:
Plan: [the initial action based on the user’s question]
:info0: = [the function to call along with the input parameter]
Plan: [the next action, considering the outcome of :info0:]
:info1: = [the next function to call and input parameter, potentially referring to prior evidence like "Considering :info0:"]
…
Final Answer: :info[n]:

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


Instruction:
A chat. Formulate a logical plan to solve the user instruction using the provided tools. Each plan will align with an evidence value, which will be the product of one of the available functions given an input string that can be the user question, former evidence values, or both.

These are the tools you can utilize:
Ecosia[input]: A tool that lets the user search for information through Ecosia. It assists in locating a list of websites that might provide the answer to the user's question.
PageLoader[input]: Loads one or more websites from the input string containing newline-delimited links, where input is one or more links, and delivers plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and gives a plain text, newline-separated list of links.
AIQA[input]: Artificial Intelligence-based Question Answering model, especially adept at answering questions based on an input text passage. The input must be a text question referencing a :datum[n]: variable, like How many species of birds exist, given :datum1:?

Each function input should just be a plain string, without quotes or "+" to merge a string with an evidence variable, e.g., AIQA[What is the lifespan of a tortoise, given :datum2:?]

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

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

Question: What are the health benefits of regular exercise and what types of exercises are recommended for beginners?


Instruction:
A chat. Please provide a systematic approach to answering the user query using the below mentioned tools. Each tool should be invoked with an appropriate input and its output should be captured in a variable :evidence[n]:

Tools Available:
1. GoogleSearch[input]: Executes a Google search based on the input string and provides a list of links as output.
2. PageReader[input]: Reads the content of a webpage given its URL as input.
3. QuestionAnswerer[input]: Answers a question based on general knowledge or specific context provided in the format "question, given :evidence[n]".
4. LinkExtractor[input]: Extracts all URLs from a block of text provided as input.
5. DataAnalyzer[input]: Analyzes data provided as input and generates insights or summaries.

Output Format:
Plan: [First Action]
:evidence0: = [Function Call]
Plan: [Subsequent Action]
:evidence1: = [Next Function Call]
...
Answer: [:evidence[n]: containing final answer.]

Question: What are the health benefits of regular exercise and how does it affect heart rate?


Instruction:
A chat. Develop 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:
CompanyProfile[input]: Tool that provides profiles of companies.
StockMarketData[input]: Tool that provides stock market data.
FinancialNews[input]: Tool that provides financial news.
IndustryTrends[input]: Tool that identifies trends in a particular industry.
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 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 current stock price of Microsoft and how has it been performing over the last year?


Instruction:
A chat. Question: What is the population of New York City and what are some notable landmarks there?

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine.
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.
LandmarkExtractor[input]: Extracts landmark names from plain text.
PopulationChecker[input]: Checks the current population of a specified location.

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 systematic plan to address the user command, leveraging the offered suite of tools. Each plan will tie to an evidence value, being the yield of one of the listed functions when fed an input string that could be the user's question, antecedent evidence values, or a mix of both.

Accessible tools:
AskJeeves[input]: Tool permitting the user to hunt for information via Ask Jeeves search engine. This tool is instrumental in spotting a range of sites that could contain the answer to the user's question.
WebFetcher[input]: Pulls one or more websites from the input string consisting of newline-divided links. The input is one or more links, leading to plain text output encapsulating the content of the links.
LinkPicker[input]: Plucks links from plain text, rendering a plain text, newline-separated catalog of links.
QASystem[input]: Question-answering language model, specifically handy in responding to questions grounded on an input text passage. The input ought to be a text-based question that cites an :evidence[n]: variable.

Output format:
Plan: [Opening action rooted in input question]
:evidence0: = [Function to trigger with input parameter]
Plan: [Ensuing action hinging on result of :evidence0:]
:evidence1: = [Succeeding function to trigger and input parameter, perhaps alluding to former evidence, e.g., "With respect to :evidence0:"]
...
Conclusive Reply: [:evidence[n]: bearing the definitive answer]

Question: Who composed the music score for the movie 'Interstellar' and what other movies have they scored?


Instruction:
A chat. Please generate a plan to solve the following question using the available tools. Each step in your plan should have an associated evidence variable, 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.
TextExtractor[input]: Extracts text from plain HTML and produces a plain text response.
LinkHarvester[input]: Harvest links from plain text and produces a plain text, newline delimited response of links.
GPT3[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 be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some major works by Charles Dickens and what themes do they explore?


Instruction:
A chat. Generate a plan to solve the following problem using the tools provided. Each step in your plan should be associated with an evidence variable that will store the output of the function called at that step.

Available Tools:
Bing[input]: This tool allows you to search for information using Bing's search engine. It can provide a list of websites related to the input query.
PageReader[input]: This tool extracts text from a webpage given its URL. The extracted text may contain the answer to the user's question.
LinkPicker[input]: This tool selects relevant links from a plain text containing multiple URLs.
QAEngine[input]: This is a question answering tool that can generate answers based on a given context. The input must include a question and a reference to an evidence variable, e.g., "What is the capital of France, given #E1?"

Output Format:
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 referencing previous evidence]
...
Final Answer: #En

Question: What are some significant achievements of Albert Einstein?


Instruction:
A chat. Create a step-by-step plan to answer the user's question using the following tools. Each plan should be followed by exactly one evidence (#E[index]) value.

Available Tools:
1. GoogleSearch[input]: This tool allows you to search for information on the internet using Google. The input is a string that represents the search query.
2. WikiInfo[input]: A tool that searches Wikipedia for information related to the input string.
3. WebScraper[input]: A tool that scrapes web pages for text content. The input is a URL or list of URLs.
4. LinkExtractor[input]: Extracts links from plain text and produces a newline delimited response of links.
5. AnswerBot[input]: An AI tool that can answer 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?"

Output Format:
Plan: [first action]
#E1 = [function with input parameter]
Plan: [next action]
#E2 = [next function with input parameter referencing previous evidence if necessary]
...
Final Answer: #E[n]

Question: What are some notable works of the author who wrote "The Old Man and the Sea"?


Instruction:
A chat. For the following task, make a plan that can solve the problem step-by-step.

Question: What is the significance of the Battle of Waterloo in European history?

Here are the tools available to be called:
HistoricalDB[input]: A tool that allows you to search for historical data and events.
GeoTagger[input]: This tool helps to identify geographical locations mentioned in the input text.
TimeLine[input]: This tool gives a chronological sequence of events related to the input query.
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.
ContextAnalyzer[input]: Analyzes the context of the provided information.

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


Instruction:
A chat. Create a step-by-step plan to answer the following question using the available tools. Each tool can be called with an input string and will produce an output that can be stored in a variable :evidence[n]: for later use.

Available Tools:
SearchEngine[input]: This tool allows you to search for information on the internet. The input should be a query related to your question.
WikiTool[input]: A tool that searches Wikipedia for information related to the input query.
LinkCollector[input]: Extracts links from a given text. Useful when you need to find more sources of information.
TextAnalyzer[input]: Analyzes a text and extracts key pieces of information based on the input query.
QA_Tool[input]: Can answer questions directly or using provided context (from previous evidence).

The output format should be as follows:
Plan: [Action to take]
:evidence1: = [Function call with input parameter]
...
Answer: [:evidence[n]: containing the final answer]

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


Instruction:
A chat. Develop a step-by-step plan to address the user query utilizing the provided tools. Each step should correspond to an evidence value, which would be the output of one of the available functions given an input string that could be the user question, prior evidence values, or a mix of both.

Here are the tools available to be used:
WikiSearch[input]: Allows the user to search for information from Wikipedia. Useful for acquiring knowledge about people, places, companies, historical events, etc.
SiteScraper[input]: Loads one or more websites from the input string containing newline separated links, where input is one or more links, and outputs plain text containing the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and generates a plain text, newline separated response of links.
AnswerBot[input]: A question-answering language model, useful for answering questions based on an input text passage. The input must be a text question referencing an :evidence[n]: variable, e.g., What is the capital of France, given :evidence1:?

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 refer 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 has it been maintained over the years?


Instruction:
A chat. Generate a plan to solve the problem presented in the following task. For each step in your plan, indicate which external tool will be used along with the necessary input parameters. You can store the outputs into variables named #E[index] that can be referenced later.

Available tools:
WikiSearch[input]: Searches Wikipedia for information related to the input query.
DataParser[input]: Parses structured data (like tables) from a provided Wikipedia page.
QueryBot[input]: Can answer questions based on the given context. The input should be a question referencing a previously stored evidence variable (#E[n]).

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

Output format:
Plan: [first action]
#E1 = [function with input parameter]
Plan: [next action, based on result of #E1]
#E2 = [next function with input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: Who won the FIFA World Cup in 2006 and who was the top scorer?


Instruction:
A chat. Formulate a plan to respond to: "Tell me about the life cycle of a butterfly and its ecological role."

Available tools:
LifeCycle[input]: Provides information about the life cycle of living organisms.
EcologicalRole[input]: Explains the ecological role of various species.
ImageSearch[input]: Searches for images related to the input query.
QA[input]: Answers questions based on common sense and general world knowledge.
Documentary[input]: Finds documentaries related to the input topic.

Output format:
Plan: Initial action
:Evidence0: = Function with input parameter
Plan: Subsequent action
:Evidence1: = Next function with input parameter
...
Answer: [:Evidence[n]: containing the final answer.]


Instruction:
A chat. Create a step-by-step execution plan to solve the following problem using the tools provided. For each step, provide the necessary input to the tool and store the output as evidence. You can refer to this evidence in subsequent steps.

Tools available:
GoogleSearch[input]: A tool that performs a Google search using the provided input and returns a list of potential sources of information.
TextParser[input]: A tool that extracts key pieces of information from a large body of text.
QAModel[input]: A tool that answers questions based on the context provided in the input.

Output format:
Plan: [description of the first step]
#E1 = [tool used and its input]
Plan: [description of the next step]
#E2 = [next tool used and its input, possibly referencing #E1]
...
Final Answer: [#En]

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


Instruction:
A chat. Create a step-by-step plan to solve the user instruction using the following tools. Each plan should have an associated evidence value which is the output of one of the available functions given an input string.

Here are the tools that can be used:
SearchEngine[input]: A tool that allows you to search for information on the internet. This tool is useful in finding relevant websites or pages that may contain the answer to your question.
TextExtractor[input]: Extracts text from webpages given their URLs. The input is one or more links, and it 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.
AnswerBot[input]: A question answering bot that can answer questions based on an input passage of text. The input must be a text question that references a :data[n]: variable, e.g., What color is the cat, given :data1:?

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

Remember to include only one evidence output per plan step.

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

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


Instruction:
A chat. Develop a strategy to solve the following problem using the described tools. Each plan must have corresponding evidence which will be stored in #E[index].

Available Tools:
DuckDuckGo[input]: This tool uses DuckDuckGo search engine to generate a list of sites related to the user's query.
URLReader[input]: This tool reads the contents of a webpage from a given URL and outputs it as plain text.
AskJeeves[input]: This tool answers questions based on common sense, general world knowledge, or given context that may contain the answer.

Output Format:
Plan: [First Action]
#E0 = [Function Call]
Plan: [Next Action]
#E1 = [Next Function Call]
...
Answer: [#En]

Question: Who was Albert Einstein and what were his major contributions to physics?


Instruction:
A chat. Please create a step-by-step execution plan to generate a solution to the user instruction. You need to make 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.

Here are the tools available to be called:
1. DuckDuckGo[input]: A tool that allows the user to search for information online. It finds a list of sites that might contain the answer to the user's question.
2. 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.
3. HyperlinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
4. ALM[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]
#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]
...
Answer: [#E[n], which contains the final answer.]

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


Instruction:
A chat. Please provide a step-by-step plan to answer the user query using the available tools. Each tool should be called with an appropriate input and will produce an output which can be used as evidence in subsequent steps.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information from Bing. This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
WebScraper[input]: A tool that extracts data from websites provided as input.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
NLP[input]: Natural Language Processing tool that can answer questions given an 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]

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


Instruction:
A chat. Create a sequential plan to respond to the user query utilizing the available tools. Each plan step should 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 mix of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding a suitable list of sites that may or may not contain 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.
SiteReader[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.
LinkSelector[input]: Selects the most relevant links from a plain text list of links and produces a plain text, newline delimited response of selected links.
SmartQA[input]: Question answering language model, especially useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the dog, given :evidence1:?

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

Make 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 discovered penicillin and what diseases does it treat?


Instruction:
A chat. Provide a comprehensive plan to solve the following problem using the provided tools. Each plan should have a corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more previous evidence values, or a mixture of both.

Here are the tools at your disposal:
WikiTool[input]: Tool that enables the user to fetch information from Wikipedia. This tool is especially handy when seeking knowledge about people, places, companies, historical events, and other types of factual data. The input to this function should be a search string that would help locate the appropriate page.
QAEngine[input]: A tool capable of answering questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
NewsAPI[input]: Fetches latest news articles related to the input query. Can be used to gather recent updates or developments on a topic.
SentimentAnalyzer[input]: Analyzes sentiment (positive, negative, neutral) of a given piece of text. Useful for understanding public opinion or reaction towards a particular event or person.

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: How did the stock market react after Apple Inc.'s last product launch?


Instruction:
A chat. Create a detailed plan to respond to the following user query using the tools provided. For each step in your plan, specify an evidence variable that corresponds to the output of a function given an input string. This string could be the user's question, prior evidence values, or a combination of both.

Available Tools:
DuckDuckGo[input]: This tool enables users to perform searches on DuckDuckGo. It is handy for locating a range of sites that might have the user's question's answer.
SiteReader[input]: Reads websites from an input string that contains newline-separated links. The input is one or more links, and it generates plain text output with the contents of these links.
URLExtractor[input]: Pulls out URLs from plain text and returns a plain text, newline-separated list of URLs.
AnswerBot[input]: An AI-powered question answering model that answers queries based on a supplied text passage. The input needs to be a textual question referencing an :evidence[n]: variable.

Output Format:
Plan: [Initial action based on the user's question]
:evidence1: = [Function to invoke with its input parameter]
Plan: [Subsequent action depending on the outcome of :evidence1:]
:evidence2: = [Next function to invoke with its input parameter, potentially referencing prior evidence]
...
Final Response: [:evidence[n]: carrying the ultimate answer]

Question: Who was Nikola Tesla and what were his most notable inventions?


Instruction:
A chat. Formulate a plan to answer the following question using the tools at your disposal. Each step should correspond to a piece of evidence produced by one of the tools.

Available Tools:
AskJeeves[input]: A search engine tool that returns a list of websites pertaining to the input query.
ContentScraper[input]: Scrapes the main content from a website link.
LinkCollector[input]: Collects all links from a block of text.
HAL9000[input]: An artificial intelligence tool that answers specific questions when given a context.

Output Format:
Plan: [First action based on the question]
#Evidence1 = [Tool used with its input]
Plan: [Subsequent action based on #Evidence1]
#Evidence2 = [Next tool used with its input]
...
Final Answer: #Evidence[n]

Question: How does climate change affect global food security?


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

Tools available:
WebSearch[input]: A tool that uses a general-purpose search engine to find information related to the input query.
PageReader[input]: Loads the full text of a webpage given its URL.
LinkCollector[input]: Collects all URLs from a block of text.
KnowledgeBase[input]: A tool that answers questions based on common knowledge and specific context provided as input.

Output Format:
Plan: [First action]
#E1 = [Function to call with input]
Plan: [Next action based on #E1]
#E2 = [Next function to call with input including reference to #E1 if needed]
...
Final Answer: #E[n]

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


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using any web search engine. This tool is useful in finding appropriate sites that may contain the answer to the user's question.
ContentExtractor[input]: Extracts content from plain text and produces a plain text response containing the main points.
LinkGatherer[input]: Gathers links from plain text and produces a plain text, newline delimited response of links.
KnowledgeBase[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :data[n]: variable, e.g. What color is the cat, given :data1:?

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

Ensure to only include one evidence output per plan step.

The output should be in format:
Plan: [first action to take based in input question]
: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 won the Nobel Prize in Literature in 2020 and what was their most famous work?


Instruction:
A chat. Formulate a systematic plan to provide an ideal response to the user request, making use of the given tools. Each plan will correspond to an evidence value, which will be the result of one of the available functions given an input string that can be the user question, one or more prior evidence values, or a blend of both.

These are the tools you can utilize:
YahooSearch[input]: Allows the user to search for information using the Yahoo search engine. This tool is handy in finding a list of sites that may or may not contain the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline separated links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkGatherer[input]: Extracts links from plain text and produces a plain text, newline separated response of links.
IntelligentQA[input]: An intelligent question-answering model particularly effective at answering questions based on an input text passage. The input must be a text question that refers to an :evidence[n]: variable, e.g., How old is the Earth, given :evidence1:?

The input to each function should simply be a plain string, without quotation marks or "+" to combine a string with an evidence variable, e.g., IntelligentQA[Who wrote Pride and Prejudice, given :evidence3:?]

Remember to include only one evidence output per plan step.

The output should be in 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 are the main causes of global warming and what measures can be taken to mitigate its effects?


Instruction:
A chat. Develop a comprehensive plan to answer the following question using the listed tools. For each step, provide the tool used along with its input. You can store the output into a variable #E[index] that can be referenced later.

Tools:
AskJeeves[input]: A tool that uses the Ask Jeeves search engine to find potential answers to a query.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and provides a plain text, newline delimited response of links.
BERT[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

Output Format:
Plan: [First action]
#E1 = [Tool name with input]
Plan: [Second action]
#E2 = [Next tool with input]
...
Final Answer: #E[n]

Question: What are some notable works of art at the Louvre Museum?


Instruction:
A chat. Create a step-by-step plan to answer the following 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 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.
TextParser[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the pages.
LinkGatherer[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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 Nobel Prize in Literature in 2019 and what was their most famous work?


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

Here are the tools available to be called:
GoogleScholar[input]: Tool that allows the user to search for academic articles from Google Scholar.  This tool is particularly useful in gaining knowledge about scientific research, historical events, and other types of factual information.
JSTOR[input]: Tool that allows the user to search for scholarly literature across many disciplines and sources.
PaperAbstractExtractor[input]: Extracts the abstract from a scientific paper link.
AIArticleSummarizer[input]: Summarizes long-form articles or papers into concise summaries.

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

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

Question: How does climate change affect the migration patterns of birds?


Instruction:
A chat. Create a systematic plan to respond to the user's request using the following tools. For each step, store the output in a variable labeled #E[index].

Tools Available:
DuckDuckGo[input]: A tool that performs a search on DuckDuckGo and returns the results.
SiteLoader[input]: Loads the full text of a website given its URL.
ContextualQA[input]: Answers questions using the context provided in the input.

Output Format:
Plan: [Initial action based on the user's question]
#E1 = [Tool to use with appropriate input]
Plan: [Subsequent action based on the outcome of #E1]
#E2 = [Next tool to use with suitable input, potentially referring to earlier evidence]
...
Final Answer: #E[n]

Question: What is the origin of the phrase "kick the bucket" and how has its meaning evolved over time?


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

Here are the tools you have at your disposal:
WebSearch[input]: This tool allows the user to search for information on the internet. It is useful 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.
TextExtractor[input]: Extracts plain text from one or more websites provided in the input string containing newline delimited links. The input must be one or more links and the output will be plain text content from these links.
LinkFilter[input]: Filters out irrelevant links from a plain text list of links and produces a plain text, newline delimited response of relevant links.
QAModel[input]: A question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Ensure each plan step has only one evidence output.

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

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


Instruction:
A chat. Generate a detailed plan to solve the following problem using the provided tools. For each step, provide the necessary command and store the result as evidence. You can refer to this evidence in later steps.

Tools Available:
GoogleSearch[input]: Search Google for information related to the input query.
TextExtractor[input]: Extracts important details from a large body of text.
QAEngine[input]: A powerful question-answering tool capable of providing answers when given context.

Output Format:
Step: [Description of the step]
#E[index] = [Command to execute]
Final Answer: #E[n]

Question: Who was responsible for discovering penicillin and what impact did it have on medicine?


Instruction:
A chat. Create a sequential plan to answer the following question using the provided tools. Each step should correspond to a piece of evidence generated by one of the tools.

Available Tools:
BingSearch[input]: Allows users to perform a Bing search. Useful for gathering a wide range of data related to the query.
SiteScraper[input]: Takes one or more URLs as input and returns the textual content of those pages.
URLFinder[input]: Finds URLs within a block of text.
InfoModel[input]: A language model designed to answer questions when given a specific context.

Output Format:
Plan: [First action]
#E1 = [Function call]
Plan: [Subsequent action]
#E2 = [Function call referencing #E1 if necessary]
...
Final Answer: [#En]

Question: Who was the first person to climb Mount Everest without supplemental oxygen?


Instruction:
A chat. Construct a plan to solve the problem below using the available tools. Record the output of each tool in a variable named #E[index], which can be used as reference in subsequent steps.

Tools available:
YahooSearch[input]: Allows the user to perform a Yahoo search. Can help locate potential sources of information.
TextExtractor[input]: Takes one or more website links (newline separated) as input and returns the textual content of those pages.
HyperlinkGatherer[input]: Extracts hyperlinks from a body of text and provides them as a newline-separated string.
KnowledgeBase[input]: An AI model that answers questions based on a given context. The input should be a question that refers to a #E[n] variable, such as "What is the capital of France, given #E1?"

Output format:
Plan: [initial action]
#E1 = [tool to use with input]
Plan: [subsequent action, considering the outcome of #E1]
#E2 = [next tool to use with input, potentially referring to prior evidence]
...
Final Answer: #E[n]

Question: What is the average lifespan of a Galapagos tortoise and where do they typically live?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding 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.
AIAnswerer[input]: Question answering AI model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What are some popular tourist attractions in Paris and what is their historical significance?


Instruction:
A chat. Create a detailed plan to find out who invented the television and when was it first used commercially. Here are the tools at your disposal:

1. WikiSearch[input]: Searches Wikipedia for information related to the input query.
2. DateExtractor[input]: Extracts dates from a given piece of text.
3. PersonIdentifier[input]: Identifies names of people from a given piece of text.
4. QandA[input]: Answers questions based on an input passage of text.

Please follow this format:
Plan: [first action]
:Evidence0: = [function call with input parameter]
Plan: [next action]
:Evidence1: = [next function call with input parameter]
...
Answer: [:EvidenceN:]


Instruction:
A chat. For the following tasks, 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 :evidence[index] that can be called by later tools.

Here are the tools available to be called:
WikiSearch[input]: Tool that allows the user to search for information from Wikipedia.  This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
QuestionSolver[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.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
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.

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

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 history of the Great Wall of China and what materials were used in its construction?


Instruction:
A chat. Create a plan to answer the following question using these available tools. Each tool can be used multiple times, but every step should have one corresponding evidence variable.

Available Tools:
1. WebSearch[input]: This tool performs a web search and returns a list of potential sources that may contain the information sought.
2. TextExtractor[input]: This tool extracts text from any given webpage link.
3. LinkFinder[input]: This tool finds relevant links within a body of text.
4. InfoQA[input]: This tool answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output format should be as follows:
Plan: [First action]
:evidence0: = [Tool to use with its input]
Plan: [Next action]
:evidence1: = [Next tool to use with its input, which might reference previous evidence]
...
Final Answer: [:evidence[n]:]

Question: What is the average lifespan of a Giant Panda in the wild and what are some threats they face?


Instruction:
A chat. Please generate a plan to solve the following question using these available tools. For each step of your plan, indicate which tool you would use and what input you would provide to that tool. You can store the output from each tool in a variable :evidence[index]: for reference in later steps.

Here are the tools available to be called:
GoogleSearch[input]: This tool allows you to perform a Google search on any given topic. The input should be a string representing the search query.
LinkExtractor[input]: This tool extracts all URLs from a given text. The input should be a string containing one or more URLs.
WebScraper[input]: This tool scrapes the content of a webpage. The input should be a URL.
TextAnalyzer[input]: This tool analyzes a block of text and answers questions based on the information found within it. The input should be a question with an optional context provided by referencing an evidence variable (e.g., "What is the main theme of the story? Given context: :evidence1:").

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

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


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:
Bing[input]: Tool that allows the user to search for information using the Bing search engine.
SiteLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkHarvester[input]: Extract hyperlinks from plain text and produces a plain text, newline delimited response of links.
AskAI[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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

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