Instruction:
A chat. Generate a comprehensive plan to solve the following user instruction using the available tools. For each step, indicate the corresponding evidence value which will be the output of one of the available tools given an input string that could be the user question, one or more prior evidence values, or a mixture of both.

Available tools:
DuckDuckGo[input]: A tool allowing users to perform searches via DuckDuckGo search engine. It helps in identifying potential sources that might have answers to the user's query.
SiteReader[input]: Loads one or multiple websites from the input string consisting of newline separated links. Input includes one or more links and outputs plain text comprising the content of these links.
URLPicker[input]: Picks URLs from plain text and provides a plain text, newline-separated response of URLs.
QAEngine[input]: A question-answering language model effective at answering queries based on an input text passage. The input needs to be a textual question referencing an :evidence[n]: variable, like What is the population of Paris, given :evidence1:?

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

Question: Which company developed the Hubble Space Telescope and what were its major contributions to astronomy?


Instruction:
A chat. Devise a methodical plan to address the user's inquiry, employing a selection of accessible tools. Each plan should correspond to an evidence value, signifying the output of a designated function given an input string. This input string might be the user's question, preceding evidence values, or a blend of both.

The following tools are at your disposal:
InternetExplorer[input]: Enables users to browse the internet for information. Particularly useful for locating lists of websites that may hold answers to the user's question.
PageReader[input]: Reads one or more websites from an input string containing newline-separated URLs. It generates plain text output containing the content of these pages.
URLCollector[input]: Collects URLs from plain text and outputs them as newline-separated strings.
InquiryResponder[input]: A language model engineered to answer questions based on an input text passage. Inputs should include references to earlier evidence variables.

Each function necessitates a straightforward string as input. Merging of strings and evidence variables (like InquiryResponder[What is the GDP of China, given :evidence3:]?) is permissible but no quotation marks or "+" symbols should be used.

Include only one evidence output per plan step.

The output format should adhere to the following structure:
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 citing earlier evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n] containing the final answer]

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


Instruction:
A chat. Develop a step-by-step plan to respond to the user query, making use of the provided tools. Every plan should correspond to an evidence value, which will be the outcome of one of the accessible functions considering an input string that could be the user question, one or more prior evidence values, or a blend of both.

Available tools to be used:
DuckDuckGo[input]: A tool enabling users to look up information via the DuckDuckGo search engine. It assists in locating a suitable list of websites that might contain the answer to the user's query. The function does not directly provide the answer; instead, it identifies potential sites that may have the solution.
HTMLStripper[input]: Strips HTML tags from a website URL and generates a plain text output comprising the content of the link.
URLCollector[input]: Collects URLs from plain text and delivers a plain text, newline-separated response of URLs.
NLPModel[input]: Natural Language Processing model adept at responding to queries based on an input text passage. The input needs to be a textual question referring to an :evidence[n]: variable, such as What is the height of the Eiffel Tower, given :evidence1:?

Each function's input should simply be a plain string, devoid of quotes or "+" to concatenate a string with an evidence variable, for instance, NLPModel[What is the population of Tokyo, given :evidence3:?]

Ensure to incorporate only one evidence output for every plan step.

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

Question: Who designed the Sydney Opera House and what inspired their design?


Instruction:
A chat. Create a step-by-step plan to answer the question: "What is the highest peak in the Andes mountain range?"

Here are the tools available:
GeoSearch[input]: Tool that allows you to search for geographical information.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
MapTool[input]: Provides map related data based on the input query.
InfoExtract[input]: Extracts specific pieces of information from a larger text.
LLM[input]: Question answering language model.

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]


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

Here are the tools available to be called:
Bing[input]: A tool that enables the user to perform an internet search using Bing. It provides a list of sites that might contain the answer to the user's question.
TextAnalyzer[input]: This tool analyzes a body of text and extracts key pieces of information such as names, dates, places, etc.
URLLoader[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and it generates plain text output containing the content of the links.
AskJeeves[input]: A question-answering tool that can provide answers based on common sense, general world knowledge, and given input context that may contain the answer.

Your output should follow this format:
Plan: [First action based on the input question]
#E1 = [Function to call with its input parameter]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call with its input parameter, possibly referencing previous evidence like "Given context #E1"]
...
Final Answer: #E[n]

Question: What is the population of Tokyo and when was the city founded?


Instruction:
A chat. Please generate a plan to solve the problem below using the tools listed. 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.
QAModel[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

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


Instruction:
A chat. Develop a strategy to identify the primary components of a traditional Japanese tea ceremony.

Tools available:
- CultureBase[input]: Database containing information about different cultures around the world.
- QA[input]: Question answering tool that uses general knowledge or given context to provide answers.
- VideoAnalyzer[input]: Analyzes video content to extract key details.
- TextSummarizer[input]: Summarizes long text into concise points.
- ImageIdentifier[input]: Identifies objects and elements within an image.

Output format follows the same pattern as TSK 1 and TSK 2.


Instruction:
A chat. Formulate a strategy to solve the problem below by using the listed tools. Each part of your plan must correspond to an evidence value, which will store the result of a function call.

Tools at your disposal:
WikiSearch[input]: A tool that searches Wikipedia for information related to the input query.
TextAnalyzer[input]: Analyzes a body of text and provides a summary or specific details based on the input question.
QA[input]: Answers questions using general knowledge or based on a given context.

Your output should follow this structure:
Plan: [first action to take]
#Evidence1 = [first function to call with its input]
Plan: [second action to take, considering the result of #Evidence1]
#Evidence2 = [second function to call with its input, possibly referencing #Evidence1]
...
Final Answer: #EvidenceN

Question: What is the main diet of the African elephant and where does it live?


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

Here are the tools available to be called:
GoogleMaps[input]: Tool that provides location-based information.
WeatherAPI[input]: Tool that provides weather data for a specified location.
TimezoneFinder[input]: Tool that determines the timezone of a specified location.
FlightTracker[input]: Tool that tracks flights and provides real-time status updates.
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: What's the current temperature in Sydney, Australia and when is the next flight from New York to Sydney?


Instruction:
A chat. Develop a step-by-step execution plan to solve the following problem, making use of the provided tools. Each plan will correspond to an evidence value which will be the output of one of the available tools when supplied with an appropriate input string.

Available Tools:
WikiSearch[input]: A tool that lets you search Wikipedia for specific information related to your query.
QAEngine[input]: A question-answering tool that can provide answers based on common sense, general world knowledge, or context from previously gathered evidence.
MapTool[input]: A tool that provides geographical data and location-based information based on the input query.
WeatherAPI[input]: A tool that provides current weather conditions for a specified location.

Output Format:
Plan: [First action based on input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on #E1]
...
Final Answer: #E[n]

Question: Where is Mount Everest located and what is the current temperature there?


Instruction:
A chat. Please generate a plan to solve the following question using these tools. For each step, indicate which tool you would use and what input you would give it. You can store the output of each tool in a variable #E[index] that can be referenced later.

Here are the available tools:
Bing[input]: A search engine tool that allows the user to find information on the internet.
ParseHTML[input]: This tool takes an HTML page as input and extracts plain text from it.
LinkCollector[input]: Extracts all URLs from a given piece of text.
AskJeeves[input]: A question answering tool that uses common sense and general world knowledge to answer questions. It can also answer questions based on a given context.

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

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

Question: What is the population of the capital city of Japan and what is its famous landmark?


Instruction:
A chat. Develop a step-by-step plan to answer the following user query, using the available tools. Each tool has an associated evidence value which is the output of that function given an input string. The input can be the user's question, previous evidence values or both.

Here are the tools you can use:
WebSearch[input]: This tool allows the user to search for information on the web. It returns a list of websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from one or more websites provided in the input string (newline separated links). Outputs plain text containing the content of the pages.
LinkParser[input]: Extracts links from plain text and produces a newline-separated list of links.
AIAnswerer[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., "What color is the cat, given :evidence1:?"

Each function should receive a plain string as input without quotes or "+" for concatenating strings with evidence variables, e.g., AIAnswerer[What is the capital of France, given :evidence3:?]

Ensure only one evidence output per plan step.

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

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


Instruction:
A chat. Create a comprehensive plan to solve the following query using the mentioned tools. Each step should correspond to an evidence number which stores the output of the respective function used.

Available Tools:
DuckDuckGo[input]: A search engine tool useful for obtaining general information related to the input query.
PageScraper[input]: Loads specific webpage(s) from the input link(s) and outputs the plain text content of the page(s).
LinkHarvester[input]: Gathers all the links present in the provided plain text.
GPT_QA[input]: An advanced language model capable of answering questions based on an input context. The input should be a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Action based on the input question]
:evidence0: = [Function along with its input]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Subsequent function and its input, possibly referring to prior evidence]
...
Final Response: :evidence[n]:

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


Instruction:
A chat. Develop a strategy to respond to the user's query using the tools provided below. For each step, there should be a matching evidence value, derived from one of the functions' outputs given an input string.

Tools Available:
1. BingSearch[input]: A tool that uses the Bing search engine to locate information related to the input query.
2. SiteLoader[input]: Loads a website from the input URL and produces plain text content from the site.
3. UrlCollector[input]: Collects URLs from a given plain text input.
4. KnowledgeQnA[input]: Answers questions based on an input text. The input must be a question that refers to an :evidence[n]: variable.

Output Format:
Plan: [Initial action]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action]
:evidence1: = [Next function to call with input parameter, possibly referencing prior evidence]
...
Answer: [:evidence[n]:]

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


Instruction:
A chat. Create a step-by-step plan to provide an accurate response to the user query using the available tools. Each plan will produce an evidence value which will be the output of a specific function when fed with the right input string.

Available Tools:
NetSearch[input]: Searches the internet for information related to the input string.
SiteReader[input]: Reads all the text from a site whose URL is provided as the input.
HyperlinkGatherer[input]: Gathers all hyperlinks embedded within a piece of text provided as the input.
QASolver[input]: An AI model that solves queries based on a piece of text provided as the input. The input should be a question referencing a #E[n] variable.

Output Format:
Plan: [Initial action]
#E0 = [Function to use with input parameters]
Plan: [Subsequent action based on the outcome of #E0]
#E1 = [Next function to use with input parameters, possibly referring to earlier evidence]
...
Final Answer: [#En]

Question: How did the Great Depression impact the United States economy and who was the President during this period?


Instruction:
A chat. Create a step-by-step plan to respond to the user query utilizing the provided tools. Each step should correspond to an evidence value which would be the output of the chosen function. The input could be a user query, prior evidence values, or a combination of both.

Available tools:
WikiSearch[input]: A tool that lets users retrieve information from Wikipedia. It is handy when seeking knowledge about various topics such as historical events, personalities, places, etc.
ContextQA[input]: A tool that answers queries directly based on common sense, general world knowledge, or given context that might contain the answer.

Output Format:
Plan: [First action based on the input query]
#E1 = [Function to invoke with input parameters]
Plan: [Next action depending on #E1]
#E2 = [Subsequent function invocation with input parameters, possibly referencing earlier evidence like "Given context #E1"]
...
Final Answer: #E[n]

Question: Who founded Microsoft and what were their initial products?


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 a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts key pieces of text from a larger body of text. Useful for identifying names, dates, places, etc.
LinkParser[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


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

Here are the tools available to be called:
GoogleSearch[input]: Tool that allows the user to search for information using Google. This tool is useful in finding relevant websites.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KnowledgeBase[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references 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: What is the history behind the creation of Microsoft Corporation and who were its key founders?


Instruction:
A chat. Devise a comprehensive plan to address the following user query employing the specified 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 might be the user's question, one or more past evidence values, or a mix of both.

These are the tools you can use:
Yandex[input]: This tool lets users perform information searches via the Yandex search engine.
LinkLocator[input]: This function extracts links from plain text and offers a plain text list of links.
WebsiteRetriever[input]: This tool fetches one or more websites from an input string containing newline-separated links, where the input is one or more links, and creates plain text content from those links.
InfoBank[input]: This tool performs a search on Info Bank for pertinent articles based on the input string.
ProblemSolver[input]: This is a question-answering language model proficient at answering questions based on an input text passage. The input must be a text question that refers to a #I[index] variable.

Output format:
Plan: [Initial action based on input question]
#I1 = [Function to call with input parameter]
Plan: [Following action based on the outcome of #I1]
...
Final Resolution: #I[n]

Question: What is the theory of relativity and how has it impacted modern physics?


Instruction:
A chat. Generate a detailed plan to address the user query utilizing the listed tools. Each step should correspond to an evidence value which is the outcome of a function given an input string that could be the user query, prior evidence values, or a combination of both.

Tools Available:
DuckDuckGo[input]: A tool that enables the user to conduct an internet search via DuckDuckGo search engine. Useful for locating sites that might contain the answer to the user's query.
SiteReader[input]: Loads one or more websites from the input string containing newline separated links. Input is one or more links and it outputs plain text containing the link contents.
URLCollector[input]: Extracts URLs from plain text and generates a plain text, newline separated response of URLs.
ZOE[input]: A question-answering language model. Particularly effective at answering queries based on an input text passage. The input needs to be a text question that refers to an #Evidence[n] variable.

Output Format:
Plan: [Initial action based on user query]
#Evidence0 = [Function call with input]
Plan: [Subsequent action based on #Evidence0]
#Evidence1 = [Next function call with input potentially referring to #Evidence0]
...
Final Answer: [#Evidencen]

Question: What are the main causes of global warming and their effects on marine life?


Instruction:
A chat. Formulate a methodical plan to address the user query utilizing the listed tools. Every step in your plan should correspond to an evidence value, which will be the output of one of the available functions when supplied with an input string. This input string can be the user question, one or more previous evidence values, or a blend of both.

Tools at disposal:
YahooSearch[input]: A tool enabling users to look up information using Yahoo search engine. Useful in finding a list of sites potentially containing the answer to the user's query. Please note that this function doesn't directly respond to the question; instead, it locates a list of sites that might hold the answer.
URLReader[input]: Reads one or more websites from the input string comprising newline separated links. Input includes one or more links and output contains the plain text content of these links.
LinkPicker[input]: Identifies links from plain text and returns a plain text, newline separated collection of links.
QuerySolver[input]: Question answering language model, especially helpful in responding to questions based on an input text passage. The input must be a text question that refers to an :evidence[n]: variable, e.g., How tall is Mount Everest, given :evidence3:?

The input to each function simply needs to be a plain string, without quotation marks or "+" to concatenate a string with an evidence variable, e.g., QuerySolver[Who is the president of USA, given :evidence2:?]

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

The output should adhere to this format:
Plan: [primary action rooted in input question]
:evidence0: = [function to call with input parameter]
Plan: [consecutive action derived from the result of :evidence0:]
:evidence1: = [next function to call and input parameter, which might refer to preceding evidence, e.g., "In light of context :evidence0"]
...
Final Response: [:evidence[n]: encompassing the definitive answer.]

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


Instruction:
A chat. Create a detailed plan to answer the following question using the tools at your disposal. Each step in your plan should correspond to an evidence value, which represents the output of a function given an input string.

Tools available:
InfoSearch[input]: Allows the user to search for information online.
URLReader[input]: Reads the contents of a specified URL.
QAMachine[input]: A tool capable of answering questions based on given context.

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

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


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 that is derived from one of the functions given an input string, which can be the user's question, previous evidence values, or both.

Here are the tools you can use:
SearchEngine[input]: This tool allows users to search for information online. The function doesn't directly provide answers but finds sites that may contain the required information.
WebScraper[input]: Loads websites from the input string containing newline separated links and produces plain text output with the content of these sites.
LinkExtractor[input]: Extracts links from plain text and returns a list of links.
QAModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a question that references an :evidence[n]: variable.

Each function accepts a plain string as input without quotes or "+" to concatenate a string with an evidence variable (e.g., QAModel[What is the capital of France, given :evidence3:?]). Only include one evidence output per plan step.

The output format should be:
Plan: [first action]
: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]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the history of the Eiffel Tower and what materials were used in its construction?


Instruction:
A chat. Create a plan to answer the following question using these tools. Each tool should be used at least once and each step in your plan should have an associated evidence value.

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.
TextAnalyzer[input]: Analyzes a block of text and identifies key pieces of information such as names, dates, places, etc.
LinkCollector[input]: Collects all URLs from a given piece of text.
InfoExtractor[input]: Extracts specific information from a webpage given a URL.
KnowledgeBase[input]: A question answering tool that can provide answers based on common knowledge or context provided by previous evidence.

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 2005 and what was their most famous work?


Instruction:
A chat. Please generate a plan to solve the following problem, using the tools provided. Each step in your plan should correspond to an evidence value that will be the output of one of the available functions given an input string. The input can be the user question, one or more previous evidence values, or a combination of both.

Here are the tools you can use:
GoogleSearch[input]: This tool allows you to search for information on Google. It's useful for finding sites that may contain the answer to the user's question.
WebsiteReader[input]: This tool loads websites from the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QuestionAnswerer[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: [first action to take based on input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: [:evidence[n]: containing the final answer.]

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


Instruction:
A chat. Develop a systematic plan to address the user's request utilizing the following tools. Each step will yield an evidence value that can be utilized in the next steps.

Tools Available:
1. WebCrawler[input]: Searches the web for specific information related to the input string.
2. TextAnalyzer[input]: Analyzes a body of text and extracts key points.
3. FactChecker[input]: Checks facts against reliable sources.
4. QASystem[input]: Answers questions based on provided context.

Output Format:
Plan: [Initial action based on the question]
:Evidence0: = [Tool to use with input parameters]
Plan: [Subsequent action based on :Evidence0:]
:Evidence1: = [Next tool to use with input parameters, may reference prior evidence]
...
Answer: [:EvidenceN:, containing the final response.]

Question: Are polar bears endangered and what are some reasons for their endangerment?


Instruction:
A chat. Provide a detailed execution plan to respond to the user's request using the set of tools at your disposal. Each step must correspond to an evidence value, which will be the result of calling a function with an appropriate input string.

Available tools include:
1. WikiSearch[input]: Searches Wikipedia for articles matching the input query.
2. WebScraper[input]: Retrieves the content of a webpage specified by the input URL.
3. LinkFinder[input]: Identifies links within a body of text provided as input.
4. AnswerBot[input]: Answers questions based on its internal knowledge base or given context. Input should be a question string, possibly referring to earlier evidence variables.

Output format:
Plan: [First action]
:Evidence0: = [Function call with input]
Plan: [Subsequent action]
:Evidence1: = [Next function call with input]
...
Answer: [:EvidenceN:]

Question: Who was Albert Einstein's first wife and what were her notable works?


Instruction:
A chat. Develop a plan to answer the question: "What is the population of Tokyo, Japan?"

Here are the tools available:
PopData[input]: Tool that provides population data for cities around the world.
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.
CityFacts[input]: Provides facts about different cities worldwide.
StatExtractor[input]: Extracts statistical data from a larger body of text.
LLM[input]: Question answering language model.

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]


Instruction:
A chat. Create a detailed plan to answer this query with the help of these tools:
AskJeeves[input]: Search engine tool.
RedditSearch[input]: Searches Reddit threads for relevant discussions.
ContentParser[input]: Parses content from a webpage.
FactChecker[input]: Checks the validity of a statement.
AIAnswer[input]: AI model that answers questions based on input context.

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


Instruction:
A chat. Please generate a plan to solve the following problem using the tools provided. Each step in your plan should be followed by an evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mixture of both.

Here are the tools available to be called:
GoogleSearch[input]: This tool allows you to search for information on Google. It is useful for finding sites that may contain answers to your questions.
TextScraper[input]: This tool extracts text from websites. The input should be one or more URLs separated by commas.
LinkExtractor[input]: This tool extracts links from plain text and produces a list of links as output.
QAModel[input]: This tool answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, 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. Generate a step-by-step execution plan to solve the following problem using the given tools. For each step, indicate the tool you would use along with the input parameters. Store the output into a variable named :evidence[index]:

Available Tools:
FactFinder[input]: Searches for factual information related to the input query.
DataAnalyzer[input]: Analyzes data from a given context and provides insights or answers to queries.
WikiReader[input]: Retrieves comprehensive information from Wikipedia based on the input query.
QAModel[input]: Answers questions based on a given context.

Output Format:
Plan: [Description of the first step]
:evidence0: = [Tool to use with input parameters]
Plan: [Description of the next step based on the outcome of the previous step]
:evidence1: = [Next tool to use with input parameters, referencing previous evidence if necessary]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who was Albert Einstein and what contributions did he make to science?


Instruction:
A chat. Create a sequential plan to respond to the user's query utilizing the following tools. Each step in the plan should correspond to an evidence value, which represents the output of a function given an input string. This input could be the user's question, previous evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: Allows users to perform searches using the DuckDuckGo search engine. Useful for locating potential sources of answers.
WebScraper[input]: Pulls content from specified websites provided via input links.
URLCollector[input]: Gathers URLs from plain text and outputs a list of these links.
KnowledgeBot[input]: A QA language model capable of answering queries based on a supplied passage of text. It requires a textual question referencing a #Evidence[n] variable as input.

Each function's input should be a simple string, without any concatenation operators like '+' or quotation marks. For instance, KnowledgeBot[What's the tallest mountain, given #Evidence3?].

Only one evidence output should be allowed per plan step.

Output format should be:
Plan: [initial action based on the input question]
#Evidence0 = [chosen function along with its input parameter]
Plan: [subsequent action, contingent upon the outcome of #Evidence0]
#Evidence1 = [the next function to invoke, including its input parameter, which might refer back to prior evidence (e.g., "In light of #Evidence0")]
...
Final Answer: [#EvidenceN contains the ultimate solution.]

Question: Who authored 'War and Peace' and what other notable works did they write?


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

Here are the tools available to be called:
Google[input]: Tool that allows the user to search for information using the Google search engine.
LinkParser[input]: Extracts all URLs from a block of text.
PageReader[input]: Reads the contents of a webpage given its URL.
QAEngine[input]: Question answering tool that uses AI to provide answers based on a given context.

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

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


Instruction:
A chat. Construct a plan to solve: "Explain the process of photosynthesis and its importance to life on Earth."

Tools available:
ScienceExplainer[input]: Provides detailed explanations of scientific processes.
EarthLife[input]: Gives information about life on Earth and its dependencies.
DiagramGenerator[input]: Generates diagrams based on the input topic.
QA[input]: Answers questions based on common sense and general world knowledge.
VideoTutorial[input]: Finds video tutorials related to the input topic.

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


Instruction:
A chat. Generate a step-by-step plan to answer the question: "What is the population of Tokyo and what are some popular tourist attractions there?"

Here are the tools available:
WikiSearch[input]: Tool that allows you to search for information from Wikipedia.
QA[input]: Tool that can answer questions based on common sense and general world knowledge.
TouristAttractionFinder[input]: Tool that finds popular tourist spots in a given location.
PopulationFinder[input]: Tool that provides the current population of a specified city or country.

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


Instruction:
A chat. Generate a plan to find out the steps involved in the water cycle.

Available tools:
WebCrawler[input]: Searches the web for information related to the input.
ImageIdentifier[input]: Identifies images related to the input query.
StepByStepGuideMaker[input]: Creates a step-by-step guide based on the input context.
QAModel[input]: Answers questions based on general knowledge or given context.
InfoOrganizer[input]: Organizes information into a structured format.

Output format:
Plan: Initial action
#Evidence1 = Function with input parameter
Plan: Subsequent action
#Evidence2 = Next function with input parameter
...
Final Response: #Evidence[n]


Instruction:
A chat. Create a plan to answer the following question using the tools provided. For each step, indicate which tool you will use and what input you will provide it. Store the output of each tool in a variable #E[index] that can be referenced by later steps.

The available tools are as follows:

Bing[input]: This tool allows you to search for information on Bing. It's useful for finding lists of websites that may contain answers to your questions.
WebReader[input]: This tool loads one or more websites from an input string containing newline delimited links. The input is one or more links, and the output is plain text content from those links.
LinkCollector[input]: This tool extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: This is a question answering AI model. It can answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the dog, given #E1?

Output should be formatted as follows:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action, based on result of #E1]
#E2 = [next function call and input parameter, referencing previous evidence if necessary]
...
Final Answer: #E[n]

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


Instruction:
A chat. Create a detailed execution plan to find out the population of New York City and its major tourist attractions.

Available Tools:
DuckDuckGo[input]: A search engine tool that retrieves information about a specific topic.
URLParser[input]: A tool that extracts URLs from a given text.
SiteReader[input]: Reads the contents of the sites from the URL list and outputs plain text.
AIQA[input]: An AI-powered Question Answering tool that answers queries based on given context.

Output Format:
Step 1: [Action]
Evidence1 = [Tool to use + Input]
Step 2: [Action]
Evidence2 = [Tool to use + Input]
...
Answer: Evidence[N]


Instruction:
A chat. Create a detailed execution plan to respond to the user's inquiry, leveraging the provided tools. Each step corresponds to an evidence value, representing the output of a function when fed an input string that could be the user's question, earlier evidence values, or a combination thereof.

These are the tools at your disposal:
Bing[input]: This tool enables users to perform searches online via Bing. It yields a list of potentially helpful sites but doesn't offer direct answers.
URLExtractor[input]: Pulls URLs from plain text, providing a plaintext list of URLs separated by newlines.
SiteLoader[input]: Loads one or multiple websites from an input string comprising newline-separated URLs, producing plaintext output featuring the content of the URLs.
AnswerBot[input]: An AI model capable of answering queries based on a supplied passage of text. The input has to be a textual question referencing a #Evidence[n] variable, like "What is the population of Tokyo, given #Evidence1?"

Input strings for each function should be simple, devoid of quotes or "+" used to merge a string with an evidence variable, such as AnswerBot[What is the population of Tokyo, given #Evidence1?]

Ensure every plan step includes only one evidence output.

Your output should follow this structure:
Plan: [Initial action derived from the input question]
#Evidence1 = [Function to invoke with input parameter]
Plan: [Subsequent action informed by the outcome of #Evidence1]
#Evidence2 = [Next function to invoke and input parameter, possibly referring to prior evidence, e.g., "In light of #Evidence1"]
...
Final Response: #Evidence[n]

Question: Who invented the telephone and what were their other notable inventions?


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

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

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

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


Instruction:
A chat. Create a step-by-step plan to answer the user's question using the following tools. Each tool can be called with an input string, and each plan should generate an evidence value which will be the output of one of the available functions.

Here are the tools you can use:

Bing[input]: This tool allows users to search for information on Bing. It is useful in finding a list of sites that may contain the answer to the user's query. The function does not directly provide answers; it generates a list of potential sources.
WebReader[input]: Load one or more websites from the input string containing newline delimited links. Input should be one or more links, and the output is plain text content of the links.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an #E[n] variable, e.g., What color is the cat, given #E1?

The output format should be as follows:
Plan: [first action]
#E0 = [function call with input parameter]
Plan: [next action, based on result of #E0]
#E1 = [next function call with input parameter, possibly referencing previous evidence like "Given context #E0"]
...
Final Answer: #E[n]

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


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.
PageLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
UrlExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
AIM[input]: Artificial Intelligence Model for answering questions based on an input passage of text.

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

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


Instruction:
A chat. Outline a methodical plan to address the upcoming question using the prescribed tools. Each segment of the plan should yield an evidence value, produced by triggering a function with an input string that can be the initial question, antecedent evidence, or a combination of both.

These are the tools at your disposal:
NetExplorer[input]: Runs a comprehensive online search based on the input string. While it doesn't furnish direct answers, it compiles a catalogue of potential information sources.
SiteScanner[input]: Scans content from one or more URLs contained in the input string (links separated by newlines) and delivers it as plain text.
URLHarvester[input]: Harvests URLs from any submitted plain text and returns them as newline-separated plain text.
SolutionProvider[input]: An advanced AI model proficient in answering questions using universal knowledge or specific context derived from prior evidence.

Function inputs should be bare strings, sans quotation marks or "+" symbols used for string concatenation, e.g., SolutionProvider[What is the longest river, given :evidence3:?]

Ensure that each plan segment corresponds to exactly one evidence output.

Output format:
Plan: [Primary action based on the question]
:evidence0: = [Triggering of function with input parameter]
Plan: [Secondary action, dependent on the outcome of :evidence0:]
:evidence1: = [Triggering of subsequent function with input parameter, possibly referencing previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is artificial intelligence and where is it mainly applied?


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

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

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

Question: Who is the current president of Harvard University and what are their notable achievements?


Instruction:
A chat. Generate a detailed execution plan to solve the user's query using the following tools. For each step, indicate the corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user's question, prior evidence values, or both.

Here are the tools available to use:
WebSearch[input]: A tool that allows the user to conduct an internet search. This tool is helpful in finding potential sites that might contain the answer to the user's question.
PageScraper[input]: Loads one or more webpages 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.
LinkGrabber[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerAI[input]: A 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 a #E[n] variable, e.g., What color is the cat, given #E1?

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

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

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

Question: What are some of the most critically acclaimed films directed by Christopher Nolan and what awards have they won?


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

Here are the tools available to be called:
GoogleScholar[input]: Tool that allows the user to search for academic articles and papers. This tool is particularly useful in gaining knowledge about scientific topics, theories, and research findings.
PubMed[input]: Tool that allows the user to search for biomedical literature. It is especially useful when looking for specific medical conditions, treatments, and research.
QAEngine[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: What is the latest research on Alzheimer's disease treatment?


Instruction:
A chat. Make a plan to discover what the primary diet of an African elephant is.

Available tools:
AnimalDiet[input]: Provides information about the diet of specified animals.
ZooDB[input]: Database of zoological information.
QA[input]: Can answer questions using common sense or given context.
NationalGeographic[input]: Provides wildlife and geographic information.
Wikipedia[input]: Allows searching for information from Wikipedia.

Output format:
Plan: First action
:Evidence0: = function with input parameter
Plan: Next action based on :Evidence0:
:Evidence1: = next function with input parameter referencing previous evidence if necessary
...
Answer: [:Evidence[n]: containing the final answer.]


Instruction:
A chat. Design a sequential plan to address the following query using the designated tools. Each stage should correspond to an evidence value, which represents the outcome of one of the available operations given an input string that could be the user's inquiry, one or multiple prior evidence values, or a blend of both.

Here are the tools available to be called:
BingSearch[input]: Allows the user to perform an online search for data using Bing. This tool helps locate potential sites that might contain the answer to the user's query.
PDFReader[input]: Reads PDF files from the URL(s) supplied as input and generates a textual output containing the file's contents.
URLFinder[input]: Finds URLs embedded within a block of text provided as input and returns them as a list.
AIQA[input]: An AI-based question-answering model that provides answers to queries based on an input text fragment. The input should be a text question referencing an #E[index] variable, e.g., What is the name of the dog, given #E1?

Each function's input should be a simple string, without quotation marks or "+" to combine a string with an evidence variable, e.g., AIQA[What is the population of New York City, given #E3?]

Ensure that there is only one evidence output for each plan step.

The output should follow this format:
Plan: [First action based on the input question]
#E1 = [Function to call with its input parameter]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call and its input parameter, possibly referring to previous evidence, e.g., "Given context #E1"]
...
Final Answer: #E[n], where n is the index of the last evidence

Question: What were the main findings of the latest climate change report published by the United Nations?


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.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
KnowledgeBaseQA[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, 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 2020 US Presidential Election and what were some key issues during their campaign?


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

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

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

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


Instruction:
A chat. Design a systematic plan to respond to the user's inquiry utilizing the following tools. Every plan should correspond to an evidence value, representing the output of a function when provided with an input string that could be the user's question, earlier evidence values, or both.

These are the tools you can use:
YahooSearch[input]: Allows users to look up information using Yahoo's search engine. It's handy for locating websites that might contain answers to the user's question.
PageLoader[input]: Loads a webpage from an input URL and returns the page's content in plain text.
URLGatherer[input]: Gathers all URLs found on a webpage. The input is a single URL and the output is a list of URLs found on the page.
AskBot[input]: A bot that can answer questions based on an input text passage. The input should be a text question that refers to an :evidence[n]: variable.

The output should follow this structure:
Plan: [First action based on the user's question]
:evidence0: = [Function call with input parameter]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Subsequent function call and input parameter, possibly referring to prior evidence]
...
Final Answer: [:evidence[n]: Containing the final answer.]

Question: How did Amazon.com start and who founded it?


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

Here are the tools available to be called:
AskJeeves[input]: Allows the user to search for information using the Ask Jeeves search engine.
PageReader[input]: Loads one or more websites from the input string containing newline delimited links, producing plain text output containing the content of the links.
URLCollector[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of links.
QAMachine[input]: Machine Learning based Question Answering tool, useful in answering questions based on an input passage of text.

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

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


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

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

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

Question: Who was the first person to climb Mount Everest without supplemental oxygen and what were the challenges they faced?


Instruction:
A chat. Create a plan to find out: "Who was Nikola Tesla and what were his major contributions to science?"

Available tools:
Biography[input]: Provides biographical information about individuals.
ScientificContributions[input]: Gives details about scientific discoveries and contributions made by individuals.
Wikipedia[input]: Allows for search of information from Wikipedia.
QA[input]: Can answer questions using common sense and general world knowledge.
TimeLine[input]: Provides a timeline of important events related to the input topic.

Output format:
Plan: initial action
:Evidence0: = function with input parameter
Plan: subsequent action
:Evidence1: = next function with input parameter
...
Answer: [:Evidence[n]: containing the final answer.]


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that uses DuckDuckGo's search engine to find information online.
WebsiteReader[input]: Reads the content of a website and provides it as plain text.
AIAnswerer[input]: An AI tool that answers questions based on the context provided.

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: When did the first manned mission land on Mars and who were the astronauts involved?


Instruction:
A chat. Formulate a step-by-step solution plan to address the query below. Use the tools provided, and for each step, specify the tool along with the required input. Store the outcome as evidence, which you can refer back to in later steps.

Available Tools:
DuckDuckGo[input]: This tool conducts a DuckDuckGo search using the supplied input and yields a collection of potentially informative resources.
ContentExtractor[input]: This tool retrieves key details from a large amount of text.
KnowledgeModel[input]: This tool provides answers to queries based on the context supplied in the input.

Format of Output:
Plan: [outline of the initial step]
:Evidence1: = [selected tool and its input]
Plan: [outline of the succeeding step]
:Evidence2: = [subsequent tool chosen and its input, possibly referring to :Evidence1:]
...
Final Response: [:EvidenceN:]

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


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

Here are the tools you can use:
WebSearch[input]: A tool that allows the user to search for information on the internet. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from HTML content and produces a plain text response.
QAEngine[input]: Answers questions based on common sense, general world knowledge, and given context. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?
LinkCollector[input]: Collects all URLs from a given text and outputs them as a newline-delimited string.

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

Remember to include only one evidence output per plan step.

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

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


Instruction:
A chat. Generate a sequential plan to respond to the user's query using the tools provided. Each step should include the use of a tool and its corresponding input. Store the output of each tool in a variable :evidence[n]:

Available tools:
Bing[input]: Tool that allows you to perform searches on Bing.
LinkExtractor[input]: Extracts links from plain text.
Scraper[input]: Loads websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
LLM[input]: Language model that answers questions based on an input passage of text.

Output format:
Plan: [First action]
:evidence0: = [Function call with input]
Plan: [Next action]
:evidence1: = [Function call with input]
...
Answer: [:evidence[n:] containing the final answer.]

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


Instruction:
A chat. Please generate a plan to solve the following question using the tools provided. Each step in your plan should correspond to an evidence value, which will be the output of one of the available functions given an input string that can be the user 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. This tool is useful in finding relevant websites and articles related to the user's query.
TextParser[input]: Extracts key details from a text passage. The input must be a plain text passage.
URLCollector[input]: Collects URLs from a list of sites. The input must be a plain text, newline delimited response of links.
QAEngine[input]: A language model that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?

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

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


Instruction:
A chat. Construct a plan to learn about the nutritional value of a medium-sized apple.

Tools available:
- NutritionDB[input]: Database providing detailed nutritional information about food items.
- QA[input]: Answers questions using general world knowledge or provided context.
- FoodAnalyzer[input]: Analyzes food items to determine their nutritional composition.
- ComparisonTool[input1, input2]: Compares two or more things based on specified criteria.
- ValidationTool[input]: Validates the accuracy of a given piece of information.

Follow the same output format as described in TSK 1 and TSK 2.


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

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

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

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


Instruction:
A chat. Please provide a detailed plan to answer the following question using the tools available. For each step, identify the tool and its input parameters that will be used to gather evidence. You can store the results of each step in a variable #E[index] for use in subsequent steps.

Here are the tools you have at your disposal:
SearchEngine[input]: This tool allows you to perform an internet search with the given input string. It returns a list of websites that may contain relevant information.
TextExtractor[input]: This tool extracts all text from a given website URL. The input should be one or more URLs separated by commas.
LinkPicker[input]: This tool picks out specific links from a block of text based on relevance to the input query.
AIAnswerer[input]: This is a sophisticated AI model capable of answering questions when provided with a context. The input should be a question, optionally followed by "Given context: #E[n]", where n refers to previous evidence.

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

Question: What is the historical 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.
TextExtractor[input]: Extracts text from plain HTML and produces a plain text, newline delimited response.
LinkFinder[input]: Finds links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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


Instruction:
A chat. Please formulate a sequential plan to tackle the user's inquiry using the designated tools. Each stage of the plan should produce an evidence value.

Tools available:
YouTube[input]: Tool that finds videos related to a specific topic.
LyricsFinder[input]: Tool that searches for song lyrics.
Spotify[input]: Tool that streams music and provides information about songs and artists.
MusicCharts[input]: Tool that provides information about top-charting songs and albums.
SongTrivia[input]: Tool that answers trivia questions about songs and artists.

Question: Find the official video of the song "Bohemian Rhapsody" by Queen, get its lyrics, play the song on Spotify, tell me its chart history, and give some trivia about the song.


Instruction:
A chat. Develop a sequential plan to generate a suitable response to the user instruction, utilizing the provided set of tools. Every plan will correspond to an evidence value, which is the outcome of one of the accessible functions with an input string that could be the user question, one or more preceding evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: Tool that lets the user search for information via DuckDuckGo search engine. It aids in locating a list of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from the input string comprising newline separated links. Input is one or more links, and it generates plain text output containing the link contents.
HyperlinkCollector[input]: Gathers links from plain text and yields a plain text, newline-separated list of links.
QAModel[input]: Question-answering language model, especially helpful in answering queries based on an input text passage. The input needs to be a textual question that refers to an :evidence[n]: variable.

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

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


Instruction:
A chat. Create a sequential plan to answer the following query using the provided tools. Each plan should correspond to an evidence value which is the output of a function given its input.

Tools Available:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to gather information related to the input query.
WebScraper[input]: Loads multiple websites from the input string which contains newline separated links. It then outputs plain text content of these links.
URLExtractor[input]: Extracts URLs from plain text and returns them as newline separated strings.
AIQA[input]: An AI-based question-answering tool that takes in a question referencing an :evidence[n]: variable.

Output Format:
Plan: [First step based on input question]
:evidence0: = [Function to call with input parameters]
Plan: [Next step based on the result of :evidence0:]
:evidence1: = [Next function to call with input parameters possibly including previous evidence]
...
Final Answer: :evidence[n]:

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


Instruction:
A chat. Generate a step-by-step plan to solve the user's query making use of the available tools: BingSearch[input], InfoExtractor[input], QAEngine[input], SiteCrawler[input], HyperlinkGatherer[input] and GeoLocator[input]. Each tool has to be utilized at least once, and there should be a question answering tool like "QA".

Descriptions of the tools are as follows:

BingSearch[input]: Allows users to find information using the Bing search engine. Finds appropriate sites that might have the answer to the user's question.

InfoExtractor[input]: Extracts important information from a block of text. Can identify names, dates, locations, etc.

QAEngine[input]: Answers questions based on common sense, general world knowledge, or given input context that contains the answer.

SiteCrawler[input]: Visits one or more websites from the input string (newline separated links) and outputs plain text content of those sites.

HyperlinkGatherer[input]: Extracts hyperlinks from a plain text and gives a newline-separated list of links.

GeoLocator[input]: Provides geographic data about a location based on the input string.

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

Question: Who was Albert Einstein and what were his major contributions to science? Also, locate his birthplace.


Instruction:
A chat. Create a plan to respond to the user instruction below using the tools provided. For each step in your plan, assign an evidence value that corresponds to the output of one of the available functions. The input string for these functions can be the user question, prior evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: Allows users to search for information via DuckDuckGo. Useful for finding websites and articles pertinent to the user's query.
InfoExtractor[input]: Pulls out crucial details from a block of text. Input must be a simple text passage.
LinkGatherer[input]: Gathers links from a set of sites. Input must be a plain text, newline separated list of links.
QAModel[input]: Language model capable of answering queries based on an input text. The input needs to be a textual question referencing a :evidence[n]: variable, such as What is the dog's breed, given :evidence1:?

Output format:
Plan: [First action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action, considering the outcome of :evidence0:]
:evidence1: = [Subsequent function to call and its input parameter, potentially referring to earlier evidence like "Considering context :evidence0"]
...
Answer: [:evidence[n]: containing the final solution.]

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


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

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

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

Question: What is the history of the Louvre Museum and who were its key architects?


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

Tools available:
NetSearch[input]: Allows the user to search for information online. This tool is useful in finding a list of sites that may or may not contain the answer to the user's question.
PageLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkGrabber[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Language model for answering questions, especially effective when answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: Who founded SpaceX and what were their motivations?


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

Here are the tools you can use:
Bing[input]: A tool that allows users to search for information via Bing. It helps find a list of websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from web pages. The input is one or more URLs and it outputs plain text containing the content of the links.
LinkHarvester[input]: Extracts links from plain text and produces a plain text response of newline-separated links.
AIQA[input]: An AI-powered Question Answering model. Useful in answering questions based on an input passage of text.

The format of each function's input should be a simple string. There's no need for quotes or "+" to concatenate a string with an evidence variable (e.g., AIQA[What is the capital of France, given :evidence3:?]).

Remember to include only one evidence output per plan step.

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

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


Instruction:
A chat. Develop a plan to generate a response to the user's instruction using the available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Available tools:
Bing[input]: Allows the user to search for information using Bing. It finds a list of sites that may contain the answer to the user's question.
LinkParser[input]: Extracts links from plain text and produces a newline delimited response of links.
WebReader[input]: Loads websites from the input string containing newline-delimited links and produces plain text output containing the content of the links.
AIAnswerer[input]: Answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: Who won the 2020 US Presidential Election and what were their main campaign promises?


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.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response 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.
WikiSearch[input]: A tool that searches Wikipedia for relevant articles based on the input string.
AnswerBot[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using any popular web search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a webpage link provided as input and produces a plain text output containing the content of the page.
LinkParser[input]: Extracts 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 are some major accomplishments of Elon Musk?


Instruction:
A chat. Please construct a step-by-step strategy to address the following inquiry, making use of the tools supplied. Every stage in your strategy should correlate with an evidence value, which represents the output of a function given an input string. This string might be the user's question, previous evidence values, or a blend of both.

Here are the tools you can utilize:
NetResearcher[input]: This tool enables the user to conduct a broad internet search for information. It's handy for locating websites that might contain the answer to the user's question.
SiteReader[input]: Retrieves the textual content from a specified website URL.
HyperlinkGatherer[input]: Extracts URLs from a block of text, producing a list of links separated by newlines.
DataQA[input]: An AI-powered question-answering tool capable of providing responses based on a specific text passage. The input needs to be a question that refers to an :evidence[n]: variable, for instance, "What is the GDP of Japan, given :evidence1:?"

Inputs to these functions should be straightforward strings, devoid of quotation marks or "+" signs used to combine a string with an evidence variable, like DataQA[Who won the 2020 US Presidential Election, given :evidence3:?].

Ensure that each plan step corresponds to exactly one evidence output.

Your output should adhere to the following structure:
Plan: [the initial action based on the input question]
:evidence0: = [the function to invoke with the appropriate input parameter]
Plan: [the subsequent action based on the outcome of :evidence0:]
:evidence1: = [the next function to call along with its input parameter, potentially referencing prior evidence, e.g., "In light of :evidence0"]
...
Final Response: [:evidence[n]: containing the conclusive answer.]

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


Instruction:
A chat. Design a detailed plan to solve the following problem step-by-step. For each plan, specify which external tool along with its input to gather evidence. You can store the gathered evidence into a variable #E[index] that can be referenced later.

Available tools:
GoogleScholar[input]: Tool that enables searching for academic articles, papers, and publications. The input should be a research-related query.
PDFParser[input]: Load PDF files from the input URL(s) and produce plain text output containing the content of the file(s).
CitationTracker[input]: Track citations made in academic papers. Input is a link to an academic paper.
QAExpert[input]: Answer questions based on common sense, world knowledge, or given input context that may contain the answer.

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

Output format:
Plan: [First action based on input question]
#E1 = [Function call with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next function call and input parameter, potentially referring to previous evidence, e.g., "Given context #E1"]
...
Final answer: #E[n]

Question: How has the theory of relativity been used in recent astrophysics research?


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
ContentExtractor[input]: Extracts text content from plain text and produces a plain text, newline delimited response of links.
TextSummarizer[input]: Summarizes large chunks of text into concise summaries.
QAEngine[input]: 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, 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?