Instruction:
Develop a systematic plan to solve the following user query, employing the provided tools. Each step in your plan should correspond to an evidence value, which is the output of a specific function given an input string that could be the user's question, prior evidence values, or a combination of both.

These are the tools at your disposal:
DuckDuckGo[input]: A tool enabling users to perform searches via DuckDuckGo. It helps locate potential sites that might hold the answer to the user's query. However, this function does not provide direct answers but lists possible sites that might contain them.
SiteLoader[input]: Fetches one or multiple websites from an input string comprising newline-separated links. The input includes one or more links, while the output consists of plain text encompassing the content of these links.
URLExtractor[input]: Retrieves links from plain text, generating a plain-text, newline-separated response of links.
ALICE[input]: A question-answering language model adept at providing answers based on a given text passage. The input needs to be a textual question referencing an :evidence[n]: variable, such as "What color is the dog, given :evidence1:?"

Each function's input should simply be a plain string, devoid of quotation marks or "+" for concatenating a string with an evidence variable, like ALICE[What is the population of Tokyo, given :evidence3:?]

Ensure that every plan step includes just one evidence output.

Your output should follow this format:
Plan: [initial action to undertake based on the input question]
:evidence0: = [function to invoke with its input parameter]
Plan: [subsequent action to execute, depending on the outcome of :evidence0:]
:evidence1: = [the next function to call along with its input parameter, possibly referring to preceding evidence, e.g., "In light of :evidence0"]
...
Final Answer: [:evidence[n]: that contains the ultimate answer.]

Question: Which company manufactured the first smartphone and when was it released?

Response:
Plan: Initiate a web search to discover the company that produced the first smartphone.
:evidence0: = DuckDuckGo[first smartphone manufacturer]
Plan: Employ a language model to parse the search outcomes and pinpoint the manufacturing company.
:evidence1: = ALICE[Which company manufactured the first smartphone, given :evidence0:?]
Plan: Carry out another web search to determine when the company launched the first smartphone.
:evidence2: = DuckDuckGo[:evidence1: + ' first smartphone release date']
Plan: Isolate pertinent links from the DuckDuckGo search results for a narrower search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Utilize SiteLoader to retrieve data from the selected links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Lastly, apply the language model to discern the release date of the first smartphone from the gathered data.
:evidence5: = ALICE[When was the first smartphone by :evidence1: released, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a sequential plan to respond to the following user query using the listed tools. Each step should provide evidence that can be used in subsequent steps.

Available Tools:
DuckDuckGo[input]: A tool that performs a web search using DuckDuckGo.
SiteReader[input]: Loads content from specified URLs and provides it as plain text.
URLExtractor[input]: Pulls all URLs from provided text.
ELIZA[input]: A natural language processing tool capable of answering questions when provided with contextual information.

Output Format:
Plan: [First action]
#E1 = [Function to call with parameters]
Plan: [Subsequent action]
#E2 = [Next function to call with parameters (can refer to prior evidence)]
...
Final Answer: #En

Question: How does photosynthesis work and what role do chloroplasts play in this process?

Response:
Plan: Start by searching the web for information about photosynthesis.
#E1 = DuckDuckGo[Photosynthesis]
Plan: Use ELIZA to get a basic understanding of photosynthesis from the search results.
#E2 = ELIZA[How does photosynthesis work? Given context: #E1]
Plan: Search the web again for specific information about the role of chloroplasts in photosynthesis.
#E3 = DuckDuckGo[Role of chloroplasts in photosynthesis]
Plan: Extract relevant URLs from the search results for further exploration.
#E4 = URLExtractor[#E3]
Plan: Use SiteReader to pull information from these URLs.
#E5 = SiteReader[#E4]
Plan: Lastly, use ELIZA to understand the role of chloroplasts in photosynthesis from the gathered information.
#E6 = ELIZA[What role do chloroplasts play in photosynthesis? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Develop a sequential plan to solve the following query using the provided tools. Each step should generate an evidence variable that can be used in subsequent steps.

Tools available:
BingSearch[input]: Searches Bing for information related to the input query.
PageReader[input]: Reads the contents of a webpage from a given URL.
LinkFinder[input]: Finds all URLs in a block of text.
InfoMaster[input]: Answers questions based on a given context. The input must be a question referencing a #E[n] variable, such as "What is the capital of France, given #E1?"

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

Question: How did the Spanish Flu pandemic end and what lessons were learned from it?

Response:
Plan: Begin by searching for information on how the Spanish Flu pandemic ended.
#E1 = BingSearch[How did the Spanish Flu pandemic end]
Plan: Use InfoMaster to extract the details on how the pandemic ended from the search results.
#E2 = InfoMaster[How did the Spanish Flu pandemic end? Given context: #E1]
Plan: Search for information on the lessons learned from the Spanish Flu pandemic.
#E3 = BingSearch[Lessons learned from the Spanish Flu pandemic]
Plan: Find relevant links from the search results for more detailed information.
#E4 = LinkFinder[#E3]
Plan: Read the contents of the most relevant page found.
#E5 = PageReader[#E4]
Plan: Finally, use InfoMaster to summarize the lessons learned from the Spanish Flu pandemic.
#E6 = InfoMaster[What lessons were learned from the Spanish Flu pandemic? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Devise a systematic plan to respond to the user query leveraging the supplied tools. Every step should coincide with an evidence value, which is the product of one of the available functions given an input string that could be the user question, past evidence values, or a mixture of both.

These are the tools at your disposal:
EncyclopediaSearch[input]: Lets the user search for information from an online encyclopedia. It's beneficial for obtaining knowledge about various subjects.
PageCrawler[input]: Loads one or more webpages from the input string containing newline divided links, where input is one or more links, and creates plain text output encompassing the content of the links.
LinkUnpacker[input]: Unpacks links from plain text and forms a plain text, newline divided response of links.
InquiryProcessor[input]: A question-answering language model, suitable for responding to inquiries based on an input text passage. The input has to be a text question pointing to an :evidence[n]: variable, e.g., What is the GDP of India, given :evidence1:?

The output should comply with this template:
Plan: [primary action to execute based on input question]
:evidence0: = [function to trigger with input parameter]
Plan: [ensuing action to execute, grounded on the result of :evidence0:]
:evidence1: = [next function to trigger and input parameter, which may hint at former evidence, e.g., "Taking into account context :evidence0"]
...
Answer: [:evidence[n]: possessing the final answer.]

Question: What is the life cycle of a butterfly and how does it contribute to pollination?

Response:
Plan: Kick off by searching for information about the life cycle of a butterfly via EncyclopediaSearch.
:evidence0: = EncyclopediaSearch[butterfly life cycle]
Plan: Leverage InquiryProcessor to parse the search findings and outline the life cycle of a butterfly.
:evidence1: = InquiryProcessor[What is the life cycle of a butterfly? Given :evidence0:]
Plan: Perform another search to discover how butterflies contribute to pollination.
:evidence2: = EncyclopediaSearch[butterflies and pollination]
Plan: Unpack the relevant links from the search results for more in-depth analysis.
:evidence3: = LinkUnpacker[:evidence2:]
Plan: Use PageCrawler to amass information from the unpacked links.
:evidence4: = PageCrawler[:evidence3:]
Plan: In the end, deploy InquiryProcessor to recognize and encapsulate how butterflies contribute to pollination from the amassed information.
:evidence5: = InquiryProcessor[How do butterflies contribute to pollination? Given :evidence4:]
Answer: Life Cycle - :evidence1:. Contribution to Pollination - :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.
ScraperTool[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What are some notable works by the author who wrote "Pride and Prejudice"?

Response:
Plan: Begin by conducting a web search to find out who the author of "Pride and Prejudice" is.
:evidence0: = Bing[Author of Pride and Prejudice]
Plan: Utilize a language model to interpret the search results and find the name of the author.
:evidence1: = QAModel[Who is the author of Pride and Prejudice, given :evidence0:?]
Plan: Conduct another web search to find the notable works written by the identified author.
:evidence2: = Bing[Notable works by :evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = ScraperTool[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the notable works by the author from the extracted information.
:evidence5: = QAModel[What are the notable works by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools. 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 general search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the current population of Tokyo and what are some famous landmarks?

Response:
Plan: Start by conducting a web search to find out the current population of Tokyo.
:evidence0: = SearchEngine[Current population of Tokyo]
Plan: Use a 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 find famous landmarks in Tokyo.
:evidence2: = SearchEngine[Famous landmarks in Tokyo]
Plan: Extract relevant links from the search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Utilize a web scraper tool to extract information from the extracted links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the question answering model to identify and summarize the famous landmarks in Tokyo from the scraped information.
:evidence5: = QAModel[What are some famous landmarks in Tokyo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a detailed execution plan to solve the problem mentioned below, making use of the set of tools available. Each step in your plan should produce an evidence value, which will be the output of one of the available functions given an input string.

Available Tools:
GoogleSearch[input]: A tool that lets you search for information online via Google. It provides a list of potential sources but does not provide direct answers.
PageLoader[input]: Loads a webpage from the input URL and returns the full text of the page.
URLFinder[input]: Finds URLs within a block of text and returns them as a newline-separated list.
InfoBot[input]: A tool that answers questions based on a given context. The input should be a question that refers to an #E[index] variable.

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

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

Response:
Plan: Start by searching online for the inventor of the telephone.
#E1 = GoogleSearch[Inventor of the telephone]
Plan: Use InfoBot to identify the inventor from the search results.
#E2 = InfoBot[Who invented the telephone? Given context: #E1]
Plan: Search online for information about the inventor's motivation.
#E3 = GoogleSearch[Motivation behind inventing the telephone by #E2]
Plan: Use InfoBot to understand the inventor's motivation from the search results.
#E4 = InfoBot[What was the motivation behind inventing the telephone by #E2? Given context: #E3]
Final Answer: #E2, #E4

System: A chat.


Instruction:
Create a sequential plan to solve the following problem, each step must involve calling one of the available tools and storing its output as evidence. You can refer to previously stored evidence in subsequent steps.

Available Tools:
DuckDuckGo[input]: A tool that lets you perform searches on DuckDuckGo. It returns a list of URLs that might contain the answer to your query.
Readability[input]: A tool that extracts readable content from a webpage. Input is a URL and it outputs the main body text of the page.
QAModel[input]: A language model designed to answer questions. It takes a question where the context can reference previous evidence variables.

Output Format:
Plan: [Describe the first step]
#E1 = [Tool to call with input]
Plan: [Describe the next step based on #E1]
#E2 = [Next tool to call with input possibly referencing #E1]
...
Final Answer: #En

Question: Who wrote the book 'To Kill a Mockingbird' and what are some interesting facts about them?

Response:
Plan: Search for the author of 'To Kill a Mockingbird'.
#E1 = DuckDuckGo['To Kill a Mockingbird' author]
Plan: Use QAModel to determine the author from the search results.
#E2 = QAModel[Who wrote 'To Kill a Mockingbird'? Given context: #E1]
Plan: Perform a new search to gather interesting facts about the author.
#E3 = DuckDuckGo[#E2 + ' interesting facts']
Plan: Extract readable content from the top link in the search results.
#E4 = Readability[#E3.split('\n')[0]]
Plan: Use QAModel to extract interesting facts about the author from the readable content.
#E5 = QAModel[What are some interesting facts about #E2? Given context: #E4]
Final Answer: #E5

System: A chat.


Instruction:
Create a step-by-step plan to answer the following user query using the tools provided. Each tool should be used at least once and each plan should have an associated evidence value.

Available Tools:
1. DuckDuckGo[input]: A search engine that can be used to find information on any topic. The input is a string of text, which it uses to return relevant web pages.
2. TextParser[input]: This tool takes in a large amount of text and extracts key pieces of information from it. It's useful for summarizing or extracting specific details from lengthy texts.
3. AskJeeves[input]: This is a question-answering tool that can provide answers to direct questions based on common knowledge or given context.
4. LinkCollector[input]: Extracts all links from a piece of text. Useful when you want to further explore resources mentioned in a document or webpage.

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: #En

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

Response:
Plan: Use a search engine to find out who won the Nobel Prize in Literature in 2020.
#E1 = DuckDuckGo[Nobel Prize in Literature 2020 winner]
Plan: Utilize a question answering tool to extract the name of the winner from the search results.
#E2 = AskJeeves[Who won the Nobel Prize in Literature in 2020? Given context: #E1]
Plan: Search again to get more information about the author's works.
#E3 = DuckDuckGo[#E2 + "most famous works"]
Plan: Extract the links from the search results for further exploration.
#E4 = LinkCollector[#E3]
Plan: Parse the content of these links to identify the author's most famous works.
#E5 = TextParser[#E4]
Plan: Finally, use the question answering tool to summarize the author's most famous works from the parsed text.
#E6 = AskJeeves[What are the most famous works of #E2? Given context: #E5]
Final Answer: #E6

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:
Wikipedia[input]: Tool that allows the user to search for information from Wikipedia.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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]
...
Final answer: #E[n]

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

Response:
Plan: Search for more information about the Battle of Waterloo.
#E1 = Wikipedia[Battle of Waterloo]
Plan: Find out the significance of the Battle of Waterloo.
#E2 = QA[What is the significance of the Battle of Waterloo? Given context: #E1]
Plan: Identify the key figures involved in the Battle of Waterloo.
#E3 = QA[Who were the key figures involved in the Battle of Waterloo? Given context: #E1]
Final answer: The significance of the Battle of Waterloo is #E2 and the key figures involved were #E3.

System: A chat.


Instruction:
Make a plan to determine the most popular tourist attractions in Paris, France.

Available tools:
- TravelGuide[input]: Provides information about popular destinations in a specified location.
- ReviewAnalyzer[input]: Analyzes reviews to determine popularity and satisfaction rates.
- QA[input]: Answers questions using general world knowledge or provided context.
- PopularityMeter[input]: Measures the popularity of a place or thing based on various factors.
- ListSorter[input]: Sorts a list based on certain criteria such as popularity or relevance.

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

Response:
1. **Task: Use TravelGuide[Paris, France]**
    - **Output:** A list of tourist attractions in Paris, France.
2. **Task: Use PopularityMeter[input] for each attraction from the previous step**
    - **Input:** Each tourist attraction obtained from step 1
    - **Output:** Popularity score for each tourist attraction.
3. **Task: Use ReviewAnalyzer[input] for each attraction from step 1**
    - **Input:** Reviews related to each tourist attraction obtained from step 1
    - **Output:** Satisfaction rates for each tourist attraction.
4. **Task: Combine popularity scores and satisfaction rates for each attraction**
    - **Output:** Combined data set with both popularity scores and satisfaction rates for each tourist attraction.
5. **Task: Use ListSorter[input] on the combined data set**
    - **Input:** The combined data set from step 4
    - **Output:** Sorted list of tourist attractions based on popularity scores and satisfaction rates.
6. **Task: Use QA[input] to verify information if necessary**
    - **Input:** Any questions or doubts about the sorted list of tourist attractions
    - **Output:** Answers and clarifications to ensure accuracy of the final list.

The final output would be a verified, sorted list of the most popular tourist attractions in Paris, France based on their popularity scores and satisfaction rates.

System: A chat.


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

Here are the tools you have at your disposal:
WebSearch[input]: This tool allows users to search for information on the internet. It is useful for finding websites that may contain answers to the user's questions. The function does not directly provide answers; it returns a list of sites that might.
TextExtractor[input]: This tool extracts text from a webpage. Input is a URL and output is plain text content of the page.
LinkFinder[input]: Extracts links from plain text and produces a plain text response with newline-separated links.
AIAnswerer[input]: An AI model capable of answering questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., "What is the capital of France, given #E1?"

The input to each function should be a simple string without quotes or "+" to concatenate a string with an evidence variable, e.g., AIAnswerer[Who won the 2019 World Series, given #E2?]

Ensure only one evidence output per plan step.

Output format should be as follows:
Plan: [first action based on input question]
#E0 = [function to call with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function to call and input parameter, possibly including reference to previous evidence, e.g., "Given context #E0"]
...
Final Answer: #E[n], where n is the final evidence number

Question: Who was the first person to reach the summit of Mount Everest and what challenges did they face?

Response:
Plan: Start by conducting a web search to find out who was the first person to reach the summit of Mount Everest.
#E0 = WebSearch[First person to reach the summit of Mount Everest]
Plan: Use the AI model to interpret the search results and identify the name of the first climber.
#E1 = AIAnswerer[Who was the first person to reach the summit of Mount Everest, given #E0?]
Plan: Conduct another web search to find the challenges faced by the identified mountaineer during their climb.
#E2 = WebSearch[Challenges faced by #E1 climbing Mount Everest]
Plan: Extract relevant links from the search results for more detailed information.
#E3 = LinkFinder[#E2]
Plan: Use the TextExtractor tool to get information from the most relevant link.
#E4 = TextExtractor[#E3]
Plan: Finally, use the AI model to summarize the main challenges faced by the first person to reach the summit of Mount Everest from the extracted information.
#E5 = AIAnswerer[What were the main challenges faced by #E1 when climbing Mount Everest, given #E4?]
Final Answer: #E5

System: A chat.


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

Available Tools:
Bing[input]: A tool that allows users to search for information on Bing. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites provided as newline delimited links. The input is one or more links and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The function inputs are just plain strings without quotes or "+" to concatenate a string with an evidence variable.

Output Format:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call and input parameter, referencing previous evidence if necessary]
...
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: Conduct 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 QAModel to identify the winner from the search results.
:evidence1: = QAModel[Who won the Nobel Prize in Literature in 2020? Given context :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified author.
:evidence2: = Bing[Most famous work of :evidence1:]
Plan: Extract relevant links from the search results for further analysis.
:evidence3: = LinkFinder[:evidence2:]
Plan: Extract text from the relevant links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the QAModel to identify and summarize the most famous work of the author from the extracted texts.
:evidence5: = QAModel[What is the most famous work of :evidence1:, given context :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a detailed execution plan utilizing the below mentioned tools. Remember to assign the output of each tool to a unique variable #E[index].

Available Tools:
YahooSearch[input]: Fetches search results related to the query from Yahoo search engine.
WebScraper[input]: Scrapes the webpage(s) provided as input and returns the text content.
LinkHarvester[input]: Extracts all the hyperlinks present in the input text.
BOB[input]: An AI model capable of answering questions when provided with a context.

Output Format:
Plan: [First Action]
#E1 = [Tool name with input]
Plan: [Subsequent actions based on prior results]
#E2 = [Next tool name with input possibly referencing prior evidences]
...
Final Answer: #E[n]

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

Response:
Plan: Initiate a search for the history of the Eiffel Tower.
#E1 = YahooSearch[Eiffel Tower History]
Plan: Extract the useful links from the search results.
#E2 = LinkHarvester[#E1]
Plan: Scrape the webpages linked in the search results.
#E3 = WebScraper[#E2]
Plan: Utilize BOB to get a summarized history of the Eiffel Tower.
#E4 = BOB[What is the history behind the Eiffel Tower? Given context: #E3]
Plan: Conduct another search focusing on the construction process of the Eiffel Tower.
#E5 = YahooSearch[Eiffel Tower Construction]
Plan: Extract the useful links from these search results.
#E6 = LinkHarvester[#E5]
Plan: Scrape the webpages linked in these search results.
#E7 = WebScraper[#E6]
Plan: Utilize BOB to understand the construction process of the Eiffel Tower.
#E8 = BOB[How was the Eiffel Tower constructed? Given context: #E7]
Final Answer: #E4 and #E8

System: A chat.


Instruction:
Generate an execution plan to answer the user's question by utilizing the tools at hand. Store the output of each tool in a variable :evidence[n]:

Tools available:
Bing[input]: A tool that enables the user to perform a Bing search. Input is a search string.
WebScraper[input]: Loads websites from the input string containing newline-delimited links. Produces plain text output containing the content of the links.
LinkFinder[input]: Finds links within plain text and returns them as a newline-delimited list.
AIModel[input]: An AI model capable of answering questions based on an input passage of text.

Output format:
Plan: [action based on input question]
:evidence0: = [tool to call with input]
Plan: [next action, based on result of :evidence0:]
:evidence1: = [next tool to call with input, possibly referencing prior evidence]
...
Answer: [:evidence[n]: containing final answer.]

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

Response:
Plan: Start by performing 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 AI model to interpret the search results and identify the winner.
:evidence1: = AIModel[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Conduct another web search to find the notable works of the identified laureate.
:evidence2: = Bing[:evidence1: notable works]
Plan: Extract relevant links from the search results for detailed information.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use the WebScraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the AI model to summarize the notable works of the laureate from the extracted information.
:evidence5: = AIModel[What are the notable works of :evidence1:, given :evidence4:?]
Answer: :evidence5:

(Continued in next part due to character limit.)

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a general web search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
DataExtractor[input]: Extracts structured data from unstructured text. The function takes as input a piece of text and outputs structured data related to the query.
InfoQA[input]: Question answering tool particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :data[n]: variable.
NewsAPI[input]: Retrieves news articles relevant to the input query. It provides a list of links to news articles.

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

Question: What are some recent scientific breakthroughs in the field of quantum computing?

Response:
Plan: Begin by conducting a web search to find out about recent breakthroughs in quantum computing.
:data0: = WebSearch[Recent breakthroughs in quantum computing]
Plan: Utilize the InfoQA tool to interpret the search results and summarize the breakthroughs.
:data1: = InfoQA[What are the recent breakthroughs in quantum computing, given :data0:?]
Plan: Conduct another web search to find news articles related to these breakthroughs.
:data2: = NewsAPI[:data1:]
Plan: Use the DataExtractor tool to extract detailed information from the news articles.
:data3: = DataExtractor[:data2:]
Plan: Finally, utilize the InfoQA tool to identify and summarize the key details of the breakthroughs from the extracted information.
:data4: = InfoQA[What are the details of the breakthroughs mentioned in :data1:, given :data3:?]
Answer: :data4:

System: A chat.


Instruction:
Generate a step-by-step plan to answer the following user query using the tools provided. Each tool should be used at least once and each plan must 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 mixture of both.

Available Tools:
Bing[input]: A tool that allows the user to search for information on Bing. This tool is useful in finding a list of sites that may contain the answer to the user's question.
PageLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of URLs.
SAM[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output format should be as follows:
Plan: [first action]
:evidence0: = [function with input parameter]
Plan: [next action]
:evidence1: = [next function with input parameter]
...
Answer: [:evidence[n]:]

Question: Who won the Nobel Prize in Literature in 2019 and what are some of their most popular works?

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2019.
:evidence0: = Bing[Nobel Prize in Literature 2019 winner]
Plan: Use SAM to interpret the search results and identify the winner.
:evidence1: = SAM[Who won the Nobel Prize in Literature in 2019, given :evidence0:?]
Plan: Conduct another web search to find the most popular works of the identified laureate.
:evidence2: = Bing[Most popular works of :evidence1:]
Plan: Extract relevant URLs from the Bing search results for further investigation.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use PageLoader to extract information from the relevant URLs.
:evidence4: = PageLoader[:evidence3:]
Plan: Finally, use SAM to summarize the most popular works of the laureate from the extracted information.
:evidence5: = SAM[What are the most popular works of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a plan to describe the structure of DNA.

Tools available:
BioInfoSearch[input]: Searches for biological information related to the input.
StructureSketcher[input]: Sketches structures based on the input context.
InDepthQA[input]: Gives in-depth answers to questions based on the input.
ScientificDataCollector[input]: Collects scientific data related to the input.
SummaryCreator[input]: Creates a summary based on the input context.

Output format:
Plan: Initial step
#Data1 = Function with input parameter
Plan: Next step
#Data2 = Next function with input parameter
...
Final Description: #Data[n]

Response:
Plan: Start by collecting scientific data on the structure of DNA.
#Data1 = ScientificDataCollector["DNA Structure"]

Plan: Search for more specific biological information related to DNA structure.
#Data2 = BioInfoSearch["DNA Structure"]

Plan: Sketch a visual representation of the DNA structure using the gathered information.
#Data3 = StructureSketcher[#Data1 and #Data2]

Plan: Use InDepthQA to answer potential questions about the structure of DNA, such as its double helix formation, base pairing rules, etc.
#Data4 = InDepthQA["Questions about DNA structure"]

Plan: Finally, create a comprehensive summary of the DNA structure including visuals and in-depth answers to common questions.
Final Description: SummaryCreator[#Data3 and #Data4]

System: A chat.


Instruction:
Provide a systematic plan to answer the following question utilizing the resources at your disposal. Each step should involve one of the available tools, and the output of each tool should be stored in a variable #E[index] for future reference.

Available Tools:
GoogleScholar[input]: A tool that searches academic papers and scholarly articles. The input should be a research topic or query, and the output will be a list of relevant academic sources.
PDFExtractor[input]: A tool that extracts text from a PDF file. The input should be a link to a PDF file, and the output will be the full text of the PDF.
NLP[input]: A natural language processing tool that can understand and answer questions based on a given context. The input should be a question and some context, and the output will be an answer to the question.

Format:
Plan: [First Action]
#E1 = [Tool with Input Parameter]
Plan: [Next Action]
#E2 = [Next Tool with Input Parameter]
...
Final Answer: #E[n]

Question: What is the latest research on the effects of climate change on polar bear populations?

Response:
Plan: Search Google Scholar for recent academic papers on the effects of climate change on polar bear populations.
#E1 = GoogleScholar[Effects of climate change on polar bear populations]
Plan: Extract the text from the most relevant academic paper.
#E2 = PDFExtractor[#E1]
Plan: Use NLP to find the key findings of the paper regarding the effects of climate change on polar bear populations.
#E3 = NLP[What are the key findings of the paper on the effects of climate change on polar bear populations? Given context: #E2]
Final Answer: #E3

System: A chat.


Instruction:
Develop a strategy to respond to the following query using the available resources. For each stage in your strategy, specify which external tool you would use along with the corresponding input. Store the outcome into an evidence variable (#E[index]) that can be referenced later.

Tools Available:
DuckDuckGo[input]: A tool that lets users perform searches using DuckDuckGo. This tool provides a list of sites that might contain the answer to the user's question.
SiteScraper[input]: Loads one or more websites from the input string (containing newline delimited links), producing plain text output containing the content of the pages.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline-delimited response of URLs.
QAModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., "What color is the cat, given :evidence1:?"

The output format should be as follows:
Plan: [first action]
:evidence0: = [function to call with input parameter]
Plan: [next action, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may 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: Begin 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 contributions made by the identified laureate.
:evidence2: = DuckDuckGo[:evidence1: Nobel Prize contribution]
Plan: Extract the relevant links from the DuckDuckGo search results.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use SiteScraper to extract information from the relevant links.
:evidence4: = SiteScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the key contributions made by the laureate from the extracted information.
:evidence5: = QAModel[What were the contributions of :evidence1: that led to the Nobel Prize, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please provide a detailed plan to solve the following problem, using the tools provided. For each step of your plan, specify which tool you will use and what input you will give it. You can store the output from each tool in a variable :E[index] that can be used as input for subsequent steps.

Here are the tools available:

SearchEngine[input]: This tool allows you to search the internet for information on any topic. The input should be a string containing the query. The output is a list of links that may contain relevant information.
TextExtractor[input]: This tool extracts all text content from a given URL. The input should be a single URL, and the output is a plain text version of the webpage's content.
QA[input]: This tool can answer questions based on general knowledge or given context. The input should be a question, optionally followed by "Given context: :E[n]" where n is the index of a previous evidence.
ImageFinder[input]: This tool finds images related to a given input. The input should be a string describing what you're looking for, and the output is a link to an image.
Translate[input]: This tool translates a given text into English. The input should be a string in any language, and the output is the translated text in English.

The output should follow this format:
Plan: [description of the first action]
:E1 = [tool to call with input parameter]
Plan: [description of the next action, based on the result of :E1]
:E2 = [next tool to call with input parameter, possibly referencing previous evidence like ":E1"]
...
Final Answer: :En

Question: What is the significance of Mona Lisa painting and who painted it? Also find an image of the painting.

Response:
Plan: Use the SearchEngine tool to find information about the Mona Lisa painting.
:E1 = SearchEngine[Mona Lisa painting]
Plan: Extract the text content from the most relevant link found in the search results.
:E2 = TextExtractor[:E1]
Plan: Use the QA tool to find out who painted the Mona Lisa and its significance, using the extracted text as context.
:E3 = QA[Who painted the Mona Lisa and what is its significance? Given context: :E2]
Plan: Use the ImageFinder tool to find an image of the Mona Lisa painting.
:E4 = ImageFinder[Mona Lisa painting]
Final Answer: :E3 and :E4

System: A chat.


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

Here are the tools you can use:
SearchEngine[input]: This tool allows users to search for information on the internet. It doesn't directly provide answers but offers a list of websites that might contain the needed information.
WebScraper[input]: This tool extracts plain text from one or more websites provided in the input string (links separated by newline).
LinkExtractor[input]: This tool pulls out links from any given plain text and provides a plain text response with newline-separated links.
QAEngine[input]: A tool capable of answering questions based on common knowledge as well as specific context derived from prior evidence. The input should be a question that may reference an :evidence[n]: variable.

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

Remember to include only one evidence output per plan step.

Output format:
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, potentially referencing previous evidence like "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

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

Response:
Plan: Start by conducting an online search to find out the current population of Tokyo.
:evidence0: = SearchEngine[Current population of Tokyo]
Plan: Use the QAEngine to interpret the search results and determine the population.
:evidence1: = QAEngine[What is the current population of Tokyo, given :evidence0:?]
Plan: Conduct another online search to find popular tourist attractions in Tokyo.
:evidence2: = SearchEngine[Popular tourist attractions in Tokyo]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Utilize the WebScraper tool to extract information from these selected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, employ the QAEngine to identify and summarize the popular tourist attractions in Tokyo from the scraped data.
:evidence5: = QAEngine[What are some popular tourist attractions in Tokyo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to respond to the following inquiry using the provided tools. Each stage of the plan should have a corresponding piece of evidence, which is the output of one of the available functions. This could be the user's question, prior evidence, or a combination of both.

These are the tools you can use:
YahooSearch[input]: This tool lets the user search for information via Yahoo. It returns a list of sites that might contain the answer to the user's question.
SiteReader[input]: This tool loads one or more websites from an input string (containing newline-separated links), producing plain text output with the contents of those links.
LinkCollector[input]: This tool extracts links from plain text, returning a plain text, newline-separated list of links.
AIQA[input]: An AI-powered question-answering tool that responds to queries based on an input text passage. The input must be a text question that refers to an :evidence[n]: variable, such as "What is the lifespan of a turtle, given :evidence1:?"

Each function's input should be a simple string, without quotation marks or "+" to combine a string with an evidence variable, like AIQA[What is the lifespan of a goldfish, given :evidence3:?]

Only one piece of evidence should be included per plan step.

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

Question: What is the process of photosynthesis and why is it important for life on Earth?

Response:
Plan: Start by performing a web search to find information about the process of photosynthesis.
:evidence0: = YahooSearch[Process of photosynthesis]
Plan: Use the SiteReader tool to extract information from the top links returned by the search.
:evidence1: = SiteReader[:evidence0:]
Plan: Use the AIQA tool to interpret the extracted information and describe the process of photosynthesis.
:evidence2: = AIQA[What is the process of photosynthesis, given :evidence1:?]
Plan: Perform another web search to find information about the importance of photosynthesis for life on Earth.
:evidence3: = YahooSearch[Importance of photosynthesis for life on Earth]
Plan: Use the LinkCollector tool to gather the most relevant links from the search results.
:evidence4: = LinkCollector[:evidence3:]
Plan: Use the SiteReader tool again to extract information from these selected links.
:evidence5: = SiteReader[:evidence4:]
Plan: Lastly, use the AIQA tool to interpret the extracted information and explain why photosynthesis is important for life on Earth.
:evidence6: = AIQA[Why is photosynthesis important for life on Earth, given :evidence5:?]
Answer: :evidence6:

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:
WebSearch[input]: Tool that allows the user to search for information using a general web search engine. This tool is useful in finding a list of sites that may contain the answer to the user's query.
ContentScraper[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 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: = WebSearch[Nobel Prize in Physics 2020 winner]
Plan: Use a language model to interpret the search results and find the name of the laureate.
: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: = WebSearch[:evidence1: Nobel Prize winning contribution]
Plan: Extract the relevant links from the web search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = ContentScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and 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 plan to answer the following question using the tools provided. Each step in your plan should be followed by an evidence value that corresponds to the output of one of the available functions given an input string, which can be the user's query, previous evidence values, or both.

Here are the tools you have at your disposal:
WebSearch[input]: A tool that allows the user to search for information on the internet. The function does not directly provide answers but gives a list of websites that may contain the required information.
TextExtractor[input]: Extracts text from web pages based on a newline delimited list of links as input and produces plain text content of these links.
LinkFilter[input]: Filters out irrelevant links from a newline delimited list of links and provides a more focused list of links.
AskJeeves[input]: A tool that answers questions based on general knowledge or context provided. The input must be a question that references an :evidence[n]: variable, e.g., What is the population of Paris, given :evidence1:?

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

Each plan step should only include one evidence output.

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

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

Response:
Plan: Start by conducting a web search to find out who won the 2020 Nobel Prize in Physics.
:evidence0: = WebSearch[2020 Nobel Prize in Physics winner]
Plan: Use AskJeeves to interpret the search results and identify the winner.
:evidence1: = AskJeeves[Who won the 2020 Nobel Prize in Physics, given :evidence0:?]
Plan: Conduct another web search to find information about the scientific contributions of the identified laureate.
:evidence2: = WebSearch[:evidence1: scientific contributions]
Plan: Filter out irrelevant links from the search results for a more targeted investigation.
:evidence3: = LinkFilter[:evidence2:]
Plan: Use TextExtractor to extract relevant information from the filtered links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use AskJeeves to summarize the key scientific contributions of the laureate from the extracted information.
:evidence5: = AskJeeves[What were the key scientific contributions of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Devise a consecutive plan to meet the user mandate, harnessing the presented array of tools. Each plan will correlate with an evidence value, which is the output of one of the specified functions when furnished an input string that could be the user's question, former evidence values, or a blend of both.

Presented tools:
InfoSeek[input]: Tool allowing the user to delve for information via InfoSeek search engine. This tool is advantageous in discovering a spectrum of sites that may harbor the answer to the user's question.
WebExtractor[input]: Seizes one or more websites from the input string embodying newline-broken links. The input is one or more links, culminating in plain text output enveloping the content of the links.
LinkSnatcher[input]: Nabs links from plain text, delivering a plain text, newline-separated directory of links.
QAProcessor[input]: Question-answering language model, notably proficient in addressing questions premised on an input text passage. The input has to be a text-based question that denotes an :evidence[n]: variable.

Output format:
Plan: [Outset action cemented in input question]
:evidence0: = [Function to initiate with input parameter]
Plan: [Subsequent action reliant on result of :evidence0:]
:evidence1: = [Successive function to initiate and input parameter, likely signifying prior evidence, e.g., "Pertaining to :evidence0:"]
...
Finalized Response: [:evidence[n]: owning the conclusive answer]

Question: Who painted the artwork 'Starry Night' and what other artworks have they created?

Response:
Plan: Commence by executing a web search to learn who painted 'Starry Night'.
:evidence0: = InfoSeek['Starry Night' painter]
Plan: Wield QAProcessor to dissect the search results and spot the painter.
:evidence1: = QAProcessor[Who painted 'Starry Night', regarding :evidence0:?]
Plan: Trigger another web search to detect other artworks created by the spotted painter.
:evidence2: = InfoSeek[Other artworks created by :evidence1:]
Plan: Amass the fitting links from the InfoSeek search results for a complete search.
:evidence3: = LinkSnatcher[:evidence2:]
Plan: Operate WebExtractor to secure information from the amassed links.
:evidence4: = WebExtractor[:evidence3:]
Plan: Eventually, turn to QAProcessor to distinguish and distill the other artworks created by the painter from the secured information.
:evidence5: = QAProcessor[What other artworks were created by :evidence1:, concerning :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question using the tools provided. For each step, indicate which tool will be used and what input it will receive. You can store the results of each tool in a variable #E[index] that can be referred to in later steps.

The available tools are:
WebSearch[input]: A tool that performs an internet search based on the given input.
ReadArticle[input]: A tool that reads an online article from a given URL and provides a summary of its content.
QA[input]: A tool that answers questions based on general knowledge or specific context provided as part of the input.
ExtractLinks[input]: A tool that extracts all URLs from a given text.

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

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

Response:
Plan: Conduct a web search to find out the tallest building in New York City.
#E1 = WebSearch[Tallest building in New York City]
Plan: Use QA tool to extract the name of the tallest building from the search results.
#E2 = QA[What is the tallest building in New York City? Given context: #E1]
Plan: Perform another web search to find more information about the tallest building.
#E3 = WebSearch[#E2]
Plan: Extract links from the search results for detailed information.
#E4 = ExtractLinks[#E3]
Plan: Read one of the articles linked for more detailed information.
#E5 = ReadArticle[#E4]
Plan: Use QA tool to determine when the tallest building was built from the article.
#E6 = QA[When was #E2 built? Given context: #E5]
Final Answer: #E6

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine. This tool is useful in finding an appropriate list of sites that may include the answer to the user's question.
TextExtractor[input]: Extracts plain text from a website URL provided as input and produces a plain text output containing the content of the link.
QAEngine[input]: A powerful question answering tool that uses AI to provide direct answers to questions based on general world knowledge or specific context provided.
LinkPicker[input]: Picks the most relevant links from a list of URLs provided as input.
InfoProcessor[input]: Processes a passage of text and extracts key pieces of information related to a specific query.

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

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

Response:
Plan: Start by conducting a web search to find out about the history of the Eiffel Tower.
#E1 = WebSearch[Eiffel Tower History]
Plan: Use LinkPicker to select the most relevant links from the search results.
#E2 = LinkPicker[#E1]
Plan: Extract the text from the selected links.
#E3 = TextExtractor[#E2]
Plan: Utilize QAEngine to interpret the extracted text and summarize the history of the Eiffel Tower.
#E4 = QAEngine[What is the history of the Eiffel Tower? Given context: #E3]
Plan: Conduct another web search to find out about the materials used in the construction of the Eiffel Tower.
#E5 = WebSearch[Materials used in Eiffel Tower construction]
Plan: Select the most relevant links from the new search results.
#E6 = LinkPicker[#E5]
Plan: Extract the text from these selected links.
#E7 = TextExtractor[#E6]
Plan: Finally, utilize InfoProcessor to identify and summarize the materials used in the construction of the Eiffel Tower from the extracted information.
#E8 = InfoProcessor[What materials were used in the construction of the Eiffel Tower? Given context: #E7]
Final Answer: The history of the Eiffel Tower is summarized in #E4 and the materials used in its construction are detailed in #E8.

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. Each step of your plan should be accompanied by an evidence variable that captures the output of the tool used in that step.

Here are the available tools:
1. WebSearch[input]: This tool allows you to perform a web search with any given input string. The results can be a list of websites or articles that may contain the answer to your query.
2. TextExtractor[input]: This tool extracts plain text from one or more URLs provided as newline-separated strings in the input.
3. LinkCollector[input]: This tool collects all the links present in a given piece of text and outputs them as newline-separated strings.
4. QAModel[input]: This is a question-answering model that can provide answers based on a given context. The input must be a question that references an :evidence[n]: variable, e.g., "What is the capital of France, given :evidence1:?"

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

Question: What is the most populated city in Canada and what is its main industry?

Response:
Plan: Conduct a web search to find out the most populated city in Canada.
:evidence0: = WebSearch[Most populated city in Canada]
Plan: Use the question answering model to identify the city from the search results.
:evidence1: = QAModel[What is the most populated city in Canada, given :evidence0:?]
Plan: Perform another web search to find out the main industry in the identified city.
:evidence2: = WebSearch[Main industry in :evidence1:]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = LinkCollector[:evidence2:]
Plan: Extract information from the collected links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the question answering model to identify the main industry in the city from the extracted information.
:evidence5: = QAModel[What is the main industry in :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools you have at your disposal:
Bing[input]: This tool allows users to search for information using the Bing search engine. It is useful for finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: This tool loads one or more websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
LinkExtractor[input]: This tool extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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

Response:
Plan: Start by conducting a web search to find out about popular tourist attractions in Paris.
:evidence0: = Bing[Popular tourist attractions in Paris]
Plan: Use a link extractor to gather relevant links from the search results.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Utilize a web scraper to extract information from these links.
:evidence2: = WebScraper[:evidence1:]
Plan: Apply the QAModel to identify popular tourist attractions in Paris from the extracted information.
:evidence3: = QAModel[What are some popular tourist attractions in Paris, given :evidence2:?]
Plan: Conduct another web search to find the historical significance of each identified attraction.
:evidence4: = Bing[Historical significance of :evidence3:]
Plan: Extract the relevant links from the Bing search results for detailed information.
:evidence5: = LinkExtractor[:evidence4:]
Plan: Use the web scraper again to extract detailed information from these links.
:evidence6: = WebScraper[:evidence5:]
Plan: Finally, apply the QAModel to summarize the historical significance of each attraction from the scraped information.
:evidence7: = QAModel[What is the historical significance of :evidence3:, given :evidence6:?]
Answer: :evidence7:

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

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

Question: What is the population of New York City and what languages are most commonly spoken there?

Response:
Plan: Start by conducting a web search to find out the current population of New York City.
:evidence0: = SearchEngine[Current population of New York City]
Plan: Use the QAModel to interpret the search results and find the population figure.
:evidence1: = QAModel[What is the current population of New York City, given :evidence0:?]
Plan: Conduct another web search to find the most commonly spoken languages in New York City.
:evidence2: = SearchEngine[Most commonly spoken languages in New York City]
Plan: Extract the relevant links from the search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the WebScraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the QAModel to identify and summarize the most commonly spoken languages in New York City from the extracted information.
:evidence5: = QAModel[What are the most commonly spoken languages in New York City, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to answer the user's question using the tools provided. Each step in the plan should have corresponding evidence produced by one of the tools. The evidence is represented as :evidence[n]:

Tools Available:
DuckDuckGo[input]: A tool that performs a search using DuckDuckGo search engine.
Readability[input]: A tool that summarizes the main points from a long piece of text.
LLM[input]: A language model that can answer questions when given a passage of text as context.
LinkCollector[input]: A tool that collects all the links from a given piece of text.

Output Format:
Plan: [Description of the first action]
:evidence0: = [First function call with input]
Plan: [Description of the second action]
:evidence1: = [Second function call with input]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the 2020 Nobel Prize in Literature?

Response:
Plan: Perform a web search to find out who won the 2020 Nobel Prize in Literature.
:evidence0: = DuckDuckGo[2020 Nobel Prize in Literature winner]
Plan: Collect all the links from the search results.
:evidence1: = LinkCollector[:evidence0:]
Plan: Summarize the main points from the collected links.
:evidence2: = Readability[:evidence1:]
Plan: Utilize the language model to extract the name of the winner from the summarized text.
:evidence3: = LLM[Who won the 2020 Nobel Prize in Literature, given :evidence2:?]
Answer: :evidence3:

(Note: Continue this pattern for eight more unique instruction/response pairs.)

System: A chat.


Instruction:
Create a systematic plan to solve the following problem. You can make use of any of the tools listed below. For each step in your plan, indicate the tool you would use and the input you would give it. Store the output of each tool in a variable #E[index].

Available Tools:
GoogleSearch[input]: Searches Google for the input query and returns a list of potential sources.
ReadPage[input]: Reads the full text of a webpage specified by the input URL.
AskJeeves[input]: A tool that answers questions based on general knowledge and specific context provided as input.
ExtractLinks[input]: Takes a block of text as input and extracts any URLs contained within.

Output Format:
Plan: [Description of the first step]
#E1 = [Tool used and its input]
Plan: [Description of the next step, possibly referencing the output of the previous step]
#E2 = [Next tool and its input]
...
Final Answer: #En

Question: How did the invention of the steam engine impact industrialization?

Response:
Plan: Begin by searching for general information on the impact of the steam engine on industrialization.
#E1 = GoogleSearch[Impact of steam engine on industrialization]
Plan: Extract all the links from the search results for further investigation.
#E2 = ExtractLinks[#E1]
Plan: Read the full text of the most promising source.
#E3 = ReadPage[#E2]
Plan: Ask Jeeves to summarize the impact of the steam engine on industrialization based on the information obtained.
#E4 = AskJeeves[How did the invention of the steam engine impact industrialization? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
For the following task, create a step-by-step plan to generate an ideal response using the available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Here are the tools available to be called:
GoogleMaps[input]: Tool that allows the user to search for geographical information and distances between locations.
Wikipedia[input]: Tool that allows the user to search for factual information from Wikipedia.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge or answering questions given input context that may contain the answer.
WeatherAPI[input]: Tool that provides weather forecasts for specific locations.
FlightTracker[input]: Tool that provides real-time flight status and tracking.

Question: What is the distance between London and Paris, what's the current weather in both cities, and are there any flights delayed between these two cities?

Response:
Step 1: Use the GoogleMaps tool with the input "Distance between London and Paris" to find out the distance between these two cities.
    - Input: "Distance between London and Paris"
    - Tool: GoogleMaps

Step 2: Use the WeatherAPI tool twice, once for each city, to get the current weather in both locations.
    - Input: "London"
    - Tool: WeatherAPI
    - Input: "Paris"
    - Tool: WeatherAPI

Step 3: Use the FlightTracker tool with the input "Flights from London to Paris" to check if there are any delayed flights between these two cities.
    - Input: "Flights from London to Paris"
    - Tool: FlightTracker

System: A chat.


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

Available Tools:
1. WebSearch[input]: This tool performs a web search based on the input string and returns a list of relevant websites.
2. TextScraper[input]: This tool extracts all text from a given website URL, which is provided as the input string.
3. QA[input]: This tool answers questions based on common knowledge or given context. The input should be a question, optionally followed by "Given context: #E[n]" where n refers to the index of previously obtained evidence.
4. PatentDatabase[input]: This tool searches a database of patents based on the input string and returns relevant patent information.
5. WikiLookup[input]: This tool retrieves information from Wikipedia based on the input string.

The output format should be:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action based on result of #E1]
#E2 = [next function call with input parameter]
...
Final answer: #E[n]

Question: Who invented the steam engine and what were some of their notable inventions?

Response:
Plan: Start by looking up who invented the steam engine.
#E1 = WikiLookup[steam engine]
Plan: Extract the inventor's name from the information retrieved.
#E2 = QA[Who invented the steam engine? Given context: #E1]
Plan: Search for more detailed information about the inventor.
#E3 = WebSearch[#E2]
Plan: Extract text from the most relevant website found.
#E4 = TextScraper[#E3]
Plan: Identify other notable inventions by this person.
#E5 = QA[What are some notable inventions by #E2? Given context: #E4]
Plan: Verify and find additional details about these inventions from the patent database.
#E6 = PatentDatabase[#E5]
Plan: Summarize the information about the inventions.
#E7 = QA[Can you summarize the key features of the inventions #E5? Given context: #E6]
Final answer: #E7

System: A chat.


Instruction:
Create a sequential plan to respond to the following user query utilizing the provided tools. Each plan should correspond to an evidence value, which would be the output of a function given an input string.

Available tools:
DuckDuckGo[input]: A tool that enables users to perform internet searches via DuckDuckGo.
URLExtractor[input]: This tool extracts URLs from any given plaintext input.
WebReader[input]: This tool reads and converts webpage contents into plaintext from a given URL.
KnowledgeEngine[input]: A language model designed to answer questions based on context provided as input. It requires a question referencing an :Evidence[n]: variable.

Output Format:
Plan: [Initial course of action]
:Evidence0: = [Function to execute with its input]
Plan: [Subsequent course of action]
:Evidence1: = [Next function to execute with its input, possibly referring to prior Evidence]
…
Final Answer: [:Evidence[n]: Containing the ultimate answer]

Question: Who wrote the book "To Kill a Mockingbird" and what other works did they author?

Response:
Plan: Conduct an initial internet search to determine who authored "To Kill a Mockingbird".
:Evidence0: = DuckDuckGo["Author of To Kill a Mockingbird"]
Plan: Apply KnowledgeEngine to interpret the search results and ascertain the author's name.
:Evidence1: = KnowledgeEngine[Who wrote "To Kill a Mockingbird", given :Evidence0:?]
Plan: Perform another internet search to uncover other works written by this author.
:Evidence2: = DuckDuckGo["Other works by :Evidence1:"]
Plan: Use URLExtractor to isolate pertinent links from the search results.
:Evidence3: = URLExtractor[:Evidence2:]
Plan: Deploy WebReader to convert the website contents into plaintext.
:Evidence4: = WebReader[:Evidence3:]
Plan: Lastly, apply KnowledgeEngine to discern and summarize the other works penned by the author from the obtained information.
:Evidence5: = KnowledgeEngine[What other books were written by :Evidence1:, given :Evidence4:?]
Final Answer: :Evidence5:

System: A chat.


Instruction:
Create a sequential plan to address the user query using the below-mentioned tools. Each step will result in an evidence variable that could be referenced in subsequent steps.

Tools Available:
DuckDuckGo[input]: Search tool using DuckDuckGo search engine. It doesn't provide direct answers but lists potential sites having the required information.
URLReader[input]: Reads one or multiple websites from the input string containing newline separated links. Input is one or more links and it outputs plain text content of those links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and returns them in a newline-separated manner.
NLPAnswerer[input]: Natural Language Processing model capable of answering queries based on an input text passage.

Output Format:
Plan: [Initial Action]
:Evidence0: = [Function Call with Parameter]
Plan: [Next Step Based on :Evidence0:]
:Evidence1: = [Subsequent Function Call with Parameter, might refer back to previous Evidence]
...
Answer: [:EvidenceN:, which contains the final answer.]

Question: Who was the architect behind the design of Sydney Opera House and what other significant buildings did they design?

Response:
Plan: Initiate a web search to determine the architect of Sydney Opera House.
:Evidence0: = DuckDuckGo[Architect of Sydney Opera House]
Plan: Employ NLPAnswerer to parse the search results and identify the architect's name.
:Evidence1: = NLPAnswerer[Who designed the Sydney Opera House? Given context: :Evidence0:?]
Plan: Perform another web search to discover other significant buildings designed by the named architect.
:Evidence2: = DuckDuckGo[Significant buildings designed by :Evidence1:]
Plan: Utilize HyperlinkExtractor to derive relevant links from the search results for further examination.
:Evidence3: = HyperlinkExtractor[:Evidence2:]
Plan: Deploy URLReader to fetch data from the derived links.
:Evidence4: = URLReader[:Evidence3:]
Plan: Lastly, use NLPAnswerer to outline the key buildings designed by the architect from the fetched data.
:Evidence5: = NLPAnswerer[What are the significant buildings designed by :Evidence1:, given context: :Evidence4:?]
Answer: :Evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAEngine[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: = Bing[Major accomplishments of Albert Einstein]
Plan: Use LinkExtractor to get relevant links from the search results.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Use WebScraper to extract information from the relevant links.
:evidence2: = WebScraper[:evidence1:]
Plan: Finally, utilize QAEngine to identify and summarize the major accomplishments of Albert Einstein from the extracted information.
:evidence3: = QAEngine[What are some major accomplishments of Albert Einstein? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
For the following task, generate a step-by-step plan to solve it. The tools available are:
GoogleSearch[input]: This tool allows you to search for information using Google.
Wikipedia[input]: This tool lets you find information from Wikipedia.
QA[input]: A tool that can answer questions based on common sense and general world knowledge.
Scraper[input]: Load one or more websites from the input string containing newline delimited links.
LinkExtractor[input]: Extracts links from plain text.

Question: What is the historical significance of the Colosseum in Rome?

Response:
Step 1: Use the Wikipedia tool with input "Colosseum" to get a general overview of the historical significance of the Colosseum in Rome.
Step 2: From the information gathered, identify key points about its historical significance.
Step 3: If more detailed or specific information is needed, use GoogleSearch tool with inputs like "Historical significance of the Colosseum".
Step 4: Analyze the search results and find reliable sources that provide more details on the topic.
Step 5: Use Scraper tool to load these websites and extract relevant information regarding the historical significance of the Colosseum.
Step 6: Summarize the findings from all the sources.
Step 7: If there are any uncertainties or ambiguities, use QA tool to answer questions based on common sense and general world knowledge.
Step 8: Compile all the information into a comprehensive explanation of the historical significance of the Colosseum in Rome.

System: A chat.


Instruction:
Generate a step-by-step plan to address the following question using the available tools. Each stage of your plan should correspond to an evidence value, which represents the output of one of the available functions given an input string that might be the user question, one or more prior evidence values, or a mix of both.

Tools at your disposal:
YahooSearch[input]: Allows users to search for information using Yahoo's search engine. Useful for locating a range of sites that may contain the answer to the user's question.
HyperlinkGatherer[input]: Extracts hyperlinks from plain text and returns them as a plain text, newline-separated list of links.
WebsiteParser[input]: Retrieves the content of one or more websites from an input string containing newline-separated links.
InfoModel[input]: A language model capable of answering questions based on a supplied passage of text. The input must be a textual question referencing an :evidence[n]: variable.

The output should follow this format:
Plan: [Initial action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, possibly referring to earlier evidence]
...
Answer: [:evidence[n]: Contains the final answer]

Question: What are the main ingredients used in making traditional Italian lasagna?

Response:
Plan: Initiate a web search to find the recipe for traditional Italian lasagna.
:evidence0: = YahooSearch[Traditional Italian lasagna recipe]
Plan: Utilize InfoModel to interpret the search results and locate a reliable recipe source.
:evidence1: = InfoModel[What is a reliable source for a traditional Italian lasagna recipe, given :evidence0:?]
Plan: Extract the relevant links from the Yahoo search results for detailed examination.
:evidence2: = HyperlinkGatherer[:evidence1:]
Plan: Use WebsiteParser to pull information from the chosen links.
:evidence3: = WebsiteParser[:evidence2:]
Plan: Finally, employ InfoModel to identify and list the main ingredients required for traditional Italian lasagna from the parsed data.
:evidence4: = InfoModel[What are the main ingredients in the recipe found in :evidence3:?]
Answer: :evidence4:

System: A chat.


Instruction:
Please develop a plan to answer the following question using the tools provided. For each step in your plan, indicate which tool you will use and what input you will provide to that tool. You can store the output of each tool into a variable #E[index] for reference in later steps.

Here are the available tools:
SearchEngine[input]: A tool that allows the user to search for information on the internet. The input should be a query string related to the information needed.
ArticleReader[input]: This tool reads articles from the given URL(s) and provides the text content as output.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, or answering questions given input context that may contain the answer.

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

Question: What is the history of the Eiffel Tower and who designed it?

Response:
Plan: Search for more information about the Eiffel Tower.
#E1 = SearchEngine[Eiffel Tower]
Plan: Extract useful links from the search results.
#E2 = LinkExtractor[#E1]
Plan: Read articles from the extracted links.
#E3 = ArticleReader[#E2]
Plan: Find out the history of the Eiffel Tower.
#E4 = QA[What is the history of the Eiffel Tower? Given context: #E3]
Plan: Find out who designed the Eiffel Tower.
#E5 = QA[Who designed the Eiffel Tower? Given context: #E3]
Final answer: #E4 and #E5

System: A chat.


Instruction:
Create a plan to solve the user's question using the provided tools. For each step, specify the tool used and its input, storing the result in an evidence variable.

Tools Available:
WikiLookup[input]: Searches Wikipedia for information related to the input query.
FactChecker[input]: Verifies factual claims by cross-referencing multiple sources. Input should be a claim to verify.
QAModel[input]: Answers questions using common sense, world knowledge, or given context. The input should be a question, possibly referencing previous evidence.
ImageSearch[input]: Finds images related to the input query.

Output Format:
Plan: [first action]
:Evidence0: = [tool with input]
Plan: [next action]
:Evidence1: = [tool with input, possibly referencing :Evidence0:]
...
Answer: [:EvidenceN:]

Question: Who was the first person to climb Mount Everest and are there any pictures of him during the expedition?

Response:
Plan: Search Wikipedia for information about the first person to climb Mount Everest.
:Evidence0: = WikiLookup[First person to climb Mount Everest]
Plan: Use the QAModel to identify the name of the first climber from the Wikipedia information.
:Evidence1: = QAModel[Who was the first person to climb Mount Everest? Given context: :Evidence0:]
Plan: Use ImageSearch to find pictures of the identified climber during the expedition.
:Evidence2: = ImageSearch[:Evidence1: climbing Mount Everest]
Plan: Verify the fact that this person was indeed the first one to climb Mount Everest.
:Evidence3: = FactChecker[:Evidence1: was the first person to climb Mount Everest]
Answer: :Evidence1:, :Evidence2: and :Evidence3:

System: A chat.


Instruction:
Create a step-by-step plan to find out the average lifespan of an African elephant in the wild.

Here are the tools available:
- Encyclopedia[input]: A tool that allows you to search for information from a large online encyclopedia.
- 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.
- AnimalDatabase[input]: A specialized database containing detailed information about various animal species.
- FactChecker[input]: Validates the accuracy of a statement or piece of information.
- DataComparer[input1, input2]: Compares two pieces of data and determines which one is more accurate.

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

Response:
Plan: Start by searching the general information about African elephant's lifespan from a large online encyclopedia.
#E1 = Encyclopedia["African elephant lifespan"]

Plan: Verify the information obtained from the encyclopedia using a specialized animal database.
#E2 = AnimalDatabase["African elephant lifespan"]

Plan: Compare the data obtained from both sources to determine which one is more accurate.
#E3 = DataComparer[#E1, #E2]

Plan: Use the QA tool to answer any questions or clear up any uncertainties that may arise from the comparison of the two pieces of data.
#E4 = QA["What is the average lifespan of an African elephant in the wild?", Given context #E3]

Plan: Fact check the final answer obtained from the QA tool to ensure its accuracy.
#E5 = FactChecker[#E4]

Final answer: #E5

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:
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 include the answer to the user's query.
TextExtractor[input]: Extracts plain text from websites provided as input and produces a plain text output containing the content of the links.
URLFinder[input]: Extracts URLs from plain text and produces a plain text, newline separated response of URLs.
AnswerBot[input]: Question answering bot, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, 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 reasons for doing so?

Response:
Plan: Start by conducting a web search to find out who the first person to climb Mount Everest without supplemental oxygen was.
:evidence0: = Bing[First person to climb Mount Everest without supplemental oxygen]
Plan: Use AnswerBot to interpret the search results and identify the name of the climber.
:evidence1: = AnswerBot[Who was the first person to climb Mount Everest without supplemental oxygen, given :evidence0:?]
Plan: Conduct another web search to find the reasons why this person decided to climb Mount Everest without supplemental oxygen.
:evidence2: = Bing[Why did :evidence1: climb Mount Everest without supplemental oxygen?]
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:evidence3: = URLFinder[:evidence2:]
Plan: Use TextExtractor to extract information from the relevant URLs.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use AnswerBot to identify and summarize the reasons why the identified climber chose to climb Mount Everest without supplemental oxygen from the extracted information.
:evidence5: = AnswerBot[What were the reasons why :evidence1: climbed Mount Everest without supplemental oxygen, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Available tools are:
DuckDuckGo[input]: Allows the user to search for information using DuckDuckGo's search engine. Useful for locating a list of sites that might contain the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline-delimited links. Input is one or more links, producing plain text output containing the link contents.
UrlExtractor[input]: Extracts URLs from plain text, providing a plain text, newline-separated response of URLs.
InfoGenie[input]: Question-answering language model, particularly adept at answering questions based on an input passage of text. The input must be a text question referencing a :fact[n]: variable, e.g., What color is the cat, given :fact1:?

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

Question: Who won the Nobel Prize in Literature in 2020 and what are their most acclaimed works?

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
:fact0: = DuckDuckGo[Nobel Prize in Literature 2020 winner]
Plan: Use InfoGenie to parse the search results and determine the winner's name.
:fact1: = InfoGenie[Who won the Nobel Prize in Literature in 2020, given :fact0:?]
Plan: Perform another web search to find the most acclaimed works by the identified laureate.
:fact2: = DuckDuckGo[Most acclaimed works by :fact1:]
Plan: Extract the relevant URLs from the DuckDuckGo search results for further analysis.
:fact3: = UrlExtractor[:fact2:]
Plan: Use SiteLoader to retrieve information from the extracted URLs.
:fact4: = SiteLoader[:fact3:]
Plan: Lastly, utilize InfoGenie to identify and summarize the most acclaimed works by the laureate from the retrieved information.
:fact5: = InfoGenie[What are the most acclaimed works by :fact1:, given :fact4:?]
Answer: :fact5:

System: A chat.