Instruction:
Please generate a step-by-step plan to answer the user query using the following tools. Each tool will have an output, which is stored in a variable :evidence[n]:.

Here are the available tools:
SearchEngine[input]: This tool allows you to search for information from various sources on the internet. The input should be a string related to the query.
ArticleExtractor[input]: Extracts full text of articles from the provided links. The input must be one or more newline separated URLs.
LinkParser[input]: Parses plain text and extracts all URL links present in it.
QAEngine[input]: A question answering tool that can provide answers based on common knowledge or given context.

The output format should be as follows:
Plan: [first action]
:evidence0: = [function call with input]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with input possibly referencing previous evidence]
...
Answer: [:evidence[n]: containing final answer]

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

Response:
Plan: Start by searching online for popular dishes in Italian cuisine.
:evidence0: = SearchEngine[Popular Italian dishes]
Plan: Use the QA engine to identify some popular Italian dishes from the search results.
:evidence1: = QAEngine[What are some popular dishes in Italian cuisine? Given context: :evidence0:]
Plan: Conduct separate searches for each identified dish to find out their typical ingredients.
:evidence2: = SearchEngine[:evidence1: + " ingredients"]
Plan: Extract the relevant links from the search results.
:evidence3: = LinkParser[:evidence2:]
Plan: Extract the content of the linked articles.
:evidence4: = ArticleExtractor[:evidence3:]
Plan: Finally, use the QA engine to summarize the typical ingredients of each dish from the extracted article contents.
:evidence5: = QAEngine[What are the typical ingredients of :evidence1:? Given context: :evidence4:]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to solve the following problem using the listed tools. Each plan will correspond to an evidence value which will be the result of a function called with an input string.

Available Tools:
AskJeeves[input]: A tool that searches for information online via Ask Jeeves. It returns a list of sites related to the input query.
PageReader[input]: Reads the contents of a page at a given URL. Input is a URL and output is the plain text content of the page.
LinkCollector[input]: Collects links from a block of text. Input is a block of text and output is a list of URLs found within the text.
InfoMaster[input]: Answers questions based on provided context. Input is a question and optionally a reference to previous evidence.

Output Format:
Plan: [First action based on input question]
:Evidence0: = [Function to call with input parameter]
Plan: [Next action based on :Evidence0:]
:Evidence1: = [Next function to call with input parameters, potentially including :Evidence0:]
...
Answer: [:EvidenceN:, containing final answer]

Question: What year did Queen Elizabeth II ascend to the throne and how long has she reigned?

Response:
Plan: Begin by searching for when Queen Elizabeth II ascended to the throne.
:Evidence0: = AskJeeves[Queen Elizabeth II ascension year]
Plan: Use InfoMaster to determine the exact year from the search results.
:Evidence1: = InfoMaster[When did Queen Elizabeth II ascend to the throne? Given :Evidence0:]
Plan: Next, calculate how long she has reigned by subtracting the ascension year from the current year.
:Evidence2: = InfoMaster[How many years has it been since :Evidence1:?]
Answer: :Evidence2:

System: A chat.


Instruction:
Generate a step-by-step plan to answer the question: "What is the history and significance of the Eiffel Tower in Paris?"

Here are the tools available:
HistoricalData[input]: A tool that provides historical data about various topics.
CulturalSignificance[input]: A tool that gives information on the cultural importance of different places, events, or people.
Translate[input]: Translates text from one language to another.
QA[input]: Answers questions based on common sense and general world knowledge.
GoogleMaps[input]: Provides geographical information and location details.

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

Response:
Plan: Use the HistoricalData tool to gather information about the history of the Eiffel Tower.
#E1 = HistoricalData["Eiffel Tower"]

Plan: Use the CulturalSignificance tool to understand the significance of the Eiffel Tower in Paris.
#E2 = CulturalSignificance["Eiffel Tower"]

Plan: Combine the historical data and cultural significance into a coherent answer.
Final Answer: #E1 + " " + #E2

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:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine.
PageLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkRetriever[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: An artificial intelligence-based question-answering model, particularly useful in answering questions based on an input passage of text.

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

Question: Who designed the Sydney Opera House and what was his inspiration?

Response:
Plan: Start by conducting a web search to find out who designed the Sydney Opera House.
#E1 = DuckDuckGo[Sydney Opera House designer]
Plan: Use AIQA to interpret the search results and find the name of the architect.
#E2 = AIQA[Who designed the Sydney Opera House? Given context: #E1]
Plan: Conduct another web search to find the inspiration behind the design of the Sydney Opera House.
#E3 = DuckDuckGo[Inspiration behind Sydney Opera House design]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
#E4 = HyperlinkRetriever[#E3]
Plan: Use PageLoader to extract information from the relevant links.
#E5 = PageLoader[#E4]
Plan: Lastly, use AIQA to identify and summarize the inspiration behind the design of the Sydney Opera House from the extracted information.
#E6 = AIQA[What was the inspiration behind the design of the Sydney Opera House? Given context: #E5]
Final answer: #E6

Continuing this pattern, you can create additional instruction/response pairs as needed.

System: A chat.


Instruction:
For the following tasks, create a detailed plan to solve the problem step-by-step. For each step in your plan, specify which external tool will be used along with its input to gather evidence. The gathered evidence can be stored into a variable #E[index] that can be referenced by subsequent tools.

Here are the available tools:
Bing[input]: A tool that allows you to search for information using the Bing search engine. This tool is useful for finding a list of sites that may contain the answer to your question. However, it doesn't directly provide an answer; instead, it provides a list of sites that might have the answer.
WebScraper[input]: Loads one or more websites from the input string containing newline-delimited links. The input should be one or more links and produces plain text output containing the content of these links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?

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

The output should be in format:
Plan: [first action to take based 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: Who was the first person to climb Mount Everest without supplemental oxygen and what book did they write about their experience?

Response:
Plan: Start by conducting a web search to find out who was the first person to climb Mount Everest without supplemental oxygen.
#E1 = Bing[First person to climb Mount Everest without supplemental oxygen]
Plan: Use the QAModel to interpret the search results and identify the name of the climber.
#E2 = QAModel[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: #E1]
Plan: Conduct another web search to find the book written by this person about their experience.
#E3 = Bing[Book written by #E2 about climbing Mount Everest without supplemental oxygen]
Plan: Extract relevant links from the Bing search results for further investigation.
#E4 = LinkExtractor[#E3]
Plan: Use the WebScraper tool to extract information from the relevant links.
#E5 = WebScraper[#E4]
Plan: Finally, use the QAModel to identify and summarize the title of the book written by the climber from the extracted information.
#E6 = QAModel[What is the title of the book written by #E2 about their experience climbing Mount Everest without supplemental oxygen? Given context: #E5]
Final answer: #E6

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.
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.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What are some notable achievements of the current Prime Minister of Canada?

Response:
Plan: Start by conducting a web search to find out who the current Prime Minister of Canada is.
:evidence0: = Bing[Current Prime Minister of Canada]
Plan: Use AIQA to interpret the search results and find the name of the Prime Minister.
:evidence1: = AIQA[Who is the current Prime Minister of Canada, given :evidence0:?]
Plan: Conduct another web search to find the notable achievements of the identified Prime Minister of Canada.
:evidence2: = Bing[Notable achievements of :evidence1:]
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use WebCrawler tool to extract information from the relevant URLs.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, utilize the AIQA to identify and summarize the notable achievements of the Prime Minister of Canada from the extracted information.
:evidence5: = AIQA[What are the notable achievements of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools you have at your disposal:
SearchEngine[input]: This tool allows users to search for information on the internet. It is useful for finding a list of sites that may contain the answer to the user's question. The function doesn't directly provide answers; it finds websites that might.
TextExtractor[input]: Extracts text from one or more websites from the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkParser[input]: Extracts links from plain text and generates a plain text, newline delimited response of links.
QAModel[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 :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., QAModel[What is the capital of France, given :data3:?]

Ensure there is only one evidence output per plan step.

The output format should be as follows:
Plan: [first action to take based on the input question]
: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 is the author of the book 'To Kill a Mockingbird' and what other books did they write?

Response:
Plan: Start by conducting an online search to find out who wrote 'To Kill a Mockingbird'.
:data0: = SearchEngine['To Kill a Mockingbird author']
Plan: Use the question answering model to interpret the search results and identify the author.
:data1: = QAModel[Who is the author of 'To Kill a Mockingbird', given :data0:?]
Plan: Conduct another online search to find other books written by the identified author.
:data2: = SearchEngine[:data1: + ' bibliography']
Plan: Parse the relevant links from the search results for a more focused search.
:data3: = LinkParser[:data2:]
Plan: Use the TextExtractor tool to extract information from the relevant links.
:data4: = TextExtractor[:data3:]
Plan: Finally, use the question answering model to identify and summarize the other books written by the author from the extracted information.
:data5: = QAModel[What other books were written by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
Generate a solution plan for the user query using the tools at disposal. Each plan will correspond to an evidence value which will be the result of a function call.

Tools Available:
1. Yahoo[input]: Tool that uses Yahoo search engine to find relevant sites. The input is a string containing the search query.
2. LinkExtractor[input]: Extracts links from the plain text. The input is plain text with newline delimited links.
3. Scraper[input]: Scrapes websites mentioned in the input links and produces plain text content.
4. QAModel[input]: A language model that answers questions based on the input passage of text. The input must reference an :evidence[n]: variable.

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

Question: What is the significance of Fibonacci sequence in nature?

Response:
Plan: Start by searching for information about Fibonacci sequence in nature.
:evidence0: = Yahoo[Fibonacci sequence in nature]
Plan: Extract useful links from the search results.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Scrape the contents of the extracted links.
:evidence2: = Scraper[:evidence1:]
Plan: Generate an answer to the question using the scraped content.
:evidence3: = QAModel[What is the significance of Fibonacci sequence in nature? Given :evidence2:]
Final Answer: :evidence3

System: A chat.


Instruction:
Provide a step-by-step plan to generate an appropriate response to the user's query, utilizing the following tools. Each plan should correspond to an evidence value, which would be the output of a specific function given an input string.

Tools available:
BingSearch[input]: A tool that enables users to conduct a Bing search. It provides a list of potential sites that might contain the answer to the user's query.
URLExtractor[input]: A tool that extracts URLs from a provided piece of text.
SiteReader[input]: Reads the contents of a website provided as a URL.
QAModel[input]: A question-answering model that can answer queries based on a given context. For instance, it could answer "What is the main theme of the article?" given ":evidence1:".

Output format:
Plan: [First action based on the input question]
#E1 = [Function to call with input parameters]
Plan: [Next action based on #E1]
#E2 = [Next function to call with input parameters (can refer to previous evidence)]
...
Final Answer: #En

Question: Who wrote the novel '1984' and what are some major themes discussed in the book?

Response:
Plan: Begin by searching for the author of the novel '1984'.
#E1 = BingSearch['1984' novel author]
Plan: Use QAModel to determine the author from the search results.
#E2 = QAModel[Who wrote the novel '1984'? Given context: #E1]
Plan: Conduct a search to find discussions about the major themes in '1984'.
#E3 = BingSearch['1984' novel major themes]
Plan: Extract the relevant URLs from the search results.
#E4 = URLExtractor[#E3]
Plan: Read the contents of the websites found.
#E5 = SiteReader[#E4]
Plan: Use QAModel to summarize the major themes in '1984' from the website contents.
#E6 = QAModel[What are the major themes in the novel '1984'? Given context: #E5]
Final Answer: #E2 and #E6

System: A chat.


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

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

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

Question: What are some of the most popular dishes in French cuisine?

Response:
Plan: Start by conducting a web search to find out about popular dishes in French cuisine.
:evidence0: = Bing[Popular dishes in French cuisine]
Plan: Use LinkFinder to extract relevant links from the search results.
:evidence1: = LinkFinder[:evidence0:]
Plan: Utilize TextScraper to gather information from the extracted links.
:evidence2: = TextScraper[:evidence1:]
Plan: Finally, utilize QAModel to identify and summarize the popular dishes in French cuisine from the scraped information.
:evidence3: = QAModel[What are some popular dishes in French cuisine, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Please provide a plan to find out who the founder of Microsoft is and what was their first product? Make use of the tools below and store each result in a variable #E[index].

Tools Available:
DuckDuckGo[input]: This tool uses DuckDuckGo search engine to fetch information.
DataMiner[input]: Extracts specific information like names, products, dates etc., from a given text.
WebPageLoader[input]: Loads webpages from provided links and returns their textual content.
AIQA[input]: AI-powered Question Answering system that can answer queries given an input context.

Response:
Plan: Initiate a search to find out who founded Microsoft.
#E1 = DuckDuckGo[Microsoft founder]
Plan: Use DataMiner to extract the name of the founder from the search results.
#E2 = DataMiner[#E1]
Plan: Conduct another search to get information about the first product developed by Microsoft.
#E3 = DuckDuckGo[#E2 + " first product"]
Plan: Load the webpage content for more detailed information.
#E4 = WebPageLoader[#E3]
Plan: Use AIQA to determine the first product created by the founder of Microsoft.
#E5 = AIQA[What was the first product created by #E2? Given context: #E4]
Final answer: #E5

System: A chat.


Instruction:
Generate a step-by-step plan to respond to the following user request:

Question: What are the main causes of the Great Depression and its impact on global economy?

Here are the tools available to be called:
HistoricalDB[input]: A tool that allows you to search for historical data and events.
EconomicIndicator[input]: Provides economic indicators for a specific period.
GlobalImpact[input]: Assesses the global impact of a particular event or phenomenon.
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.
TextSummarizer[input]: Summarizes long texts into shorter versions.

Follow the same planning and output format as TSK 1.

Response:
Plan:

Step 1: Use the HistoricalDB tool to gather information about the main causes of the Great Depression. Input for this step would be "Great Depression Causes".

Step 2: Analyze the output from Step 1 and summarize it using TextSummarizer tool to provide a concise explanation of the main causes of the Great Depression.

Step 3: Use the EconomicIndicator tool with input as "1929-1939" (the period of the Great Depression) to get data on economic indicators during that time.

Step 4: Interpret the results from Step 3, explaining how these economic indicators show the impact of the Great Depression on the economy at that time.

Step 5: Use the GlobalImpact tool with the input as "Great Depression" to assess its global impact.

Step 6: Summarize the output from Step 5 using the TextSummarizer tool to provide a brief overview of the global impact of the Great Depression.

Step 7: If any further clarification is needed or if there are gaps in the response, use the QA tool to fill them by asking relevant questions based on the user's original request.

Step 8: Combine all the summarized outputs into one coherent answer detailing the main causes of the Great Depression and its impact on the global economy.

System: A chat.


Instruction:
Create a plan to solve the following problem using the tools at your disposal. For each step in your plan, indicate which tool you would use along with the necessary inputs. You can store the outputs into a variable #E[index] that can be referenced later.

Here are the tools you can use:
DuckDuckGo[input]: A tool that lets you perform searches using DuckDuckGo. Useful for finding lists of websites that might have the required information.
SiteReader[input]: Reads the content of one or more websites specified by newline-separated links in the input string.
URLExtractor[input]: Extracts URLs from plain text and returns them as newline-separated strings.
InfoModel[input]: An AI model that can answer questions based on a given context. The input should be a textual question that references a #E[n] variable, like "What is the population of Paris, given #E1?"

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

The output should look like this:
Plan: [first action based on the input question]
#E1 = [function call with input parameter]
Plan: [next action based on the result of #E1]
#E2 = [next function call and input parameter, possibly referencing previous evidence, e.g., "Given context #E1"]
...
Final Answer: #E[n]

Question: What is the tallest building in New York City and when was it completed?

Response:
Plan: Begin by searching for the tallest building in New York City.
#E1 = DuckDuckGo[Tallest building in New York City]
Plan: Use InfoModel to parse the search results and determine the name of the building.
#E2 = InfoModel[What is the tallest building in New York City? Given context: #E1]
Plan: Perform another search to find out when the identified building was completed.
#E3 = DuckDuckGo[Completion date of #E2]
Plan: Extract the relevant links from the search results for detailed information.
#E4 = URLExtractor[#E3]
Plan: Read the content of the extracted websites for accurate information.
#E5 = SiteReader[#E4]
Plan: Lastly, use InfoModel to determine the completion date of the building from the read content.
#E6 = InfoModel[When was #E2 completed? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a step-by-step plan to answer the following user question using the available tools. Each tool execution will generate an evidence value, which is the output of one of the available functions given an input string that can be either the user's question or previous evidence values.

Here are the tools you can use:
Bing[input]: A search engine tool that allows users to find information from various websites across the internet.
PageReader[input]: Loads a website from the input URL and produces plain text containing the content of the webpage.
LinkCollector[input]: Extracts links from plain text and generates a list of URLs.
TextAnalyzer[input]: Analyzes a passage of text and answers questions based on it. The input must be a question referencing an :evidence[n]: variable.

Each function takes a plain string as input without quotes or "+" for concatenation with an evidence variable (for example, TextAnalyzer[What is the capital of France, given :evidence2:?]).

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

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

Response:
Plan: Start by searching for the author of "To Kill a Mockingbird".
:evidence0: = Bing[Author of To Kill a Mockingbird]
Plan: Use the TextAnalyzer to identify the author's name from the search results.
:evidence1: = TextAnalyzer[Who is the author of "To Kill a Mockingbird", given :evidence0:?]
Plan: Conduct another web search to find notable works by the identified author.
:evidence2: = Bing[Notable works by :evidence1:]
Plan: Extract relevant links from the search results for more detailed information.
:evidence3: = LinkCollector[:evidence2:]
Plan: Load the content of the extracted links using PageReader.
:evidence4: = PageReader[:evidence3:]
Plan: Finally, use the TextAnalyzer to summarize the notable works by the author from the loaded page contents.
:evidence5: = TextAnalyzer[What are some notable works by :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.

Question: Who composed the music for the film 'Inception' and what other notable films have they worked on?

Here are the tools available to be called:
IMDbSearch[input]: Search for movie-related information using IMDb database.
ComposerInfo[input]: Get detailed information about a specific composer.
Filmography[input]: Get a list of all films a person has worked on.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.

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

Response:
Plan: Identify the composer of the film 'Inception'.
:evidence0: = IMDbSearch['Inception']

Plan: Get detailed information about the identified composer.
:evidence1: = ComposerInfo[:evidence0:]

Plan: List all notable films that the composer has worked on.
:evidence2: = Filmography[:evidence1:]

Answer: [:evidence2: containing the final answer.]

System: A chat.


Instruction:
Please create a plan to solve the following user query using the tools provided. Each step of the plan should correspond to an evidence value, which is the output of one of the available functions given an input string that could be the user question, previous evidence values, or a mixture of both.

Available tools:
WikiSearch[input]: Tool that allows the user to search for information from Wikipedia.
PageScraper[input]: Load a website from the input link and produces plain text output containing the content of the link.
QAEngine[input]: Answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Response:
Plan: Search for information about Tokyo's population.
#E1 = WikiSearch[Tokyo Population]
Plan: Find out the population of Tokyo.
#E2 = QAEngine[What is the population of Tokyo? Given context: #E1]
Plan: Search for information about popular tourist attractions in Tokyo.
#E3 = WikiSearch[Tourist attractions in Tokyo]
Plan: Scrape the page for detailed information.
#E4 = PageScraper[#E3]
Plan: Identify the popular tourist attractions in Tokyo.
#E5 = QAEngine[What are some popular tourist attractions in Tokyo? Given context: #E4]
Final answer: #E2 and #E5

System: A chat.


Instruction:
Design a systematic plan to provide an optimal response to the user's command, leveraging the following tools. Each step in the plan will yield an evidence value that represents the output of one of the accessible functions. The inputs to these functions could either be the user's question, preceding evidence values, or a blend of both.

Tools Available:
YahooSearch[input]: Allows the user to conduct searches via the Yahoo search engine. This tool generates a list of potential websites that may hold the answer to the user's inquiry.
SiteScanner[input]: Fetches one or more websites from the input string, which contains newline-separated links. Produces a plain-text output comprising the contents of the links.
HyperlinkExtractor[input]: Gleans hyperlinks from plain text and delivers a plain-text, newline-separated list of links.
AIQA[input]: Artificial Intelligence Question-Answering model adept at responding to queries based on an input text passage. The input needs to be a textual question that refers to a #E[index] variable (e.g., What is the population of New York City, given #E1?)

Output Format:
Plan: [First action derived from the user's question]
#E0 = [Function to invoke with its input]
Plan: [Following action, based on the outcome of #E0]
#E1 = [Subsequent function to invoke with its input, possibly referring to earlier evidence (e.g., "Given context #E0")]
...
Answer: [#E[n] containing the final answer]

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

Response:
Plan: Initiate a web search to discover the author of 'To Kill a Mockingbird'.
#E0 = YahooSearch[Author of To Kill a Mockingbird]
Plan: Employ the AIQA model to parse the search results and pinpoint the author's name.
#E1 = AIQA[Who is the author of 'To Kill a Mockingbird'? Given context: #E0]
Plan: Launch another web search to uncover other books penned by the identified author.
#E2 = YahooSearch[Other books written by #E1]
Plan: Extract suitable links from the search results for a more comprehensive investigation.
#E3 = HyperlinkExtractor[#E2]
Plan: Utilize the SiteScanner tool to glean information from the chosen links.
#E4 = SiteScanner[#E3]
Plan: Ultimately, apply the AIQA model to identify and summarize the other books authored by the writer from the gathered information.
#E5 = AIQA[What other books has #E1 written? Given context: #E4]
Answer: #E5

System: A chat.


Instruction:
Create a sequential plan to generate a response to the user instruction, utilizing the set of available tools. Each plan will have a corresponding evidence value, which is the output of one of the functions given an input string - this could be the user's question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
Bing[input]: Tool that enables the user to perform a Bing search. Useful for finding a range of sites that might include the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string (containing newline-delimited links), producing plain text output containing the website content.
URLPicker[input]: Picks URLs from plain text and generates a plain text, newline-delimited list of URLs.
NLPModel[input]: Language model for answering questions based on an input text passage. The input must be a textual question that references an :evidence[n]: variable, e.g., What is the population of Tokyo, given :evidence1:?

Only one evidence output should be included per plan step.

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

Question: Who is the current president of Microsoft and what significant contributions have they made to the company?

Response:
Plan: Begin by conducting a Bing search to find out who the current president of Microsoft is.
:evidence0: = Bing[Current president of Microsoft]
Plan: Utilize NLPModel to interpret the search results and find the name of the president.
:evidence1: = NLPModel[Who is the current president of Microsoft, given :evidence0:?]
Plan: Conduct another Bing search to find the significant contributions made by the identified president of Microsoft.
:evidence2: = Bing[Significant contributions of :evidence1: at Microsoft]
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:evidence3: = URLPicker[:evidence2:]
Plan: Use SiteLoader to extract information from the relevant URLs.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, utilize the NLPModel to identify and summarize the significant contributions made by the president of Microsoft from the extracted information.
:evidence5: = NLPModel[What are the significant contributions of :evidence1: at Microsoft, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a detailed plan to answer the following query using the set of tools at your disposal. Each step of the plan should yield an evidence value, produced by calling a function with an input string that could be the original question, previously obtained evidence, or a combination of both.

Available tools:
WikiLookup[input]: Searches Wikipedia for information related to the input string. While it may not always give direct answers, it often provides valuable context.
TextAnalyzer[input]: Analyzes a body of text and summarizes key points. Particularly useful when dealing with large amounts of information.
QAHelper[input]: Answers questions using general knowledge or specific context provided through previous evidence.

Each function requires a simple string as input, without the need for quotes or concatenation symbols. For instance, QAHelper[Who won the 2020 presidential election, given :evidence2:?].

Ensure each plan step has exactly one corresponding evidence output.

Output format:
Plan: [initial action based on the question]
:evidence0: = [call to function with input parameter]
Plan: [subsequent action, considering the outcome of :evidence0:]
:evidence1: = [call to next function with input parameter, possibly referring to earlier evidence such as "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

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

Response:
Plan: Begin by searching Wikipedia for information about Nikola Tesla.
:evidence0: = WikiLookup[Nikola Tesla]
Plan: Use TextAnalyzer to summarize the key points about Nikola Tesla from the Wikipedia page.
:evidence1: = TextAnalyzer[:evidence0:]
Plan: Use QAHelper to identify who Nikola Tesla was based on the summarized information.
:evidence2: = QAHelper[Who was Nikola Tesla, given :evidence1:?]
Plan: Look up Nikola Tesla's major scientific contributions on Wikipedia.
:evidence3: = WikiLookup[Nikola Tesla's contributions to science]
Plan: Apply TextAnalyzer to summarize the main scientific contributions of Nikola Tesla.
:evidence4: = TextAnalyzer[:evidence3:]
Plan: Lastly, utilize QAHelper to specify Nikola Tesla's major contributions to science based on the summary.
:evidence5: = QAHelper[What were Nikola Tesla's major contributions to science, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Generate a plan to answer the following question using these available tools. Each tool should be used with an input and will produce an output that can be stored in a variable :evidence[n]: for further use.

Available Tools:
Bing[input]: A search engine tool useful for finding relevant websites based on the input query.
WebReader[input]: This tool takes one or more URLs as input, reads the content of the webpage(s), and produces plain text output containing the information from the page(s).
LinkPicker[input]: Extracts links from plain text and outputs them in a list format.
AskAI[input]: An AI model capable of answering questions based on given context (text). The input must be a text question referencing an :evidence[n]: variable.

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

Question: What are some notable accomplishments of Elon Musk?

Response:
Plan: Use Bing to find webpages about Elon Musk's accomplishments.
:evidence0: = Bing[Elon Musk accomplishments]
Plan: Extract the most relevant links from the Bing search results.
:evidence1: = LinkPicker[:evidence0:]
Plan: Read the contents of the extracted webpages.
:evidence2: = WebReader[:evidence1:]
Plan: Ask the AI model to summarize Elon Musk's notable accomplishments based on the gathered information.
:evidence3: = AskAI[What are some notable accomplishments of Elon Musk? Given :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Generate a step-by-step plan to answer the user's question, using the following tools at your disposal. Each plan should be followed by an evidence value that will be the output of one of the available functions given an input string.

Here are the tools you can use:

WebSearch[input]: This tool allows you to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
PageReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the pages.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
InfoExtractor[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 :info[n]: variable, e.g. What color is the cat, given :info1:?

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

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

Response:
Plan: Start by conducting a web search to find out who the first woman to win a Nobel Prize was.
:info0: = WebSearch[First woman to win a Nobel Prize]
Plan: Use the InfoExtractor to interpret the search results and identify the name of the woman.
:info1: = InfoExtractor[Who was the first woman to win a Nobel Prize, given :info0:?]
Plan: Conduct another web search to find the scientific contributions made by this woman.
:info2: = WebSearch[Scientific contributions of :info1:]
Plan: Extract the relevant links from the web search results for a detailed investigation.
:info3: = LinkPicker[:info2:]
Plan: Use the PageReader tool to extract information from the selected links.
:info4: = PageReader[:info3:]
Plan: Finally, utilize the InfoExtractor to summarize the key scientific contributions made by this woman from the extracted information.
:info5: = InfoExtractor[What were the scientific contributions of :info1:, given :info4:?]
Answer: :info5:

System: A chat.


Instruction:
Generate 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:
NewsAggregator[input]: Tool that collects news articles related to a particular topic.
SocialMediaMonitor[input]: Tool that monitors social media posts related to a specific keyword or hashtag.
SentimentAnalyzer[input]: Tool that analyzes the sentiment (positive, negative, neutral) of a piece of text.
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.
WebCrawler[input]: Tool that visits websites to collect information.

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 is the latest iPhone model being received by the public?

Response:
Plan: First, find out what the latest iPhone model is.
#E1 = QA["What is the latest iPhone model?"]

Plan: Then, gather news articles about this latest iPhone model to understand its features and any initial reactions.
#E2 = NewsAggregator[#E1]

Plan: Analyze sentiment of these news articles to get a sense of public reception.
#E3 = SentimentAnalyzer[#E2]

Plan: Monitor social media posts related to the latest iPhone model for additional insights into public opinion.
#E4 = SocialMediaMonitor[#E1]

Plan: Analyze sentiment of these social media posts to supplement the information gathered from news articles.
#E5 = SentimentAnalyzer[#E4]

Final answer: The latest iPhone model is being received by the public with a sentiment of #E3 in news articles and #E5 on social media.

System: A chat.


Instruction:
Develop a strategy to solve the problem at hand using the provided tools. For each step, indicate which external tool along with its input would be used to gather evidence. Store this evidence into a variable #E[index] that can be referred to later.

Available tools:
FactFinder[input]: Tool that enables the user to retrieve factual information about people, places, companies, historical events, etc. It uses a database of facts instead of searching the entire internet. The input should be a specific fact-related query.
AskMe[input]: A tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

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

Response:
Plan: Search for the winner of the Nobel Prize in Literature in 2019.
#E1 = FactFinder[Nobel Prize in Literature 2019 winner]
Plan: Find out the most famous work of the winner.
#E2 = AskMe[What is the most famous work of #E1?]
Final answer: #E2

System: A chat.


Instruction:
Formulate a systematic approach to answer the query utilizing the available tools. Every stage of your plan should produce an evidence variable.

Available Tools:
WikiLookup[input]: Retrieves information about the input topic from Wikipedia.
DataCrawler[input]: Crawls the internet to gather data related to the input.
QAModel[input]: AI-powered Question-Answering model that provides answers based on the input context.

Required Output Format:
Plan: [Action to perform]
:Evidence[index]: = [Tool to employ with its input]
...
Final Response: :Evidence[n]:

Question: When was the Eiffel Tower built and who was its architect?

Response:
Plan: Begin by looking up the Eiffel Tower on Wikipedia.
:Evidence0: = WikiLookup[Eiffel Tower]
Plan: Utilize the QAModel to determine when the Eiffel Tower was built.
:Evidence1: = QAModel[When was the Eiffel Tower built? Given context: :Evidence0:]
Plan: Again, use the QAModel to identify the architect of the Eiffel Tower.
:Evidence2: = QAModel[Who was the architect of the Eiffel Tower? Given context: :Evidence0:]
Plan: To verify the gathered information, run a Data Crawl.
:Evidence3: = DataCrawler[Eiffel Tower construction date and architect]
Plan: Lastly, cross-check the crawled data with the initial information using the QAModel.
:Evidence4: = QAModel[Is the construction date and architect of the Eiffel Tower as per :Evidence1: and :Evidence2:? Given context: :Evidence3:]
Final Response: :Evidence4:

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the user's question, making use of the available tools. Each step in your plan will correspond to an evidence value, which is the output of one of the given functions with an input string that can be the user's question, previous evidence values, or both.

Here are the tools you can call:
WebSearch[input]: This tool allows users to search for information on the internet using a general web search engine. It finds a list of sites that may contain the answer to the user's query but does not directly provide the answer.
PageReader[input]: This function loads one or more websites from the input string containing newline-delimited links and produces plain text output containing the content of those pages.
LinkFinder[input]: Extracts links from plain text and provides a plain text, newline-delimited response of links.
QAExpert[input]: A question-answering language model useful for answering questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., "What is the capital of France, given #E1?"

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

Remember to include only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search about the history of the Eiffel Tower.
#E1 = WebSearch[Eiffel Tower History]
Plan: Use the link finder to extract relevant links from the search results.
#E2 = LinkFinder[#E1]
Plan: Use the page reader to load the content of these links.
#E3 = PageReader[#E2]
Plan: Utilize the QAExpert to interpret the loaded content and find out about the history of the Eiffel Tower.
#E4 = QAExpert[What is the history of the Eiffel Tower, given #E3?]
Plan: Conduct another web search to find out who the main architects of the Eiffel Tower were.
#E5 = WebSearch[Main architects of the Eiffel Tower]
Plan: Again, utilize the QAExpert to interpret the search results and identify the main architects.
#E6 = QAExpert[Who were the main architects of the Eiffel Tower, given #E5?]
Final Answer: #E4 and #E6

System: A chat.


Instruction:
Generate a sequential plan to respond optimally to the user's request, leveraging the range of tools available. Each plan will correspond to an evidence value, which is the output of one of the accessible functions given an input string that could be the user's question, one or more past evidence values, or a blend of both.

Here are the tools available to be called:
EncyclopediaSearch[input]: Allows the user to search for information from an online encyclopedia. It's particularly helpful for acquiring knowledge about individuals, locations, businesses, historical occurrences, and other kinds of factual data.
TextSimplifier[input]: Simplifies a chunk of text and outputs the main ideas.
URLAggregator[input]: Aggregates URLs from a piece of text and provides them as a line-separated list.
QueryEngine[input]: A language model skilled at answering inquiries based on an input paragraph of text. The input has to be a text question that cites a |fact[n]| variable, such as 'What is the climate of Antarctica, given |fact1|?'

Each function merely requires a plain string as input, without quotation marks or '+' symbols to merge a string with a fact variable, like QueryEngine[What is the currency of Japan, given |fact3|?].

Be sure to offer only one evidence output for each planning stage.

The output should conform to this format:
Plan: [First action derived from the input question]
|fact0 = [Function to call with input parameter]
Plan: [Following action, based on the consequence of |fact0]
|fact1 = [Next function to call and input parameter, perhaps citing previous evidence, such as 'Given context |fact0']
...
Final Answer: [|fact[n], comprising the final answer.]

Question: What were the significant contributions of Nikola Tesla to the field of electrical engineering and how did they influence modern technology?

Response:
Plan: Initiate an encyclopedia search to gather information about Nikola Tesla's contributions to electrical engineering.
|fact0 = EncyclopediaSearch[Nikola Tesla contributions to electrical engineering]
Plan: Apply the TextSimplifier to distill the major contributions of Nikola Tesla from the encyclopedia entry.
|fact1 = TextSimplifier[Significant contributions of Nikola Tesla to electrical engineering. Given context: |fact0]
Plan: Execute another encyclopedia search for more granular information about these contributions.
|fact2 = EncyclopediaSearch[|fact1]
Plan: Once again, employ the TextSimplifier to comprehend how these contributions influenced modern technology.
|fact3 = TextSimplifier[Influence of Nikola Tesla's contributions on modern technology. Given context: |fact2]
Final Answer: |fact3

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

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

Question: Who 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 SAM to interpret the search results and find the name of the laureate.
: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: = LinkCollector[:evidence2:]
Plan: Use WebCrawler to extract information from the relevant links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, utilize SAM 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:
Develop a step-by-step plan to address the user's query using the tools at your disposal. Each plan will have a corresponding evidence value, generated by one of the functions.

Here are the tools available to be called:
GoogleSearch[input]: Searches for information on Google and returns a list of sites that might contain the answer.
SiteReader[input]: Reads the content of a site and outputs the text.
QAModel[input]: Answers questions based on general knowledge or given context.
LinkGatherer[input]: Gathers links from a block of text and outputs them in a list.

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

Question: How does photosynthesis work and what are its main stages?

Response:
Plan: Start by conducting a Google search on how photosynthesis works.
:evidence0: = GoogleSearch[How does photosynthesis work]
Plan: Use QAModel to interpret the search results and provide a basic explanation of photosynthesis.
:evidence1: = QAModel[What is photosynthesis? Given context: :evidence0:]
Plan: Conduct another Google search to find out the main stages of photosynthesis.
:evidence2: = GoogleSearch[Main stages of photosynthesis]
Plan: Gather the relevant links from the Google search results.
:evidence3: = LinkGatherer[:evidence2:]
Plan: Read the content of the gathered links.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, use QAModel to identify and explain the main stages of photosynthesis from the read content.
:evidence5: = QAModel[What are the main stages of photosynthesis? Given context: :evidence4:]
Answer: :evidence5:

System: A chat.


Instruction:
Design a plan to solve the problem below 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:
YahooSearch[input]: Tool that allows the user to search for information from Yahoo Search.  This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.  The input to this function should be a search string that would help find the appropriate page.  The output may be quite verbose and noisy, but often contains the correct piece of information related to the input query.
TextParser[input]: Parse 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.
HyperlinkCollector[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
SmartAnswer[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: Who is the founder of Microsoft and what were his major contributions to the company?

Response:
Plan: Search for more information about the founder of Microsoft.
#E1 = YahooSearch[Founder of Microsoft]
Plan: Find out the name of the founder of Microsoft.
#E2 = SmartAnswer[Who is the founder of Microsoft? Given context: #E1]
Plan: Search for more information about the founder's contributions to Microsoft.
#E3 = YahooSearch[#E2 contributions to Microsoft]
Plan: Extract the relevant links from the Yahoo search results for a more detailed search.
#E4 = HyperlinkCollector[#E3]
Plan: Parse the information from the collected hyperlinks.
#E5 = TextParser[#E4]
Plan: Identify and summarize the major contributions of the founder to Microsoft.
#E6 = SmartAnswer[What were the major contributions of #E2 to Microsoft? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Devise a systematic plan to respond to the user instruction using the provided tools. Each plan will correlate 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, past evidence values, or both.

Here are the tools available to be used:
AskJeeves[input]: A tool that allows the user to search for information on Ask Jeeves. This tool is beneficial in finding a list of sites that may 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.
LinkMiner[input]: Mines links from plain text and produces a plain text, newline separated response of links.
MLQA[input]: Machine Learning-based Question Answering model, specifically useful in answering questions based on an input passage of text. The input must be a text question that refers to a :fact[n]: variable, e.g., What is the distance between Earth and Mars, given :fact1:?

Each function input should just be a plain string, without quotes or "+" to combine a string with an evidence variable, e.g., MLQA[What is the GDP of India, given :fact2:?]

Be sure 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]
:fact0: = [function to call with input parameter]
Plan: [next action to take, based on result of :fact0:]
:fact1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :fact0"]
...
Final Answer: [:fact[n]: containing the final answer.]

Question: What are the primary causes of global warming and what steps can individuals take to mitigate its effects?

Response:
Plan: Start by conducting a web search to find out the primary causes of global warming.
:fact0: = AskJeeves[Primary causes of global warming]
Plan: Use the MLQA model to interpret the search results and identify the primary causes.
:fact1: = MLQA[What are the primary causes of global warming, given :fact0:?]
Plan: Conduct another web search to find the steps individuals can take to mitigate the effects of global warming.
:fact2: = AskJeeves[Steps to mitigate global warming effects]
Plan: Mine relevant links from the Ask Jeeves search results for more focused research.
:fact3: = LinkMiner[:fact2:]
Plan: Use the SiteReader tool to read information from the mined links.
:fact4: = SiteReader[:fact3:]
Plan: Finally, use the MLQA model to identify and summarize the steps individuals can take to mitigate the effects of global warming from the read information.
:fact5: = MLQA[What steps can individuals take to mitigate the effects of global warming, given :fact4:?]
Final Answer: :fact5:

System: A chat.


Instruction:
Construct a sequential plan to answer the following user question using the tools provided. Each step in your plan should produce an evidence output that informs the next step.

Tools Available:
InfoSeeker[input]: Searches the internet broadly for information related to the input string.
TextAnalyzer[input]: Analyzes a body of text and answers questions based on the content.
LinkGatherer[input]: Gathers all URLs linked within a piece of text.

Output Format:
Plan: [Initial action based on user question]
:E1: = [Tool to use with specific input]
Plan: [Subsequent action informed by prior evidence]
:E2: = [Next tool to use with specific input, potentially referencing earlier evidence]
...
Final Answer: :En:

Question: When was the Eiffel Tower built and who was its architect?

Response:
Plan: Start by using InfoSeeker to gather broad information about the Eiffel Tower.
:E1: = InfoSeeker[Eiffel Tower]
Plan: Use TextAnalyzer to determine when the Eiffel Tower was built from the gathered information.
:E2: = TextAnalyzer[When was the Eiffel Tower built? Given context: :E1:]
Plan: Now use InfoSeeker again to specifically look for information about the architect of the Eiffel Tower.
:E3: = InfoSeeker[Eiffel Tower architect]
Plan: Use TextAnalyzer to determine who the architect of the Eiffel Tower was from the new information.
:E4: = TextAnalyzer[Who was the architect of the Eiffel Tower? Given context: :E3:]
Final Answer: :E4

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

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

Question: What is the capital city of Australia and what is its population?

Response:
Plan: Begin by conducting a web search to find out the capital city of Australia.
#E1 = DuckDuckGo[Capital city of Australia]
Plan: Utilize SAM to interpret the search results and find the name of the capital city.
#E2 = SAM[What is the capital city of Australia? Given context: #E1]
Plan: Conduct another web search to find the population of the identified capital city.
#E3 = DuckDuckGo[Population of #E2]
Plan: Extract the relevant URLs from the DuckDuckGo search results for a more focused search.
#E4 = URLCollector[#E3]
Plan: Use WebScraper to extract information from the relevant URLs.
#E5 = WebScraper[#E4]
Plan: Finally, utilize SAM to identify and summarize the population of the capital city from the extracted information.
#E6 = SAM[What is the population of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Develop a sequential plan to answer the user's query using the provided tools. Store each tool's output in a variable named #Evidence[index] for future reference.

Available Tools:
1. GoogleSearch[input]: Performs a Google search with the input string.
2. TextSummarizer[input]: Summarizes large blocks of text into concise paragraphs.
3. QAEngine[input]: Answers queries based on common sense, world knowledge, and given context.
4. ImageFinder[input]: Finds images related to the input string.

Output Format:
Plan: [First action description]
#Evidence1 = [Function call]
Plan: [Second action description based on #Evidence1]
#Evidence2 = [Next function call, possibly referring to #Evidence1]
...
Final Answer: [#Evidence[n] containing the final response]

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

Response:
Plan: Perform a Google search to find information about Nikola Tesla.
#Evidence1 = GoogleSearch[Nikola Tesla]
Plan: Summarize the obtained information for easier understanding.
#Evidence2 = TextSummarizer[#Evidence1]
Plan: Extract specific details about Nikola Tesla's major contributions to science.
#Evidence3 = QAEngine[What were Nikola Tesla's major contributions to science? Given context: #Evidence2]
Plan: Find images related to Nikola Tesla's scientific contributions.
#Evidence4 = ImageFinder[Nikola Tesla's contributions]
Final Answer: #Evidence3, #Evidence4

Continue this process until you have 10 unique instruction/response pairs.

System: A chat.


Instruction:
Formulate a detailed execution plan to resolve the user query utilizing the listed tools. Every step should be associated with an evidence marker that holds the result of the respective function invoked.

Tools at Disposal:
YahooSearch[input]: Search engine tool suitable for gathering broad details about the input query.
SiteReader[input]: Fetches specific website(s) from the input link(s) and returns the plain text content of the site(s).
HyperlinkCollector[input]: Accumulates all hyperlinks embedded within the supplied plain text.
BERT_QA[input]: A state-of-the-art language model adept at responding to queries based on an input context. The input should pose a question citing an :evidence[n]: variable.

Format of Output:
Plan: [Step derived from the input question]
:evidence0: = [Function accompanied by its input]
Plan: [Subsequent step influenced by the result of :evidence0:]
:evidence1: = [Following function and its input, potentially referring to earlier evidence]
...
Final Solution: :evidence[n]:

Question: Who invented the World Wide Web and what was the main purpose behind its creation?

Response:
Plan: Begin with a web search to identify the inventor of the World Wide Web.
:evidence0: = YahooSearch[Inventor of the World Wide Web]
Plan: Employ BERT_QA to interpret the search findings and pinpoint the inventor's name.
:evidence1: = BERT_QA[Who invented the World Wide Web, given :evidence0:?]
Plan: Execute another web search to learn about the primary motive behind the invention of the World Wide Web.
:evidence2: = YahooSearch[Main purpose behind the creation of the World Wide Web by :evidence1:]
Plan: Collect relevant hyperlinks from the search outcomes for deeper exploration.
:evidence3: = HyperlinkCollector[:evidence2:]
Plan: Utilize SiteReader to retrieve data from the collected hyperlinks.
:evidence4: = SiteReader[:evidence3:]
Plan: Ultimately, use BERT_QA to discern and encapsulate the main purpose behind the creation of the World Wide Web from the retrieved data.
:evidence5: = BERT_QA[What was the main purpose behind the creation of the World Wide Web by :evidence1:, given :evidence4:?]
Final Solution: :evidence5:

System: A chat.


Instruction:
Develop a systematic plan to respond to the user query utilizing the provided tools. Each plan will correspond to an evidence value which is the outcome of one of the functions when fed an input string that could be the user question, earlier evidence values or both.

Available tools:
BingSearch[input]: Allows the user to look up information via Bing. It finds potential sites that might hold the answer to the user's query.
SiteLoader[input]: Loads websites from the input string having newline separated links. Input is one or more links and it outputs plain text content of those links.
URLCollector[input]: Collects URLs from plain text and provides a plain text, newline separated list of URLs.
InfoProcessor[input]: A language model adept at answering queries based on an input text chunk. The input needs to be a textual question referencing an #E[n] variable.

Input to each function should simply be a plain string, without any quotation marks or "+" to join a string with an evidence variable.

Output should follow this format:
Plan: [initial action based on input question]
#E0 = [function to call with input parameter]
Plan: [subsequent action, based on result of #E0]
#E1 = [next function to call and input parameter, possibly referring to prior evidence]
...
Final Answer: #E[n]

Question: Who invented the telephone and what were their other significant contributions?

Response:
Plan: Begin with a Bing search to find out who invented the telephone.
#E0 = BingSearch[Inventor of the telephone]
Plan: Utilize InfoProcessor to determine the inventor's name from the search results.
#E1 = InfoProcessor[Who invented the telephone? Given context: #E0]
Plan: Perform another Bing search to discover other major contributions made by this person.
#E2 = BingSearch[Other contributions by #E1]
Plan: Gather pertinent links from the Bing search results for further exploration.
#E3 = URLCollector[#E2]
Plan: Employ SiteLoader to extract data from these links.
#E4 = SiteLoader[#E3]
Plan: Lastly, use InfoProcessor to recognize and summarize the key contributions made by the inventor from the extracted data.
#E5 = InfoProcessor[What are the other significant contributions by #E1? Given context: #E4]
Final Answer: #E5

System: A chat.


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

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 helpful in finding a list of sites that may contain the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
UrlCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QuerySolver[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 is the capital of France, given :evidence1:?

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

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

Response:
Plan: Begin by conducting a web search to find out who invented the telephone.
:evidence0: = Bing[Inventor of the telephone]
Plan: Utilize QuerySolver to interpret the search results and find the inventor's name.
:evidence1: = QuerySolver[Who invented the telephone, given :evidence0:?]
Plan: Conduct another web search to find the patent date of the telephone.
:evidence2: = Bing[Telephone patent date]
Plan: Extract the relevant links from the Bing search results for a focused search.
:evidence3: = UrlCollector[:evidence2:]
Plan: Use SiteLoader to extract information from the relevant links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, utilize QuerySolver to identify the patent date of the telephone from the extracted information.
:evidence5: = QuerySolver[When was the telephone patented, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to solve the following problem using the tools provided. For each step, indicate the tool used along with its input. Store the output of each tool into a variable #E[index] that can be referenced later.

Available Tools:
WikiLookup[input]: A tool that searches Wikipedia for information related to the input query.
WebCrawler[input]: A tool that crawls the web for information related to the input query.
QAModel[input]: A tool that answers questions based on common sense, world knowledge, or given context. It can reference previous evidence variables in its input.

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

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

Response:
Plan: Search for information about the history of the Eiffel Tower.
#E1 = WikiLookup[Eiffel Tower History]
Plan: Extract specific details about the construction process of the Eiffel Tower.
#E2 = QAModel[How was the Eiffel Tower constructed? Given context: #E1]
Plan: Verify and supplement the information by crawling the web for additional sources.
#E3 = WebCrawler[Eiffel Tower Construction Process]
Plan: Summarize the information gathered from multiple sources.
#E4 = QAModel[Can you summarize the construction process of the Eiffel Tower? Given context: #E2 and #E3]
Final Answer: #E4

System: A chat.


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

Here are the tools available to be called:
BiographyTool[input]: Tool that provides biographical information about individuals.
ScienceArchive[input]: Tool that provides information about scientific discoveries and contributions.
QA[input]: Tool that can answer questions based on common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
TimelineCreator[input]: Tool that creates timelines showing key events in a person's life or a sequence of events.
ImageSearch[input]: Tool that searches for images related to a specified topic.

Plan: First action to take based on input question
#E1 = BiographyTool["Albert Einstein"]
Plan: Next action to take, based on result of #E1
#E2 = ScienceArchive["Albert Einstein"]
Plan: Create a timeline of Einstein's life and achievements
#E3 = TimelineCreator[#E1 + " " + #E2]
Plan: Search for relevant images
#E4 = ImageSearch["Albert Einstein"]
Final Answer: #E1 + ", " + #E2 + ", " + #E3 + ", " + #E4

Response:
Albert Einstein was a theoretical physicist who is best known for developing the theory of relativity, one of the two pillars of modern physics (the other being quantum mechanics). His work is also known for its influence on the philosophy of science. He is best known to the general public for his mass–energy equivalence formula E = mc2, which has been dubbed "the world's most famous equation". He received the 1921 Nobel Prize in Physics "for his services to theoretical physics, and especially for his discovery of the law of the photoelectric effect", a pivotal step in the development of quantum theory.

Einstein's major contributions to physics include:

- Special Theory of Relativity: In 1905, Einstein published four papers in the scientific journal Annalen der Physik, each of which would alter the course of modern physics. The first paper provided a theory of light, the second explained Brownian motion, the third introduced special relativity, and the fourth posited that energy and matter are interchangeable at a fundamental level with the equation E=mc^2.

- General Theory of Relativity: In 1915, Einstein presented this groundbreaking theory, which describes gravity not as a force but as a consequence of the curvature of spacetime caused by mass and energy.

- Quantum Mechanics: While he had reservations about the full philosophical implications of quantum mechanics, Einstein made significant contributions to its development, including his work on the photoelectric effect, for which he won the Nobel Prize in Physics in 1921.

A timeline of Albert Einstein's life and achievements:

- March 14, 1879: Born in Ulm, in the Kingdom of Württemberg in the German Empire.
- 1896 - 1900: Studied physics and mathematics at the Polytechnic Institute in Zurich, Switzerland.
- 1905: Published four groundbreaking papers during his 'Annus Mirabilis' or 'miracle year', introducing the special theory of relativity and explaining Brownian motion and the photoelectric effect.
- 1915: Presented the general theory of relativity.
- 1921: Awarded the Nobel Prize in Physics for his explanation of the photoelectric effect.
- April 18, 1955: Died in Princeton, New Jersey, USA.

Images related to Albert Einstein can be found through an online search.

System: A chat.


Instruction:
Develop a step-by-step plan to respond to the user's instruction using the available tools. Each plan should have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Tools Available:
GoogleSearch[input]: Allows the user to search for information via Google. Finds a list of sites that might contain the answer to the user's question.
WebScraper[input]: Loads one or more websites from the input string (containing newline delimited links) and produces plain text output containing the content of the links.
LinksExtractor[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
QAModel[input]: Language model that answers questions based on an input passage of text.

The output should follow this format:
Plan: [First action based on input question]
:Evidence0: = [Function to call with input parameter]
Plan: [Next action based on result of :Evidence0:]
:Evidence1: = [Next function to call and input parameter, possibly referring to previous evidence, e.g., "Given context :Evidence0:"]
...
Answer: [:Evidence[n]: containing the final answer.]

Question: Who invented the Internet and what was their motivation?

Response:
Plan: Begin by conducting a web search to find out who invented the Internet.
:Evidence0: = GoogleSearch[Inventor of the Internet]
Plan: Utilize the QAModel to interpret the search results and find the name of the inventor.
:Evidence1: = QAModel[Who invented the Internet, given :Evidence0:?]
Plan: Conduct another web search to find the motivation behind inventing the Internet.
:Evidence2: = GoogleSearch[Motivation behind inventing the Internet]
Plan: Extract the relevant links from the Google search results for a more focused search.
:Evidence3: = LinksExtractor[:Evidence2:]
Plan: Use the WebScraper tool to extract information from the relevant links.
:Evidence4: = WebScraper[:Evidence3:]
Plan: Finally, utilize the QAModel to identify and summarize the motivation behind inventing the Internet from the extracted information.
:Evidence5: = QAModel[What was the motivation behind inventing the Internet, given :Evidence4:?]
Answer: :Evidence1: and :Evidence5:

System: A chat.


Instruction:
Develop a detailed execution plan for solving the following problem. You have access to a number of external tools which you can use to retrieve data. Store this data into variables #E[index] that can be referenced later.

Available Tools:
Bing[input]: A tool that uses Bing's search engine to gather information related to the input query.
DataMiner[input]: A tool that extracts structured data from unstructured text obtained from a webpage.
QA_Solver[input]: A tool that answers questions using general world knowledge and specific context provided as input.

Output Format:
Plan: [First step based on input question]
#E1 = [Function to call with input parameter]
Plan: [Next step based on result of #E1]
#E2 = [Next function to call with input parameter, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: Who invented the light bulb and what was their motivation behind it?

Response:
Plan: Start by searching for who invented the light bulb.
#E1 = Bing[Who invented the light bulb]
Plan: Identify the inventor from the search results.
#E2 = QA_Solver[Who invented the light bulb? Given context: #E1]
Plan: Search for more information about the inventor's motivation behind inventing the light bulb.
#E3 = Bing[Motivation behind invention of light bulb by #E2]
Plan: Extract structured data from the search results.
#E4 = DataMiner[#E3]
Plan: Identify the inventor's motivation from the structured data.
#E5 = QA_Solver[What was the motivation behind the invention of the light bulb by #E2? Given context: #E4]
Final Answer: #E5

System: A chat.


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

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

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

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

Response:
Plan: Begin by conducting a web search to find out about Nikola Tesla's significant contributions.
:evidence0: = GoogleSearch[Nikola Tesla significant contributions]
Plan: Extract relevant links from the search results for detailed information.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Use the WebScraper tool to extract information from these links.
:evidence2: = WebScraper[:evidence1:]
Plan: Finally, use the QAModel to summarize Nikola Tesla's significant contributions from the extracted information.
:evidence3: = QAModel[What are some significant contributions made by Nikola Tesla? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Generate a step-by-step plan to answer the question: "Who won the Wimbledon Men's Singles title in 2019?"

Here are the tools available:
SportsDB[input]: A tool that provides sports-related information.
QA[input]: A tool that answers questions using common sense and general world knowledge or given an input context.
NewsArchive[input]: This tool searches archived news articles.
TextAnalyzer[input]: Analyzes a piece of text and extracts key details.
LLM[input]: Question answering language model.

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

Response:
Plan: First, use the SportsDB tool to find out who won the Wimbledon Men's Singles title in 2019.
#E1 = SportsDB["Wimbledon Men's Singles winner 2019"]

Final answer: #E1

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:
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 include the answer to the user's question.
TextParser[input]: Extracts key information from plain text and produces a plain text response containing this information.
SiteScraper[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.
AnswerBot[input]: Question answering bot, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the history behind the construction of the Eiffel Tower?

Response:
Plan: Begin by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = WebSearch[History of the Eiffel Tower]
Plan: Utilize TextParser to extract key information from the search results.
:evidence1: = TextParser[:evidence0:]
Plan: Conduct another web search to find detailed information about the construction of the Eiffel Tower.
:evidence2: = WebSearch[Construction of the Eiffel Tower]
Plan: Use SiteScraper to extract detailed information from the relevant links.
:evidence3: = SiteScraper[:evidence2:]
Plan: Finally, utilize AnswerBot to summarize the history behind the construction of the Eiffel Tower from the extracted information.
:evidence4: = AnswerBot[What is the history behind the construction of the Eiffel Tower? Given context: :evidence3:]
Answer: :evidence4:

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. Each step of your plan should correspond with an evidence variable, 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 you have at your disposal:
DuckDuckGo[input]: A tool that allows users to search for information on the internet via DuckDuckGo. This function doesn't directly provide answers but offers a list of sites that might contain the required information.
WebReader[input]: Load one or more websites from the input string containing newline delimited links. The input is one or more links and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and provides a plain text, newline delimited response of links.
InfoProcessor[input]: Question answering language model, useful in providing answers based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Remember to include only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who was the first person to climb Mount Everest.
:evidence0: = DuckDuckGo[First person to climb Mount Everest]
Plan: Use the language model to interpret the search results and identify the name of the climber.
:evidence1: = InfoProcessor[Who was the first person to climb Mount Everest, given :evidence0:?]
Plan: Conduct another web search to find the key achievements of the identified climber.
:evidence2: = DuckDuckGo[Key achievements of :evidence1:]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use the WebReader tool to extract information from the selected links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, use the language model to summarize the key achievements of the climber from the extracted information.
:evidence5: = InfoProcessor[What are the key achievements of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

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

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

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

Response:
Plan: Search for more information about Galapagos tortoise.
#E1 = Britannica[Galapagos tortoise]
Plan: Find out the average lifespan of a Galapagos tortoise.
#E2 = QAPlus[What is the average lifespan of a Galapagos tortoise? Given context: #E1]
Plan: Find out where Galapagos tortoises primarily live.
#E3 = QAPlus[Where do Galapagos tortoises primarily live? Given context: #E1]
Final answer: The average lifespan of a Galapagos tortoise is #E2 and they primarily live in #E3.

System: A chat.


Instruction:
Develop a step-by-step plan to answer the user query, using the available 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 use:
Bing[input]: A tool that allows the user to search for information via Bing's search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites given an input string containing newline delimited links.
LinkParser[input]: Parses plain text and produces a plain text, newline-delimited response of links.
AIQA[input]: An artificial intelligence question answering model that answers questions based on an input passage of text. The input must be a text question that references a :data[n]: variable.

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

Remember to include only one evidence output per plan step.

The output format should be:
Plan: [first action based on input question]
:data0: = [function to call with input parameter]
Plan: [next action based on result of :data0:]
:data1: = [next function to call and input parameter, referencing previous evidence if necessary]
...
Answer: [:data[n]: containing the final answer.]

Question: What is the population of the largest city in Canada and what languages are commonly spoken there?

Response:
Plan: Start by conducting a web search to find out the largest city in Canada.
:data0: = Bing[Largest city in Canada]
Plan: Use the AIQA model to interpret the search results and identify the city.
:data1: = AIQA[What is the largest city in Canada, given :data0:?]
Plan: Conduct another web search to find the population of the identified city.
:data2: = Bing[Population of :data1:]
Plan: Use the AIQA model again to determine the population from the search results.
:data3: = AIQA[What is the population of :data1:, given :data2:?]
Plan: Perform a third web search to find the common languages spoken in the identified city.
:data4: = Bing[Common languages spoken in :data1:]
Plan: Parse the relevant links from the Bing search results for a more detailed search.
:data5: = LinkParser[:data4:]
Plan: Use the TextExtractor tool to extract information from the parsed links.
:data6: = TextExtractor[:data5:]
Plan: Finally, utilize the AIQA model to identify and summarize the common languages spoken in the city from the extracted information.
:data7: = AIQA[What are the common languages spoken in :data1:, given :data6:?]
Answer: :data3: and :data7:

System: A chat.