Instruction:
Generate a sequential plan to address the user request leveraging the available tools. Each step in the plan corresponds to an evidence value which is the outcome of a specific function. The input can be either a user query, previous evidence values, or a mix of both.

Tools at disposal:
NetSearch[input]: A tool that enables users to fetch information through internet search engines. This tool helps in locating a list of potential sites that may hold the answer to the user's query.
DataScraper[input]: Loads one or more websites from the input string (containing newline separated links). Input here is one or more URLs and it outputs plain text containing the website contents.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and provides a plain text, newline-separated list of links.
AIModel[input]: A language model adept at answering questions based on an input text. The input has to be a textual question that refers to an :evidence[n]: variable.

Output Format:
Plan: [Initial action based on the input query]
:evidence0: = [Invoke function with input parameters]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Invoke next function with input parameters, potentially referring to prior evidence like "Given context :evidence0"]
...
Answer: [:evidence[n]: holding the final answer.]

Question: Who designed the Eiffel Tower and what materials were used in its construction?

Response:
Plan: Initiate a web search to find out who designed the Eiffel Tower.
:evidence0: = NetSearch[Eiffel Tower designer]
Plan: Employ the AI Model to decipher the search results and identify the designer.
:evidence1: = AIModel[Who designed the Eiffel Tower, given :evidence0:?]
Plan: Perform another web search to determine the materials used in constructing the Eiffel Tower.
:evidence2: = NetSearch[Eiffel Tower construction materials]
Plan: Extract the pertinent links from the search results for a deeper dive.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Deploy the Data Scraper tool to pull out details from the selected links.
:evidence4: = DataScraper[:evidence3:]
Plan: Lastly, leverage the AI Model to recognize and summarize the materials used in building the Eiffel Tower from the scraped data.
:evidence5: = AIModel[What materials were used in the construction of the Eiffel Tower, 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.

Here are the tools available to be called:
BingSearch[input]: Tool that allows the user to search for information using Bing's search engine.
TextAnalyzer[input]: Analyzes a block of text and extracts key phrases and topics.
QAEngine[input]: Question answering engine, 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: Who won the Nobel Prize in Literature in 2020 and what was their most famous work?

Response:
Plan: Conduct a web search to find out who won the Nobel Prize in Literature in 2020.
#E1 = BingSearch[Nobel Prize in Literature 2020 winner]
Plan: Use the QAEngine to interpret the search results and find the name of the laureate.
#E2 = QAEngine[Who won the Nobel Prize in Literature in 2020? Given context: #E1]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E3 = BingSearch[#E2 most famous work]
Plan: Finally, use the QAEngine to identify the most famous work of the laureate from the search results.
#E4 = QAEngine[What is the most famous work of #E2? Given context: #E3]
Final answer: #E4

System: A chat.


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

Here are the tools available to be called:
BingSearch[input]: Tool that allows the user to search for information using Bing. This tool is helpful in finding an appropriate list of sites that may include the answer to the user's question.
TextAnalyzer[input]: Analyzes the text from the input string and extracts key points.
URLCollector[input]: Collects URLs from the input string and produces a plain text, newline-delimited response of URLs.
QAModel[input]: Language model designed to answer questions based on an input passage of text.

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

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

Response:
Plan: Start by conducting a web search to find out who won the 2020 US Presidential Election.
:Evidence0: = BingSearch[2020 US Presidential Election winner]
Plan: Utilize QAModel to interpret the search results and find the name of the winner.
:Evidence1: = QAModel[Who won the 2020 US Presidential Election? Given context: :Evidence0:?]
Plan: Conduct another web search to find the main campaign promises of the identified winner.
:Evidence2: = BingSearch[:Evidence1: 2020 campaign promises]
Plan: Extract the relevant URLs from the Bing search results for further analysis.
:Evidence3: = URLCollector[:Evidence2:]
Plan: Use TextAnalyzer to extract key points from the collected URLs.
:Evidence4: = TextAnalyzer[:Evidence3:]
Plan: Lastly, utilize the QAModel to identify and summarize the main campaign promises of the winner from the analyzed text.
:Evidence5: = QAModel[What were the main campaign promises of :Evidence1:? Given context: :Evidence4:?]
Answer: :Evidence5:

System: A chat.


Instruction:
Please construct a systematic plan to generate an optimal response to the user instruction, utilizing a set of provided tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string
that could be the user's question, one or more prior evidence values, or a combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that enables the user to search for information using the DuckDuckGo search engine. This tool is helpful in locating a suitable list of sites that may contain the answer to the user's query. It does not directly answer the question but finds a list of sites that might have the answer.
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.
HyperlinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
KnowledgeModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2020 winner]
Plan: Utilize the KnowledgeModel to interpret the search results and find the name of the laureate.
:evidence1: = KnowledgeModel[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = DuckDuckGo[Most famous work of :evidence1:]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use the TextScraper tool to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, utilize the KnowledgeModel to identify and summarize the most famous work of the laureate from the extracted information.
:evidence5: = KnowledgeModel[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
PDFReader[input]: Load one or more PDF files 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 PDFs.
URLExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
SAM[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = Bing[Nobel Prize in Physics 2020 winner]
Plan: Use SAM to interpret the search results and find the name of the laureate.
:evidence1: = SAM[Who won the Nobel Prize in Physics in 2020, given :evidence0:?]
Plan: Conduct another web search to find the contributions made by the identified laureate.
:evidence2: = Bing[:evidence1: + 'Nobel Prize contribution']
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use the PDF Reader tool to extract information from the relevant PDFs.
:evidence4: = PDFReader[:evidence3:]
Plan: Finally, utilize SAM to identify and summarize the key contributions made by the laureate from the extracted information.
:evidence5: = SAM[What were the key contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step plan to answer the user's question using the available tools. Each step should produce an evidence value which corresponds to the output of one of the provided functions.

Tools available:
YahooSearch[input]: Allows the user to search for information using Yahoo.
SiteReader[input]: Reads one or more websites from the input string (newline-separated links) and outputs the content in plain text.
HyperlinkGatherer[input]: Extracts hyperlinks from plain text and returns them in a newline-separated format.
AIQA[input]: An artificial intelligence model designed to answer questions based on an input text passage.

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

Question: What is the highest peak in the Andes and how high is it?

Response:
Plan: Start by conducting a web search to find out the highest peak in the Andes.
:Evidence1: = YahooSearch[Highest peak in the Andes]
Plan: Use the AIQA model to interpret the search results and determine the name of the peak.
:Evidence2: = AIQA[What is the highest peak in the Andes, given :Evidence1:?]
Plan: Conduct another web search to find out the height of the identified peak.
:Evidence3: = YahooSearch[Height of :Evidence2:]
Plan: Extract relevant links from the search results for further investigation.
:Evidence4: = HyperlinkGatherer[:Evidence3:]
Plan: Use the SiteReader tool to extract detailed information from the selected links.
:Evidence5: = SiteReader[:Evidence4:]
Plan: Finally, use the AIQA model to determine the height of the peak from the extracted information.
:Evidence6: = AIQA[How high is :Evidence2:, given :Evidence5:?]
Answer: :Evidence6:

System: A chat.


Instruction:
Formulate a plan to address the following inquiry using the provided tools. For each plan, assign an evidence variable.

Tools:
YahooSearch[input]: Function that searches Yahoo for information. Provides a list of potential sources containing the answer.
SiteLoader[input]: Takes one or more links as input and returns the textual content of those links.
HyperlinkGatherer[input]: Gathers hyperlinks from any given plain text and returns them in a line-separated format.
QAModel[input]: An AI model capable of answering questions when provided with contextual information.

Output Format:
Plan: [Initial action]
$Evidence1 = [Tool invocation with input]
Plan: [Subsequent action]
$Evidence2 = [Next tool invocation with input, potentially referencing $Evidence1]
...
Final Answer: $EvidenceN

Question: Who is the founder of SpaceX and what was their primary reason for starting the company?

Response:
Plan: Initiate a web search to discover the founder of SpaceX.
$Evidence1 = YahooSearch[Founder of SpaceX]
Plan: Employ QAModel to sift through the search results and pinpoint the founder.
$Evidence2 = QAModel[Who is the founder of SpaceX? Given context: $Evidence1]
Plan: Launch another web search to uncover the main reasons why the founder started SpaceX.
$Evidence3 = YahooSearch[Why did $Evidence2 start SpaceX?]
Plan: Utilize HyperlinkGatherer to collect pertinent links from the search results.
$Evidence4 = HyperlinkGatherer[$Evidence3]
Plan: Deploy SiteLoader to retrieve data from the collected links.
$Evidence5 = SiteLoader[$Evidence4]
Plan: Lastly, utilize QAModel to distill the primary reason for starting SpaceX from the gathered data.
$Evidence6 = QAModel[What was the primary reason for $Evidence2 to start SpaceX? Given context: $Evidence5]
Final Answer: $Evidence6

System: A chat.


Instruction:
Create a detailed plan to solve the following problem using the available tools. Each plan should have an associated evidence variable, which represents the output of a function when given an input string. This input string could be the user's query, prior evidence variables, or a combination of both.

These are the tools at your disposal:
WikiSearch[input]: Allows users to look up information on Wikipedia. It's useful for finding factual information about various topics.
URLGrabber[input]: Retrieves all URLs contained within a block of text.
TextAnalyzer[input]: Analyzes a block of text and provides a summary.
QueryBot[input]: Answers questions based on an input passage of text.

Your output should follow this structure:
Plan: [the first step based on the input question]
#E1 = [the function to call with its input parameter]
Plan: [the next step, depending on the outcome of #E1]
#E2 = [the next function to call with its input parameter, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: What is the history behind the construction of the Eiffel Tower and why was it built?

Response:
Plan: Search for information regarding the Eiffel Tower's construction history.
#E1 = WikiSearch[Eiffel Tower Construction History]
Plan: Extract any URLs present in the returned data for more specific information.
#E2 = URLGrabber[#E1]
Plan: Scrape the contents of these URLs for additional details.
#E3 = TextAnalyzer[#E2]
Plan: Determine why the Eiffel Tower was constructed using the analyzed text.
#E4 = QueryBot[Why was the Eiffel Tower built? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Create a detailed execution plan to solve the user's question using the following tools. Each step of the plan should have a corresponding evidence variable which will hold the output of the function used at that step.

Tools available:
DuckDuckGo[input]: A tool that lets you perform searches using DuckDuckGo search engine.
PageLoader[input]: Loads a webpage from the provided link and returns its textual content.
URLPicker[input]: Picks URLs from the provided text.
InfoProcessor[input]: A language model that answers questions based on the provided context. It requires a question that refers to an :info[n]: variable.

Output format:
Plan: [First action]
:info0: = [Function with input]
Plan: [Next action based on :info0:]
:info1: = [Next function with input including possible reference to :info0:]
...
Final Answer: :info[n]:

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

Response:
Plan: Begin by searching who won the 2020 Nobel Prize in Physics.
:info0: = DuckDuckGo[2020 Nobel Prize in Physics winner]
Plan: Use InfoProcessor to determine the winner from the search results.
:info1: = InfoProcessor[Who won the 2020 Nobel Prize in Physics? Given context: :info0:]
Plan: Search for the contributions made by the winner.
:info2: = DuckDuckGo[:info1: Nobel Prize contribution]
Plan: Extract the relevant links from the search results.
:info3: = URLPicker[:info2:]
Plan: Load the webpage content from the extracted links.
:info4: = PageLoader[:info3:]
Plan: Use InfoProcessor to determine the contributions made by the winner.
:info5: = InfoProcessor[What were the contributions of :info1:? Given context: :info4:]
Final Answer: :info5:

Continue this process for additional eight unique instruction/response pairs.

System: A chat.


Instruction:
Generate a step-by-step plan to respond to the user's instruction using the tools provided. 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's question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine. It finds a list of sites that might contain 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.
URLExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Language model for 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 tallest building in Dubai and when was it completed?

Response:
Plan: Begin by conducting a web search to find out the tallest building in Dubai.
:evidence0: = YahooSearch[Tallest building in Dubai]
Plan: Utilize QAModel to interpret the search results and find the name of the building.
:evidence1: = QAModel[What is the tallest building in Dubai, given :evidence0:?]
Plan: Conduct another web search to find the completion date of the identified building.
:evidence2: = YahooSearch[Completion date of :evidence1:]
Plan: Extract the relevant links from the Yahoo search results for a more focused search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use TextScraper to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, utilize the QAModel to identify and summarize the completion date of the building from the extracted information.
:evidence5: = QAModel[When was :evidence1: completed, 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:
GoogleScholar[input]: Tool that allows the user to search for academic articles and papers. This tool is particularly useful in gaining knowledge about scientific studies, historical research, and other types of scholarly information.
PubMed[input]: Tool that allows the user to search for biomedical literature. This tool is especially useful when looking for medical and health-related information.
QAExpert[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 are the latest advancements in cancer treatment?

Response:
Plan: Search for recent academic articles related to advancements in cancer treatment.
#E1 = GoogleScholar[Latest advancements in cancer treatment]
Plan: Find out the key points from the most relevant articles.
#E2 = QAExpert[What are the key points from these articles? Given context: #E1]
Plan: Search for more detailed information about these advancements in biomedical literature.
#E3 = PubMed[#E2]
Plan: Summarize the information found in the biomedical literature.
#E4 = QAExpert[Can you summarize the information about these advancements? Given context: #E3]
Final answer: #E4

System: A chat.


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

Available Tools:
WikiLookup[input]: A tool that retrieves information from Wikipedia. Input should be a keyword or phrase related to the desired information.
DataExtractor[input]: Extracts specific data points from a larger body of text.
QueryMaster[input]: Can answer questions based on previously gathered evidence.

Output Format:
Plan: [action based on input question]
#E1 = [tool with input]
Plan: [next action based on #E1]
#E2 = [next tool with input, referencing #E1 if necessary]
...
Final Answer: #E[n]

Question: Who was involved in the signing of the Treaty of Versailles and what were their roles?

Response:
Plan: Retrieve information about the Treaty of Versailles.
#E1 = WikiLookup[Treaty of Versailles]
Plan: Extract details about who was involved in the signing.
#E2 = DataExtractor[Who was involved in the signing of the Treaty of Versailles? Given context: #E1]
Plan: Retrieve additional information about these individuals.
#E3 = WikiLookup[#E2]
Plan: Determine the roles of these individuals during the signing.
#E4 = QueryMaster[What were the roles of #E2 during the signing of the Treaty of Versailles? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Develop a step-by-step plan to respond to the following query using the tools provided. Each tool should be used at least once and each plan must 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:
YahooSearch[input]: Allows the user to search for information using the Yahoo search engine.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, producing plain text output containing the content of the links.
LinkGrabber[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering tool, useful in answering questions based on an input passage of text.

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

Question: What is the capital city of Bhutan and what notable landmarks does it contain?

Response:
Plan: Start by conducting a web search to find out the capital city of Bhutan.
:Evidence1: = YahooSearch[Capital city of Bhutan]
Plan: Use AIQA to interpret the search results and identify the capital city.
:Evidence2: = AIQA[What is the capital city of Bhutan, given :Evidence1:?]
Plan: Conduct another web search to find notable landmarks in the identified capital city.
:Evidence3: = YahooSearch[Notable landmarks in :Evidence2:]
Plan: Extract relevant links from the Yahoo search results for further investigation.
:Evidence4: = LinkGrabber[:Evidence3:]
Plan: Use SiteLoader to extract detailed information from the selected links.
:Evidence5: = SiteLoader[:Evidence4:]
Plan: Finally, use AIQA to summarize the key landmarks in the capital city from the extracted information.
:Evidence6: = AIQA[What are the notable landmarks in :Evidence2:, given :Evidence5:?]
Answer: :Evidence6:

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question using the available tools. Each tool can be used with an input parameter, and its output will be stored in a variable :evidence[n]: for further use.

Here are the tools you can call:
WebSearch[input]: This tool allows you to search the web for information related to the input string.
TextAnalyzer[input]: Analyzes text from the given context and answers questions based on it.
ImageFinder[input]: Finds images related to the input string.
ImageAnalyzer[input]: Analyzes an image and provides descriptive information about it.
QA[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 have exactly one evidence (:evidence[n]:) value.

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

Question: What is the significance of the painting 'Starry Night' by Vincent Van Gogh?

Response:
Plan: Start by searching the web for information about the painting 'Starry Night'.
:evidence1: = WebSearch['Starry Night by Vincent Van Gogh']
Plan: Use TextAnalyzer to extract key details about the painting from the search results.
:evidence2: = TextAnalyzer[:evidence1:]
Plan: Find an image of the painting 'Starry Night'.
:evidence3: = ImageFinder['Starry Night by Vincent Van Gogh']
Plan: Use ImageAnalyzer to get descriptive information about the painting.
:evidence4: = ImageAnalyzer[:evidence3:]
Plan: Finally, use QA to determine the significance of the painting based on all gathered information.
:evidence5: = QA[What is the significance of the painting 'Starry Night'? Given context :evidence2: and :evidence4:]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
GoogleMaps[input]: Tool that allows the user to search for geographical information and location-based data.
WikiSearch[input]: A tool that searches Wikipedia for relevant articles based on the input query.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
AIQA[input]: An artificial intelligence tool that answers questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

Question: What is the population density of the capital city of Japan?

Response:
Plan: Use Google Maps to find out the name of the capital city of Japan.
#E1 = GoogleMaps[Capital city of Japan]
Plan: Use AIQA to interpret the results and identify the capital city of Japan.
#E2 = AIQA[What is the capital city of Japan? Given context: #E1]
Plan: Search Wikipedia for more information about the identified capital city.
#E3 = WikiSearch[#E2]
Plan: Use AIQA to extract the population density from the Wikipedia article.
#E4 = AIQA[What is the population density of #E2? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Develop a step-by-step execution plan to respond to the user query utilizing the provided tools. Each plan should include an evidence variable, representing the output of a function call.

Available tools:
IMDb[input]: A tool for retrieving movie-related information.
RottenTomatoes[input]: A tool for obtaining movie ratings and reviews.
BoxOfficeMojo[input]: A tool for getting box office data about movies.
Twitter[input]: A tool for searching tweets related to a particular topic.
AskAI[input]: A question-answering AI model that uses its vast knowledge base to provide answers.

Question: Who directed the movie "Inception", how was it rated on Rotten Tomatoes, how much did it earn at the box office, and what are people saying about it on Twitter?

Response:
Step 1: Retrieve the director of the movie "Inception".
- Tool: IMDb["Inception"]
- Function Call: get_director()
- Evidence Variable: inception_director

Step 2: Get the rating of the movie "Inception" on Rotten Tomatoes.
- Tool: RottenTomatoes["Inception"]
- Function Call: get_rating()
- Evidence Variable: inception_rt_rating

Step 3: Obtain the box office earnings for the movie "Inception".
- Tool: BoxOfficeMojo["Inception"]
- Function Call: get_box_office_earnings()
- Evidence Variable: inception_box_office

Step 4: Search for tweets related to the movie "Inception".
- Tool: Twitter["Inception"]
- Function Call: search_tweets()
- Evidence Variable: inception_tweets

The final output should include the information stored in the evidence variables inception_director, inception_rt_rating, inception_box_office, and inception_tweets.

System: A chat.


Instruction:
Develop a detailed execution plan to solve the following problem, making use of the available tools. For each step in the plan, indicate the tool you would use along with its input to gather evidence. You can store this evidence into a variable #E[index] that can be referenced later.

Here are the tools available to be called:
BingSearch[input]: A tool that lets users search for information via Bing. It helps locate potential sites that might hold answers to the user's query.
SiteReader[input]: Loads one or more websites from an input string (containing newline separated links), producing plain text output with the content of those links.
LinkPicker[input]: Picks out links from plain text, generating a plain text, newline-separated list of links.
InfoAnalyzer[input]: A language model capable of answering questions based on an input text passage. The input should be a question referencing a #E[n] variable, like 'What is the capital of France, 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 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 was the architect behind the Sydney Opera House and what other buildings did they design?

Response:
Plan: Begin by searching for the architect of the Sydney Opera House.
#E1 = BingSearch[Architect of Sydney Opera House]
Plan: Use InfoAnalyzer to determine the architect's name from the search results.
#E2 = InfoAnalyzer[Who was the architect of the Sydney Opera House? Given context: #E1]
Plan: Perform another search to find other buildings designed by the identified architect.
#E3 = BingSearch[Other buildings designed by #E2]
Plan: Extract relevant links from the search results for deeper investigation.
#E4 = LinkPicker[#E3]
Plan: Use SiteReader to obtain information from the selected links.
#E5 = SiteReader[#E4]
Plan: Lastly, employ InfoAnalyzer to summarize the main points about the other buildings designed by the architect from the obtained information.
#E6 = InfoAnalyzer[What other buildings were designed by #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. Each step in your plan should be accompanied by an evidence variable, which will store 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:
WebSearch[input]: This tool allows users to search for information on the web. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response with newline-separated links.
SiteScraper[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and the output is plain text content from these links.
InfoQA[input]: A question-answering tool that answers questions based on general knowledge as well as context from previously gathered evidence.

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

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

Response:
Plan: Start by searching the web for information about the Battle of Hastings.
#E1 = WebSearch[Battle of Hastings]
Plan: Extract useful links from the search results.
#E2 = LinkExtractor[#E1]
Plan: Scrape the content from the extracted links.
#E3 = SiteScraper[#E2]
Plan: Use the InfoQA tool to find out the significance of the Battle of Hastings.
#E4 = InfoQA[What is the significance of the Battle of Hastings? Given context: #E3]
Plan: Use the InfoQA tool again to identify the key figures involved in the battle.
#E5 = InfoQA[Who were the key figures in the Battle of Hastings? Given context: #E3]
Final Answer: #E4 and #E5

System: A chat.


Instruction:
Draft a meticulous scheme to resolve the forthcoming question. Each phase should prescribe a function to trigger with its corresponding input. Preserve the yield of each function in a defined :Result[index]: variable, which can subsequently be invoked in future phases.

On-hand Functions:
BaiduSearch[input]: Runs a Baidu search for the input keyword and procures a compilation of potential leads.
LinkIsolator[input]: Given a chunk of text (like the output of a BaiduSearch), this function spots all URLs housed within the text.
SiteFetcher[input]: Visits the page at the stipulated URL and transcribes its contents into plain text.
Cerebro[input]: An advanced AI-centric question-answering entity adept at furnishing direct solutions to a multitude of queries. It can also devise answers drawing upon background info (e.g., the text from a webpage).

Output Scheme:
Plan: [Sketch of the primary step]
:Result0: = [Primary step function activation]
Plan: [Sketch of the succeeding step]
:Result1: = [Succeeding step function activation]
... Sustain this progression until ...
Final Answer: :ResultN:

Question: Who composed 'Fur Elise' and what other compositions are they celebrated for?

Response:
Plan: Launch a Baidu search to unearth who composed 'Fur Elise'.
:Result0: = BaiduSearch[composer of 'Fur Elise']
Plan: Employ Cerebro to parse the search yields and discern the composer.
:Result1: = Cerebro[Who composed 'Fur Elise'? Given context: :Result0:]
Plan: Undertake another Baidu search to detect other compositions attributed to the discerned musician.
:Result2: = BaiduSearch[:Result1: other compositions]
Plan: Detach the URLs from the search outputs for in-depth scrutiny.
:Result3: = LinkIsolator[:Result2:]
Plan: Procure the content of the foremost URL from the array.
:Result4: = SiteFetcher[:Result3[0]]
Plan: In the end, engage Cerebro to examine the webpage text and highlight the other renowned compositions of the musician.
:Result5: = Cerebro[What other compositions is :Result1: famous for? Given context: :Result4:]
Final Answer: :Result5:

System: A chat.


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

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

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

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

Response:
Plan: Start by conducting a web search to find out who designed the Eiffel Tower.
:E0: = Bing[Architect of Eiffel Tower]
Plan: Use the machine learning model to interpret the search results and identify the architect.
:E1: = MLM[Who designed the Eiffel Tower, given :E0:?]
Plan: Conduct another web search to find other notable structures designed by the identified architect.
:E2: = Bing[Notable structures designed by :E1:]
Plan: Extract relevant links from the Bing search results for a deeper dive.
:E3: = LinkCollector[:E2:]
Plan: Use the WebScraper tool to extract information from the collected links.
:E4: = WebScraper[:E3:]
Plan: Finally, use the machine learning model to summarize the key structures designed by the architect from the extracted information.
:E5: = MLM[What are the notable structures designed by :E1:, given :E4:?]
Answer: :E5:

System: A chat.


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

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
PageReader[input]: Load a website from the input URL and produces plain text output containing the content of the page.
LinkCollector[input]: Extract links from plain text and produces a list of URLs.
AIAnswerer[input]: AI model capable of answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

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

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

Response:
Plan: Start by conducting an online search to find out who won the Nobel Prize in Literature in 2020.
#E1 = SearchEngine[Nobel Prize in Literature 2020 winner]
Plan: Use AIAnswerer to interpret the search results and find the name of the laureate.
#E2 = AIAnswerer[Who won the Nobel Prize in Literature in 2020? Given context: #E1]
Plan: Conduct another online search to find the most famous work of the identified laureate.
#E3 = SearchEngine[Most famous work of #E2]
Plan: Extract the relevant links from the search results for a more detailed search.
#E4 = LinkCollector[#E3]
Plan: Use PageReader to extract information from the relevant links.
#E5 = PageReader[#E4]
Plan: Finally, use AIAnswerer to identify and summarize the most famous work of the laureate from the extracted information.
#E6 = AIAnswerer[What is the most famous work of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Question: What is the nutritional value of an apple and how does it compare to a banana?

Here are the tools available to be called:
NutritionData[input]: Provides nutrition facts for a specified food item.
FoodComparer[input]: Compares the nutritional values of two specified food items.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

Response:
Plan: First, get the nutritional value of an apple.
#E1 = NutritionData["apple"]
Plan: Next, get the nutritional value of a banana.
#E2 = NutritionData["banana"]
Plan: Then, compare the nutritional values of an apple and a banana.
#E3 = FoodComparer["apple", "banana"]
Final answer: #E3

System: A chat.


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

Here are the tools available to be called:
Bing[input]: A tool that allows you to search for information using the Bing search engine. This tool is useful in finding relevant sites that may contain the answer to your question.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
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 dog, given :evidence1:?

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

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

Response:
Plan: Start by conducting a web search to find out who was the first person to climb Mount Everest without supplemental oxygen.
:evidence0: = Bing[First person to climb Mount Everest without supplemental oxygen]
Plan: Use the SAM language model to interpret the search results and identify the climber's name.
:evidence1: = SAM[Who was the first person to climb Mount Everest without supplemental oxygen, given :evidence0:?]
Plan: Conduct another web search to find the motivations of the identified climber.
:evidence2: = Bing[Motivations of :evidence1: for climbing Mount Everest without supplemental oxygen]
Plan: Extract the relevant links from the Bing search results for a more detailed search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use the WebReader tool to extract information from the relevant links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, use the SAM language model to summarize the key motivations of the climber from the extracted information.
:evidence5: = SAM[What were the motivations of :evidence1: for climbing Mount Everest without supplemental oxygen, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools you can use:
Bing[input]: A tool that allows users to search for information on Bing. This function is useful for finding a list of sites that may contain the answer to the user's query.
WebScraper[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 separated response of links.
QAModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

Ensure there is 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: What is the population of Tokyo and what are some popular tourist attractions?

Response:
Plan: Start by conducting a web search to find out the current population of Tokyo.
:evidence0: = Bing[Current population of Tokyo]
Plan: Use the question-answering model to interpret the search results and determine the population.
:evidence1: = QAModel[What is the current population of Tokyo, given :evidence0:?]
Plan: Conduct another web search to identify popular tourist attractions in Tokyo.
:evidence2: = Bing[Popular tourist attractions in Tokyo]
Plan: Extract relevant links from the Bing search results for further investigation.
:evidence3: = LinkPicker[:evidence2:]
Plan: Utilize the WebScraper tool to extract detailed information from the selected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, employ the question-answering model to summarize the popular tourist attractions in Tokyo from the extracted data.
:evidence5: = QAModel[What are some popular tourist attractions in Tokyo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a step-by-step plan to address the following user query:

Question: What are some popular dishes in Japanese cuisine and how are they typically prepared?

Here are the tools available to be called:
CuisineExplorer[input]: Provides information about various cuisines around the world.
RecipeFinder[input]: Finds recipes based on the input dish name.
IngredientLister[input]: Lists ingredients used in a particular dish.
CookingInstructions[input]: Provides cooking instructions for a specified dish.
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.

Follow the same planning and output format as TSK 2.

Response:
Plan:

1. Call CuisineExplorer["Japanese cuisine"] to get a list of popular dishes in Japanese cuisine.
2. For each dish from step 1, call RecipeFinder[dish] to find recipes for the dish.
3. For each recipe from step 2, call IngredientLister[recipe] to list out the ingredients used in the recipe.
4. For each recipe from step 2, also call CookingInstructions[recipe] to provide cooking instructions for the dish.
5. If there are any ambiguities or further questions about the dishes, use QA[input] to answer these queries.

Output:

1. CuisineExplorer["Japanese cuisine"]
2. RecipeFinder["Sushi"]
3. IngredientLister["Sushi recipe"]
4. CookingInstructions["Sushi recipe"]
5. QA["What is sushi typically served with?"]

6. RecipeFinder["Ramen"]
7. IngredientLister["Ramen recipe"]
8. CookingInstructions["Ramen recipe"]
9. QA["What types of ramen are there?"]

10. RecipeFinder["Tempura"]
11. IngredientLister["Tempura recipe"]
12. CookingInstructions["Tempura recipe"]
13. QA["What is tempura typically served with?"]

And so on for other dishes.

System: A chat.


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

Here are the tools you have at your disposal:
Bing[input]: This tool allows the user to search for information using Bing search engine. It is useful in finding relevant sites that may contain the answer to the user's query.
TextExtractor[input]: Extracts plain text from a webpage given its URL. The input must be a link and the output will be the content of the page in plain text.
LinkCollector[input]: Collects all links present on a web page. Input is a single URL and output is a list of URLs found on the page.
QAModel[input]: A model capable of answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The function inputs should be simple strings without quotes or "+" for concatenation. For example: QAModel[What is the capital of France, given :evidence1:?]

Each plan step should only include one evidence output.

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

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

Response:
Plan: Start by conducting a web search to find information about the history of the Eiffel Tower's construction.
:evidence0: = Bing[Eiffel Tower construction history]
Plan: Use LinkCollector to gather all the links from the search results for more detailed information.
:evidence1: = LinkCollector[:evidence0:]
Plan: Select the most relevant link and extract the text from it using TextExtractor.
:evidence2: = TextExtractor[:evidence1:]
Plan: Utilize the QAModel to identify the main points in the history of the Eiffel Tower's construction from the extracted text.
:evidence3: = QAModel[What is the history behind the construction of the Eiffel Tower? Given context: :evidence2:]
Plan: Conduct another web search to find out who the main architects involved in the construction were.
:evidence4: = Bing[Main architects of Eiffel Tower]
Plan: Use the QAModel again to identify the names of the main architects from the new search results.
:evidence5: = QAModel[Who were the main architects involved in the construction of the Eiffel Tower? Given context: :evidence4:]
Answer: :evidence3: and :evidence5:

System: A chat.


Instruction:
Formulate a comprehensive plan to address the following user inquiry, employing the listed tools. Every plan should correlate to an evidence value, which would be the output of one of the accessible functions given an input string. This could be the user's question, prior evidence values, or a blend of both.

Tools available:
YahooSearch[input]: Allows users to seek information through Yahoo Search. It aids in identifying possible sites that may contain responses to the user's question. It does not offer direct answers but compiles a list of sites that might possess the answer.
PageLoader[input]: Takes one or more websites from an input string comprising newline-separated links. The input includes one or more links, and the output provides the plain text content of these links.
URLGatherer[input]: Collects links from plain text and returns a plain text, newline-separated compilation of links.
QuerySolver[input]: An AI-based question-solving model proficient in supplying answers derived from a specified text passage. The input needs to be a text question referencing an :evidence[n]: variable, such as 'Who wrote Pride and Prejudice, given :evidence1:'?

Each function's inputs should be simple strings, devoid of quotation marks or '+' symbols used to concatenate a string with an evidence variable, like QuerySolver[Who directed Titanic, given :evidence3:?].

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

The output should adhere to this format:
Plan: [First action based on the input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Following action based on the result of :evidence0:]
:evidence1: = [Subsequent function to invoke with input parameter, possibly referring to earlier evidence, i.e., 'Given context :evidence0']
...
Final Answer: [:evidence[n]: containing the definitive answer.]

Question: How has climate change affected the Great Barrier Reef over the past decade?

Response:
Plan: Begin with a web search to collect information about the impact of climate change on the Great Barrier Reef.
:evidence0: = YahooSearch[Climate change effects on Great Barrier Reef last decade]
Plan: Apply the AI model to interpret the search results and comprehend the impacts of climate change on the Great Barrier Reef.
:evidence1: = QuerySolver[What are the effects of climate change on the Great Barrier Reef over the past decade, given :evidence0:?]
Plan: Perform another web search to delve deeper into how climate change has influenced the Great Barrier Reef.
:evidence2: = YahooSearch[Great Barrier Reef climate change impacts in detail]
Plan: Extract relevant links from the Yahoo Search results for a more precise exploration.
:evidence3: = URLGatherer[:evidence2:]
Plan: Use the PageLoader tool to extract details from the chosen links.
:evidence4: = PageLoader[:evidence3:]
Plan: Ultimately, apply the AI model to identify and summarise the specific ways in which climate change has affected the Great Barrier Reef from the extracted details.
:evidence5: = QuerySolver[In what specific ways has climate change affected the Great Barrier Reef over the past decade, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Concoct a complete game plan to unravel the impending query. Each division should designate a function to kick-start with its allied input. Safeguard the dividend of each function in a labeled :Clue[index]: variable, which can thereafter be summoned in ensuing divisions.

Ready-to-use Functions:
ExciteSearch[input]: Triggers an Excite search for the input idiom and collects an accumulation of plausible sources.
UrlDivider[input]: Supplied a volume of text (like the output from an ExciteSearch), this function locates all URLs ensconced within the text.
PageHarvester[input]: Routes to the page at the specified URL and transposes its contents into plain text.
OmegaThinker[input]: A state-of-the-art AI-oriented question-answering unit skilled at dispensing instant solutions to a diverse range of inquiries. It can also fabricate answers relying on auxiliary specifics (e.g., the text from a webpage).

Output Sketch:
Plan: [Portrayal of the inaugural step]
:Clue0: = [Inaugural step function kick-start]
Plan: [Portrayal of the sequential step]
:Clue1: = [Sequential step function kick-start]
... Persist this chain until ...
Final Answer: :ClueN:

Question: Who discovered penicillin and what other scientific breakthroughs are they hailed for?

Response:
Plan: Spark an Excite search to decode who discovered penicillin.
:Clue0: = ExciteSearch[discoverer of penicillin]
Plan: Harness OmegaThinker to sieve through the search dividends and identify the discoverer.
:Clue1: = OmegaThinker[Who discovered penicillin? Given context: :Clue0:]
Plan: Set in motion another Excite search to track down other scientific breakthroughs credited to the identified scientist.
:Clue2: = ExciteSearch[:Clue1: other scientific breakthroughs]
Plan: Disconnect the URLs from the search dividends for thorough analysis.
:Clue3: = UrlDivider[:Clue2:]
Plan: Secure the content of the principal URL from the batch.
:Clue4: = PageHarvester[:Clue3[0]]
Plan: At last, mobilize OmegaThinker to peruse the webpage text and underline the other lauded scientific breakthroughs of the scientist.
:Clue5: = OmegaThinker[What other scientific breakthroughs is :Clue1: praised for? Given context: :Clue4:]
Final Answer: :Clue5:

System: A chat.


Instruction:
Create a methodical plan to respond to the user request, making use of the provided toolkit. Each plan will associate with an evidence value, which is the product of one of the available functions given an input string that could be the user's question, earlier evidence values, or both.

Tools at disposal:
YahooSearch[input]: A tool enabling the user to seek information through Yahoo Search. This tool assists in identifying appropriate sites that may hold the answer to the user's inquiry.
PageLoader[input]: Fetches one or more websites from the input string containing newline-separated links. The input consists of one or more links, producing plain text output encompassing the content of these links.
URLGatherer[input]: Retrieves links from plain text, generating a plain text, newline-separated response of links.
QAEngine[input]: A question-answering language model, adept at answering inquiries based on an input text passage. The input has to be a text-based question referring to an :evidence[n]: variable.

Output format:
Plan: [Initial action predicated on input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action contingent upon result of :evidence0:]
:evidence1: = [Following function to invoke and input parameter, potentially citing prior evidence, e.g., "In light of :evidence0:"]
...
Ultimate Response: [:evidence[n]: carrying the final answer]

Question: Who invented the telephone and what patents do they hold?

Response:
Plan: Initiate a web search to ascertain who invented the telephone.
:evidence0: = YahooSearch[Inventor of the telephone]
Plan: Apply QAEngine to decipher the search results and pinpoint the inventor.
:evidence1: = QAEngine[Who invented the telephone, considering :evidence0:?]
Plan: Undertake another web search to discover the patents held by the identified inventor.
:evidence2: = YahooSearch[Patents held by :evidence1:]
Plan: Accumulate the pertinent links from the YahooSearch results for a comprehensive search.
:evidence3: = URLGatherer[:evidence2:]
Plan: Employ PageLoader to pull information from the selected links.
:evidence4: = PageLoader[:evidence3:]
Plan: Ultimately, utilize QAEngine to outline the patents held by the inventor from the obtained information.
:evidence5: = QAEngine[What patents does :evidence1: hold, taking into account :evidence4:?]
Answer: :evidence5:

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 combination of both.

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

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

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

Response:
Plan: Begin by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = SearchEngine[History of the Eiffel Tower]
Plan: Utilize AnswerBot to interpret the search results and summarize the history of the Eiffel Tower.
:evidence1: = AnswerBot[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find the main architects of the Eiffel Tower.
:evidence2: = SearchEngine[Main architects of the Eiffel Tower]
Plan: Extract the relevant links from the search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use WebCrawler to extract information from the relevant links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, utilize AnswerBot to identify and summarize the main architects of the Eiffel Tower from the extracted information.
:evidence5: = AnswerBot[Who were the main architects of the Eiffel Tower, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to solve the following question using the available tools. For each step of your plan, provide an evidence variable that will be used in subsequent steps or as the final answer.

Here are the tools you can use:
Bing[input]: This tool allows users to search for information using Bing's search engine. It is useful for finding a list of sites that may contain answers to the user's query.
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 separated response of links.
AnswerBot[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question that references a :data[n]: variable, e.g., What is the capital of France, given :data1:?

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

Ensure there is 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, which may include reference to previous data, e.g., "Given context :data0"]
...
Final Answer: [:data[n]: containing the final answer.]

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

Response:
Plan: Start by conducting a web search to find out who the architect of the Sydney Opera House is.
:data0: = Bing[Architect of Sydney Opera House]
Plan: Use the language model to interpret the search results and identify the name of the architect.
:data1: = AnswerBot[Who is the architect of the Sydney Opera House, given :data0:?]
Plan: Conduct another web search to find other notable works by the identified architect.
:data2: = Bing[Notable works by :data1:]
Plan: Extract relevant links from the Bing search results for a deeper investigation.
:data3: = LinkPicker[:data2:]
Plan: Utilize the WebReader tool to extract information from the selected links.
:data4: = WebReader[:data3:]
Plan: Finally, employ the language model to identify and summarize the notable works of the architect from the extracted information.
:data5: = AnswerBot[What are the notable works by :data1:, given :data4:?]
Final Answer: :data5:

System: A chat.


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

Here are the tools you can use:
DuckDuckGo[input]: A tool that allows users to search for information using the DuckDuckGo search engine. This tool is useful for finding a list of sites that may contain the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that might have the answer.
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 language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

Ensure only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = DuckDuckGo[Nobel Prize in Physics 2020 winner]
Plan: Use a language model to interpret the search results and identify the winner.
:evidence1: = QAModel[Who won the Nobel Prize in Physics in 2020, given :evidence0:?]
Plan: Conduct another web search to find the key contributions made by the identified laureate.
:evidence2: = DuckDuckGo[:evidence1: Nobel Prize contribution]
Plan: Extract the relevant links from the DuckDuckGo search results for a detailed investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to summarize the key contributions made by the laureate from the extracted information.
:evidence5: = QAModel[What were the key contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the user's question using the tools provided. Each step should have a corresponding evidence value which is the output of the tool used.

Available Tools:
WikiSearch[input]: Searches Wikipedia for information related to the input string.
PageParser[input]: Parses a webpage and produces plain text content.
URLExtractor[input]: Extracts URLs from plain text.
AnswerBot[input]: Answers questions based on the context provided in the input.

Output Format:
Plan: [first action]
#Evidence0 = [function call with input]
Plan: [next action]
#Evidence1 = [next function call with input]
...
Final Answer: #EvidenceN

Question: What is the main diet of the Blue Whale?

Response:
Plan: Start by searching Wikipedia for information on the Blue Whale.
#Evidence0 = WikiSearch[Blue Whale]
Plan: Extract relevant URLs from the Wikipedia page for further investigation.
#Evidence1 = URLExtractor[#Evidence0]
Plan: Parse the pages linked in the Wikipedia article to get more details.
#Evidence2 = PageParser[#Evidence1]
Plan: Determine the main diet of the Blue Whale from the parsed page contents.
#Evidence3 = AnswerBot[What is the main diet of the Blue Whale? Given context: #Evidence2]
Final Answer: #Evidence3

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

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

Question: What are some major accomplishments of Albert Einstein?

Response:
Plan: Start by conducting a web search to find out about Albert Einstein's major accomplishments.
:evidence0: = SearchEngine[Major accomplishments of Albert Einstein]
Plan: Use LinkFinder to extract relevant links from the search results.
:evidence1: = LinkFinder[:evidence0:]
Plan: Utilize WebScraper to gather information from these links.
:evidence2: = WebScraper[:evidence1:]
Plan: Finally, utilize AnswerBot to summarize Albert Einstein's major accomplishments from the gathered information.
:evidence3: = AnswerBot[What are some major accomplishments of Albert Einstein, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Please generate a plan to answer the following question using the available tools. Each step in your plan should be followed by an evidence value that corresponds to the output of one of the functions given an input string. This input can be the user's question, previous evidence values, or both.

Here are the tools you can use:
WebSearch[input]: A tool that allows the user to search for information on the web. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextExtractor[input]: Extracts text from a webpage given its URL. The input is a link and the output is plain text containing the content of the page.
QAEngine[input]: Answers questions based on common sense, general world knowledge, and given context that may contain the answer. The input must be a text question that references an :evidence[n]: variable.
LinkPicker[input]: Picks the most relevant links from a set of URLs. The input is a newline-delimited string of URLs and the output is a single URL that seems most likely to contain the answer to the user's question.

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

Question: What was the cause of death of the famous painter Vincent van Gogh?

Response:
Plan: Start by searching the web for information about Vincent van Gogh's cause of death.
:evidence0: = WebSearch[Vincent van Gogh cause of death]
Plan: Pick the most relevant link from the search results.
:evidence1: = LinkPicker[:evidence0:]
Plan: Extract the text from the selected webpage.
:evidence2: = TextExtractor[:evidence1:]
Plan: Use the QA engine to find the cause of death from the extracted text.
:evidence3: = QAEngine[What was the cause of death of Vincent van Gogh? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Construct a comprehensive plan to respond to this query using these tools:
QuoraSearch[input]: Searches Quora for relevant discussions.
BlogFinder[input]: Finds blogs related to the input topic.
TextCondenser[input]: Condenses large amounts of text into key points.
TruthAssessor[input]: Assesses the truthfulness of a statement.
QuerySolver[input]: Solves queries based on input context.

Question: What are the main theories about the construction of the pyramids of Egypt?

Response:
Plan:

1. Use QuoraSearch[input]: Start by using the QuoraSearch tool with the input "main theories about the construction of the pyramids of Egypt". This will provide a range of discussions and viewpoints on the topic from different users.

2. Use BlogFinder[input]: Then, use the BlogFinder tool with the same input to find blogs that discuss this topic in depth. These blogs may offer more detailed explanations or perspectives that were not covered in the Quora discussions.

3. Use TextCondenser[input]: After gathering all the information from Quora and blogs, use the TextCondenser tool to condense the large amounts of text into key points. This will help to create a clear and concise summary of the main theories.

4. Use TruthAssessor[input]: Apply the TruthAssessor tool to each of the summarized theories. This will assess the truthfulness of each theory based on available evidence and consensus among experts.

5. Use QuerySolver[input]: Finally, use the QuerySolver tool with the condensed and assessed information as input. This will generate a comprehensive answer to the query about the main theories regarding the construction of the pyramids of Egypt.

System: A chat.


Instruction:
Develop a plan to answer the following question: "What is the process of photosynthesis and what are its main components?" using the tools provided. The tools available include:

1. Bing[input]: A tool that allows you to search for information on the internet via the Bing search engine.
2. TextSummarizer[input]: This tool can summarize large chunks of text, making it easier to extract relevant information.
3. QA[input]: A tool capable of answering questions based on common sense, general world knowledge or given input context.
4. DocumentReader[input]: Reads documents from the specified URL and outputs plain text.

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

The output format should be as follows:
Plan: [first action]
#E1 = [function with input parameter]
Plan: [next action]
#E2 = [next function with input parameter]
...
Final Answer: #E[n]

Response:
Plan: Use Bing to gather more information about photosynthesis.
#E1 = Bing[Photosynthesis]
Plan: Summarize the obtained information to make it more manageable.
#E2 = TextSummarizer[#E1]
Plan: Identify the process of photosynthesis from the summarized information.
#E3 = QA[What is the process of photosynthesis? Given context: #E2]
Plan: Identify the main components of photosynthesis from the summarized information.
#E4 = QA[What are the main components of photosynthesis? Given context: #E2]
Final Answer: #E3 and #E4

System: A chat.


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

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.
URLExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text.

The 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 current Prime Minister of Japan and what are some major policies they implemented?

Response:
Plan: Begin by conducting a web search to find out who the current Prime Minister of Japan is.
#E1 = DuckDuckGo[Current Prime Minister of Japan]
Plan: Utilize AIQA to interpret the search results and find the name of the Prime Minister.
#E2 = AIQA[Who is the current Prime Minister of Japan? Given context: #E1]
Plan: Conduct another web search to find the key policies implemented by the identified Prime Minister of Japan.
#E3 = DuckDuckGo[Key policies implemented by #E2]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
#E4 = URLExtractor[#E3]
Plan: Use WebScraper to extract information from the relevant links.
#E5 = WebScraper[#E4]
Plan: Finally, utilize AIQA to identify and summarize the key policies implemented by the Prime Minister of Japan from the extracted information.
#E6 = AIQA[What are the key policies implemented by #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Please create a detailed plan to generate an ideal response to the user query, making use of the set of tools provided. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user question, one or more prior evidence values, or a mixture of both.

Here are the tools available to be used:
DuckDuckGo[input]: A tool that enables the user to search for information via the DuckDuckGo search engine. This tool helps in locating a suitable list of sites that might contain the answer to the user's query.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-separated response of URLs.
SiteReader[input]: Loads one or more websites from the input string containing newline-delimited links, where input is one or more links, and outputs plain text containing the content of the links.
QAModel[input]: Question-answering model, especially effective at answering queries based on an input text passage. The input needs to be a text question that refers to an :evidence[n]: variable, e.g., What is the height of the Eiffel Tower, given :evidence1:?

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

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

Response:
Plan: Begin by conducting a web search to find out the tallest building in Dubai.
:evidence0: = DuckDuckGo[Tallest building in Dubai]
Plan: Utilize the QAModel to interpret the search results and identify the name of the building.
:evidence1: = QAModel[What is the tallest building in Dubai, given :evidence0:?]
Plan: Conduct another web search to find the number of floors in the identified building.
:evidence2: = DuckDuckGo[Number of floors in :evidence1:]
Plan: Extract the relevant URLs from the DuckDuckGo search results for a more focused search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use the SiteReader tool to extract information from the relevant URLs.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, utilize the QAModel to identify and state the number of floors in the building from the extracted information.
:evidence5: = QAModel[How many floors does :evidence1: have, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools you can call:
SearchEngine[input]: A tool that allows users to search for information using a generic search engine. This tool helps in finding relevant sites that may contain the answer to the user's question.
WebScraper[input]: Load websites from the input string containing newline separated links. The input is one or more links and produces plain text output with the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response of links separated by newlines.
QAModel[input]: Question answering model useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Include only one evidence output 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, referencing previous evidence if necessary]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What are some major accomplishments of Elon Musk?

Response:
Plan: Start by conducting a web search to find out about Elon Musk's major accomplishments.
:evidence0: = SearchEngine[Major accomplishments of Elon Musk]
Plan: Use the link extractor to get relevant links from the search results.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Use the web scraper to extract information from these links.
:evidence2: = WebScraper[:evidence1:]
Plan: Finally, use the question answering model to summarize Elon Musk's major accomplishments from the extracted information.
:evidence3: = QAModel[What are some major accomplishments of Elon Musk, given :evidence2:?]
Answer: :evidence3:

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:
DuckDuckGo[input]: Tool that allows the user to search for information from DuckDuckGo. This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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 temperature in July for the city that hosts the largest annual jazz festival?

Response:
Plan: Search for more information about the city that hosts the largest annual jazz festival.
#E1 = DuckDuckGo[Largest annual jazz festival location]
Plan: Find out the name of the city that hosts the largest annual jazz festival.
#E2 = QA[What is the name of the city that hosts the largest annual jazz festival? Given context: #E1]
Plan: Search for more information about the average temperature in July for the identified city.
#E3 = DuckDuckGo[Average temperature in July for #E2]
Plan: Determine the average temperature in July for the city.
#E4 = QA[What is the average temperature in July for the city #E2? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Formulate a systematic plan to address the user's inquiry, employing the following tools. Every stage in your strategy should correspond to an evidence value, which represents the output of one of the provided functions when supplied with an appropriate input string.

Tools at your disposal:
1. DuckDuckGo[input]: Allows users to search for information via the DuckDuckGo search engine. Useful for locating potential sources of information related to the user's query.
2. SiteParser[input]: Takes as input a string containing newline-separated URLs and returns plain text content from these sites.
3. URLSelector[input]: Extracts URLs from plain text and outputs them as newline-separated strings.
4. ALICE[input]: A language model designed to answer questions based on a passage of text. The input should be a question referencing a :fact[n]: variable, e.g., How tall is the Eiffel Tower, given :fact1:?

Input to each function should simply be a plain string without any special characters used to concatenate it with a fact variable, e.g., ALICE[What is the population of Tokyo, given :fact3:?]

Only one evidence output should be included per plan step.

Output format:
Plan: [initial action based on input question]
:fact0: = [function to call with input parameter]
Plan: [subsequent action based on outcome of :fact0:]
:fact1: = [next function to call with input parameter, possibly referring to earlier facts, e.g., "Given context :fact0"]
...
Final Answer: [:fact[n]: contains the ultimate answer.]

Question: Who is the founder of SpaceX and what notable missions has the company accomplished?

Response:
Plan: Initiate a web search to determine the founder of SpaceX.
:fact0: = DuckDuckGo[Founder of SpaceX]
Plan: Employ the language model to parse the search results and ascertain the name of the founder.
:fact1: = ALICE[Who is the founder of SpaceX, given :fact0:?]
Plan: Execute another web search to uncover notable missions accomplished by SpaceX.
:fact2: = DuckDuckGo[Notable missions of SpaceX]
Plan: Isolate pertinent links from the DuckDuckGo search results for further examination.
:fact3: = URLSelector[:fact2:]
Plan: Utilize the SiteParser tool to glean information from the selected links.
:fact4: = SiteParser[:fact3:]
Plan: Lastly, deploy the language model to identify and summarize SpaceX's notable missions from the parsed information.
:fact5: = ALICE[What are the notable missions of SpaceX, given :fact4:?]
Final Answer: :fact5:

System: A chat.


Instruction:
Develop a plan to answer the following question: "What is the main diet of an adult Bengal tiger and where can they be found in the wild?" Here are some tools that you can use:

WebSearch[input]: A tool that allows users to search for information using a web-based search engine. The input should be a query string, and the output will be a list of websites that may contain relevant information.
PageScraper[input]: This tool takes one or more URLs as input and outputs plain text content from those pages.
QAEngine[input]: This tool can answer questions based on common knowledge or given context. It requires a question string as input, which may reference previous evidence variables.
MapInfo[input]: This tool provides geographical information about a specific location when provided with a place name.

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

Response:
Plan: Search the web for information on the diet of an adult Bengal tiger.
#E1 = WebSearch[Adult Bengal tiger diet]
Plan: Use QAEngine to interpret the results and identify the main diet.
#E2 = QAEngine[What is the main diet of an adult Bengal tiger? Given context: #E1]
Plan: Conduct another web search to find out where Bengal tigers can be found in the wild.
#E3 = WebSearch[Bengal tiger habitat]
Plan: Extract useful information about the locations where Bengal tigers live.
#E4 = MapInfo[#E3]
Final Answer: The main diet of an adult Bengal tiger is #E2 and they can be found in the wild at #E4.

System: A chat.


Instruction:
Create a step-by-step plan to solve the user's question, using any of the following tools. Each tool should be used at least once and each plan will have an associated evidence value, which is the output from one of the available functions given an input string.

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

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
:evidence0: = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the advanced language model to interpret the search results and identify the winner.
:evidence1: = ALM[Who won the Nobel Prize in Literature in 2020, 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 the WebScraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the advanced language model to identify and summarize the most famous work of the laureate from the extracted information.
:evidence5: = ALM[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a detailed plan to address the user's query, making use of the following tools. Each plan should have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Available Tools:
DuckDuckGo[input]: Allows the user to search for information using the DuckDuckGo search engine. It provides a list of sites that could potentially hold the answer to the user's question.
PageReader[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.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of URLs.
QAModel[input]: Question answering model useful in answering questions based on an input passage of text. The input must be a text question that references an #E[n] variable, e.g. What is the capital of France, given #E1?

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

Question: What was the highest grossing movie of 2019 and who directed it?

Response:
Plan: Begin by conducting a web search to find out the highest grossing movie of 2019.
#E1 = DuckDuckGo[Highest grossing movie of 2019]
Plan: Utilize the QAModel to interpret the search results and find the name of the movie.
#E2 = QAModel[What was the highest grossing movie of 2019? Given context: #E1]
Plan: Conduct another web search to find the director of the identified movie.
#E3 = DuckDuckGo[Director of #E2]
Plan: Extract the relevant URLs from the DuckDuckGo search results for a more focused search.
#E4 = URLExtractor[#E3]
Plan: Use the PageReader tool to extract information from the relevant URLs.
#E5 = PageReader[#E4]
Plan: Finally, utilize the QAModel to identify the director of the movie from the extracted information.
#E6 = QAModel[Who directed the movie #E2? Given context: #E5]
Final Answer: #E6

System: A chat.