Instruction:
A chat. Formulate 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 hold the output of one of the available functions given its input string.

Available tools:
YahooSearch[input]: A tool that uses Yahoo's search engine to find potentially useful websites. It does not directly answer queries but provides a list of sites that could contain the answer.
SiteReader[input]: Reads and extracts plain text from one or more websites based on the input string containing newline-separated links. The input can be one or several links, and the output is plain text content of these links.
HyperlinkGatherer[input]: Gathers hyperlinks from plain text and produces a plain text response with newline-separated links.
InfoBot[input]: A language model designed to answer questions based on a text passage. The input must be a text question referencing an :evidence[n]: variable, e.g., When was America discovered, given :evidence1:?

Each function requires a simple string as input without quotes or "+" to concatenate a string with an evidence variable, e.g., InfoBot[When did World War II end, given :evidence3:?]

Ensure only one evidence output per plan step.

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

Question: Who invented the telephone and where were they born?


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 variable that will store the output of one of the functions given its input string.

Here are the tools available to be called:
GoogleSearch[input]: This tool allows you to search for information using Google's search engine. It can find a list of sites related to the user's query.
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]: A question answering model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


Instruction:
A chat. Create a plan to answer the following question using the tools provided. For each step in your plan, provide an evidence value that corresponds to the output of one of the available functions given an input string. This could be either 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. It is useful for finding sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from a webpage given its URL. The input should be a single link and the output will be plain text content of the page.
LinkPicker[input]: Picks the most relevant links from a list of URLs based on the input query.
AnswerBot[input]: A tool that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What is the capital of France, given #E1?

Each function takes a plain string as input without quotes or "+" to concatenate a string with an evidence variable, e.g., AnswerBot[What is the population of Tokyo, given #E2?]

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

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


Instruction:
A chat. Generate a step-by-step plan to answer the user query using the following tools. Each tool should be used at least once and every plan must have an associated evidence value.

Here are the available tools:

1. Bing[input]: This function allows users to search for information on the Bing search engine. It is useful in finding websites that may contain answers to the user's question.
2. Extractor[input]: A tool that extracts text from web pages given one or more URLs as input.
3. URLFinder[input]: A tool that finds URLs within a body of text.
4. QAModel[input]: A language model that can answer questions based on a provided context. The input should be a question referencing an :evidence[n]: variable.

The output format should be:
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 is the significance of the Battle of Waterloo?


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

Here are the tools you can use:
Bing[input]: This tool allows users to search for information on Bing. It is useful for finding lists of sites that may contain answers to the user's questions.
TextExtractor[input]: Extracts text from websites provided as newline-separated links in the input string. The output is plain text containing the content of the linked pages.
LinkParser[input]: Parses plain text and produces a list of links separated by newlines.
AIQA[input]: An AI-based question answering model capable of providing answers based on an input passage of text. The input must be a textual question referencing an :evidence[n]: variable.

Each function takes a simple string as input without quotes or "+" for concatenating strings with evidence variables (e.g., AIQA[What is the capital of France, given :evidence2:?]).

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

Question: What is the significance of Leonardo da Vinci's painting 'The Last Supper'?


Instruction:
A chat. Using the available tools, create a detailed plan to answer the user's question. Each plan should correspond to an evidence value.

Available Tools:
1. WebCrawler[input]: A tool that scans the web for information relevant to the input.
2. QAEngine[input]: A question answering tool that uses AI to answer questions based on common sense, world knowledge, or provided context.
3. DocumentAnalyzer[input]: Analyzes documents to extract important details and summaries.

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

Question: What are the main features of the Eiffel Tower and when was it last renovated?


Instruction:
A chat. Please develop a plan to answer the following question using the listed tools. Each step should correspond to an evidence variable, which represents the output of a function given an input string (the user's question, prior evidence variables, or both).

Available tools:
YahooSearch[input]: Allows users to search for information via Yahoo. It provides a list of potentially helpful sites but does not directly answer the question.
WebCrawler[input]: Retrieves the content of one or more websites specified by newline-separated links in the input string.
HyperlinkHarvester[input]: Extracts hyperlinks from plain text and delivers them as newline-separated strings.
QueryBot[input]: A language model designed to answer questions based on a supplied passage of text. The input should be a text question that refers to an :evidence[n]: variable, such as "How tall is Mount Everest, given :evidence1:?"

Input to each function should be a simple string, no need for quotes or "+" to concatenate a string with an evidence variable, e.g., QueryBot[What is the capital of Italy, given :evidence2:?]

Ensure to provide only one evidence output per plan step.

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

Question: Who directed the movie Inception and what other movies have they directed?


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

Here are the tools available to be called:
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.
LinkHarvester[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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 historical significance of the Rosetta Stone and where is it currently located?


Instruction:
A chat. Create a step-by-step plan to solve the following user query using the available tools. Each plan will be followed by an evidence value which is the output of one of the available functions given an input string that can be either the user 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 relevant websites that may contain the answer to the user's question.
HTMLParser[input]: Load one or more websites from the input string containing newline delimited 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.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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


Instruction:
A chat. Create a plan to solve the following problem step-by-step. Each step should use one of the available tools and produce an evidence value that can be used in subsequent steps.

Here are the tools available to be called:
Bing[input]: A tool that uses Bing search engine to find information related to the input query.
TextExtractor[input]: Extracts plain text from websites given as input links, newline delimited.
LinkPicker[input]: Picks out relevant links from a large set of links provided as input.
KnowledgeBot[input]: This is a question answering bot that can answer questions based on common knowledge or using context provided by previous evidence values.

The output should follow this 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]
...
Final Answer: #E[n]

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


Instruction:
A chat. Generate a plan to respond to the following query utilizing the tools provided. Each step in your plan should correspond to an evidence value which will be the output of one of the available functions.

Available Tools:
DuckDuckGo[input]: Allows users to conduct a web search using DuckDuckGo search engine.
PageReader[input]: Reads the contents of a webpage from a link and provides a textual summary.
URLCollector[input]: Gathers all URLs present within a block of text.
KnowledgeEngine[input]: Answers questions using a pre-existing knowledge base. It requires a question referencing an :evidence[n]:

Output Format:
Plan: [First Action]
:evidence0: = [Function with Input Parameter]
Plan: [Subsequent Actions]
:evidence[n]: = [Function with Input Parameter including possible references to prior evidences]
Final Answer: :evidence[n]:

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what other significant achievements do they have?


Instruction:
A chat. Create a plan that uses 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.

Here are the tools available to be called:
DuckDuckGo[input]: Allows the user to search for information using DuckDuckGo search engine.
PDFReader[input]: Load a PDF file from the input link and produces plain text output containing the content of the PDF.
HTMLParser[input]: Parse HTML from a website and produces plain text output containing the content of the site.
ALICE[input]: A language model that answers questions based on an input passage of text.

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

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

Question: Who wrote the book "1984" and what is its main theme?


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

Here are the tools you can call:
Bing[input]: A tool that allows users to search for information using Bing. This tool is useful in finding appropriate 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.
WebReader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Remember to include only one evidence output per plan step.

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 2020 NBA Finals MVP award and what college did they attend?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
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.
LinkMiner[input]: Extract 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 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 walk on the moon and what were some major challenges they faced during the mission?


Instruction:
A chat. Question: What is the history and cultural significance of the Eiffel Tower?

Here are the tools available to be called:
HistoricalDatabase[input]: Tool that provides historical information about a specific topic.
CulturalSignificanceChecker[input]: Tool that provides details on the cultural importance of a particular entity.
QA[input]: Tool that can answer questions based on common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
GoogleTranslate[input]: Tool that translates text from one language to another.
WebSearch[input]: Tool that allows the user to search for information using a web search engine.

Plan: First action to take based on input question
#E1 = HistoricalDatabase["Eiffel Tower"]
Plan: Next action to take, based on result of #E1
#E2 = CulturalSignificanceChecker["Eiffel Tower"]
Plan: Final step, translate the results if necessary
#E3 = GoogleTranslate[#E1 + " " + #E2]
Final Answer: #E3


Instruction:
A chat. Question: What is the primary diet of the Australian saltwater crocodile?

Here are the tools available to be called:
WikiSearch[input]: Tool that allows the user to search for information from Wikipedia.
AskJeeves[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.
GoogleMaps[input]: This tool provides geographical data about a specific location.
NatGeoData[input]: This tool provides access to National Geographic's database of animal facts and figures.
ZooDB[input]: This tool gives access to a comprehensive database of zoological 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 plan to answer the following question using these available tools. Each step of your plan should be followed by an evidence value, which will be the output of one of the available functions given an input string that can be the user question, previous evidence values, or both.

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information from various websites on the internet. The input is a search string and the output is a list of website links related to the query.
ReadPage[input]: This tool takes a URL as input and returns the text content of the webpage.
LinkFilter[input]: Extracts relevant links from a plain text containing multiple URLs.
AIAnswerer[input]: An AI model that answers questions based on an input passage of text. The input must be a text question that references an #E[n] variable.

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

Question: What's the history behind the creation of Google?


Instruction:
A chat. Create a plan to answer the following question using these available tools. Each step in your plan should be associated with an evidence variable, which will store the output of the tool used in that step.

Here are the tools you can use:

1. BingSearch[input]: This tool uses the Bing search engine to find information related to the input query. It returns a list of websites that might contain the required information.
2. WebScraper[input]: This tool takes one or more URLs as input and retrieves plain text content from those pages.
3. URLExtractor[input]: This tool extracts all URLs from the provided plain text.
4. WikiInfo[input]: This tool searches Wikipedia for information on the input topic.
5. QAModel[input]: This is a question answering model that can provide answers based on given context (from previous evidence variables).

Remember, each function's input must be a plain string without quotes or concatenation operators. The final format should look like this:

Plan: [first action]
#E1 = [function call with input]
Plan: [next action]
#E2 = [function call with input, possibly referencing #E1]
...
Final Answer: [#En]

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


Instruction:
A chat. Develop a systematic 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.

Here are the tools available to be called:
GoogleScholar[input]: Allows the user to search for academic articles using Google Scholar.
PDFReader[input]: Reads PDF files and outputs their contents as plain text.
CitationFinder[input]: Finds citations within a block of text.
AIAssistant[input]: Answers 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]
...
Final answer: #E[n]

Question: Who first proposed the theory of continental drift and what were their main arguments?


Instruction:
A chat. Generate a systematic plan to respond to the user's request, leveraging the tools provided. Each plan should have a corresponding evidence value, which will be the outcome of one of the available functions given an input string that can be the user's question, one or more preceding evidence values, or a mix of both.

Here are the tools you can use:
YahooSearch[input]: A tool that lets the user look up information through the Yahoo search engine. It aids in identifying a suitable list of sites that might hold the answer to the user's question.
LinkGatherer[input]: Gathers links from plain text and delivers a plain text, newline-separated response of links.
WebCrawler[input]: Fetches one or more websites from the input string containing newline-separated links, where input is one or more links, and yields plain text comprising the content of the links.
FAQModel[input]: Frequently Asked Questions model, notably adept at answering questions based on an input text passage. The input has to be a text question that points to an :evidence[n]: variable, e.g., What is the population of Tokyo, given :evidence1:?

The output should be structured as follows:
Plan: [initial action to undertake based on the input question]
:evidence0: = [function to invoke with input parameter]
Plan: [following action to undertake, hinging on the outcome of :evidence0:]
:evidence1: = [subsequent function to invoke and input parameter, which might point to earlier evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: holding the final answer.]

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


Instruction:
A chat. Develop a systematic plan to respond to the user's inquiry using the tools at your disposal. Each tool generates an evidence value, which serves as the output of the function and can be utilized in later stages.

Available tools include:

WikiLookup[input]: This tool allows you to retrieve information from Wikipedia. It's useful for obtaining factual data about people, places, events, etc. The output could be verbose but often contains the necessary information.
URLGrabber[input]: Grabs all URLs contained within a block of text.
SiteReader[input]: Reads the contents of a website specified by its URL and returns the text.
AskBot[input]: A language model capable of answering questions based on a provided context. The input must reference an :evidence[n]: variable, e.g., "Who won the World Series in 2020, given :evidence1:?"

Output should adhere to the following structure:
Plan: [initial action]
:evidence0: = [function with corresponding input]
Plan: [subsequent action, based on outcome of :evidence0:]
:evidence1: = [following function and input, potentially referring to prior evidence such as ":evidence0:"]
...
Answer: [:evidencen:]

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


Instruction:
A chat. Create a step-by-step plan to answer the following question using the tools provided. Each step in your plan should correspond with an evidence value, which will be the output of one of the available functions given an input string that can be either the user's 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 using a general-purpose search engine. It is useful for finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a website URL. The input is a single URL and the output is the plain text content of the site.
LinkCollector[input]: Extracts URLs from plain text. The output is a newline-separated list of links.
InfoQA[input]: A question-answering model that can provide answers based on a passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., "What is the population of New York City, given :evidence1:?"

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

Ensure that there is only one evidence output per plan step.

The output format should be as follows:
Plan: [first action to take based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on the 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 most popular tourist attraction in Paris and what is its history?


Instruction:
A chat. Generate a step-by-step plan to find out the population of the city where Microsoft headquarters is located.

Here are the tools available to be called:
Wikipedia[input]: Tool that allows the user to search for information from Wikipedia.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
CityPopulation[input]: A tool that retrieves the current population of a specified city.
CompanyInfo[input]: A tool that provides information about a specific company including its location.
GoogleMaps[input]: A tool that provides geographical data about a place.

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


Instruction:
A chat. Provide a detailed execution plan to respond to the following query using the tools provided. Remember, each step should be followed by an evidence value.

Tools Available:
WikiLookup[input]: Searches Wikipedia for articles related to the input query.
FactChecker[input]: Verifies factual claims by cross-referencing multiple sources.
QAEngine[input]: Answers questions based on the context provided in the input.
ImageSearch[input]: Searches the internet for images related to the input query.

Output Format:
Step: [Action based on the input question]
#E1 = [Function to call with appropriate input]
Step: [Next action based on the outcome of #E1]
#E2 = [Next function to call with appropriate input, referencing previous evidence if necessary]
...
Final Answer: #En

Question: Who was Leonardo da Vinci and what are some of his most famous works?


Instruction:
A chat. Formulate a plan to answer the question: "How does photosynthesis work and why is it important?" Here are the tools at your disposal:

1. EncyclopediaSearch[input]: Searches an online encyclopedia for information based on the input string.
2. DiagramGenerator[input]: Generates diagrams based on the input string.
3. InfoSummarizer[input]: Summarizes complex information into simpler terms.
4. QuerySolver[input]: Answers questions based on the input string and any provided context.

Your plan should include an evidence variable (#E[index]) for each step. Format your output like so:

Plan: [first action]
#E1 = [function call with input]
Plan: [next action]
#E2 = [function call with input, possibly referencing previous evidence]
...
Final Answer: #E[n]


Instruction:
A chat. Provide a detailed execution plan for the following task using the listed tools. Remember each plan step should be followed by exactly one evidence (#E[index]) value.

Available Tools:
WikiSearch[input]: Searches Wikipedia for the provided input and returns a verbose and noisy output.
QAAssistant[input]: Answers questions directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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


Instruction:
A chat. Create a step-by-step plan to solve the problem using the following tools:

YahooSearch[input]: A tool that uses Yahoo's search engine to look up information.
SiteLoader[input]: Takes one or more website URLs and outputs the text content of those sites.
LinkGatherer[input]: Extracts all URLs from a block of text.
KnowledgeProcessor[input]: A language model designed to answer questions based on a given text. It requires a question referencing a #Evidence[index] variable as input.

The output should follow this format:
Plan: [First action]
#Evidence1 = [Function to call with input]
Plan: [Next action]
#Evidence2 = [Next function to call with input, possibly referencing previous evidence]
...
Final Answer: #Evidence[n]

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


Instruction:
A chat. Please develop a step-by-step plan to generate a response to the user instruction, making use of 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.

Here are the tools available to be called:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine. This tool finds 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.
HyperlinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AskAI[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, e.g. What color is the car, 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: What are the main ingredients in a traditional Greek moussaka and how is it prepared?


Instruction:
A chat. Develop a plan to answer the user query using the listed tools. Each step should have a corresponding evidence value which is the output of the function called at that step.

Available tools:
DuckDuckGo[input]: A tool that lets users search for information via DuckDuckGo. Useful for getting a list of sites that might contain the answer.
PageLoader[input]: Loads one or more websites from an input string containing newline-delimited links. Input is one or more links and the output is the text content of these links.
URLPicker[input]: Picks out URLs from a block of plain text and outputs them as a newline-delimited string.
InfoBot[input]: An AI model capable of answering questions based on an input text passage. The input should be a question that refers to an :evidence[n]: variable, like "What is the population of Paris, given :evidence1:?"

Output format:
Plan: [first action]
:evidence0: = [function call with input]
Plan: [next action, based on :evidence0:]
:evidence1: = [next function call with input, possibly referring to previous evidence]
...
Answer: [:evidence[n]: contains final answer.]

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


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

Here are the tools available to be called:
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.
LinkParser[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
NLPModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :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 book did they write about their experience?


Instruction:
A chat. Plan a structured way to handle this request using these tools:
LibraryCatalogSearch[input]: Searches library catalogs for relevant resources.
ManuscriptReader[input]: Reads manuscripts for pertinent information.
AbstractCreator[input]: Creates abstracts of lengthy texts.
VeracityExaminer[input]: Examines the veracity of assertions.
ContextualAnswerer[input]: Provides answers based on contextual comprehension.

Question: Discuss the evolution of English literature from the Middle Ages to the present day.


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

Here are the tools you have at your disposal:
WebSearch[input]: This tool allows you to perform a web search for any given input string. It returns a list of sites that may contain relevant information.
ReadPage[input]: This tool reads and extracts text from a specific webpage URL. The output is plain text containing the content of the page.
AskAI[input]: This tool answers questions based on common sense, general world knowledge, or given context. It requires a question as input and can use previous evidence values for context.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response of newline-delimited links.

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

The output format should be:
Plan: [first action]
#E1 = [function with input parameter]
Plan: [next action]
#E2 = [next function with input parameter, possibly referencing #E1]
...
Final answer: #E[n]

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


Instruction:
A chat. Please generate a step-by-step plan to answer the user's query by utilizing the below mentioned tools. Each tool requires an input and generates an output which can be saved into a variable #E[index] for future references.

Tools Available:
DuckDuckGo[input]: A search engine tool that helps in finding appropriate sites related to the input query.
URLLoader[input]: Loads the content of one or multiple URLs provided in the input string and returns a plain text output containing the content of the pages.
HyperlinkExtractor[input]: Extracts hyperlinks from the plain text and provides a newline delimited response of links.
NLPModel[input]: A language model designed to answer questions based on a given passage of text. It requires a textual question that refers to an #E[n] variable.

Output Format:
Plan: [Initial Action]
#E1 = [Function Call with Input Parameter]
Plan: [Next Step Based on Result of #E1]
#E2 = [Subsequent Function Call and Input Parameter, May Include Reference to Previous Evidence]
...
Final Answer: #E[n]

Question: Who is the founder of SpaceX and what are their major achievements?


Instruction:
A chat. Formulate a plan to respond to: "What's the highest peak in the Alps and how high is it?"

Tools at your disposal:
MountainInfo[input]: Tool that gives information about a specific mountain, including its height.
GeoSearch[input]: Tool that searches geographical facts and data.
QA[input]: Tool that answers questions using general world knowledge.

Output format:
Plan: starting action
#E1 = function with input parameter
Plan: following action, based on #E1
#E2 = next function with input parameter (may reference previous evidence)
...
Final Answer: #E[n]


Instruction:
A chat. Create a plan to answer the following question using the set of tools provided. Each tool can be invoked with an input string and will provide an output which can be used as evidence in subsequent steps.

Tools available:
DuckDuckGo[input]: Allows you to perform a web search using DuckDuckGo. Useful for finding potential sources of answers.
WebScraper[input]: Takes one or more URLs and returns the plain text content of those pages.
InfoExtractor[input]: Extracts specific pieces of information from a larger body of text.
SmartQA[input]: An advanced AI tool capable of answering complex questions when provided with enough context.

Output Format:
Plan: [First Action]
#Evidence1 = [Function Call]
Plan: [Next Action]
#Evidence2 = [Function Call, potentially referencing #Evidence1]
...
Final Answer: #EvidenceN

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


Instruction:
A chat. Create a step-by-step plan to answer the user query, using the following tools. Each tool should be used at least once and each plan must have an associated evidence value.

Here are the available tools:

Bing[input]: This tool allows you to search for information on Bing. It's useful for finding websites that may contain answers to your question.
WebCrawler[input]: This tool extracts text from one or more web pages provided in the input string (newline separated links). The output is plain text content of these pages.
LinkPicker[input]: Extracts URLs from plain text and outputs them as newline-separated strings.
InfoGatherer[input]: A question answering tool that can provide answers based on general knowledge or given context. The input should be a question which might reference previous evidence variables.

The output format should be as follows:
Plan: [First action]
#E1 = [Function call with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next function call with input parameters possibly referencing #E1]
...
Final Answer: #E[n]

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


Instruction:
A chat. Develop a plan to identify the author of the book 'War and Peace' and list three other books they have written.

Tools available:
BookInfo[input]: Tool that provides information about a particular book including the author's name.
AuthorWorks[input]: Tool that lists works by a particular author.
ListFormatter[input]: Tool that formats a list into a readable sentence.
QA[input]: Tool that answers questions using general world knowledge.

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


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

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

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

Ensure to only include one evidence output per plan step.

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

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


Instruction:
A chat. Generate a step-by-step execution plan to answer the user's question using the available tools. For each step, specify the corresponding evidence value which would be the output of the function used in that step.

Available Tools:
DuckDuckGo[input]: This tool uses DuckDuckGo search engine to retrieve information related to the input query. It generates a list of websites that could potentially contain the necessary information.
PageReader[input]: Reads the contents of one or more web pages provided as newline separated links in the input string and gives a plain text output of the page contents.
URLGrabber[input]: Grabs all URLs present in the given plain text and returns them as a newline separated list.
InfoBot[input]: A Question Answering bot that answers queries based on an input passage of text. The input must be a text question that refers to an :evidence[n]: variable, e.g., What is the capital of France, given :evidence1:?

Output Format:
Plan: [First Action]
:evidence0: = [Function Call with Input Parameter]
Plan: [Next Action Based on Result of :evidence0:]
:evidence1: = [Next Function Call with Input Parameter possibly referencing previous evidence like "Given Context :evidence0"]
...
Final Answer: [:evidence[n]: Containing Final Answer]

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


Instruction:
A chat. Create a detailed execution plan to respond to the following query using the provided tools. For each step in your plan, indicate the specific tool you would use along with its input parameters. You can store the outputs of these tools into variables named #E[index] that can be referenced in subsequent steps.

Available Tools:
DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to retrieve information related to the input query.
WebReader[input]: A tool that loads the contents of one or more websites specified by the input URLs and returns the text content.
LinkPicker[input]: A tool that extracts URLs from the provided text.
HAL[input]: A language model capable of answering questions when provided with a context. The input to this tool should be a question referencing a previously stored piece of evidence (e.g., "What is the population of city X, given #E1?").

Output Format:
Plan: [First step in the plan]
#E1 = [Tool to use with input parameters]
Plan: [Subsequent step(s) in the plan]
#E2 = [Next tool to use with input parameters, possibly referencing previous evidence]
...
Final Answer: #E[n]

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


Instruction:
A chat. Please provide a detailed plan to generate an ideal response to the user instruction, making use of the set of available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string.

Available Tools:
InfoFinder[input]: Searches for information online about the input query.
PageScraper[input]: Retrieves the main body of text from a webpage URL.
LinkExtractor[input]: Extracts all URLs from a block of text.
KnowledgeBase[input]: Answers questions based on general knowledge and specific context provided as input.

Output Format:
Step 1: [Action]
Data1 = [Function call with input]
Step 2: [Next action based on Data1]
Data2 = [Next function call with input, possibly referencing Data1]
...
Answer: [DataN containing the final answer.]

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


Instruction:
A chat. Create a plan to answer the following question using the tools provided. For each step, provide an evidence variable that stores the output of the tool used in that step.

Available Tools:
1. Bing[input]: This function allows you to search for information on Bing. The input should be a string containing your query.
2. TextAnalyzer[input]: Analyzes text and extracts key details such as names, places, dates etc. Input is plain text from previous steps.
3. QA[input]: Answers questions based on common sense or given context. The input must be a text question referencing one or more :evidence[n]: variables.
4. PatentSearcher[input]: Searches for patents held by a person or company. The input should be a name.

The output format should be:
Plan: [first action]
:evidence0: = [function with input parameter]
Plan: [next action]
:evidence1: = [next function with input parameter, possibly referencing :evidence0:]
...
Answer: [:evidence[n]: containing final answer]

Question: Who is the author of "War and Peace" and what are some other works they have written?


Instruction:
A chat. Create a step-by-step plan to solve the following problem 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 either the user's question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information from various sources on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a website link provided as input and produces a readable text output containing the content of the link.
LinkCollector[input]: Collects all links embedded within a block of text provided as input and outputs them as a list.
QAModel[input]: A question answering model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Remember to include 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 2022 FIFA World Cup and what was their path to victory?


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:
YahooSearch[input]: Tool that allows the user to search for information using Yahoo Search. This tool is useful in finding a suitable list of sites that may contain the answer to the user's question.
WebCrawler[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.
HyperlinkExtractor[input]: Extract hyperlinks 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 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 is the director of the movie Inception and what other movies have they directed?


Instruction:
A chat. Generate a detailed plan to respond to the following user query, utilizing the provided tools. Each plan should correspond to an evidence value which would be the output of one of the available functions given an input string. This could either be the user's question, previous evidence values, or a mix of both.

Available tools:
DuckDuckGo[input]: A tool allowing users to search for information via DuckDuckGo. It helps in locating potential sites that might contain answers to the user's question. It does not provide direct answers but generates a list of sites that might hold the answer.
SiteReader[input]: Loads one or multiple websites from an input string containing newline-separated links. The input consists of one or more links, and the output contains the plain text content of these links.
HyperlinkCollector[input]: Gathers links from plain text and outputs a plain text, newline-separated list of links.
QAModel[input]: An AI-powered question-answering model that excels at providing answers based on a given text passage. The input should be a textual question referencing an :evidence[n]: variable, such as 'What is the height of Mount Everest, given :evidence1:'?

Inputs to all functions should be plain strings, without any quotation marks or '+' symbols to concatenate a string with an evidence variable, like QAModel[What is the population of Tokyo, given :evidence2:?].

Ensure you only include one evidence output per plan step.

Output should follow this format:
Plan: [Initial action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameter, potentially referring to previous evidence, i.e., 'Given context :evidence0']
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

Question: What is the significance of the Battle of Waterloo and how did it influence European history?


Instruction:
A chat. Develop a sequential plan to respond to the following query utilizing the provided tools. For each stage of the plan, assign an evidence value that corresponds to the output of the utilized tool given an input string.

Available Tools:
DuckDuckGo[input]: A tool that enables users to perform internet searches via DuckDuckGo. It returns a list of potential sources that might contain answers to the user's query.
WebReader[input]: Loads one or more websites specified by newline separated links in the input string and provides their textual content as output.
URLExtractor[input]: Extracts URLs from a block of text and outputs them as newline-separated strings.
KnowledgeModel[input]: A language model capable of answering questions when provided with relevant context. The input should be a question referencing an :evidence[n]: variable.

Output Format:
Plan: [First action based on the input question]
:evidence0: = [Tool to utilize with corresponding input]
Plan: [Subsequent action dependent on :evidence0:]
:evidence1: = [Next tool and input, potentially referencing prior evidence]
...
Final Answer: [:evidence[n]: holding the final response]

Question: Who won the 2020 US Presidential Election and what were some key issues during his campaign?


Instruction:
A chat. Generate a detailed plan to respond to the user's instruction utilizing the available tools. For every step in the plan, there must be corresponding evidence obtained from one of the tools.

Available tools include:
Bing[input]: A tool that uses Bing search engine to look up information online.
PageReader[input]: Reads a webpage and extracts plain text content.
QAEngine[input]: A question answering tool that can provide answers given a specific context.
HyperlinkCollector[input]: Collects all hyperlinks present in a given piece of text.

Output Format:
Plan: [Initial Action]
#Evidence1 = [Tool to use with its input]
Plan: [Subsequent action]
#Evidence2 = [Next tool to use with its input, could reference prior evidence]
...
Answer: [#EvidenceN]

Question: Who was the first person to climb Mount Everest and what challenges did they face?


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

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

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

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


Instruction:
A chat. Create a detailed execution plan to respond to the following query, utilizing the provided digital tools. Each step in your plan should correspond to an evidence value, derived from the output of a specific tool function, fed by either the original query, preceding evidence values, or a mix of both.

Available Tools:
Encyclopedia[input]: A tool enabling users to pull data from an online encyclopedia. This tool is especially handy when seeking factual details regarding individuals, locations, organizations, historical occurrences, etc.
QA_Bot[input]: A tool capable of providing answers directly based on general knowledge and common sense, as well as responding to queries given an input context possibly containing the answer.
DataMiner[input]: A tool that extracts structured data from unstructured sources.
TextAnalyzer[input]: Analyzes a body of text and provides a summary.

Output Format:
Plan: [Initial action based on input query]
#E1 = [Function to invoke with input parameters]
Plan: [Subsequent action depending on #E1 outcome]
#E2 = [Next function invocation with input parameters, potentially referencing prior evidence like "Given context #E1"]
...
Final Response: #E[n]

Question: Who was Leonardo da Vinci and what are some of his most notable works?


Instruction:
A chat. Develop a sequential plan to generate an optimal response to the user instruction, utilizing a variety of available tools. Every plan should correspond to an evidence value, which will be the outcome of one of the accessible functions provided an input string that could be the user query, one or several prior evidence values, or a combination of both.

Available tools:
BingSearch[input]: Allows the user to look up information using Bing. It is handy in locating sites that might contain the user's question's answer.
SiteReader[input]: Loads one or multiple websites from the input string comprising newline separated links, where input is one or more links, and generates plain text output having the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and creates a plain text, newline separated response of links.
QuerySolver[input]: A question-answering tool, especially useful in responding to queries based on an input text passage. The input needs to be a textual question that refers to an :evidence[n]: variable, e.g., Who wrote War and Peace, given :evidence1:?

Output format:
Plan: [initial action based on input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action, depending on :evidence0:'s result]
:evidence1: = [following function to call and input parameter, possibly referencing previous evidence, e.g., "Considering context :evidence0"]
...
Final Answer: [:evidence[n]: holding the ultimate answer]

Question: Can you provide details about the major works of J.K. Rowling and her contribution to literature?


Instruction:
A chat. Provide a detailed plan to find the answer to the user's query using the available tools. Each step must correspond to one piece of evidence.

Tools Available:
DuckDuckGo[input]: Performs a DuckDuckGo search with the input string.
ReadPage[input]: Reads a webpage and returns the plain text content.
QA[input]: Answers questions based on general knowledge or given context.
LinkExtractor[input]: Extracts links from plain text.

Output Format:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action]
:evidence1: = [function call with input parameter]
...
Answer: [:evidence[n]:

Question: How did Albert Einstein contribute to the field of physics?


Instruction:
A chat. Formulate a systematic approach to address the user's question employing the tools provided. Each step should align with an evidence value, which stands as the output of a function given its input.

Accessible Tools:
ExciteSearch[input]: A tool that uses Excite search engine to compile information relating to the input query.
PageFetcher[input]: Retrieves numerous websites from the input string featuring newline separated links and offers plain text content of these links.
AnchorRetriever[input]: Retrieves anchors from plain text and delivers them as newline separated strings.
GeniusAnswer[input]: An AI-facilitated question-answering tool that necessitates a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Primary action based on input question]
:evidence0: = [Function to execute with input parameters]
Plan: [Succeeding action based on the fallout of :evidence0:]
:evidence1: = [Future function to operate with input parameters possibly alluding to earlier evidence]
...
Final Answer: :evidence[n]:

Question: What is the highest mountain in Europe and how high is it?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
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 output should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the 2022 FIFA World Cup and what was their journey to victory?


Instruction:
A chat. Provide a comprehensive plan to solve the user's question using the tools at hand. Each action taken should correspond to a function call and store the result in a variable #E[index] for future reference.

Tools Available:
GoogleSearch[input]: Searches Google for relevant websites and returns a list of results.
WebScraper[input]: Loads a website from the input URL and produces plain text content.
FactChecker[input]: Verifies factual information given a specific claim.
LLM_QA[input]: Answers questions based on an input passage of text.

The output should follow this structure:
Plan: [First action]
#E1 = [Function call with input]
...
Final Answer: #E[n]

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


Instruction:
A chat. Formulate a strategy to answer the following inquiry utilizing the tools listed below. For every step of your strategy, provide an associated evidence value, which represents the output of one of the available functions when fed a particular input string.

Tools at your disposal:
DuckDuckGo[input]: Allows users to perform searches using DuckDuckGo. Can help locate a variety of sites potentially containing the answer to the user's query.
WebReader[input]: Reads one or more websites from the input string containing newline delimited links, where input is one or more links, and generates plain text output containing the content of the links.
HyperlinkCollector[input]: Gathers hyperlinks from plain text and provides a plain text, newline separated list of links.
InfoBot[input]: A language model capable of answering questions given an input context that may contain the answer.

Each function requires a plain string as input. Do not use quotes or "+" to combine a string with an evidence variable (for example, InfoBot[What is the population of Canada, considering :evidence3:?]).

Ensure to generate just one evidence output for each step of the plan.

The output should follow this structure:
Plan: [initial action]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action, based on outcome of :evidence0:]
:evidence1: = [next function to call and input parameter, possibly referring to prior evidence]
...
Final Response: [:evidence[n]: which includes the ultimate answer.]

Question: What is the primary diet of kangaroos and how does it affect their lifestyle?


Instruction:
A chat. Please provide a step-by-step plan to solve the user's query using the available tools. For each plan, indicate the tool along with the input to retrieve evidence. You can store the evidence into a variable #E[index] that can be called by later tools.

Available tools:
Bing[input]: Allows users to search for information using Bing search engine.
PDFReader[input]: Reads PDF files from the provided link and outputs plain text.
Translate[input]: Translates text from one language to another.
QA[input]: Can answer questions based on common sense, general world knowledge or given input context.

Output format:
Plan: [first action]
#E1 = [function with input]
Plan: [next action based on #E1]
#E2 = [next function and input]
...
Final answer: #E[n]

Question: What are the main points discussed in the French version of the research paper at https://www.example.com/research.pdf?


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:
WebSearch[input]: Tool that allows the user to search for information using any popular web search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the historical significance of the Battle of Gettysburg?


Instruction:
A chat. Generate a plan to solve the following problem using the tools at your disposal. Each plan should be accompanied by an evidence value, which represents the output of one of the available functions given an input string that could be the user question, previous evidence values, or a combination of both.

Available tools:
BingSearch[input]: A tool that enables users to search for information via Bing. Useful for locating potential sources of answers.
WebReader[input]: This tool reads content from websites. Input should be one or more URLs, separated by commas.
URLCollector[input]: Collects URLs from a block of text and outputs them as a list.
KnowledgeProcessor[input]: Answers questions based on a supplied text passage. The input needs to be a textual question referencing an :evidence[n]: variable, such as 'What is the capital city, given :evidence1:?'.

Output format:
Plan: [First action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action, based on outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, potentially referring to prior evidence, e.g., 'Given context :evidence0']
...
Final Answer: [:evidence[n]: - contains the final response]

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


Instruction:
A chat. Formulate a plan to address the user's query using the tools provided. Each step in your plan should generate an evidence value, which is the output of a function called with a specific input string (the user's question, prior evidence values, or a combination).

Available tools:
InfoFinder[input]: Searches the internet for information related to the input. Outputs a list of potential sources.
ContentReader[input]: Reads the content of a URL and provides it as plain text.
QuerySolver[input]: Can answer questions based on general knowledge and given context. References an :evidence[n]: variable in its input.
URLPicker[input]: Picks URLs from a given text and outputs them as a comma-separated string.

The output should follow this structure:
Plan: [initial action based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action based on the outcome of :evidence0:]
:evidence1: = [next function to call and input parameter, potentially referencing earlier evidence]
...
Final Answer: [:evidencen:, which contains the ultimate answer.]

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


Instruction:
A chat. Develop a plan to address the following query using the listed tools. Every step in your plan should be associated with an evidence value, representing the output of one of the available functions.

Tools at your disposal:
Bing[input]: This tool enables you to conduct a Bing search for information. It provides a list of potentially useful sites but does not directly provide an answer.
URLProcessor[input]: This extracts all the URLs from a block of text.
SiteReader[input]: This tool reads the contents of websites specified by their URLs.
InfoSolver[input]: This tool responds to queries based on a supplied text passage. The input should be a question referencing a :evidence[n]: variable, like "Who won the 2010 world cup, given :evidence1:?"

Output Format:
Plan: [Initial action based on the input question]
:evidence0: = [Function to call with its input parameter]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to call along with its input parameter, possibly referring to prior evidence, such as "Given context :evidence0:"]
...
Answer: [:evidence[n]: Containing the final response.]

Question: What was the main cause of the fall of the Roman Empire and how did it impact Europe?


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

Here are the tools available to be called:
BioInfo[input]: This tool provides biological information related to various life processes.
ScienceDirect[input]: This tool gives access to scientific articles and research papers.
Wikipedia[input]: Tool that allows the user to search for information from Wikipedia.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
PlantDatabase[input]: This tool provides detailed information about different plant species and their biological processes.

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


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

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

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

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


Instruction:
A chat. Develop a comprehensive plan to respond to the user's inquiry using the tools listed below. Each step in your plan should have an associated outcome stored in a variable named :evidenceN:.

Tools Available:
WebCrawler[input]: Crawls the web for information related to the input string.
URLCollector[input]: Collects all URLs from the provided text.
TextExtractor[input]: Extracts all text from the pages of the provided URLs.
AIResponder[input]: Responds to questions using either common sense, general world knowledge, or given context.

Output Format:
Plan: [Initial Step]
:evidence0: = [Call to Function with Input]
Plan: [Subsequent Step Based on Outcome of :evidence0:]
:evidence1: = [Next Call to Function with Input Possibly Referring to Prior Evidence]
...
Answer: [:evidenceN: containing the final response]

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


Instruction:
A chat. Please provide a detailed plan to solve the following question using the tools provided. For each step, indicate which tool you will use and what input you will give it. You can store the output of each tool in a variable :evidence[index]: that can be used as input for subsequent steps.

The available tools are:

WebSearch[input]: This tool allows you to search the web for information related to the input string. It returns a list of relevant websites but does not directly answer the question.
TextAnalyzer[input]: This tool analyzes a text and extracts key pieces of information such as names, dates, places etc. The input should be a piece of text and the output is a structured summary of the key details from the text.
QA[input]: This tool answers questions based on general knowledge or given context. The input should be a question and the output is an answer to the question.
DocumentReader[input]: This tool reads a document (like a PDF) and outputs its content as plain text. The input should be a link to a document and the output is the text content of the document.

Your response should follow this format:
Plan: [first action]
:evidence1: = [tool to call with input parameter]
Plan: [next action]
:evidence2: = [next tool to call with input parameter, possibly referencing previous evidence]
...
Final Answer: :evidence[n]:

Question: What were the main causes of World War II according to the book "The Second World War" by Antony Beevor?


Instruction:
A chat. Please create a step-by-step plan to respond to the user's instruction, making use of the available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that can be the user's question, previous evidence values, or both.

Here are the tools available to be called:
YahooSearch[input]: Allows the user to search for information using the Yahoo search engine. Useful in finding a list of sites that may or may not contain the answer to the user's question.
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.
HyperlinkHarvester[input]: Extracts hyperlinks from plain text and produces a plain text, newline-delimited response of links.
QAModel[input]: Question-answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., How tall is the Eiffel Tower, given #E1?

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

Ensure to include only one evidence output per plan step.

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

Question: Who invented the telephone and when was the first successful demonstration conducted?


Instruction:
A chat. Formulate a step-by-step strategy to address this question using these tools:
DuckDuckGoSearch[input]: Uses DuckDuckGo to find information.
ForumExplorer[input]: Explores forums for relevant discussions.
ContentSimplifier[input]: Simplifies complex text into understandable language.
FactInspector[input]: Inspects facts for accuracy.
ContextualInquirer[input]: Inquires contextually to answer questions.

Question: How did the Renaissance influence modern art?


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

Here are the tools available to be called:
GoogleSearch[input]: Tool that allows the user to search for information using the Google search engine.
ExtractLinks[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
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.
AnswerGenerator[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 on input question]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #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. Create a detailed action plan to address the user's request by leveraging the listed tools. Every plan must correspond to an evidence output.

Tools available:
LinkedIn[input]: Tool that retrieves professional profiles and company information.
Glassdoor[input]: Tool that provides company reviews and salary information.
Indeed[input]: Tool that fetches job postings based on location and job title.
ResumeParser[input]: Tool that extracts information from a resume document.
JobMatch[input]: Tool that matches skills extracted from a resume with job requirements.

Question: Find out more about the company 'Microsoft', check if there are any software engineer job openings in Seattle, extract skills from my resume, and see if they match the job requirements.


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:
GoogleSearch[input]: Tool that allows the user to search for information using Google. This tool is useful in finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KnowledgeModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


Instruction:
A chat. Please generate a step-by-step plan to answer the following question, making use of the available tools. Each plan will have a corresponding evidence value which is 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 available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from websites provided as newline delimited links in the input string.
LinkPicker[input]: Picks out links from plain text and produces a plain text response with newline separated links.
ALM[input]: An advanced language model designed to answer questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

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


Instruction:
A chat. Develop a sequential plan to respond to the user query utilizing the provided tools. Each step in the plan should generate an evidence value which corresponds to the output of one of the available functions when supplied with an appropriate input string (which could be the original query, prior evidence values, or a mix).

Available tools:
BingSearch[input]: A tool enabling users to conduct informational searches via Bing. It provides a list of potentially relevant websites but does not directly provide answers.
URLLoader[input]: Loads one or multiple websites from an input string consisting of newline-separated URLs. Outputs plaintext content from these sites.
HyperlinkHarvester[input]: Extracts hyperlinks from plaintext and returns them as a newline-separated plaintext list.
QueryBot[input]: A question-answering language model adept at generating responses based on a textual context. Input must be a question referencing an :evidence[n]: variable.

Output format:
Plan: [initial action based on input query]
:evidence0: = [function call with input parameters]
Plan: [subsequent action based on :evidence0:]
:evidence1: = [next function call with input parameters, possibly referencing earlier evidence]
...
Final Answer: [:evidence[n]: - contains the ultimate answer]

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


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.  This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.  The function doesn't directly answer the question; it finds a list of sites that may have the answer.
SiteLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLGrabber[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text.  The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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

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

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


Instruction:
A chat. Develop a step-by-step plan to generate an ideal response to the user instruction, using the set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string 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:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkFinder[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 input must be a text question that references an :evidence[n]: variable, e.g., What color is the car, 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., AIQA[What is the capital of New York, given :evidence3:?]

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

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

Question: Who was the first person to walk on the moon and when did this happen?


Instruction:
A chat. Devise a structured plan to tackle the following query using the designated tools. Every stage of the plan should result in an evidence value, formed by calling a function with an input string that could be the first question, former evidence, or a blend of both.

Here are the tools you can utilize:
LibrarySearch[input]: Searches an online library database for information related to the input string. While it may not offer direct answers, it frequently yields valuable contextual information.
TextCondenser[input]: Condenses a piece of text into its essential points. Especially beneficial when handling voluminous information.
InquiryResponder[input]: Responds to inquiries using ordinary wisdom, general awareness, or particular context derived from previous evidence.

Inputs to each function should be uncomplicated strings, void of quotation marks or "+" signs for string concatenation, e.g., InquiryResponder[Who wrote Pride and Prejudice, given :evidence2:?].

Ensure that every stage in the plan matches up with precisely one evidence output.

Output format:
Plan: [Initial action based on the question]
:evidence0: = [Call to function with input parameter]
Plan: [Subsequent action, bearing in mind the result of :evidence0:]
:evidence1: = [Call to next function with input parameter, possibly referring to earlier evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

Question: Who was Jane Austen and what are her most famous works?


Instruction:
A chat. Please create a detailed plan to answer the following question using the tools provided. Each step in your plan should be accompanied by an evidence variable, representing the output of a particular function when given appropriate inputs.

Available Tools:
YahooSearch[input]: Allows users to conduct a Yahoo search. While it doesn't offer direct answers, it provides a list of potential sources of information.
SiteScraper[input]: Fetches content from one or multiple websites specified in an input string containing newline-separated URLs.
LinkCollector[input]: Pulls out links from a chunk of plain text and presents them in a newline-separated manner.
DataAnalyzer[input]: An AI language model capable of answering queries based on supplied text. The input needs to be a question that refers to a :data[n]: variable.

Output Format:
Plan: [First action based on the question]
:data0: = [Function to run with input parameters]
Plan: [Following action considering :data0:]
:data1: = [Next function to run with input parameters, possibly referencing earlier data such as "With respect to :data0:"]
...
Answer: [:data[n]: contains the final answer.]

Question: Who wrote the novel '1984' and what are some notable works they produced?


Instruction:
A chat. Create a step-by-step plan to answer the user query using 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 that can be the user question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references 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 is the highest peak in the Andes mountain range and what is its elevation?


Instruction:
A chat. Create a plan to solve the following problem using the tools provided. Every plan needs to have a corresponding evidence value which is the result of calling a function with an appropriate input string.

Tools Available:
DuckDuckGo[input]: Allows users to perform a web search using DuckDuckGo. It returns a list of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from the input string containing newline delimited links. Input is one or more links, and it outputs plain text content of the links.
LinkGatherer[input]: Extracts links from plain text and provides a plain text, newline separated list of links.
ALICE[input]: A language model that answers questions based on an input text passage. The input should be a text question referencing an :evidence[n]: variable.

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

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