Instruction:
A chat. Develop a detailed execution plan for solving the following query. Each step of your plan should involve invoking one of the listed functions with a specific input. Store the output of each function invocation in a numbered :Evidence[index]: variable, which you can refer back to in subsequent steps.

Available Functions:
DuckDuckGo[input]: Searches DuckDuckGo for the provided input and returns a list of potential sources.
ExtractLinks[input]: Given a block of text (such as the output of a DuckDuckGo search), this function will return a list of all URLs found within the text.
ReadURL[input]: Given a URL, this function will fetch the page at that URL and return its contents as plain text.
AIQA[input]: A powerful AI-based question-answering system. Can provide direct answers to many types of questions, and can also generate answers based on provided context (for example, the text of a webpage).

Output Format:
Plan: [Description of the first step]
:Evidence0: = [Function call for the first step]
Plan: [Description of the second step]
:Evidence1: = [Function call for the second step]
... and so forth until ...
Final Answer: :EvidenceN:

Question: Who won the Nobel Prize in Literature in 1954 and what were their most significant works?


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

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


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

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

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

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

Question: Who was Alexander Hamilton and what were his major contributions to American history?


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

Here are the tools you can use:
WebSearch[input]: This tool allows users to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
TextScraper[input]: This tool extracts text from one or more websites from the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: An artificial intelligence question answering model, useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


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

Here are the tools available to you:
Bing[input]: This tool allows the user to search for information using the Bing search engine. It is useful in finding sites that may contain the answer to the user's question.
HTMLParser[input]: This tool extracts plain text from HTML content. The input must be HTML content and it produces plain text as output.
URLCollector[input]: This tool collects URLs from plain text and produces a list of newline delimited links.
DeepQA[input]: A deep learning based question answering model. Useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


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

Here are the tools available to be called:
GoogleMaps[input]: Tool that allows the user to search for geographical information using Google Maps.
IMDb[input]: Tool that allows the user to search for information about movies and TV shows from IMDb.
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.
YouTube[input]: Tool that allows the user to search for videos on YouTube.
Dictionary[input]: Tool that provides definitions of words.

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

Question: What is the location of the filming of the movie 'Inception' and what does the word 'inception' mean?


Instruction:
A chat. Please develop a systematic plan to answer the user's query utilizing the provided tools. Each phase of the plan will produce an evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
YahooSearch[input]: A tool that enables the user to look up information using the Yahoo search engine. This tool is handy for locating a list of sites that may hold the answer to the user's question. It does not provide a direct answer to the question but identifies potential sources of answers.
WebScraper[input]: Loads one or more websites from the input string containing newline-delimited links, where input is one or more links, and generates plain text output containing the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and produces a plain text, newline-delimited response of links.
MLQA[input]: Machine Learning Question Answering model, particularly effective at answering questions 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 height of Mount Everest, 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 author of the book 'To Kill a Mockingbird' and what other books have they written?


Instruction:
A chat. Create a plan to answer the following question using the available tools. For each step of the plan, specify which tool you would use and what input you would give it. Store the output of each tool in a variable #E[index] that can be used as input for subsequent steps.

Here are the tools available to be called:
SearchEngine[input]: A tool that allows the user to search for information on the internet. The input should be a string containing the query.
DocumentReader[input]: This tool reads documents and extracts relevant information based on the given input.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
LinkExtractor[input]: Extracts links from plain text and produces a list of links.
Scraper[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.

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

Question: What is the population of the largest city in France?


Instruction:
A chat. Generate a detailed execution plan to address the following user instruction, making use of the provided set of tools. Each plan will correspond to an evidence value, which will be the outcome of one of the accessible functions given an input string that could be the user's question, one or more preceding evidence values, or a combination of both.

Available tools to be used:
DuckDuckGo[input]: A tool that enables the user to search for information via the DuckDuckGo search engine. It assists in locating a suitable list of sites that might have the answer to the user's inquiry.
WebReader[input]: Loads one or more websites from the input string consisting of newline separated links. The input is one or more links, and it generates a plain text output containing the link contents.
HyperlinkFinder[input]: Extracts hyperlinks from plain text and delivers a plain text, newline-separated response of links.
ASKER[input]: A question-answering language model, especially effective at answering queries based on an input text passage. The input has to be a textual question that refers to an :evidence[n]: variable, like 'What is the population of Tokyo, given :evidence1:?'.

Output format:
Plan: [First action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action based on the result of :evidence0:]
:evidence1: = [Next function to call and input parameter, possibly referencing previous evidence, such as "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the final answer]

Question: What is the current market capitalization of Amazon and how did it change over the last year?


Instruction:
A chat. Provide a detailed plan to solve the following problem using the tools at your disposal. Each tool execution will provide an evidence value which can be utilized in subsequent steps.

Tools Available:
WebSearch[input]: A tool that searches the web for information related to the input query.
LinkCollector[input]: Collects all links present in the provided text.
ContentScraper[input]: Scrapes the content of the provided URLs.
InfoProcessor[input]: Processes the scraped content and provides concise information.
QueryAnswerer[input]: Answers queries based on the processed information.

Output Format:
Step: [Action to take]
:Evidence1: = [Tool to use with input parameters]
Step: [Next action based on :Evidence1:]
:Evidence2: = [Next tool to use with input parameters, potentially referencing :Evidence1:]
...
Final Response: [:EvidenceN:]

Question: Who won the Nobel Prize in Literature in 2019?


Instruction:
A chat. Create a plan to answer the following question: "What is the main diet of the Giant Panda and where can they be found in the wild?" using these tools:

1. WebSearch[input]: A tool that performs an internet search based on the input string.
2. Extractor[input]: This tool extracts key information from a large amount of text, such as the results of a web search.
3. Atlas[input]: A tool that provides geographical information about specific places or regions.
4. QandA[input]: A tool that answers questions based on provided context.

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


Instruction:
A chat. Create a sequential plan to answer the following question using the provided tools. Each step in your plan should correspond to an evidence variable.

Tools Available:
Encyclopedia[input]: Searches for detailed information about the input topic from an online encyclopedia.
FactChecker[input]: Verifies the truthfulness of a statement or fact.
NewsArchive[input]: Searches through archived news articles related to the input topic.
AIQA[input]: AI Question Answering system that answers questions based on the input context.

Output Format:
Plan: [action to take]
#E[index] = [tool to use with input]
...
Final Answer: #E[n]

Question: Did Albert Einstein win a Nobel Prize and if so, what was it for?


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:
Google[input]: Tool that allows the user to search for information using the Google search engine.
Scraper[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.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
LLM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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

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


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

Tools Available:
YahooSearch[input]: Uses Yahoo's search engine to gather information related to the input query.
PageLoader[input]: Loads webpage content from one or multiple URLs provided in the input.
HyperlinkFinder[input]: Extracts hyperlinks from a block of text.
ALICE[input]: An AI-driven question-answering tool. It requires a question and a context (which can be a previous #E[index]) to provide an answer.

Output Format:
Plan: [description of the first step]
#E1 = [tool to use with input]
Plan: [description of the subsequent step based on the result of #E1]
#E2 = [next tool to use with input, potentially referring to #E1]
...
Final Answer: #E[n]

Question: What were the main causes of World War I and what countries were primarily involved?


Instruction:
A chat. Develop a detailed execution plan to respond to the following query using the below mentioned tools. Each plan will correspond to an evidence value which will be the output of a particular function when supplied with an appropriate input string.

Tools available:
WikiSearch[input]: A tool that searches Wikipedia for information related to the input string.
PageScraper[input]: Scrapes all the text from a webpage whose URL is provided as the input.
URLCollector[input]: Collects all URLs embedded within a piece of text provided as the input.
AIAnswerer[input]: An AI model that answers questions based on a piece of text provided as the input. The input should be a question referencing a :evidence[n]: variable.

Output format:
Plan: [First action]
:evidence0: = [Function to execute with input parameters]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Next function to execute with input parameters, possibly referring to prior evidence]
...
Final Answer: [:evidencen:]

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


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[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 cat, given :evidence1:?

The input to each function 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 won the Nobel Prize in Physics in 2020 and what was their contribution?


Instruction:
A chat. Please develop a plan to solve 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 either the user's query or one or more previous evidence values.

Here are the tools you have at your disposal:

1. Bing[input]: This tool allows users to search for information using the Bing search engine. It doesn't directly answer questions but provides a list of sites that might contain the desired information.
2. SiteReader[input]: This function loads one or more websites from the input string containing newline-delimited links and produces plain text output with the content of those links.
3. LinkPicker[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
4. QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

Question: What is the history of Microsoft Corporation and who is its current CEO?


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a general 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.
PageReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the pages.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


Instruction:
A chat. Generate a step-by-step plan to address the user query, utilizing the provided tools. Each plan will correspond to an evidence value, derived from the output of a function given an input string that could be the user's question, prior evidence values, or a combination thereof.

Available tools:
DuckDuckGo[input]: A tool allowing users to search for information via the DuckDuckGo search engine. Useful for locating potential sources that might hold answers to the user's question.
SiteLoader[input]: Loads one or more websites from an input string comprising newline-separated links. Input is one or more links; output is plain text containing link contents.
HyperlinkExtractor[input]: Pulls out hyperlinks from plain text, returning a plain-text, newline-separated list of links.
InfoModel[input]: A question-answering language model adept at providing answers based on an input text passage. The input needs to be a textual question referencing an :evidence[n]: variable.

Output format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on :evidence0:'s outcome]
:evidence1: = [Next function to call and its input parameter, potentially referring back to earlier evidence]
...
Answer: [:evidence[n]: - contains the final answer]

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


Instruction:
A chat. Generate a methodical plan to address the user instruction utilizing the given tools. Each plan will correspond to an evidence value, which will be the result of one of the available functions given an input string that can be the user question, preceding evidence values, or both.

These are the tools you can use:
YahooSearch[input]: Tool that enables the user to look up information via Yahoo Search. This tool is handy in identifying a suitable list of sites that may hold the answer to the user's question.
HTMLParser[input]: Parses HTML from a webpage link and produces plain text containing the content of the link.
HyperlinkHarvester[input]: Harvests hyperlinks from plain text and yields a plain text response of links.
DeepQA[input]: Deep learning-based Question Answering model, particularly effective in answering queries based on an input text passage. The input must be a text question referring to a :knowledge[n]: variable, e.g., Who won the Nobel Prize in Literature in 2019, given :knowledge1:?

Function inputs should be simple strings without quotes or "+" to concatenate a string with an evidence variable, e.g., DeepQA[Who was the first person to walk on the moon, given :knowledge3:?]

Ensure only one evidence output per plan step.

The output should adhere to this format:
Plan: [first action predicated on input question]
:knowledge0: = [function to call with input parameter]
Plan: [following action based on the outcome of :knowledge0:]
:knowledge1: = [next function to call and input parameter, which may reference earlier evidence, e.g., "Given context :knowledge0"]
...
Answer: [:knowledge[n]: containing the final resolution.]

Question: What are the main ingredients in a traditional Italian lasagna and how is it prepared?


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:
GoogleSearch[input]: Tool that allows the user to search for information using Google's search engine.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
WikiSearch[input]: Searches Wikipedia for information related to the input string.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

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

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


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

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


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
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 Nobel Prize in Physics in 2020 and what was their contribution?


Instruction:
A chat. Develop a plan to answer the following question: "What is the main diet of the African elephant and where can they be found in the wild?" Use the tools provided below:

1. SearchEngine[input]: This tool allows you to search for information using an online search engine. The input should be a string that represents your query.
2. TextParser[input]: This tool extracts key pieces of information from a large body of text. It's useful when you have a lot of data and need to find specific details.
3. MapLocator[input]: This tool helps locate places on a map based on the input string.
4. QA_Tool[input]: A tool that answers questions based on common sense, general world knowledge or given context.

Remember, each step in your plan should correspond with one evidence value (#E[index]). Your final output should follow this format:

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. Generate a comprehensive plan to answer the following query making use of the provided tools. For each step, indicate the corresponding evidence output.

Available Tools:
WikiSearch[input]: Allows users to retrieve information from Wikipedia.
InfoScraper[input]: Scrapes data from specified URL(s) producing plain text output.
LinkGatherer[input]: Extracts links from a given text and returns them as a list.
AnswerBot[input]: Answers questions based on context provided. It requires a text question referencing an #E[index] variable.

Output Format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on the outcome of #E1]
#E2 = [Subsequent function to call with input parameters, potentially referring to prior evidence]
...
Final Response: #E[n]

Question: Who invented the first electric car and when was it made?


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

Available Tools:
AskJeeves[input]: This tool lets users perform a search using the Ask Jeeves search engine.
DataExtractor[input]: This tool pulls out important details from a large amount of text.
HyperlinkHarvester[input]: This tool collects hyperlinks from plain text and returns them in a list.
InfoAnalyzer[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The output should follow this format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on the result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which might reference previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: Containing the final answer.]

Question: Who is the author of War and Peace and what other books did they write?


Instruction:
A chat. Construct a detailed plan to generate a response to the following query using the resources listed below. For each step, assign an evidence value corresponding to the output of a specific function, which could be derived from the initial question or previous evidence variables.

Tools at your disposal include:
BingSearch[input]: Enables users to perform a search using Bing. It provides a list of potentially relevant websites but does not offer direct answers.
UrlGrabber[input]: Retrieves URLs from any given plaintext input, producing a list of newline-separated URLs.
WebsiteReader[input]: Fetches and presents the textual content of any URL(s) provided as newline-separated inputs.
KnowledgeBot[input]: Answers queries based on common knowledge and context obtained from prior evidence.

Your output should follow this structure:
Plan: [Initial action]
:Evidence0: = [Function invocation with appropriate input]
Plan: [Subsequent action dependent on :Evidence0:]
:Evidence1: = [Next function invocation with suitable input, possibly referring to :Evidence0:]
...
Answer: [:EvidenceN:, where N represents the final piece of evidence]

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


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

Here are the tools you can use:
Bing[input]: This tool allows users to search for information using Bing search engine. It is useful in finding websites that may contain answers to the user's questions.
PageReader[input]: This function loads one or more web pages from the input string containing newline separated links. The input is one or more URLs and it produces plain text output with the content of the pages.
LinkCollector[input]: Extracts links from plain text and produces a plain text response with newline-separated links.
QAModel[input]: A language model for answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Remember to include only one evidence output per plan step.

The output format should be as follows:
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 reference previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

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


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
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.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the history of IBM and who were its key founders?


Instruction:
A chat. Create a step-by-step plan to solve the following problem using these tools. Each tool can be called with an input string and will produce some output which you can store in a variable :evidence[n]: for later use.

Here are the available tools:
1. WikiSearch[input]: This tool allows you to search Wikipedia for information on a specific topic. The input should be a search term or phrase.
2. QandA[input]: This is a question answering tool that uses general knowledge and context from previous evidence to answer questions.
3. MapTool[input]: A tool that provides geographical information about a place when given its name as input.
4. Translate[input]: This tool translates text from one language to another, given the input text and target language.

The output format should be as follows:
Plan: [description of first action]
:evidence0: = [first function call]
Plan: [description of second action based on result of :evidence0:]
:evidence1: = [second function call referencing :evidence0:, if necessary]
...
Final Answer: [:evidence[n]: containing the final answer]

Question: What is the history of the Eiffel Tower and what does "Eiffel Tower" translate to in Spanish?


Instruction:
A chat. Please develop a detailed plan to respond to the user's inquiry, utilizing the set of available tools. For each plan, indicate the corresponding evidence value, which would be the output of one of the available functions given an input string.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables the user to search for information via the DuckDuckGo search engine. This tool is beneficial for identifying a range of sites that might contain the answer to the user's question.
LinkGrabber[input]: Grabs links from plain text and generates a plain text, newline separated response of links.
WebReader[input]: Loads one or more websites from the input string containing newline-separated links, where input is one or more links, and produces plain text output containing the content of the links.
AIQA[input]: An artificial intelligence-based question-answering model, especially effective at 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: Who was Nikola Tesla and what were his major contributions to science?


Instruction:
A chat. Develop a systematic plan to tackle this question using these tools:
ScholarlyArticleSearch[input]: Searches scholarly articles for relevant information.
PubMedLookup[input]: Looks up medical research papers on PubMed.
ResearchSummarizer[input]: Summarizes research papers into key points.
FactVerifier[input]: Verifies factual statements.
KnowledgeEngine[input]: AI model that answers questions based on input context.

Question: What is the role of serotonin in human brain function?


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.

Here are the tools available to be called:
BookSummary[input]: Tool that provides summaries of books.
AuthorInfo[input]: Tool that provides information about authors.
GenreClassifier[input]: Tool that classifies books into genres.
ReviewAnalyzer[input]: Tool that analyzes book reviews.
LLM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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

Question: Who wrote the book 'To Kill a Mockingbird' and what genre does it belong to?


Instruction:
A chat. Construct a methodical plan to tackle the user's inquiry utilizing the provided tools. Make sure to label each step of your plan with an evidence marker.

Tools Accessible:
SportsStats[input]: Offers statistics for various sports.
ConcertFinder[input]: Locates concerts based on artist and location.
RecipeSearch[input]: Searches for recipes based on ingredients.
FitnessTracker[input]: Tracks physical activity and health data.
KnowledgeBot[input]: Answers queries using general knowledge or supplied context.

Output Format:
Plan: Preliminary step guided by the input question
#Evidence1 = Operation to carry out with suitable input
Plan: Ensuing step dictated by the outcome of #Evidence1
#Evidence2 = Subsequent operation to undertake with its input, perhaps referring to past evidence like "In light of #Evidence1"
...
Final Answer: #EvidenceN

Question: Who won the last NBA championship, when is the next concert of Coldplay, can you give me a recipe for a high protein meal, and how many calories do I burn running for 30 minutes?


Instruction:
A chat. Create a step-by-step plan to answer the following question using the available tools. Each tool should be used with an input string that can be the user's query, one or more previous evidence values, or both.

Here are the tools available to be called:
GoogleSearch[input]: A tool that allows you to search for information using Google. This tool is useful in finding a list of sites that may contain the answer to your question.
WebScraper[input]: Loads one or more websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QA_Tool[input]: Question answering tool that can answer questions based on common sense, general world knowledge, as well as given input context that may contain the answer.

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

Question: What are some of the most significant contributions made by Nikola Tesla?


Instruction:
A chat. Construct a detailed plan to respond to the following user question using the listed tools. Each plan will align with an evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more former evidence values, or a combination of both.

Here are the tools you can use:
AskJeeves[input]: This tool allows users to search for information using the Ask Jeeves search engine.
URLUnearther[input]: This function extracts URLs from plain text and delivers a plain text list of URLs.
WebFetcher[input]: This tool loads one or more websites from an input string containing newline-separated links, where the input is one or more links, and yields plain text content from those links.
WorldBook[input]: This tool carries out a search on World Book for applicable articles based on the input string.
QuestionCracker[input]: This is a question-answering language model that excels at responding to questions based on an input text passage. The input must be a text question that cites a #H[index] variable.

Output format:
Plan: [First action based on input question]
#H1 = [Function to call with input parameter]
Plan: [Subsequent action based on the result of #H1]
...
Final Reply: #H[n]

Question: What is photosynthesis and why is it important to life on Earth?


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

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information using any popular 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.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the most recent archaeological discovery in Egypt and what significance does it hold?


Instruction:
A chat. Develop a systematic 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 that could be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
URLLoader[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.
HyperlinkParser[input]: Extract hyperlinks from plain text and produces a plain text, newline delimited response of links.
DeepQA[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

The input to each function just just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g., DeepQA[What is the capital of France, 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: What is the significance of the Battle of Hastings and how did it impact England?


Instruction:
A chat. Formulate a plan to answer the following query using the specified tools. Each phase of your plan should correlate with an evidence variable, which will be the output of one of the accessible functions given an input string, which can be the user's question, earlier evidence values, or both.

Tools at your disposal:
YahooSearch[input]: Tool that enables the user to look for information via the Yahoo search engine. It helps in locating websites that may possess the answer to the user's inquiry.
TextScraper[input]: Retrieves plaintext from a website given its URL.
HyperlinkHarvester[input]: Gathers hyperlinks from plaintext and returns a list of newline-separated links.
NeuralNetQA[input]: A neural network-based question-answering model. Especially handy in responding to queries based on an input passage of text. The input has to be a textual question mentioning an :evidence[n]: variable.

Output structure:
Plan: [Initial action predicated on input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action predicated on the outcome of :evidence0:]
:evidence1: = [Following function to invoke and input parameter, potentially alluding to preceding evidence]
...
Answer: [:evidence[n]: Carrying the ultimate response]

Question: Who is the author of "War and Peace" and where were they born?


Instruction:
A chat. Construct a methodical plan to resolve the following user inquiry using the given tools. Each stage of your plan should correspond to an evidence value which signifies the outcome of a function when supplied with its input.

Available Tools:
DataMiner[input]: Uses a broad search engine to gather potential data sources.
ContentReader[input]: Reads through a text and extracts crucial details.
HyperlinkGatherer[input]: Collects all hyperlinks embedded within a specific text.
QuerySolver[input]: Solves queries based on a given context.

Required Output Format:
Step: [Initial action derived from input]
@Evidence1 = [Called function with input]
Step: [Following action derived from @Evidence1]
@Evidence2 = [Next called function with input, could refer to @Evidence1]
...
Final Response: @Evidence[n]

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


Instruction:
A chat. Generate a plan to answer the following query using the provided tools. Each tool should be used at least once and each step of the plan should correspond to an evidence value.

Available Tools:
WikiLookup[input]: Searches Wikipedia for information related to the input string.
WebCrawler[input]: Crawls the web for additional sources of information based on the input string.
TextAnalyzer[input]: Analyzes a block of text and extracts key points and summaries.
QAAssistant[input]: Answers questions based on the input text.

Output Format:
Plan: [First step based on the input question]
#E1 = [Function to call with input parameters]
Plan: [Next step based on the result of #E1]
#E2 = [Next function to call with input parameters]
...
Final Answer: #E[last]

Question: How did the Battle of Waterloo impact Europe's political landscape?


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

Here are the tools available to you:
1. SearchEngine[input]: This tool allows users to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
2. TextExtractor[input]: Extracts text from a webpage given its URL. Input is a link and produces plain text output containing the content of the link.
3. LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
4. AnswerBot[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

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


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 a 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.
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.
LinkPicker[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
NLPModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

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

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


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

Here are the tools you can use:
GoogleScholar[input]: Allows users to search for scholarly literature such as articles, theses, books, conference papers, etc.
PubMed[input]: A free search engine accessing primarily the MEDLINE database of references and abstracts on life sciences and biomedical topics.
SemanticQA[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.
ArxivScraper[input]: Load one or more ArXiv preprints 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.

The output should follow this format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: What are the latest advancements in neurobiology research related to Alzheimer's disease?


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

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

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

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


Instruction:
A chat. Create a systematic plan to solve the user instruction, utilizing a variety of available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user question, one or more previous evidence values, or a mixture of both.

Available tools:
YahooSearch[input]: Allows the user to search for information using Yahoo. Useful for finding lists of sites that might contain the answer to the user's query.
WebScraper[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkGatherer[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
InfoBot[input]: A question-answering bot capable of answering queries based on an input passage of text. The input must be a text question that references a #E[index] variable, e.g., What is the population of Tokyo, given #E1?

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, which may include reference to previous evidence, e.g., "Given context #E1"]
...
Final answer: #E[n]

Question: What is the history behind the construction of the Eiffel Tower and how was it received by the public when it was built?


Instruction:
A chat. Create a sequential plan to solve the problem below using the described tools. Every step should have corresponding evidence which stores the result of the function used in that step.

Tools Available:
DuckDuckGo[input]: Uses DuckDuckGo search engine to fetch relevant data for the input string.
Parser[input]: Parses a webpage and extracts all the textual content.
WebCrawler[input]: Crawls through multiple pages of a website starting from the input URL.
InfoFinder[input]: Answers questions using common sense, world knowledge, or given context.

The output format should be:
Plan: [First action]
$Evi1 = [Function call with input]
Plan: [Next action]
$Evi2 = [Function call with input referring to $Evi1 if necessary]
...
Answer: [$Evin]

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


Instruction:
A chat. Formulate a stepwise plan to generate an answer to the user query, utilizing a selection of available tools. Each step in the plan corresponds to an evidence value, which represents the output of a specific function when supplied with an input string. This input string can either be the user's question, one or more previously obtained evidence values, or a combination thereof.

Tools available for use:
YahooSearch[input]: A tool enabling users to conduct searches via the Yahoo search engine. This tool aids in identifying a range of websites that may hold the answer to the user's question.
SiteReader[input]: Loads one or more websites from an input string consisting of newline-separated links. The input consists of one or more links, yielding plain text output comprising the contents of these links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text, providing a plain text, newline-separated list of hyperlinks as output.
InfoBot[input]: A language model designed to answer questions based on a given passage of text. The input should be a textual question referring to an :evidence[n]: variable.

Output format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, potentially referring to earlier evidence]
...
Final Answer: [:evidence[n]: containing the final answer]

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


Instruction:
A chat. Devise a stepwise plan to respond to the user's inquiry using the listed tools. Each step should produce an evidence value, which is the output of a function invoked with a particular input string - this could be the user's question, past evidence values, or a mix of both.

Tools at your disposal:
NetSearch[input]: Enables the user to look up information online. It yields a list of websites that might hold the answer to the user's question.
PageLoader[input]: Loads the webpage(s) from the supplied link(s) and delivers the content as plain text.
InquiryMaster[input]: Capable of answering questions based on common knowledge and given context. It refers to a *Evidence[index]* variable in its input.
HyperlinkGatherer[input]: Gathers all hyperlinks from the provided text and returns them as a newline-separated string.

Output should adhere to the following format:
Plan: [First action based on the input question]
*Evidence0* = [Function to call with input parameter]
Plan: [Next action, influenced by the result of *Evidence0*]
*Evidence1* = [Subsequent function to call and input parameter, possibly referring back to previous evidence, e.g., "Considering context *Evidence0*"]
...
Final Response: [*EvidenceN*, which includes the final answer.]

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


Instruction:
A chat. Please generate a comprehensive plan to solve the problem below, making use of the available tools. For each plan, indicate which external tool together with tool input to retrieve evidence. You can store the evidence into a variable #Evidence[index] that can be called by later tools.

Here are the tools available to be called:
BingSearch[input]: Tool that allows the user to search for information from Bing.  This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
ParseHTML[input]: Load one or more websites from the input string and produces plain text output containing the content of the site.
URLExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
AIQA[input]: Artificial Intelligence Question Answering tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: When was the first iPhone released and what were its key features?


Instruction:
A chat. Formulate a systematic plan to address the subsequent user question, employing the specified tools. Every stage in your plan should yield a piece of evidence, signifying the output of a designated function upon receipt of its input. Such input could be the primary user question, any evidence produced earlier, or a blend of both.

You can use these tools:
AskJeeves[input]: Enables users to carry out searches via Ask Jeeves. It compiles a list of possible sites that may contain the answer, though it doesn't provide the answer itself.
PageRenderer[input]: Receives one or more URLs (split by newlines) as input and renders the plaintext contents of those pages.
LinkCollector[input]: Collects links from plaintext and presents them as newline-separated plaintext.
QueryEngine[input]: A machine learning language model adept at answering questions when presented with a text excerpt as context. The input needs to be a question pointing to an :evidence[n]: variable, such as "When was the Declaration of Independence signed, given :evidence1:?"

Inputs to these functions should be unadorned strings, free of quotation marks or '+' characters for merging strings with evidence variables. As an illustration, QueryEngine[Who is the President of the United States, given :evidence2:?].

Ensure each plan step incorporates just one piece of evidence.

Your output should adhere to this layout:
Plan: [Primary action derived from input question]
:evidence0: = [Function to execute with input parameter]
Plan: [Subsequent action, guided by the outcome of :evidence0:]
:evidence1: = [Next function to execute with input parameter, potentially alluding to preceding evidence like "Considering :evidence0"]
...
Final Solution: [:evidence[n]: encompassing the definitive answer.]

Question: What led to the fall of the Roman Empire and what impact did it have on Europe?


Instruction:
A chat. Develop a plan to respond to the user's inquiry using the provided tools. For each stage of your plan, create an evidence variable to hold the output of a function call.

Available tools:
InternetSearch[input]: Searches the internet for information relevant to the input query.
SiteScraper[input]: Scrapes a website for textual content. Input is a URL, and output is the site's text content.
InfoExtractor[input]: Extracts key pieces of information from a text based on the input query.
QAModel[input]: Provides answers to questions either from common sense or given a context.

Output format:
Plan: [first action]
:Evidence0: = [first function call with input]
Plan: [subsequent action, based on :Evidence0:]
:Evidence1: = [next function call with input, potentially referring to :Evidence0:]
...
Answer: [:EvidenceN:, containing the final response.]

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


Instruction:
A chat. Generate a step-by-step execution plan to solve the user's query using the following tools. Each plan should correspond to an evidence value (#E[index]).

Tools:
DuckDuckGo[input]: Allows users to search for information via DuckDuckGo. Finds websites that might have the answer.
WebParser[input]: Loads websites from an input string (newline delimited links) and outputs the content in plain text.
URLExtractor[input]: Extracts URLs from plain text and provides a newline-delimited list of links.
AIQA[input]: AI-based question answering system. Can answer questions given context from prior evidence variables.

Output Format:
Plan: [First action]
#E1 = [Function call with input]
Plan: [Next action]
#E2 = [Next function call with input, possibly referencing #E1]
...
Final Answer: #E[n]

Question: Who invented the Python programming language and what were his motivations?


Instruction:
A chat. Create a step-by-step plan to answer the user's question: "Who was the first person to climb Mount Everest without supplemental oxygen and what were his reasons?" You have the following tools available:

WikiLookup[input]: Searches Wikipedia for a page matching the input query and returns the full text of the page.
LinkExtractor[input]: Extracts all links from a block of text.
DeepRead[input]: Reads a long passage of text and answers questions based on it.
InterviewSimulator[input]: Simulates an interview with a historical figure based on known facts about them.

Your output should look like this:
Plan: [first action]
:Evidence0: = [tool to use with input]
Plan: [next action]
:Evidence1: = [next tool to use with input, possibly referencing :Evidence0:]
...
Answer: [:EvidenceN:]


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

Available Tools:
Bing[input]: A tool for searching information on Bing search engine. This function does not directly answer questions but provides a list of websites which may contain the answers.
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.
LinkPicker[input]: Extracts links from plain text and generates a plain text, newline delimited response of links.
AIQA[input]: An AI-based question answering tool that can provide direct answers based on general knowledge or given context (input passage of text).

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 parameter, possibly referencing previous evidence]
...
Final Answer: #E[n]

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


Instruction:
A chat. Please generate a step-by-step execution plan to solve the problem using the provided tools. Each tool should produce an evidence value, which is the output of a function given an input string (which could be the user's question, previous evidence values, or both).

Available tools:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to find information. It provides a list of sites that might contain the answer to the user's question.
WebScraper[input]: Loads one or more websites from the input string, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: An AI-powered question answering model. It 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 car, given :evidence1:?

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

Question: Who invented the World Wide Web and what were its initial purposes?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information from Bing search engine. This tool is useful in finding relevant websites that may contain the answer to the user's query.
SiteReader[input]: Loads and reads the content of a website provided as input and produces plain text output containing the content of the site.
LinkPicker[input]: Extracts links from plain text and provides a list of links.
LMQA[input]: Language model question answering tool, useful in answering questions based on an input passage of text. The input must be a text question that references a :proof[n]: variable, e.g., What color is the dog, given :proof1:?

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

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]
:proof0: = [function to call with input parameter]
Plan: [next action to take, based on result of :proof0:]
:proof1: = [next function to call and input parameter, which may include reference to previous proof, e.g., "Given context :proof0"]
...
Answer: [:proof[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. Provide a comprehensive plan to respond to the user query utilizing the available tools. Every plan will correspond to an evidence value, which will be the output of one of the provided functions. The input could be the user question, previous evidence values, or a combination of both.

Available tools:
BingSearch[input]: A tool that enables users to conduct information searches via Bing. It provides a list of potential sites that might contain answers to the user's query.
TextExtractor[input]: Extracts text from one or multiple websites listed in the input string (newline separated links). The input consists of one or more links, and the output is plain text containing the content of these links.
HyperlinkCollector[input]: Collects hyperlinks from plain text and generates a plain text, newline-separated list of links.
LanguageProcessor[input]: A question-answering language model effective at answering queries based on a given text passage. The input should be a text-based question referencing an :evidence[n]: variable, such as "What is the dog's name, given :evidence1:?"

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

Question: What is the population of Tokyo and what are some of its major landmarks?


Instruction:
A chat. Develop a plan to answer: "Who won the Nobel Prize in Literature in 2015 and what was their most famous work?"

Available tools:
NobelPrizeData[input]: Tool that provides data about Nobel Prize winners.
AuthorWorks[input]: Tool that lists notable works by a particular author.
QA[input]: Tool that answers questions using general world knowledge.

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


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

Here are the tools you can use:
DuckDuckGo[input]: Allows the user to conduct an internet search using DuckDuckGo. It yields a list of websites that may hold the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline-separated links. The input is one or more links, and it outputs plain text containing the content of the links.
HyperlinkGatherer[input]: Gathers hyperlinks from plain text and creates a plain text, newline-separated list of links.
AIOne[input]: An AI-powered question answering tool that can answer queries based on an input text passage. The input needs to be a textual question that refers to a #E[n] variable.

The output format should be:
Plan: [Initial action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Subsequent action based on the outcome of #E1]
#E2 = [Next function to call and input parameter, which may refer to preceding evidence, e.g., "Given context #E1"]
...
Final answer: #E[n]

Question: What is the tallest building in Dubai and how many floors does it have?


Instruction:
A chat. Develop a systematic plan to respond to the following user query using the tools provided. Each plan will be accompanied by an evidence value which represents the output of one of the available functions given an input string that can be the user's question, prior evidence values, or both.

Tools available for usage:
YahooSearch[input]: A tool that lets the user search for information through the Yahoo search engine. It helps in identifying appropriate websites that may hold the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline separated links, producing a plain text output containing the content of the links.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-separated response of URLs.
QUORA[input]: A question-answering language model, highly efficient in answering questions based on an input text passage. The input needs to be a text question that references an :evidence[n]: variable, e.g., 'What is the GDP of India, given :evidence1:?'.

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

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


Instruction:
A chat. Provide a detailed execution plan to respond to the following user query. You have access to various tools, each having a specific functionality. You can store the output of these tools into a variable called #E[index] which can later be referred to by subsequent tools.

Available Tools:
Bing[input]: Tool that enables the user to perform a search operation over Bing search engine.
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.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: An AI-based question-answering model that provides answers either directly from general world knowledge or given input context that may contain the answer.

Your output should follow this structure:
Plan: [first action based on input question]
#E1 = [function to call with input parameter]
Plan: [next action based on the result of #E1]
#E2 = [next function to call with input parameter, which might refer to previous evidence like "Given context #E1"]
...
Final Answer: #E[n]

Question: What are the main ingredients in a traditional Italian lasagna recipe?


Instruction:
A chat. Create a plan to solve the following problem. Indicate the external tool along with the tool input for each step and store the evidence into a variable #E[index].

Available Tools:
GoogleSearch[input]: Allows searching for information on Google.
ParseText[input]: Parses a block of text and extracts important details.
AskJeeves[input]: Answers questions using a vast database of common knowledge.
URLScraper[input]: Scrapes text content from a URL.

Output Format:
Plan: [First Action]
#E1 = [Tool with Input Parameter]
Plan: [Next Action Based on #E1]
#E2 = [Next Tool with Input Parameter (Can Reference Previous Evidence)]
...
Final Answer: #En

Question: What is the average temperature in Alaska during winter and what wildlife can be seen there during this season?


Instruction:
A chat. Develop a plan to find out who composed the soundtrack for the movie 'Interstellar'. Here are your available tools:
- IMDbLookup[input]: Fetches information about movies from IMDb.
- WebScraper[input]: Scrapes content from provided web links.
- LinkExtractor[input]: Extracts links from plain text.
- MusicDB[input]: Looks up music-related information.
- QAModel[input]: Answers questions using either common sense, world knowledge, or given context.

Output should follow this format:
Plan: [first action]
#Evidence1 = [function call with input]
Plan: [next action]
#Evidence2 = [next function call and input, possibly referencing previous evidence]
...
Final Answer: #Evidence[n]


Instruction:
A chat. Create a step-by-step plan to respond to this user query: "What is the population of Tokyo and what are some famous landmarks there?" You have these tools at your disposal:

1. GoogleSearch[input]: A tool that lets you perform a Google search using an input string.
2. PageScraper[input]: Takes one or more URLs as input and produces plain text containing the content of those pages.
3. QuestionSolver[input]: Can answer questions based on input context.

Please follow this output format:
Step 1: [First action]
#Evidence1 = [Call to function with input parameter]
Step 2: [Subsequent action]
#Evidence2 = [Next function call with input parameter, possibly referencing earlier evidence, e.g., "Using context #Evidence1"]
...
Answer: #Evidence[n]


Instruction:
A chat. Create a detailed plan to respond to the user query using the following tools. Each step in your plan should produce an evidence value, which will be the output of one of the available functions given an input string that could be the user question, prior evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: A tool that enables the user to perform a search using the DuckDuckGo search engine. It finds a list of potential sources that might contain the answer to the user's question.
PageLoader[input]: Loads one or more websites from an input string consisting of newline-separated links. The input is one or more links, and it outputs plain text containing the link contents.
URLCollector[input]: Extracts URLs from plain text and returns a plain text, newline-separated list of URLs.
QAEngine[input]: A question-answering language model capable of answering queries based on a provided text passage. The input must be a text-based question referencing an :evidence[n]: variable.

Output format:
Plan: [First action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameter, potentially referencing previous evidence]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

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


Instruction:
A chat. Create a detailed execution plan to respond to the following query using the tools provided. Each step should produce a piece of evidence (#E[index]) which can be used in subsequent steps.

Available Tools:
DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to find potentially relevant information online.
TextParser[input]: Takes a block of text (such as a webpage) and extracts important details into a structured format.
URLCollector[input]: Scans a block of text and identifies any URLs contained within it.
NLPModel[input]: An AI-powered natural language processing tool capable of answering specific questions when provided with a relevant context.

Output Format:
Plan: [Description of the first step]
#E1 = [Function to execute with relevant parameters]
Plan: [Description of the next step, considering the outcome of #E1]
#E2 = [Next function to execute with relevant parameters, possibly referencing #E1]
...
Final Answer: #E[n]

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


Instruction:
A chat. Question: What are the opening hours of the Louvre Museum and what are its most famous exhibits?

Here are the tools available to be called:
GoogleMaps[input]: Provides information about locations including opening hours.
MuseumExhibitFinder[input]: Finds the most famous exhibits of a specified museum.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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


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

Available tools:
WikiSearch[input]: Allows users to search for information from Wikipedia. It provides knowledge about various topics like people, places, events, etc. The input should be a search string.
QA_System[input]: Can answer questions using common sense, general world knowledge, or given context that may contain the answer.

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

Question: Who invented the telephone and where was it first demonstrated?


Instruction:
A chat. Please generate a step-by-step plan to answer the following question, using the tools provided. Each tool should be used at least once and each plan should correspond with an evidence value.

The available tools are as follows:

1. WikiSearch[input]: This tool allows you to search for information on Wikipedia. The input should be a keyword or phrase related to your query.
2. AskAI[input]: This is a question-answering tool that can provide answers based on general knowledge or specific context provided in the form of previous evidence.
3. GoogleNews[input]: This tool searches for recent news articles on Google News. It's useful when looking for current events or recent developments related to your query.
4. TextSummarizer[input]: This tool takes large amounts of text (like a full article) and provides a brief summary.

Each plan will have one corresponding evidence value which is the output from one of the above functions given an input string.

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

Question: Who is the author of the book "To Kill a Mockingbird" and what are some recent news about them?


Instruction:
A chat. Develop a step-by-step execution plan for the following task, utilizing the tools provided. Every step should have a corresponding evidence value, generated by one of the available tools given an input string (which could be the original query, prior evidence values, or a combination).

Tools at your disposal:
BingSearch[input]: Allows users to conduct searches via Bing. Useful for locating sites potentially containing answers to the user's query.
SiteReader[input]: Loads and converts into plain text one or multiple websites indicated by newline-separated links in the input string.
URLFinder[input]: Extracts URLs from plain text, producing a newline-separated list of links as output.
InfoRetriever[input]: A question-answering language model adept at answering queries based on an input text passage. Questions should refer to an :evidence[n]: variable, e.g., 'What is the capital of France, given :evidence1:?'

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

Question: Which actor played Tony Stark in the Marvel Cinematic Universe, and what other movies has he starred in?


Instruction:
A chat. Design a step-by-step plan to respond to the user's inquiry using the provided tools. Each plan should correspond to an evidence value, which is the output of a function given an input string.

Available tools include:
DuckDuckGo[input]: Allows users to search for information via DuckDuckGo. Useful for locating sites that might have the answer to the user's question.
PageLoader[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and the output contains the content of these links.
LinkPicker[input]: Picks links from plain text and provides a plain text, newline-separated list of links.
InfoFinder[input]: An AI language model designed to answer questions based on an input text passage. The input must be a text question referring to an :evidence[n]: variable, such as 'What is the capital of France, given :evidence1:?'

Output format:
Plan: [initial action]
:evidence0: = [function call with input parameter]
Plan: [subsequent action, based on outcome of :evidence0:]
:evidence1: = [next function call with input parameter, potentially referencing prior evidence like "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the significance of the Rosetta Stone and where is it currently located?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebCrawler[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
LMQA[input]: Language model question answering tool, 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 main diet of the snow leopard and where do they usually live?


Instruction:
A chat. Create a plan to solve the following problem using these tools. Each tool will be used with an input and produce an output that can be stored in a variable #E[index] for use in subsequent steps.

Here are the available tools:
Bing[input]: This is a search engine tool that allows you to find information from various websites on the internet.
TextParser[input]: This tool extracts specific pieces of information from a large text, such as names, dates, or places.
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 can answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

The output should follow this format:
Plan: [first action]
#E1 = [function to call with input parameter]
Plan: [next action]
#E2 = [next function to call with input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

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


Instruction:
A chat. Formulate a comprehensive plan to solve the following user inquiry using the set of tools at your disposal. Store the output of each tool in a variable labeled @Evidence[index], which can subsequently be referenced by other tools.

Tools Available:
DuckDuckGo[input]: Allows the user to conduct a search via the DuckDuckGo search engine.
WebCrawler[input]: Takes one or more URLs (separated by new lines) from the input string and generates a plain text output containing the content of those links.
HyperlinkHarvester[input]: Gathers all the hyperlinks embedded within a given text.
AIAgent[input]: A sophisticated question-answering AI that can generate responses based on common knowledge or given a particular context that may include the answer.

Output Format:
Plan: [Initial action based on the input question]
@Evidence1 = [Function to invoke with corresponding input parameter]
Plan: [Subsequent action based on the outcome of @Evidence1]
@Evidence2 = [Next function to invoke with appropriate input parameter, potentially referring to prior evidence such as "Considering context @Evidence1"]
...
Final Response: @Evidence[n]

Question: Who invented the telephone and when was it first patented?