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

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

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

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

Response:
Plan: Start off by performing an online search to discover who invented the World Wide Web.
:info0: = DuckDuckGo[Inventor of the World Wide Web]
Plan: Apply the InfoProcessor to analyze the search results and pinpoint the inventor's name.
:info1: = InfoProcessor[Who invented the World Wide Web? Considering :info0:]
Plan: Perform another online search to understand the main motivation behind the invention.
:info2: = DuckDuckGo[Primary motivation of :info1: for inventing the World Wide Web]
Plan: Extract pertinent links from the search results relating to the inventor's motivation.
:info3: = URLCollector[:info2:]
Plan: Use PageScraper to obtain the content from the selected links.
:info4: = PageScraper[:info3:]
Plan: Lastly, employ the InfoProcessor to discern and summarize the inventor's primary motivation from the scraped data.
:info5: = InfoProcessor[What was the primary motivation of :info1: for inventing the World Wide Web? Considering :info4:]
Final Answer: :info5:

System: A chat.


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

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

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

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

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

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

Response:
Plan: Initiate a web search to find the health benefits of regular exercise.
:datum0: = Ecosia[Health benefits of regular exercise]
Plan: Utilize the AIQA model to extract the health benefits from the search results.
:datum1: = AIQA[What are the health benefits of regular exercise, given :datum0:?]
Plan: Perform another web search to discover the types of exercises recommended for beginners.
:datum2: = Ecosia[Exercises recommended for beginners]
Plan: Extract relevant links from the Ecosia search results for further investigation.
:datum3: = LinkExtractor[:datum2:]
Plan: Use the PageLoader tool to gather information from the extracted links.
:datum4: = PageLoader[:datum3:]
Plan: Lastly, employ the AIQA model to determine and summarize the recommended exercises for beginners from the loaded pages.
:datum5: = AIQA[What types of exercises are recommended for beginners, given :datum4:?]
Final Answer: :datum5:

System: A chat.


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

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

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

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

Response:
Plan: Conduct a Google search to find information on the health benefits of regular exercise.
:evidence0: = GoogleSearch[Health benefits of regular exercise]
Plan: Extract the links from the search results for further analysis.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Read the contents of the top link from the extracted links.
:evidence2: = PageReader[:evidence1:]
Plan: Use the QuestionAnswerer tool to identify the health benefits from the page content.
:evidence3: = QuestionAnswerer[What are the health benefits of regular exercise, given :evidence2:?]
Plan: Conduct another Google search to find information on how regular exercise affects heart rate.
:evidence4: = GoogleSearch[Effects of regular exercise on heart rate]
Plan: Extract the links from the new search results.
:evidence5: = LinkExtractor[:evidence4:]
Plan: Read the contents of the top link from the newly extracted links.
:evidence6: = PageReader[:evidence5:]
Plan: Use the QuestionAnswerer tool to understand how regular exercise affects heart rate from the page content.
:evidence7: = QuestionAnswerer[How does regular exercise affect heart rate, given :evidence6:?]
Plan: Finally, analyze both pieces of information together to give a comprehensive answer.
:evidence8: = DataAnalyzer[:evidence3: + ' ' + :evidence7:]
Answer: :evidence8:

System: A chat.


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

Here are the tools available to be called:
CompanyProfile[input]: Tool that provides profiles of companies.
StockMarketData[input]: Tool that provides stock market data.
FinancialNews[input]: Tool that provides financial news.
IndustryTrends[input]: Tool that identifies trends in a particular industry.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

Question: What is the current stock price of Microsoft and how has it been performing over the last year?

Response:
Plan: First, retrieve the current stock price of Microsoft.
#E1 = StockMarketData["Microsoft"]

Plan: Next, analyze the performance of Microsoft's stock over the last year.
#E2 = StockMarketData["Microsoft, 1 year performance"]

Final answer: The current stock price of Microsoft is #E1 and its performance over the last year has been #E2.

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
LandmarkExtractor[input]: Extracts landmark names from plain text.
PopulationChecker[input]: Checks the current population of a specified location.

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

Response:
Plan: First, check the population of New York City. Then, search for notable landmarks in New York City.
#E1 = PopulationChecker["New York City"]
Plan: Use the WebSearch tool to find notable landmarks in New York City.
#E2 = WebSearch["notable landmarks in New York City"]
Final answer: The population of New York City is #E1 and some of its notable landmarks are #E2.

System: A chat.


Instruction:
Formulate a systematic plan to address the user command, leveraging the offered suite of tools. Each plan will tie to an evidence value, being the yield of one of the listed functions when fed an input string that could be the user's question, antecedent evidence values, or a mix of both.

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

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

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

Response:
Plan: Kick off by running a web search to determine who composed the music for 'Interstellar'.
:evidence0: = AskJeeves['Interstellar' music composer]
Plan: Leverage QASystem to parse the search results and single out the composer.
:evidence1: = QASystem[Who composed the music for 'Interstellar', in view of :evidence0:?]
Plan: Launch another web search to locate other movies scored by the recognized composer.
:evidence2: = AskJeeves[Other movies scored by :evidence1:]
Plan: Compile the germane links from the AskJeeves search results for an exhaustive search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use WebFetcher to draw information from the handpicked links.
:evidence4: = WebFetcher[:evidence3:]
Plan: In the end, apply QASystem to recognize and recapitulate the other movies scored by the composer from the drawn information.
:evidence5: = QASystem[What other movies were scored by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to solve the following question using the available tools. Each step in your plan should have an associated evidence variable, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a combination of both.

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

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

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

Response:
Plan: Start by conducting a web search to find out about major works by Charles Dickens.
:evidence0: = Bing[Major works by Charles Dickens]
Plan: Use GPT3 to interpret the search results and identify the major works.
:evidence1: = GPT3[What are the major works by Charles Dickens, given :evidence0:?]
Plan: Conduct another web search to find the themes explored in these works.
:evidence2: = Bing[Themes in :evidence1:]
Plan: Extract the relevant links from the Bing search results for further exploration.
:evidence3: = LinkHarvester[:evidence2:]
Plan: Use TextExtractor to extract information from the relevant links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use GPT3 to summarize the key themes explored in the works by Charles Dickens from the extracted information.
:evidence5: = GPT3[What themes are explored in the works :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

Output Format:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action based on result of #E1]
#E2 = [next function call with input parameter, possibly referencing previous evidence]
...
Final Answer: #En

Question: What are some significant achievements of Albert Einstein?

Response:
Plan: Start by searching for information about Albert Einstein using Bing.
#E1 = Bing[Albert Einstein]
Plan: Select relevant links from the search results.
#E2 = LinkPicker[#E1]
Plan: Extract text from the selected webpages.
#E3 = PageReader[#E2]
Plan: Find out the significant achievements of Albert Einstein from the extracted text.
#E4 = QAEngine[What are some significant achievements of Albert Einstein? Given context: #E3]
Final Answer: #E4

System: A chat.


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

Available Tools:
1. GoogleSearch[input]: This tool allows you to search for information on the internet using Google. The input is a string that represents the search query.
2. WikiInfo[input]: A tool that searches Wikipedia for information related to the input string.
3. WebScraper[input]: A tool that scrapes web pages for text content. The input is a URL or list of URLs.
4. LinkExtractor[input]: Extracts links from plain text and produces a newline delimited response of links.
5. AnswerBot[input]: An AI tool that can answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., "What color is the cat, given #E1?"

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

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

Response:
Plan: Search for the author of "The Old Man and the Sea".
#E1 = GoogleSearch["Author of The Old Man and the Sea"]
Plan: Use AnswerBot to extract the name of the author from the search results.
#E2 = AnswerBot["Who is the author of 'The Old Man and the Sea', given #E1?"]
Plan: Search Wikipedia for more information about the author.
#E3 = WikiInfo[#E2]
Plan: Use AnswerBot to find notable works of the author.
#E4 = AnswerBot["What are some notable works of #E2, given #E3?"]
Final Answer: #E4

System: A chat.


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

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

Here are the tools available to be called:
HistoricalDB[input]: A tool that allows you to search for historical data and events.
GeoTagger[input]: This tool helps to identify geographical locations mentioned in the input text.
TimeLine[input]: This tool gives a chronological sequence of events related to the input query.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
ContextAnalyzer[input]: Analyzes the context of the provided information.

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

Response:
Plan: Start by gathering historical data on the Battle of Waterloo.
#E1 = HistoricalDB["Battle of Waterloo"]

Plan: Next, analyze the context of the information provided from the historical database to understand its significance in European history.
#E2 = ContextAnalyzer[#E1]

Plan: Identify geographical locations mentioned in the input text to understand where the battle took place and its strategic importance.
#E3 = GeoTagger[#E1]

Plan: Get a chronological sequence of events related to the Battle of Waterloo to understand its impact over time.
#E4 = TimeLine["Battle of Waterloo"]

Plan: Finally, use all the gathered evidence to answer the question about the significance of the Battle of Waterloo in European history.
Final Answer: #E5 = QA["What is the significance of the Battle of Waterloo in European history?", Given context #E1, #E2, #E3, #E4]

System: A chat.


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

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

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

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

Response:
Plan: Start by searching for general information about the Eiffel Tower.
:evidence0: = SearchEngine[Eiffel Tower]
Plan: Use the TextAnalyzer to extract key historical facts about the Eiffel Tower.
:evidence1: = TextAnalyzer[History of the Eiffel Tower, given :evidence0:]
Plan: Find out who the main architects of the Eiffel Tower were.
:evidence2: = QA_Tool[Who were the main architects of the Eiffel Tower? Given context: :evidence0:]
Plan: Gather more detailed information about these architects from Wikipedia.
:evidence3: = WikiTool[:evidence2:]
Plan: Summarize the findings.
:evidence4: = TextAnalyzer[Summary of :evidence1: and :evidence3:]
Answer: :evidence4:

System: A chat.


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

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

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

Question: What is the history of the Eiffel Tower and how has it been maintained over the years?

Response:
Plan: Begin by searching for information about the history of the Eiffel Tower.
:evidence0: = WikiSearch[Eiffel Tower history]
Plan: Utilize AnswerBot to interpret the search results and provide a summary of the tower's history.
:evidence1: = AnswerBot[What is the history of the Eiffel Tower? Given :evidence0:]
Plan: Conduct a new search to find information about the maintenance of the Eiffel Tower.
:evidence2: = WikiSearch[Eiffel Tower maintenance]
Plan: Extract the relevant links from the search results for further investigation.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use SiteScraper to gather information from the extracted links.
:evidence4: = SiteScraper[:evidence3:]
Plan: Lastly, employ AnswerBot to summarize the maintenance history of the Eiffel Tower from the scraped data.
:evidence5: = AnswerBot[How has the Eiffel Tower been maintained over the years? Given :evidence4:]
Answer: :evidence5:

System: A chat.


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

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

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

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

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

Response:
Plan: Search Wikipedia for information about the 2006 FIFA World Cup.
#E1 = WikiSearch[2006 FIFA World Cup]
Plan: Parse the structured data from the Wikipedia page to find out who won the tournament.
#E2 = DataParser[#E1]
Plan: Use QueryBot to extract the winner from the parsed data.
#E3 = QueryBot[Who won the 2006 FIFA World Cup? Given context: #E2]
Plan: Parse the structured data again to find out who was the top scorer.
#E4 = DataParser[#E1]
Plan: Use QueryBot to extract the top scorer from the parsed data.
#E5 = QueryBot[Who was the top scorer in the 2006 FIFA World Cup? Given context: #E4]
Final Answer: #E3 and #E5

System: A chat.


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

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

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

Response:
Plan: Begin by explaining the life cycle of a butterfly.
:Evidence0: = LifeCycle["butterfly"]
Plan: Then, describe the ecological role of butterflies.
:Evidence1: = EcologicalRole["butterfly"]
Plan: To provide a visual aid, find images related to the life cycle and ecology of butterflies.
:Evidence2: = ImageSearch["butterfly life cycle"]
:Evidence3: = ImageSearch["butterfly ecological role"]
Plan: If further information is needed, answer any additional questions about butterflies using general world knowledge.
:Evidence4: = QA["What else would you like to know about butterflies?"]
Plan: Lastly, suggest documentaries for more detailed understanding.
:Evidence5: = Documentary["butterfly"]

Answer: [:Evidence0:, :Evidence1:, :Evidence2:, :Evidence3:, :Evidence4:, :Evidence5:]

System: A chat.


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

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

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

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

Response:
Plan: Search for the winner of the Nobel Prize in Literature in 2020.
#E1 = GoogleSearch[Nobel Prize in Literature 2020 winner]
Plan: Extract the name of the winner from the search results.
#E2 = TextParser[#E1]
Plan: Find the most famous work of the author.
#E3 = GoogleSearch[Most famous work of #E2]
Plan: Extract the name of the work from the search results.
#E4 = TextParser[#E3]
Final Answer: #E4

System: A chat.


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

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

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

Remember to include only one evidence output per plan step.

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

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

Response:
Plan: Start by searching the internet to find out who wrote the book '1984'.
:data0: = SearchEngine['1984 book author']
Plan: Use AnswerBot to interpret the search results and identify the author's name.
:data1: = AnswerBot[Who is the author of the book '1984', given :data0:?]
Plan: Conduct another internet search to find other books written by the identified author.
:data2: = SearchEngine[Books written by :data1:]
Plan: Collect the relevant links from the search results for a detailed search.
:data3: = LinkCollector[:data2:]
Plan: Use TextExtractor to extract information from the collected links.
:data4: = TextExtractor[:data3:]
Plan: Finally, use AnswerBot to identify and list the other books written by the author from the extracted information.
:data5: = AnswerBot[What other books were written by :data1:, given :data4:?]
Final Answer: :data5:

System: A chat.


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

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

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

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

Response:
Plan: Search for information about Albert Einstein.
#E0 = DuckDuckGo[Albert Einstein]
Plan: Read the content of the top pages from the search results.
#E1 = URLReader[#E0]
Plan: Find out who Albert Einstein was.
#E2 = AskJeeves[Who was Albert Einstein? Given context: #E1]
Plan: Identify Albert Einstein's major contributions to physics.
#E3 = AskJeeves[What were Albert Einstein's major contributions to physics? Given context: #E1]
Answer: Albert Einstein was #E2 and his major contributions to physics were #E3.

System: A chat.


Instruction:
Please create a step-by-step execution plan to generate a solution to the user instruction. You need to make use of the set of available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string.

Here are the tools available to be called:
1. DuckDuckGo[input]: A tool that allows the user to search for information online. It finds a list of sites that might contain the answer to the user's question.
2. WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
3. HyperlinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
4. ALM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.  The input must be a text question that references a #E[n] variable.

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

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

Response:
Plan: Start by conducting a web search to find out the population of Tokyo.
#E0 = DuckDuckGo[Population of Tokyo]
Plan: Utilize the ALM to interpret the search results and find the population.
#E1 = ALM[What is the population of Tokyo, given context: #E0]
Plan: Conduct another web search to find popular tourist attractions in Tokyo.
#E2 = DuckDuckGo[Tourist attractions in Tokyo]
Plan: Extract the relevant links from the DuckDuckGo search results.
#E3 = HyperlinkExtractor[#E2]
Plan: Use the WebScraper tool to extract information from the relevant links.
#E4 = WebScraper[#E3]
Plan: Lastly, utilize the ALM to identify and summarize the popular tourist attractions in Tokyo from the extracted information.
#E5 = ALM[What are some popular tourist attractions in Tokyo, given context: #E4]
Answer: #E5

System: A chat.


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

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

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

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

Response:
Plan: Search for more information about Bitcoin.
#E1 = Bing[Bitcoin]
Plan: Use NLP to extract the name of the inventor of Bitcoin.
#E2 = NLP[Who invented Bitcoin? Given context: #E1]
Plan: Extract relevant links related to the history of Bitcoin.
#E3 = LinkExtractor[#E1]
Plan: Scrape web content from extracted links.
#E4 = WebScraper[#E3]
Plan: Use NLP to summarize the history of Bitcoin.
#E5 = NLP[What is the history of Bitcoin? Given context: #E4]
Final answer: #E5

System: A chat.


Instruction:
Create a sequential plan to respond to the user query utilizing the available tools. Each plan step should have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a mix of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding a suitable list of sites that may or may not contain the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
SiteReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkSelector[input]: Selects the most relevant links from a plain text list of links and produces a plain text, newline delimited response of selected links.
SmartQA[input]: Question answering language model, especially useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the dog, given :evidence1:?

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

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

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

Question: Who discovered penicillin and what diseases does it treat?

Response:
Plan: Start by conducting a web search to find out who discovered penicillin.
:evidence0: = DuckDuckGo[Who discovered penicillin]
Plan: Use the question answering model to interpret the search results and identify the discoverer.
:evidence1: = SmartQA[Who discovered penicillin, given :evidence0:?]
Plan: Conduct another web search to find the diseases treated by penicillin.
:evidence2: = DuckDuckGo[Diseases treated by penicillin]
Plan: Select the relevant links from the DuckDuckGo search results for detailed analysis.
:evidence3: = LinkSelector[:evidence2:]
Plan: Use the SiteReader tool to extract information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, use the question answering model to summarize the diseases treated by penicillin from the extracted information.
:evidence5: = SmartQA[What diseases does penicillin treat, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

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

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

Question: How did the stock market react after Apple Inc.'s last product launch?

Response:
Plan: Gather information about Apple Inc.'s last product launch.
#E1 = WikiTool[Apple Inc. product launches]
Plan: Identify the date and details of the last product launch.
#E2 = QAEngine[When was the last product launch by Apple Inc.? Given context: #E1]
Plan: Get recent news articles about the stock market reaction after the product launch.
#E3 = NewsAPI[Stock market reaction after Apple product launch on #E2]
Plan: Determine the overall sentiment of these articles.
#E4 = SentimentAnalyzer[#E3]
Final answer: #E4

System: A chat.


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

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

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

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

Response:
Plan: Initiate a web search to gather information about Nikola Tesla.
:evidence1: = DuckDuckGo[Nikola Tesla]
Plan: Employ the URLExtractor tool to obtain pertinent URLs from the search results.
:evidence2: = URLExtractor[:evidence1:]
Plan: Use the SiteReader tool to pull data from the identified URLs.
:evidence3: = SiteReader[:evidence2:]
Plan: Lastly, utilize AnswerBot to analyze the gathered data and identify Nikola Tesla's most significant inventions.
:evidence4: = AnswerBot[What were Nikola Tesla's most notable inventions? Given context: :evidence3:]
Final Response: :evidence4:

System: A chat.


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

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

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

Question: How does climate change affect global food security?

Response:
Plan: Initiate a search for information on how climate change affects global food security.
#Evidence1 = AskJeeves[Climate change impact on global food security]
Plan: Collect all links from the search results for further investigation.
#Evidence2 = LinkCollector[#Evidence1]
Plan: Scrape the main content from the collected links to obtain detailed information.
#Evidence3 = ContentScraper[#Evidence2]
Plan: Utilize HAL9000 to analyze the scraped content and answer the question on how climate change affects global food security.
#Evidence4 = HAL9000[How does climate change affect global food security? Given context: #Evidence3]
Final Answer: #Evidence4

System: A chat.


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

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

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

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

Response:
Plan: Search for the first woman to win a Nobel Prize.
#E1 = WebSearch[First woman to win a Nobel Prize]
Plan: Identify the name of the first woman to win a Nobel Prize.
#E2 = KnowledgeBase[Who was the first woman to win a Nobel Prize? Given context: #E1]
Plan: Search for more information about her contributions.
#E3 = WebSearch[#E2 + ' contributions']
Plan: Extract links from the search results for further investigation.
#E4 = LinkCollector[#E3]
Plan: Read the contents of the linked pages.
#E5 = PageReader[#E4]
Plan: Identify her main contributions.
#E6 = KnowledgeBase[What were the contributions of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


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

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

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

Ensure to only include one evidence output per plan step.

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

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

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
:data0: = WebSearch[Nobel Prize in Literature 2020 winner]
Plan: Utilize the knowledge base to interpret the search results and find the name of the laureate.
:data1: = KnowledgeBase[Who won the Nobel Prize in Literature in 2020, given :data0:?]
Plan: Conduct another web search to find the most famous work by the identified laureate.
:data2: = WebSearch[Most famous work by :data1:]
Plan: Extract the relevant links from the web search results for a more focused search.
:data3: = LinkGatherer[:data2:]
Plan: Use the content extractor tool to extract information from the relevant links.
:data4: = ContentExtractor[:data3:]
Plan: Finally, utilize the knowledge base to identify and summarize the most famous work by the laureate from the extracted information.
:data5: = KnowledgeBase[What is the most famous work by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


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

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

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

Remember to include only one evidence output per plan step.

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

Question: What are the main causes of global warming and what measures can be taken to mitigate its effects?

Response:
Plan: Start by conducting a web search to find out the main causes of global warming.
:evidence0: = YahooSearch[Main causes of global warming]
Plan: Use the IntelligentQA model to interpret the search results and identify the main causes.
:evidence1: = IntelligentQA[What are the main causes of global warming, given :evidence0:?]
Plan: Conduct another web search to find the measures that can be taken to mitigate the effects of global warming.
:evidence2: = YahooSearch[Measures to mitigate the effects of global warming]
Plan: Extract the relevant links from the Yahoo search results for a more detailed search.
:evidence3: = HyperlinkGatherer[:evidence2:]
Plan: Use the SiteReader tool to extract information from the relevant links.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, use the IntelligentQA model to identify and summarize the mitigation measures from the extracted information.
:evidence5: = IntelligentQA[What measures can be taken to mitigate the effects of global warming, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

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

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

Response:
Plan: Begin by searching for notable works of art at the Louvre Museum.
#E1 = AskJeeves[Notable works of art at the Louvre Museum]
Plan: Use BERT to interpret the search results and identify some notable works of art.
#E2 = BERT[What are some notable works of art at the Louvre Museum? Given context: #E1]
Plan: Search for more details about these notable works of art.
#E3 = AskJeeves[#E2]
Plan: Extract the relevant links from the search results for further exploration.
#E4 = LinkPicker[#E3]
Plan: Load the content of the selected links.
#E5 = SiteLoader[#E4]
Plan: Finally, use BERT to summarize the information about the notable works of art from the loaded site contents.
#E6 = BERT[Tell me more about the notable works of art :#E2:. Given context: #E5]
Final Answer: #E6

System: A chat.


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

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

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

Only include one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2019.
:evidence0: = Bing[Nobel Prize in Literature 2019 winner]
Plan: Use a language model to interpret the search results and identify the winner.
:evidence1: = SAM[Who won the Nobel Prize in Literature in 2019, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = Bing[Most famous work of :evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkGatherer[:evidence2:]
Plan: Use a text parser tool to extract information from the relevant links.
:evidence4: = TextParser[:evidence3:]
Plan: Finally, use the language model to identify and summarize the most famous work of the laureate from the extracted information.
:evidence5: = SAM[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

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

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

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

Response:
Plan: Search for academic articles related to how climate change affects bird migration.
#E1 = GoogleScholar[Climate change effects on bird migration]
Plan: Find the most relevant article from the search results.
#E2 = JSTOR[#E1]
Plan: Extract the abstract from the selected article.
#E3 = PaperAbstractExtractor[#E2]
Plan: Summarize the abstract to get a concise explanation.
#E4 = AIArticleSummarizer[#E3]
Final answer: #E4

System: A chat.


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

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

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

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

Response:
Plan: Perform a search to find the origin of the phrase "kick the bucket".
#E1 = DuckDuckGo[Origin of the phrase "kick the bucket"]
Plan: Use ContextualQA to determine the origin from the search results.
#E2 = ContextualQA[What is the origin of the phrase "kick the bucket"? Given context: #E1]
Plan: Perform another search to understand how the meaning of the phrase has evolved over time.
#E3 = DuckDuckGo[Evolution of the phrase "kick the bucket"]
Plan: Load the most relevant site from the search results to get detailed information.
#E4 = SiteLoader[URL from #E3]
Plan: Use ContextualQA to summarize how the meaning of the phrase has changed over time.
#E5 = ContextualQA[How has the meaning of the phrase "kick the bucket" evolved over time? Given context: #E4]
Final Answer: #E5

System: A chat.


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

Here are the tools you have at your disposal:
WebSearch[input]: This tool allows the user to search for information on the internet. It is useful in finding a list of sites that may contain the answer to the user's question. The function doesn't directly provide the answer; it finds a list of sites that might.
TextExtractor[input]: Extracts plain text from one or more websites provided in the input string containing newline delimited links. The input must be one or more links and the output will be plain text content from these links.
LinkFilter[input]: Filters out irrelevant links from a plain text list of links and produces a plain text, newline delimited response of relevant links.
QAModel[input]: A question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Ensure each plan step has only one evidence output.

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = WebSearch[Nobel Prize in Physics 2020 winner]
Plan: Use the question answering model to interpret the search results and identify the winner.
:evidence1: = QAModel[Who won the Nobel Prize in Physics in 2020, given :evidence0:?]
Plan: Conduct another web search to find the contributions made by the identified laureate.
:evidence2: = WebSearch[:evidence1: Nobel Prize contribution]
Plan: Filter out the relevant links from the Google search results for detailed analysis.
:evidence3: = LinkFilter[:evidence2:]
Plan: Use the TextExtractor tool to extract information from the filtered links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the question answering model to summarize the key contributions made by the laureate from the extracted information.
:evidence5: = QAModel[What were the contributions of :evidence1: that led to the Nobel Prize, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

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

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

Response:
Step: Initiate a search for the discoverer of penicillin.
#E1 = GoogleSearch[Discoverer of penicillin]
Step: Use the QAEngine to identify the person from the search results.
#E2 = QAEngine[Who discovered penicillin? Given context: #E1]
Step: Conduct a new search focusing on the impact of penicillin on medicine.
#E3 = GoogleSearch[Impact of penicillin on medicine]
Step: Extract the key points regarding the impact of penicillin on medicine.
#E4 = TextExtractor[#E3]
Step: Utilize the QAEngine to summarize the impact of penicillin on medicine.
#E5 = QAEngine[What was the impact of penicillin on medicine? Given context: #E4]
Final Answer: #E5

System: A chat.


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

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

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

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

Response:
Plan: Begin by searching for who was the first person to climb Mount Everest without supplemental oxygen.
#E1 = BingSearch[first person to climb Mount Everest without supplemental oxygen]
Plan: Extract URLs from the search results for more detailed information.
#E2 = URLFinder[#E1]
Plan: Scrape the websites for their content.
#E3 = SiteScraper[#E2]
Plan: Use the InfoModel to interpret the scraped website content and determine the answer.
#E4 = InfoModel[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: #E3]
Final Answer: #E4

And so on until you reach 10 unique instruction/response pairs.

System: A chat.


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

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

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

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

Response:
Plan: Start by performing a web search to find out the average lifespan of a Galapagos tortoise.
#E1 = YahooSearch[Average lifespan of a Galapagos tortoise]
Plan: Use KnowledgeBase to interpret the search results and determine the average lifespan.
#E2 = KnowledgeBase[What is the average lifespan of a Galapagos tortoise? Given context: #E1]
Plan: Perform another web search to find out where Galapagos tortoises typically live.
#E3 = YahooSearch[Typical habitat of Galapagos tortoises]
Plan: Extract relevant links from the Yahoo search results for more detailed information.
#E4 = HyperlinkGatherer[#E3]
Plan: Load the content of the extracted links for further examination.
#E5 = TextExtractor[#E4]
Plan: Lastly, use KnowledgeBase to determine the typical habitat of Galapagos tortoises from the loaded content.
#E6 = KnowledgeBase[Where do Galapagos tortoises typically live? Given context: #E5]
Final Answer: #E6

System: A chat.


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

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

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

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

Response:
Plan: Start by conducting a web search to find out about popular tourist attractions in Paris.
:evidence0: = Bing[Popular tourist attractions in Paris]
Plan: Use the AI model to interpret the search results and identify the attractions.
:evidence1: = AIAnswerer[What are some popular tourist attractions in Paris, given :evidence0:?]
Plan: Conduct another web search to find the historical significance of these attractions.
:evidence2: = Bing[Historical significance of :evidence1:]
Plan: Extract the relevant URLs from the Bing search results for detailed information.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use the WebCrawler tool to extract information from the relevant URLs.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, use the AI model to summarize the historical significance of the attractions from the extracted information.
:evidence5: = AIAnswerer[What is the historical significance of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

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

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

Response:
Plan: Search Wikipedia for information about the invention of the television.
:Evidence0: = WikiSearch[Invention of Television]
Plan: Identify the inventor's name from the retrieved information.
:Evidence1: = PersonIdentifier[:Evidence0:]
Plan: Extract the date when the television was first used commercially.
:Evidence2: = DateExtractor[:Evidence0:]
Plan: Confirm the inventor's name and the commercial use date.
:Evidence3: = QandA[Who invented the television and when was it first used commercially? Given :Evidence1: and :Evidence2:]
Answer: :Evidence3:

(Continued in next section due to character limit)

System: A chat.


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

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

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

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

Question: What is the history of the Great Wall of China and what materials were used in its construction?

Response:
Plan: Search for more information about the Great Wall of China.
:evidence1: = WikiSearch[Great Wall of China]
Plan: Find out the history of the Great Wall of China.
:evidence2: = QuestionSolver[What is the history of the Great Wall of China? Given context: :evidence1:]
Plan: Find out the materials used in the construction of the Great Wall of China.
:evidence3: = QuestionSolver[What materials were used in the construction of the Great Wall of China? Given context: :evidence1:]
Final answer: The history of the Great Wall of China is described in :evidence2: and the materials used in its construction are detailed in :evidence3:.

System: A chat.


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

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

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

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

Response:
Plan: Start by performing a web search to find out about the average lifespan of a Giant Panda in the wild.
:evidence0: = WebSearch[Average lifespan of a Giant Panda in the wild]
Plan: Use the InfoQA tool to extract the average lifespan from the search results.
:evidence1: = InfoQA[What is the average lifespan of a Giant Panda in the wild? Given context: :evidence0:]
Plan: Perform another web search to find out about the threats faced by Giant Pandas in the wild.
:evidence2: = WebSearch[Threats faced by Giant Pandas in the wild]
Plan: Extract useful links from the search results for more detailed information.
:evidence3: = LinkFinder[:evidence2:]
Plan: Extract text from the most relevant links found.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the InfoQA tool to summarize the threats faced by Giant Pandas in the wild from the extracted text.
:evidence5: = InfoQA[What are the threats faced by Giant Pandas in the wild? Given context: :evidence4:]
Final Answer: :evidence1:, :evidence5:

System: A chat.


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

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

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

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

Response:
Plan: Start by performing a Google search about the history of the Eiffel Tower's construction.
:evidence0: = GoogleSearch[History of Eiffel Tower construction]
Plan: Extract relevant links from the search results for further investigation.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Scrape the content of the extracted webpages for detailed information.
:evidence2: = WebScraper[:evidence1:]
Plan: Analyze the scraped content to find out about the history of the Eiffel Tower's construction.
:evidence3: = TextAnalyzer[What is the history behind the construction of Eiffel Tower? Given context: :evidence2:]
Plan: Further analyze the scraped content to identify the key people involved in the construction.
:evidence4: = TextAnalyzer[Who were the key people involved in the construction of Eiffel Tower? Given context: :evidence2:]
Answer: The history behind the construction of Eiffel Tower is contained in :evidence3: and the key people involved are listed in :evidence4:.

System: A chat.


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

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

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

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

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2019.
:Evidence0: = Bing[Nobel Prize in Literature 2019 winner]
Plan: Utilize AskAI to interpret the search results and find the name of the laureate.
:Evidence1: = AskAI[Who won the Nobel Prize in Literature in 2019, given :Evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:Evidence2: = Bing[Most famous work of :Evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:Evidence3: = HyperlinkHarvester[:Evidence2:]
Plan: Use SiteLoader to extract information from the relevant links.
:Evidence4: = SiteLoader[:Evidence3:]
Plan: Finally, utilize AskAI to identify and summarize the most famous work of the laureate from the extracted information.
:Evidence5: = AskAI[What is the most famous work of :Evidence1:, given :Evidence4:?]
Answer: :Evidence5:

System: A chat.


Instruction:
Develop a systematic plan to address the query using the tools at your disposal. For each plan, indicate the corresponding evidence value which would be the outcome of calling one of the available functions with an appropriate input string.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables the user to conduct searches using the DuckDuckGo search engine. It helps locate potential sites that might hold answers to the user's question.
TextExtractor[input]: Retrieves plain text from one or more websites specified in the input string (newline separated links). Input includes one or more links and outputs plain text containing the site contents.
URLFetcher[input]: Pulls out URLs from plain text and generates a plain text response of newline-separated links.
InfoBot[input]: An AI model capable of answering queries based on an input text excerpt. The input needs to be a textual question referencing an :evidence[n]: variable.

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

Question: Who invented the first airplane and what was their inspiration?

Response:
Plan: Initiate a web search to discover who invented the first airplane.
:evidence0: = DuckDuckGo[First airplane inventor]
Plan: Utilize InfoBot to decipher the search results and identify the inventor of the first airplane.
:evidence1: = InfoBot[Who invented the first airplane, given :evidence0:?]
Plan: Carry out another web search to understand the inspiration behind the invention of the first airplane.
:evidence2: = DuckDuckGo[Inspiration behind the invention of the first airplane]
Plan: Retrieve pertinent links from the search results for a more detailed investigation.
:evidence3: = URLFetcher[:evidence2:]
Plan: Employ TextExtractor to glean information from the chosen links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Lastly, use InfoBot to determine and summarize the inspiration behind the invention of the first airplane from the gathered data.
:evidence5: = InfoBot[What was the inspiration behind the invention of the first airplane, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: A tool that allows users to search for information using Bing's search engine. This tool is useful in finding relevant sites that may contain the answer to the user's query.
WebCrawler[input]: Loads websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly effective at answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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

Response:
Plan: Start by conducting a web search to find out about the Battle of Waterloo.
:evidence0: = Bing[Battle of Waterloo]
Plan: Use a language model to interpret the search results and find the historical significance of the Battle of Waterloo.
:evidence1: = SAM[What is the historical significance of the Battle of Waterloo, given :evidence0:?]
Plan: Conduct another web search to find the key figures involved in the Battle of Waterloo.
:evidence2: = Bing[Key figures in the Battle of Waterloo]
Plan: Extract the relevant links from the Bing search results for more focused information.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use WebCrawler to extract information from the relevant links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the key figures involved in the Battle of Waterloo from the extracted information.
:evidence5: = SAM[Who were the key figures in the Battle of Waterloo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question using the available tools. Each tool should be called with an appropriate input and its output stored in a variable named :evidence[n]:, where n is a number starting from 0. The final answer should reference the last evidence.

Available Tools:
1. Bing[input]: A tool that allows you to search for information on the internet using the Bing search engine.
2. TextAnalyzer[input]: Analyzes a block of text and extracts key details such as names, dates, places etc.
3. DocReader[input]: Reads documents provided in the form of links and outputs their content as plain text.
4. QnAMaker[input]: Answers questions based on given context. The input must include a question and a reference to an evidence variable for context.

Question: Who won the Nobel Prize in Literature in 2005 and what are some of his/her most famous works?

Response:
Plan: Start by searching for the winner of the Nobel Prize in Literature in 2005.
:evidence0: = Bing[Nobel Prize in Literature 2005 winner]
Plan: Use TextAnalyzer to extract the name of the winner from the search results.
:evidence1: = TextAnalyzer[:evidence0:]
Plan: Search for more information about the author's work.
:evidence2: = Bing[:evidence1: + ' bibliography']
Plan: Extract relevant links from the search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Read the contents of the linked pages to gather more data.
:evidence4: = DocReader[:evidence3:]
Plan: Ask QnAMaker to identify the most famous works of the author from the gathered data.
:evidence5: = QnAMaker[What are the most famous works of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
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.
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.
URLCollector[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
AIML[input]: Artificial Intelligence Markup Language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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

Response:
Plan: Start by conducting a web search to find out who won the 2022 Nobel Prize in Physics.
:evidence0: = Bing[2022 Nobel Prize in Physics winner]
Plan: Use AIML to interpret the search results and identify the winner.
:evidence1: = AIML[Who won the 2022 Nobel Prize in Physics, given :evidence0:?]
Plan: Conduct another web search to find the key contributions made by the identified laureate.
:evidence2: = Bing[:evidence1: + ' key contributions']
Plan: Collect the relevant URLs from the Bing search results for a more detailed search.
:evidence3: = URLCollector[:evidence2:]
Plan: Use WebReader to extract information from the collected URLs.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, use AIML to summarize the key contributions made by the laureate from the extracted information.
:evidence5: = AIML[What were the key contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please provide a step-by-step plan to solve the following problem using the provided tools. For each step, indicate the external tool along with its input to retrieve evidence. Store the evidence into a variable :evidence[index]:

Available Tools:
Britannica[input]: A tool that fetches information from Britannica Encyclopedia. It's useful for gaining knowledge about historical events, people, places, etc.
AskJeeves[input]: A tool that answers questions directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Output Format:
Plan: [First action]
:evidence0: = [Function call with input]
Plan: [Next action based on :evidence0:]
:evidence1: = [Next function call with input possibly referencing :evidence0:]
...
Final Answer: [:evidencen:]

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

Response:
Plan: Search for information about the Industrial Revolution.
:evidence0: = Britannica[Industrial Revolution]
Plan: Ask how the Industrial Revolution impacted society.
:evidence1: = AskJeeves[How did the Industrial Revolution impact society? Given context: :evidence0:]
Plan: Ask how the Industrial Revolution impacted the economy.
:evidence2: = AskJeeves[How did the Industrial Revolution impact the economy? Given context: :evidence0:]
Final Answer: Impact on Society: :evidence1:, Impact on Economy: :evidence2:

System: A chat.


Instruction:
Question: What is the history of the English language?

Here are the tools available to be called:
HistoryArchive[input]: This tool provides access to historical archives and documents.
LinguisticsDB[input]: This tool provides linguistic information related to various languages.
Wikipedia[input]: Tool that allows the user to search for information from Wikipedia.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
LanguageEvolution[input]: This tool provides information about the evolution of languages over time.

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

Response:
Plan: The first action is to use the Wikipedia tool to get a general overview of the history of the English language.
#E1 = Wikipedia["History of the English language"]

Plan: After obtaining a general overview, we will delve into more specific aspects of the evolution of the English language using the LanguageEvolution tool.
#E2 = LanguageEvolution["English language"]

Plan: Next, we can use the LinguisticsDB tool to gain further insights about the linguistic characteristics that have changed over time in the English language.
#E3 = LinguisticsDB["English language"]

Plan: Finally, if there are any unclear or unanswered parts regarding the history of the English language, we can use the QA tool to answer these questions based on the context provided by previous evidence.
#E4 = QA[Given context #E1, #E2, and #E3]

Final answer: #E4

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine. This tool is useful in finding an appropriate list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites provided as newline separated links. The input should be one or more links and it produces plain text output containing the content of the links.
LinkParser[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAEngine[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Ensure to only include one evidence output per plan step.

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

Question: What are some notable achievements of the current president of Harvard University?

Response:
Plan: Start by conducting a web search to find out who the current president of Harvard University is.
:evidence0: = WebSearch[Current president of Harvard University]
Plan: Use the QAEngine to interpret the search results and identify the name of the president.
:evidence1: = QAEngine[Who is the current president of Harvard University, given :evidence0:?]
Plan: Conduct another web search to find the notable achievements of the identified president of Harvard University.
:evidence2: = WebSearch[Notable achievements of :evidence1:]
Plan: Parse the relevant links from the web search results for detailed information.
:evidence3: = LinkParser[:evidence2:]
Plan: Utilize TextExtractor to extract information from the parsed links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, utilize the QAEngine to summarize the notable achievements of the president from the extracted information.
:evidence5: = QAEngine[What are the notable achievements of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a step-by-step plan to solve the problem using the tools provided. Each plan needs to have an associated evidence value.

Tools available:
PubMed[input]: Tool that searches for scientific articles and abstracts.
ChemSpider[input]: Tool that provides information about different chemical compounds.
MathSolver[input]: Tool that solves mathematical equations.
ScienceDirect[input]: Tool that provides access to full-text scientific studies.
SciAnswer[input]: Tool that answers science-based questions using a large database of scientific knowledge.

Question: What is the molecular structure of caffeine, find recent research papers about its effects on human health, and calculate the molar mass of caffeine.

Response:
Step 1: Use ChemSpider[input] to find the molecular structure of caffeine.
Evidence Value: The information provided by ChemSpider is reliable as it contains comprehensive data on different chemical compounds.

Step 2: Use PubMed[input] and ScienceDirect[input] to search for recent research papers about the effects of caffeine on human health.
Evidence Value: Both PubMed and ScienceDirect are reputable sources that provide access to a vast number of scientific articles and studies, ensuring up-to-date and accurate information.

Step 3: After obtaining the molecular formula of caffeine from ChemSpider in step 1, use MathSolver[input] to calculate the molar mass of caffeine.
Evidence Value: MathSolver can accurately solve mathematical equations including calculations related to chemistry such as determining molar mass.

Step 4: For any additional or complex science-based questions related to caffeine, use SciAnswer[input].
Evidence Value: SciAnswer has a large database of scientific knowledge and can answer more complex queries that may arise during the process.

System: A chat.