Instruction:
Provide a comprehensive plan to respond to the user query utilizing the available tools. Every plan will correspond to an evidence value, which will be the output of one of the provided functions. The input could be the user question, previous evidence values, or a combination of both.

Available tools:
BingSearch[input]: A tool that enables users to conduct information searches via Bing. It provides a list of potential sites that might contain answers to the user's query.
TextExtractor[input]: Extracts text from one or multiple websites listed in the input string (newline separated links). The input consists of one or more links, and the output is plain text containing the content of these links.
HyperlinkCollector[input]: Collects hyperlinks from plain text and generates a plain text, newline-separated list of links.
LanguageProcessor[input]: A question-answering language model effective at answering queries based on a given text passage. The input should be a text-based question referencing an :evidence[n]: variable, such as "What is the dog's name, given :evidence1:?"

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

Question: What is the population of Tokyo and what are some of its major landmarks?

Response:
Plan: Initiate a web search to determine the population of Tokyo.
:evidence0: = BingSearch[Population of Tokyo]
Plan: Apply the language processor to decipher the search results and ascertain the population.
:evidence1: = LanguageProcessor[What is the population of Tokyo, given :evidence0:?]
Plan: Carry out another web search to discover the major landmarks in Tokyo.
:evidence2: = BingSearch[Major landmarks in Tokyo]
Plan: Extract pertinent links from the search results for a more thorough investigation.
:evidence3: = HyperlinkCollector[:evidence2:]
Plan: Employ the text extractor tool to gather information from the selected links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Lastly, apply the language processor to identify and provide a summary of Tokyo's major landmarks from the gathered data.
:evidence5: = LanguageProcessor[What are the major landmarks in Tokyo, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to answer: "Who won the Nobel Prize in Literature in 2015 and what was their most famous work?"

Available tools:
NobelPrizeData[input]: Tool that provides data about Nobel Prize winners.
AuthorWorks[input]: Tool that lists notable works by a particular author.
QA[input]: Tool that answers questions using general world knowledge.

Output format:
Plan: initial action
:Evidence0: = function with input
Plan: subsequent action, referencing :Evidence0:
:Evidence1: = next function with input (can refer to prior evidence)
...
Answer: [:Evidence[n]: containing final answer.]

Response:
Plan: initial action
:Evidence0: = NobelPrizeData[2015, "Literature"]
Plan: subsequent action, referencing :Evidence0:
:Evidence1: = AuthorWorks[:Evidence0:]
Answer: [:Evidence0: won the Nobel Prize in Literature in 2015. Their most famous work is :Evidence1:.]

System: A chat.


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

Here are the tools you can use:
DuckDuckGo[input]: Allows the user to conduct an internet search using DuckDuckGo. It yields a list of websites that may hold the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline-separated links. The input is one or more links, and it outputs plain text containing the content of the links.
HyperlinkGatherer[input]: Gathers hyperlinks from plain text and creates a plain text, newline-separated list of links.
AIOne[input]: An AI-powered question answering tool that can answer queries based on an input text passage. The input needs to be a textual question that refers to a #E[n] variable.

The output format should be:
Plan: [Initial action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Subsequent action based on the outcome of #E1]
#E2 = [Next function to call and input parameter, which may refer to preceding evidence, e.g., "Given context #E1"]
...
Final answer: #E[n]

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

Response:
Plan: Initiate a web search to find out the tallest building in Dubai.
#E1 = DuckDuckGo[Tallest building in Dubai]
Plan: Use the AI-powered QA tool to identify the building from the search results.
#E2 = AIOne[What is the tallest building in Dubai? Given context: #E1]
Plan: Perform another web search to find out the number of floors in the identified building.
#E3 = DuckDuckGo[Number of floors in #E2]
Plan: Gather relevant links from the search results for more comprehensive information.
#E4 = HyperlinkGatherer[#E3]
Plan: Read the content from the gathered links.
#E5 = SiteReader[#E4]
Plan: Lastly, use the AI-powered QA tool to ascertain the number of floors in the building from the read content.
#E6 = AIOne[How many floors does #E2 have? Given context: #E5]
Final answer: Building - #E2, Floors - #E6

System: A chat.


Instruction:
Develop a systematic plan to respond to the following user query using the tools provided. Each plan will be accompanied by an evidence value which represents the output of one of the available functions given an input string that can be the user's question, prior evidence values, or both.

Tools available for usage:
YahooSearch[input]: A tool that lets the user search for information through the Yahoo search engine. It helps in identifying appropriate websites that may hold the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline separated links, producing a plain text output containing the content of the links.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-separated response of URLs.
QUORA[input]: A question-answering language model, highly efficient in answering questions based on an input text passage. The input needs to be a text question that references an :evidence[n]: variable, e.g., 'What is the GDP of India, given :evidence1:?'.

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

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

Response:
Plan: Initiate a web search to find out who directed the movie "Inception".
:evidence0: = YahooSearch[Director of Inception]
Plan: Use QUORA language model to parse the search results and find the name of the director.
:evidence1: = QUORA[Who is the director of the movie Inception, given :evidence0:?]
Plan: Carry out another web search to find other movies directed by the identified director.
:evidence2: = YahooSearch[Movies directed by :evidence1:]
Plan: Extract the relevant URLs from the Yahoo search results for a more concentrated search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use SiteLoader tool to extract information from the relevant URLs.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, employ the QUORA language model to identify and summarize the other movies directed by the same person from the extracted information.
:evidence5: = QUORA[What other movies were directed by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Provide a detailed execution plan to respond to the following user query. You have access to various tools, each having a specific functionality. You can store the output of these tools into a variable called #E[index] which can later be referred to by subsequent tools.

Available Tools:
Bing[input]: Tool that enables the user to perform a search operation over Bing search engine.
SiteReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: An AI-based question-answering model that provides answers either directly from general world knowledge or given input context that may contain the answer.

Your output should follow this structure:
Plan: [first action based on input question]
#E1 = [function to call with input parameter]
Plan: [next action based on the result of #E1]
#E2 = [next function to call with input parameter, which might refer to previous evidence like "Given context #E1"]
...
Final Answer: #E[n]

Question: What are the main ingredients in a traditional Italian lasagna recipe?

Response:
Plan: Initiate a Bing search to find a traditional Italian lasagna recipe.
#E1 = Bing[Traditional Italian Lasagna Recipe]
Plan: Extract useful links from the search results.
#E2 = LinkCollector[#E1]
Plan: Read the contents of the extracted links.
#E3 = SiteReader[#E2]
Plan: Identify the main ingredients in a traditional Italian lasagna recipe from the read contents.
#E4 = AIQA[What are the main ingredients in a traditional Italian lasagna recipe? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Create a plan to solve the following problem. Indicate the external tool along with the tool input for each step and store the evidence into a variable #E[index].

Available Tools:
GoogleSearch[input]: Allows searching for information on Google.
ParseText[input]: Parses a block of text and extracts important details.
AskJeeves[input]: Answers questions using a vast database of common knowledge.
URLScraper[input]: Scrapes text content from a URL.

Output Format:
Plan: [First Action]
#E1 = [Tool with Input Parameter]
Plan: [Next Action Based on #E1]
#E2 = [Next Tool with Input Parameter (Can Reference Previous Evidence)]
...
Final Answer: #En

Question: What is the average temperature in Alaska during winter and what wildlife can be seen there during this season?

Response:
Plan: Search for the average winter temperature in Alaska.
#E1 = GoogleSearch[Average winter temperature in Alaska]
Plan: Parse the search results to get the average temperature.
#E2 = ParseText[#E1]
Plan: Now, search for the wildlife in Alaska during winter.
#E3 = GoogleSearch[Alaska winter wildlife]
Plan: Scrape the content from the top URLs obtained from the search results.
#E4 = URLScraper[#E3]
Plan: Ask Jeeves about the wildlife in Alaska during winter using the scraped content as context.
#E5 = AskJeeves[What wildlife can be seen in Alaska during winter? Given context: #E4]
Final Answer: #E5

System: A chat.


Instruction:
Develop a plan to find out who composed the soundtrack for the movie 'Interstellar'. Here are your available tools:
- IMDbLookup[input]: Fetches information about movies from IMDb.
- WebScraper[input]: Scrapes content from provided web links.
- LinkExtractor[input]: Extracts links from plain text.
- MusicDB[input]: Looks up music-related information.
- QAModel[input]: Answers questions using either common sense, world knowledge, or given context.

Output should follow this format:
Plan: [first action]
#Evidence1 = [function call with input]
Plan: [next action]
#Evidence2 = [next function call and input, possibly referencing previous evidence]
...
Final Answer: #Evidence[n]

Response:
Plan: Use IMDbLookup to find information about the movie 'Interstellar'.
#Evidence1 = IMDbLookup['Interstellar']

Plan: From the obtained data, extract the name of the composer.
#Evidence2 = QAModel["Who composed the soundtrack for the movie?", #Evidence1]

Final Answer: #Evidence2

System: A chat.


Instruction:
Create a step-by-step plan to respond to this user query: "What is the population of Tokyo and what are some famous landmarks there?" You have these tools at your disposal:

1. GoogleSearch[input]: A tool that lets you perform a Google search using an input string.
2. PageScraper[input]: Takes one or more URLs as input and produces plain text containing the content of those pages.
3. QuestionSolver[input]: Can answer questions based on input context.

Please follow this output format:
Step 1: [First action]
#Evidence1 = [Call to function with input parameter]
Step 2: [Subsequent action]
#Evidence2 = [Next function call with input parameter, possibly referencing earlier evidence, e.g., "Using context #Evidence1"]
...
Answer: #Evidence[n]

Response:
Step 1: Begin by conducting a Google search to find out the population of Tokyo.
#Evidence1 = GoogleSearch[Population of Tokyo]
Step 2: Scrape the page contents from the search results.
#Evidence2 = PageScraper[#Evidence1]
Step 3: Use the scraped data to determine the population of Tokyo.
#Evidence3 = QuestionSolver[What is the population of Tokyo? Using context #Evidence2]
Step 4: Conduct another Google search to find famous landmarks in Tokyo.
#Evidence4 = GoogleSearch[Famous landmarks in Tokyo]
Step 5: Scrape the page contents from the new search results.
#Evidence5 = PageScraper[#Evidence4]
Step 6: Use the newly scraped data to list famous landmarks in Tokyo.
#Evidence6 = QuestionSolver[What are some famous landmarks in Tokyo? Using context #Evidence5]
Answer: #Evidence3 and #Evidence6

System: A chat.


Instruction:
Create a detailed plan to respond to the user query using the following tools. 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 that could be the user question, prior evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: A tool that enables the user to perform a search using the DuckDuckGo search engine. It finds a list of potential sources that might contain the answer to the user's question.
PageLoader[input]: Loads one or more websites from an input string consisting of newline-separated links. The input is one or more links, and it outputs plain text containing the link contents.
URLCollector[input]: Extracts URLs from plain text and returns a plain text, newline-separated list of URLs.
QAEngine[input]: A question-answering language model capable of answering queries based on a provided text passage. The input must be a text-based question referencing an :evidence[n]: variable.

Output format:
Plan: [First action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameter, potentially referencing previous evidence]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

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

Response:
Plan: Initiate a web search to determine who won the Nobel Prize in Literature in 2019.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2019 winner]
Plan: Employ the language model to decipher the search results and pinpoint the winner's name.
:evidence1: = QAEngine[Who won the Nobel Prize in Literature in 2019, given :evidence0:?]
Plan: Execute another web search to uncover the major works of the identified laureate.
:evidence2: = DuckDuckGo[Major works of :evidence1:]
Plan: Isolate the pertinent links from the DuckDuckGo search results for a more targeted search.
:evidence3: = URLCollector[:evidence2:]
Plan: Utilize the PageLoader tool to glean information from the selected links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, employ the language model to identify and summarize the major works of the laureate from the retrieved data.
:evidence5: = QAEngine[What are the major works of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a detailed execution plan to respond to the following query using the tools provided. Each step should produce a piece of evidence (#E[index]) which can be used in subsequent steps.

Available Tools:
DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to find potentially relevant information online.
TextParser[input]: Takes a block of text (such as a webpage) and extracts important details into a structured format.
URLCollector[input]: Scans a block of text and identifies any URLs contained within it.
NLPModel[input]: An AI-powered natural language processing tool capable of answering specific questions when provided with a relevant context.

Output Format:
Plan: [Description of the first step]
#E1 = [Function to execute with relevant parameters]
Plan: [Description of the next step, considering the outcome of #E1]
#E2 = [Next function to execute with relevant parameters, possibly referencing #E1]
...
Final Answer: #E[n]

Question: What is the history behind the creation of Bitcoin and who is its creator?

Response:
Plan: Search for general information about the creation of Bitcoin.
#E1 = DuckDuckGo[Creation of Bitcoin]
Plan: Parse the obtained information to get structured data.
#E2 = TextParser[#E1]
Plan: Identify the creator of Bitcoin from the parsed information.
#E3 = NLPModel[Who created Bitcoin? Given context: #E2]
Plan: Search for more detailed information about the creator of Bitcoin.
#E4 = DuckDuckGo[#E3]
Plan: Parse the new information to obtain more structured data.
#E5 = TextParser[#E4]
Plan: Extract the history behind the creation of Bitcoin from all the gathered information.
#E6 = NLPModel[What is the history behind the creation of Bitcoin? Given context: #E2, #E5]
Final Answer: #E6

System: A chat.


Instruction:
Question: What are the opening hours of the Louvre Museum and what are its most famous exhibits?

Here are the tools available to be called:
GoogleMaps[input]: Provides information about locations including opening hours.
MuseumExhibitFinder[input]: Finds the most famous exhibits of a specified museum.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

Response:
Plan: First, find the opening hours of the Louvre Museum.
#E1 = GoogleMaps["Louvre Museum"]

Plan: Next, find the most famous exhibits of the Louvre Museum.
#E2 = MuseumExhibitFinder["Louvre Museum"]

Final answer: The Louvre Museum is open from #E1. Its most famous exhibits include #E2.

System: A chat.


Instruction:
Create a comprehensive plan to solve the following problem using the available tools. For each step in your plan, indicate the external tool along with the input to retrieve evidence. You can store the evidence into a variable #E[index] that can be referenced later.

Available tools:
WikiSearch[input]: Allows users to search for information from Wikipedia. It provides knowledge about various topics like people, places, events, etc. The input should be a search string.
QA_System[input]: Can answer questions using common sense, general world knowledge, or given context that may contain the answer.

Output format:
Plan: [First action]
#E1 = [Function to call with input]
Plan: [Next action based on #E1]
#E2 = [Next function to call with input, possibly referencing #E1]
...
Final Answer: #E[n]

Question: Who invented the telephone and where was it first demonstrated?

Response:
Plan: Begin by searching for information about who invented the telephone.
#E1 = WikiSearch[Inventor of the telephone]
Plan: Use the QA system to identify the inventor from the retrieved information.
#E2 = QA_System[Who invented the telephone? Given context: #E1]
Plan: Now, search for information about where the telephone was first demonstrated.
#E3 = WikiSearch[First demonstration of the telephone]
Plan: Lastly, use the QA system to determine where the telephone was first demonstrated from the gathered information.
#E4 = QA_System[Where was the telephone first demonstrated? Given context: #E3]
Final Answer: #E2 and #E4

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the following question, using the tools provided. Each tool should be used at least once and each plan should correspond with an evidence value.

The available tools are as follows:

1. WikiSearch[input]: This tool allows you to search for information on Wikipedia. The input should be a keyword or phrase related to your query.
2. AskAI[input]: This is a question-answering tool that can provide answers based on general knowledge or specific context provided in the form of previous evidence.
3. GoogleNews[input]: This tool searches for recent news articles on Google News. It's useful when looking for current events or recent developments related to your query.
4. TextSummarizer[input]: This tool takes large amounts of text (like a full article) and provides a brief summary.

Each plan will have one corresponding evidence value which is the output from one of the above functions given an input string.

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

Question: Who is the author of the book "To Kill a Mockingbird" and what are some recent news about them?

Response:
Plan: Use WikiSearch to find out who the author of "To Kill a Mockingbird" is.
#E1 = WikiSearch[To Kill a Mockingbird]
Plan: Extract the name of the author from the Wikipedia page.
#E2 = AskAI[Who is the author of To Kill a Mockingbird? Given context: #E1]
Plan: Search for recent news about the author.
#E3 = GoogleNews[#E2]
Plan: Summarize the news articles to get key points.
#E4 = TextSummarizer[#E3]
Final Answer: #E4

System: A chat.


Instruction:
Develop a step-by-step execution plan for the following task, utilizing the tools provided. Every step should have a corresponding evidence value, generated by one of the available tools given an input string (which could be the original query, prior evidence values, or a combination).

Tools at your disposal:
BingSearch[input]: Allows users to conduct searches via Bing. Useful for locating sites potentially containing answers to the user's query.
SiteReader[input]: Loads and converts into plain text one or multiple websites indicated by newline-separated links in the input string.
URLFinder[input]: Extracts URLs from plain text, producing a newline-separated list of links as output.
InfoRetriever[input]: A question-answering language model adept at answering queries based on an input text passage. Questions should refer to an :evidence[n]: variable, e.g., 'What is the capital of France, given :evidence1:?'

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

Question: Which actor played Tony Stark in the Marvel Cinematic Universe, and what other movies has he starred in?

Response:
Plan: Start by performing a Bing search to determine the actor who portrayed Tony Stark in the Marvel Cinematic Universe.
:evidence0: = BingSearch[Tony Stark actor in Marvel Cinematic Universe]
Plan: Employ InfoRetriever to analyze the search results and ascertain the actor's name.
:evidence1: = InfoRetriever[Who played Tony Stark in the Marvel Cinematic Universe, given :evidence0:?]
Plan: Execute another Bing search to uncover other films featuring the identified actor.
:evidence2: = BingSearch[Movies starring :evidence1:]
Plan: Deploy URLFinder to isolate pertinent links from the Bing search results for a targeted investigation.
:evidence3: = URLFinder[:evidence2:]
Plan: Leverage SiteReader to glean information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, use InfoRetriever to pinpoint and summarize the other movies in which the actor has appeared, based on the retrieved data.
:evidence5: = InfoRetriever[What other movies has :evidence1: starred in, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Design a step-by-step plan to respond to the user's inquiry using the provided tools. Each plan should correspond to an evidence value, which is the output of a function given an input string.

Available tools include:
DuckDuckGo[input]: Allows users to search for information via DuckDuckGo. Useful for locating sites that might have the answer to the user's question.
PageLoader[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and the output contains the content of these links.
LinkPicker[input]: Picks links from plain text and provides a plain text, newline-separated list of links.
InfoFinder[input]: An AI language model designed to answer questions based on an input text passage. The input must be a text question referring to an :evidence[n]: variable, such as 'What is the capital of France, given :evidence1:?'

Output format:
Plan: [initial action]
:evidence0: = [function call with input parameter]
Plan: [subsequent action, based on outcome of :evidence0:]
:evidence1: = [next function call with input parameter, potentially referencing prior evidence like "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

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

Response:
Plan: Begin by conducting a web search to understand the significance of the Rosetta Stone.
:evidence0: = DuckDuckGo[Rosetta Stone significance]
Plan: Utilize InfoFinder to interpret the search results and outline the importance of the Rosetta Stone.
:evidence1: = InfoFinder[What is the significance of the Rosetta Stone, given :evidence0:?]
Plan: Conduct another web search to determine the current location of the Rosetta Stone.
:evidence2: = DuckDuckGo[Rosetta Stone current location]
Plan: Extract the relevant links from the DuckDuckGo search results for a more detailed search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use PageLoader to extract information from the selected links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, utilize InfoFinder to identify the current location of the Rosetta Stone from the extracted data.
:evidence5: = InfoFinder[Where is the Rosetta Stone currently located, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

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 main diet of the snow leopard and where do they usually live?

Response:
Plan: Start by conducting a web search to find out about the main diet of the snow leopard.
:evidence0: = Bing[Snow leopard diet]
Plan: Use language model question answering tool to interpret the search results and find the diet of the snow leopard.
:evidence1: = LMQA[What is the main diet of the snow leopard, given :evidence0:?]
Plan: Conduct another web search to find out where snow leopards usually live.
:evidence2: = Bing[Snow leopard habitat]
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use WebCrawler tool to extract information from the relevant URLs.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, utilize the language model question answering tool to identify and summarize the usual habitat of the snow leopard from the extracted information.
:evidence5: = LMQA[Where do snow leopards usually live, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the available tools:
Bing[input]: This is a search engine tool that allows you to find information from various websites on the internet.
TextParser[input]: This tool extracts specific pieces of information from a large text, such as names, dates, or places.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A question answering model that can answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

The output should follow this format:
Plan: [first action]
#E1 = [function to call with input parameter]
Plan: [next action]
#E2 = [next function to call with input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

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

Response:
Plan: Start by conducting a web search to find out who designed the Eiffel Tower.
#E1 = Bing[Eiffel Tower Architect]
Plan: Use TextParser to extract the name of the architect from the search results.
#E2 = TextParser[#E1]
Plan: Conduct another web search to find other significant structures designed by the identified architect.
#E3 = Bing[Significant structures designed by #E2]
Plan: Extract relevant links from the search results for detailed information.
#E4 = LinkExtractor[#E3]
Plan: Scrape the contents of the extracted links for detailed information.
#E5 = WebScraper[#E4]
Plan: Finally, use QAModel to identify and summarize the significant structures designed by the architect from the scraped information.
#E6 = QAModel[What are the significant structures designed by #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Formulate a comprehensive plan to solve the following user inquiry using the set of tools at your disposal. Store the output of each tool in a variable labeled @Evidence[index], which can subsequently be referenced by other tools.

Tools Available:
DuckDuckGo[input]: Allows the user to conduct a search via the DuckDuckGo search engine.
WebCrawler[input]: Takes one or more URLs (separated by new lines) from the input string and generates a plain text output containing the content of those links.
HyperlinkHarvester[input]: Gathers all the hyperlinks embedded within a given text.
AIAgent[input]: A sophisticated question-answering AI that can generate responses based on common knowledge or given a particular context that may include the answer.

Output Format:
Plan: [Initial action based on the input question]
@Evidence1 = [Function to invoke with corresponding input parameter]
Plan: [Subsequent action based on the outcome of @Evidence1]
@Evidence2 = [Next function to invoke with appropriate input parameter, potentially referring to prior evidence such as "Considering context @Evidence1"]
...
Final Response: @Evidence[n]

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

Response:
Plan: Begin by executing a DuckDuckGo search to determine who invented the telephone.
@Evidence1 = DuckDuckGo[Inventor of the telephone]
Plan: Utilize the AIAgent to extract the inventor's name from the search results.
@Evidence2 = AIAgent[Who invented the telephone? Considering context @Evidence1]
Plan: Execute another DuckDuckGo search to find out when the telephone was first patented.
@Evidence3 = DuckDuckGo[First patent date of the telephone]
Plan: Harvest pertinent links from the search results for deeper analysis.
@Evidence4 = HyperlinkHarvester[@Evidence3]
Plan: Deploy the WebCrawler to gather information from the harvested links.
@Evidence5 = WebCrawler[@Evidence4]
Plan: Lastly, employ the AIAgent to ascertain the date when the telephone was first patented from the gathered information.
@Evidence6 = AIAgent[When was the telephone first patented? Considering context @Evidence5]
Final Response: @Evidence6

System: A chat.


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

Here are the tools you have at your disposal:
Bing[input]: This tool allows the user to search for information on Bing. It provides a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from web pages given one or more links as input.
LinkFinder[input]: Extracts links from plain text and returns them as a newline-separated list.
QAEngine[input]: A question-answering model that answers questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

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

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

Response:
Plan: Start by conducting a web search to find out about popular dishes in Vietnamese cuisine.
:evidence0: = Bing[Popular dishes in Vietnamese cuisine]
Plan: Extract relevant links from the Bing search results for further investigation.
:evidence1: = LinkFinder[:evidence0:]
Plan: Use the TextExtractor tool to extract information from these links.
:evidence2: = TextExtractor[:evidence1:]
Plan: Finally, use the QAEngine to identify and summarize the most popular dishes in Vietnamese cuisine from the extracted information.
:evidence3: = QAEngine[What are some of the most popular dishes in Vietnamese cuisine, given :evidence2:?]
Answer: :evidence3:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool helps in finding a list of sites that may contain the answer to the user's question.
WebCrawler[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
AIM[input]: An artificial intelligence model that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?

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

Include only one evidence output per plan step.

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

Question: Who won the 2022 FIFA World Cup and what were some key moments of their journey?

Response:
Plan: Start by conducting a web search to find out who won the 2022 FIFA World Cup.
#E0 = Bing[2022 FIFA World Cup winner]
Plan: Use the AI model to interpret the search results and identify the winning team.
#E1 = AIM[Who won the 2022 FIFA World Cup, given #E0?]
Plan: Conduct another web search to find the key moments of the identified team's journey in the tournament.
#E2 = Bing[Key moments of #E1 in 2022 FIFA World Cup]
Plan: Extract the relevant URLs from the Bing search results for a deeper search.
#E3 = URLExtractor[#E2]
Plan: Use the WebCrawler tool to extract information from the relevant URLs.
#E4 = WebCrawler[#E3]
Plan: Finally, use the AI model to identify and summarize the key moments of the winning team's journey from the extracted information.
#E5 = AIM[What were the key moments of #E1's journey in the 2022 FIFA World Cup, given #E4?]
Answer: #E5

System: A chat.


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

Here are the tools you can use:
WebSearch[input]: A tool that allows users to search for information on the web. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
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 a :evidence[n]: variable.

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

Question: What are some significant accomplishments of Albert Einstein?

Response:
Plan: Start by conducting a web search to find out about Albert Einstein's significant accomplishments.
:evidence0: = WebSearch[Significant accomplishments of Albert Einstein]
Plan: Extract relevant links from the search results for further exploration.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Use the TextScraper tool to extract information from these links.
:evidence2: = TextScraper[:evidence1:]
Plan: Finally, utilize the QAModel to identify and summarize Albert Einstein's significant accomplishments from the extracted information.
:evidence3: = QAModel[What are some significant accomplishments of Albert Einstein, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Develop a sequential plan to address the user query utilizing the provided tools. Each step will yield an evidence value which is the output of the selected function given an input string that could be the user question, preceding evidence values, or a combination of both.

Available tools are:
WebCrawler[input]: A tool that enables users to search for data on the web. It's handy for locating potential sites that might have answers to the user's query.
TextExtractor[input]: Loads a webpage from the supplied URL and generates a plain text output containing the page's content.
URLPicker[input]: Extracts URLs from plain text and produces a list of URLs.
QuerySolver[input]: An AI model adept at answering queries based on an input text passage. The input has to be a text query referencing a #Evidence[n] variable, such as What is the dog's breed, given #Evidence1?

Output format should be:
Plan: [initial action based on input question]
#Evidence1 = [function to call with input parameter]
Plan: [subsequent action based on result of #Evidence1]
#Evidence2 = [next function to call and input parameter, potentially referring to prior evidence like "Given context #Evidence1"]
...
Final Answer: #Evidence[n]

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

Response:
Plan: Begin by executing a web search to determine the author of the book '1984'.
#Evidence1 = WebCrawler[Author of the book '1984']
Plan: Utilize QuerySolver to interpret the search results and ascertain the author's name.
#Evidence2 = QuerySolver[Who is the author of the book '1984'? Given context: #Evidence1]
Plan: Execute another web search to discover other books written by the identified author.
#Evidence3 = WebCrawler[Other books written by #Evidence2]
Plan: Extract pertinent links from the search results for a more comprehensive search.
#Evidence4 = URLPicker[#Evidence3]
Plan: Employ TextExtractor to retrieve information from the relevant links.
#Evidence5 = TextExtractor[#Evidence4]
Plan: Lastly, utilize QuerySolver to identify and summarize other books written by the author from the retrieved information.
#Evidence6 = QuerySolver[What other books has #Evidence2 written? Given context: #Evidence5]
Final 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 mixture of both.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
TextExtractor[input]: Extracts plain text from websites provided as newline delimited links in the input string.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerBot[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 history behind the creation of Google?

Response:
Plan: Start by conducting a web search to find out about the history of Google.
:evidence0: = Bing[History of Google]
Plan: Use LinkFinder to extract relevant links from the search results.
:evidence1: = LinkFinder[:evidence0:]
Plan: Use TextExtractor to get the content of the identified links.
:evidence2: = TextExtractor[:evidence1:]
Plan: Finally, utilize AnswerBot to summarize the history of Google from the extracted information.
:evidence3: = AnswerBot[What is the history behind the creation of Google? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


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

Here are the tools 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.
WebReader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkGrabber[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

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

Only include one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
#E0 = SearchEngine[Nobel Prize in Literature 2020 winner]
Plan: Use the AnswerBot to interpret the search results and identify the winner.
#E1 = AnswerBot[Who won the Nobel Prize in Literature in 2020, given #E0?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E2 = SearchEngine[Most famous work of #E1]
Plan: Extract the relevant links from the search results for a deeper analysis.
#E3 = LinkGrabber[#E2]
Plan: Use the WebReader tool to extract information from the relevant links.
#E4 = WebReader[#E3]
Plan: Finally, use the AnswerBot to identify and summarize the most famous work of the laureate from the extracted information.
#E5 = AnswerBot[What is the most famous work of #E1, given #E4?]
Final answer: #E5

System: A chat.


Instruction:
Formulate a sequential plan to solve the following user query using the provided tools. Each tool operation will yield an evidence value, which corresponds to the output of one of the functions when supplied with an input string that could be the user's question or prior evidence values.

Tools at your disposal include:
DuckDuckGo[input]: This tool uses the DuckDuckGo search engine to gather information from numerous online sources.
URLLoader[input]: This loads a webpage from the given URL and outputs its textual content in plain form.
HyperlinkExtractor[input]: From a block of text, this extracts hyperlinks and provides a list of URLs.
InfoProcessor[input]: This analyzes a section of text and responds to queries based on it. An :evidence[n]: variable must be referenced in the input.

For each function, simply provide a plain string as input without quotation marks or "+" symbols for concatenating with an evidence variable (like InfoProcessor[What is the population of Tokyo, given :evidence1:?]).

The output should adhere to the following structure:
Plan: [initial action]
:evidence0: = [call to function with input parameter]
Plan: [subsequent action influenced by outcome of :evidence0:]
:evidence1: = [call to next function with input parameter, possibly referring to earlier evidence]
...
Answer: [:evidence[n]: where n represents the final answer]

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

Response:
Plan: Initiate a search for the architect of the Eiffel Tower.
:evidence0: = DuckDuckGo[Eiffel Tower architect]
Plan: Utilize the InfoProcessor to extract the architect's name from the search results.
:evidence1: = InfoProcessor[Who designed the Eiffel Tower, given :evidence0:?]
Plan: Perform another web search to discover other structures designed by the named architect.
:evidence2: = DuckDuckGo[Other structures designed by :evidence1:]
Plan: Retrieve pertinent links from the search results for further investigation.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Employ URLLoader to access the content of the retrieved links.
:evidence4: = URLLoader[:evidence3:]
Plan: Lastly, utilize the InfoProcessor to outline the other structures designed by the architect from the accessed page contents.
:evidence5: = InfoProcessor[What other structures were designed by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Formulate a plan to find out the height of Mount Everest and which country it's in.

Available tools:
MountainStats[input]: Provides statistics about mountains worldwide.
CountryLocator[input]: Identifies the country a specified landmark is in.
QA[input]: Can answer questions using common sense or given context.
GoogleEarth[input]: Provides geographical data about a place.
Wikipedia[input]: Allows searching for information from Wikipedia.

Output format:
Plan: First action
#E1 = function with input parameter
Plan: Next action based on #E1
#E2 = next function with input parameter referencing previous evidence if necessary
...
Final Answer: #E[n]

Response:
Plan: First action
#E1 = MountainStats["Mount Everest"]
Plan: Next action based on #E1
Final Answer: The height of Mount Everest is #E1.height

Plan: First action for country
#E2 = CountryLocator["Mount Everest"]
Final Answer: Mount Everest is in #E2.country

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites given an input string containing newline delimited links.
LinkPicker[input]: Picks relevant links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering model, useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

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

Response:
Plan: Begin by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = Bing[History of Eiffel Tower]
Plan: Pick the most relevant links from the search results.
:evidence1: = LinkPicker[:evidence0:]
Plan: Use the TextExtractor tool to extract information from the picked links.
:evidence2: = TextExtractor[:evidence1:]
Plan: Finally, utilize the QAModel to interpret the extracted information and summarize the history of the Eiffel Tower.
:evidence3: = QAModel[What is the history behind the construction of Eiffel Tower? Given :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Create an execution plan to solve the following problem using the provided tools. Each step must include one action, one tool call with inputs, and store the result into a variable #E[index] for later reference.

Tools Available:
WebSearch[input]: Searches the web for information related to the input string.
QAEngine[input]: Answers questions using common sense, world knowledge, or given context.
CompanyDatabase[input]: Retrieves data about a specified company.
StockMarketAPI[input]: Fetches real-time stock market data for a specified company.

Format:
Plan: [Action to be performed]
#E1 = [Tool to be used with its input]
...
Final Answer: #E[n]

Question: What is the current market capitalization of Microsoft Corporation and who is their CEO?

Response:
Plan: Retrieve data about Microsoft Corporation from the company database.
#E1 = CompanyDatabase[Microsoft Corporation]
Plan: Identify the CEO of Microsoft Corporation.
#E2 = QAEngine[Who is the CEO of Microsoft Corporation? Given context: #E1]
Plan: Get the current market capitalization of Microsoft Corporation.
#E3 = StockMarketAPI[Microsoft Corporation]
Plan: Extract the market capitalization value from the retrieved data.
#E4 = QAEngine[What is the current market capitalization of Microsoft Corporation? Given context: #E3]
Final Answer: #E4

Continuing in the same manner, you can generate more instruction/response pairs as required.

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
TextExtractor[input]: Extracts text from websites provided as input and produces plain text output containing the content of the site.
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 is the history behind the creation of Bitcoin and who was involved?

Response:
Plan: Start by conducting a web search to find out about the history of Bitcoin.
:evidence0: = DuckDuckGo[History of Bitcoin]
Plan: Use a language model to interpret the search results and find the key points in the history of Bitcoin.
:evidence1: = QAModel[What is the history of Bitcoin, given :evidence0:?]
Plan: Conduct another web search to find the people involved in the creation of Bitcoin.
:evidence2: = DuckDuckGo[People involved in the creation of Bitcoin]
Plan: Extract the relevant links from the search results for further analysis.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use a text extractor tool to extract information from the relevant links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the people involved in the creation of Bitcoin from the extracted information.
:evidence5: = QAModel[Who were the people involved in the creation of Bitcoin, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information from various sources on the internet.
FactChecker[input]: Tool that verifies the accuracy of facts and figures.
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.
DatabaseLookup[input]: Tool that searches a database for specific information.
ImageAnalyzer[input]: Tool that analyzes images and provides details about them.

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

Question: What is the highest peak in the Alps and what is its elevation?

Response:
Plan: First, search for the highest peak in the Alps.
#E1 = SearchEngine["highest peak in the Alps"]

Plan: Then, verify the accuracy of the information obtained from the search engine.
#E2 = FactChecker[#E1]

Plan: Next, find out the elevation of this peak.
#E3 = SearchEngine["elevation of " + #E2]

Plan: Finally, confirm the accuracy of the elevation data.
#E4 = FactChecker[#E3]

Final answer: #E4

System: A chat.


Instruction:
Create a plan to answer the following question using the available tools. Each step in your plan should have an associated evidence variable that will be used as input for subsequent steps.

Available Tools:
WebSearch[input]: This tool allows you to search the web for information related to the input string.
TextAnalyzer[input]: Analyzes a block of text and extracts key pieces of information such as names, dates, places, etc.
QA[input]: A tool that can answer questions based on common sense, general world knowledge, or given context.
ImageFinder[input]: Searches the web for images related to the input string.
ImageAnalyzer[input]: Analyzes an image and provides a description of what it contains.

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

Question: Who won the 2019 Tour de France and where is he from?

Response:
Plan: Search the web for the winner of the 2019 Tour de France.
#E1 = WebSearch[2019 Tour de France winner]
Plan: Use TextAnalyzer to extract the name of the winner from the search results.
#E2 = TextAnalyzer[#E1]
Plan: Use QA tool to confirm the winner's name.
#E3 = QA[Who won the 2019 Tour de France? Given context: #E2]
Plan: Search the web for more information about the confirmed winner.
#E4 = WebSearch[#E3]
Plan: Extract the nationality of the winner from the new search results.
#E5 = TextAnalyzer[#E4]
Final Answer: #E5

System: A chat.


Instruction:
Question: How does the process of photosynthesis work in plants?

Here are the tools available to be called:
BiologyTextbook[input]: Tool that provides detailed explanations of biological processes.
DiagramGenerator[input]: Tool that generates diagrams or flowcharts to visually represent complex processes.
QA[input]: Tool that can answer questions based on common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
VideoFinder[input]: Tool that finds educational videos related to a specified topic.
SummaryMaker[input]: Tool that summarizes lengthy texts into concise summaries.

Plan: First action to take based on input question
#E1 = BiologyTextbook["photosynthesis"]
Plan: Next action to take, based on result of #E1
#E2 = DiagramGenerator[#E1]
Plan: Find an educational video for better understanding
#E3 = VideoFinder["photosynthesis"]
Plan: Summarize all the gathered information
#E4 = SummaryMaker[#E1 + " " + #E2 + " " + #E3]
Final Answer: #E4

Response: The assistant will first use the BiologyTextbook tool to provide a detailed explanation of photosynthesis. Then, it will generate a diagram using DiagramGenerator for visual representation. To further enhance understanding, it will find an educational video on photosynthesis using VideoFinder. Finally, all this information will be summarized into a concise summary using SummaryMaker.

System: A chat.


Instruction:
Generate a plan to respond to the user's query using the provided tools. Each step of the plan will have a corresponding evidence variable.

Here are the tools available to be called:
BingSearch[input]: A tool that uses Bing search engine to find relevant information online.
PageParser[input]: A tool that extracts text from a webpage.
QueryResponder[input]: A tool that answers questions based on an input passage of text.

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

Question: What is the population of Tokyo and what is it known for?

Response:
Plan: Start by searching for the population of Tokyo.
@Evidence1 = BingSearch[Population of Tokyo]
Plan: Use QueryResponder to get the population from the search results.
@Evidence2 = QueryResponder[What is the population of Tokyo? Given context: @Evidence1]
Plan: Next, search for what Tokyo is known for.
@Evidence3 = BingSearch[Tokyo known for]
Plan: Parse the page to extract the relevant information.
@Evidence4 = PageParser[@Evidence3]
Plan: Lastly, use QueryResponder to get the details of what Tokyo is known for from the parsed page.
@Evidence5 = QueryResponder[What is Tokyo known for? Given context: @Evidence4]
Final answer: The population of Tokyo is mentioned in @Evidence2 and it is known for the details mentioned in @Evidence5.

System: A chat.


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

Here are the tools you can use:
Bing[input]: A tool that allows users to search for information on Bing. This 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.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KnowledgeModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the dog, given #E1?

The output format should be as follows:
Plan: [first action]
#E0 = [function with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function with input parameter referencing previous evidence if necessary]
...
Answer: [#En containing the final answer]

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

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2019.
#E0 = Bing[Nobel Prize in Literature 2019 winner]
Plan: Use the KnowledgeModel to interpret the search results and identify the winner.
#E1 = KnowledgeModel[Who won the Nobel Prize in Literature in 2019? Given context: #E0]
Plan: Conduct another web search to find the most notable work of the identified laureate.
#E2 = Bing[Most notable work of #E1]
Plan: Extract relevant links from the Bing search results for detailed information.
#E3 = LinkPicker[#E2]
Plan: Use the WebScraper tool to extract information from the selected links.
#E4 = WebScraper[#E3]
Plan: Finally, use the KnowledgeModel to identify and summarize the most notable work of the laureate from the extracted information.
#E5 = KnowledgeModel[What is the most notable work of #E1? Given context: #E4]
Answer: #E5

System: A chat.


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

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

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

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

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

Response:
Plan: Search for more information about the Eiffel Tower.
#E1 = Britannica[Eiffel Tower]
Plan: Find out when the Eiffel Tower was built.
#E2 = AIQA[When was the Eiffel Tower built? Given context: #E1]
Plan: Find out who was the architect of the Eiffel Tower.
#E3 = AIQA[Who was the architect of the Eiffel Tower? Given context: #E1]
Final answer: #E2 and #E3

System: A chat.


Instruction:
Create a step-by-step plan to solve the following problem using the provided tools. Each plan will correspond to an evidence value which will be the output of the chosen function given its input parameters.

Available Tools:
GoogleScholar[input]: A tool that searches academic papers and articles related to the input query.
PDFReader[input]: A tool that reads PDF files from the input link(s) and provides a plain text output.
HyperlinkExtractor[input]: A tool that extracts hyperlinks from the input text.
BERT[input]: A language model tool that answers questions based on an input context. The input must be a text question referencing a #E[index] variable.

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

Question: What were the main findings of the research paper titled "Artificial Intelligence in Healthcare"?

Response:
Plan: Search for the research paper using Google Scholar.
#E1 = GoogleScholar["Artificial Intelligence in Healthcare"]
Plan: Extract the hyperlink of the research paper from the search results.
#E2 = HyperlinkExtractor[#E1]
Plan: Read the PDF file of the research paper.
#E3 = PDFReader[#E2]
Plan: Find the main findings of the research paper.
#E4 = BERT[What were the main findings of the research paper? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Develop a plan to answer the following query using the tools provided. Each step should specify the tool used and its input. Store the outputs in variables named :evidenceN:, where N is the index number.

Available Tools:
1. DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to gather information. It provides a list of potential sources but does not directly answer the question.
2. SiteLoader[input]: Loads the content of specified websites into plain text. Input is one or more URLs separated by newlines.
3. URLExtractor[input]: Extracts URLs from plain text and returns them as a newline-separated list.
4. AskIt[input]: A tool that answers questions based on provided context. The input is a question that refers to an :evidenceN: variable.

Output Format:
Plan: [First Action]
:evidence0: = [Function Call with Input Parameter]
Plan: [Next Action Based on Result of :evidence0:]
:evidence1: = [Next Function Call with Input Parameter Referencing Previous Evidence]
...
Answer: [:evidenceN: Containing Final Answer]

Question: Who was the first woman to win a Nobel Prize and what field was it in?

Response:
Plan: Begin by searching for the first woman to win a Nobel Prize.
:evidence0: = DuckDuckGo[First woman to win a Nobel Prize]
Plan: Use AskIt to extract the name of the woman from the search results.
:evidence1: = AskIt[Who was the first woman to win a Nobel Prize? Given context: :evidence0:?]
Plan: Perform another search to determine the field in which she won the prize.
:evidence2: = DuckDuckGo[Nobel Prize field of :evidence1:]
Plan: Extract relevant URLs from the search results.
:evidence3: = URLExtractor[:evidence2:]
Plan: Load the content of the extracted URLs.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, use AskIt to determine the field in which the first female Nobel laureate won her prize.
:evidence5: = AskIt[In what field did :evidence1: win her Nobel Prize? Given context: :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Design a plan to respond to the user instruction utilizing the set of tools provided. For each plan, indicate the corresponding evidence value, which will be the output of one of the available functions given an input string - this could be the user's question, previous evidence values, or a combination of both.

Available tools:
Bing[input]: This tool enables users to perform searches on Bing. It doesn't directly answer queries; instead, it finds a list of sites that might contain the answer.
ContentParser[input]: This tool extracts text from a list of URLs (newline-separated). The input is one or multiple links, and the output is plain text containing the content of those links.
URLSelector[input]: This tool selects relevant links from a plaintext list of links and generates a plaintext response consisting of selected links.
Oracle[input]: This is a question-answering model that responds to queries based on common sense, world knowledge, or given context. The input should be a question referencing an :evidence[n]: variable, such as 'What is the tallest mountain, given :evidence1:?'.

Remember, each function's input should be a simple string, without quotation marks or '+' to concatenate a string with an evidence variable.

Output format:
Plan: [First action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action, based on the outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, possibly referring to prior evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n]: that contains the ultimate answer.]

Question: What is the significance of the Battle of Waterloo and how did it impact Europe?

Response:
Plan: Begin by performing a web search to understand the significance of the Battle of Waterloo.
:evidence0: = Bing[Battle of Waterloo significance]
Plan: Use Oracle to analyze the search results and summarize the significance of the battle.
:evidence1: = Oracle[What is the significance of the Battle of Waterloo, given :evidence0:?]
Plan: Carry out another web search to gather information on how the Battle of Waterloo impacted Europe.
:evidence2: = Bing[Impact of Battle of Waterloo on Europe]
Plan: Select relevant links from the search results for a more detailed analysis.
:evidence3: = URLSelector[:evidence2:]
Plan: Utilize ContentParser to extract useful information from the chosen links.
:evidence4: = ContentParser[:evidence3:]
Plan: Lastly, use Oracle to summarize the impact of the Battle of Waterloo on Europe from the parsed content.
:evidence5: = Oracle[How did the Battle of Waterloo impact Europe, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step plan to respond to the user query utilizing the available tools. For each step, indicate the corresponding evidence value, which would be the output of one of the available functions given an input string that could be the user's question, prior evidence values, or a combination of both.

Available tools are as follows:
WebSearch[input]: A tool that enables users to perform a search on the web. It locates a list of sites that might contain the answer but does not directly provide the answer.
SiteReader[input]: Load one or multiple websites from the input string containing newline separated links, where input is one or several links, and generates plain text output containing the link contents.
UrlCollector[input]: Extracts URLs from plain text and returns a plain text, newline separated response of URLs.
KnowledgeBot[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.

Output should be formatted as follows:
Plan: [First action to take based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action to take, based on result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which may include reference to previous evidence]
...
Final Answer: [:evidence[n]: Containing the final answer]

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

Response:
Plan: Begin by performing a web search to determine who won the Nobel Prize in Literature in 2020.
:evidence0: = WebSearch[Nobel Prize in Literature 2020 winner]
Plan: Utilize KnowledgeBot to interpret the search results and identify the winner.
:evidence1: = KnowledgeBot[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Perform another web search to find the most famous work of the identified laureate.
:evidence2: = WebSearch[Most famous work of :evidence1:]
Plan: Extract the relevant links from the search results for deeper exploration.
:evidence3: = UrlCollector[:evidence2:]
Plan: Use SiteReader to extract information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, utilize KnowledgeBot to identify and summarize the most famous work of the laureate from the extracted data.
:evidence5: = KnowledgeBot[What is the most famous work of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available for use:
SearchEngine[input]: This tool allows you to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextExtractor[input]: Extracts plain text from one or more websites from the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should follow this 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"]
...
Final Answer: [:evidence[n]: containing the final answer.]

Question: Who wrote the book 'To Kill a Mockingbird' and what other works they have written?

Response:
Plan: Start by searching online to find out who wrote 'To Kill a Mockingbird'.
:evidence0: = SearchEngine[Who wrote To Kill a Mockingbird]
Plan: Use the AnswerBot to interpret the search results and identify the author.
:evidence1: = AnswerBot[Who wrote the book 'To Kill a Mockingbird', given :evidence0:?]
Plan: Conduct another web search to find other works written by the identified author.
:evidence2: = SearchEngine[Other works by :evidence1:]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = LinkFinder[:evidence2:]
Plan: Extract textual information from the relevant links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the AnswerBot to summarize the other works written by the author from the extracted information.
:evidence5: = AnswerBot[What are the other works written by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a detailed execution plan to solve the following problem. You have several tools at your disposal. For each step, indicate which tool you would use and how you would use it. Store the output of each tool into a variable #E[index] that can be used as input for subsequent steps.

Available Tools:
GoogleSearch[input]: A tool that uses Google's search algorithm to find relevant web pages based on the input query.
SiteReader[input]: A tool that extracts all text from a specified website URL.
QAModel[input]: A tool that answers questions based on provided context. The input should be a question and some context that might contain the answer.

Output Format:
Plan: [First action]
#E1 = [Tool and its input]
Plan: [Second action]
#E2 = [Next tool and its input, possibly referencing #E1]
...
Final Answer: #En

Question: How many languages does Pope Francis speak fluently?

Response:
Plan: Begin by searching online for information about the languages spoken by Pope Francis.
#E1 = GoogleSearch[Pope Francis languages]
Plan: Extract the most relevant link from the search results.
#E2 = SiteReader[#E1]
Plan: Use the QAModel to determine how many languages Pope Francis speaks fluently.
#E3 = QAModel[How many languages does Pope Francis speak fluently? Given context: #E2]
Final Answer: #E3

System: A chat.


Instruction:
Question: How many books has Stephen King written and what are their average ratings?

Here are the tools available to be called:
AuthorWorks[input]: Lists all works by a specified author.
BookRatings[input]: Provides average ratings for a list of books.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

Response:
Plan: First, find out all the works written by Stephen King.
#E1 = AuthorWorks["Stephen King"]
Plan: Then, calculate the average ratings for these books.
#E2 = BookRatings[#E1]
Final answer: Stephen King has written #E1.length books and their average rating is #E2.

System: A chat.


Instruction:
Please create a plan to respond to the user instruction using the set of tools below. Each tool can be used with an input string and provides an output that can be stored as #E[index] for later use.

Available tools:
DuckDuckGo[input]: Searches for information on DuckDuckGo, including web pages, news articles, images, etc.
SummaryMaker[input]: Summarizes long pieces of text into concise key points.
URLExtractor[input]: Extracts URLs from a given piece of text.
SiteLoader[input]: Loads one or more websites from the input string (newline separated links) and outputs the text content of these sites.
KnowledgeBase[input]: A question-answering tool that can provide answers based on common knowledge or given context (previous evidence).

Your output should look like this:
Plan: [First step]
#E1 = [Function call with input]
Plan: [Next step based on #E1]
#E2 = [Next function call with input, potentially referring to #E1]
...
Final Answer: #E[n]

Question: How does nuclear fusion work and what are its applications?

Response:
Plan: Search for information about nuclear fusion.
#E1 = DuckDuckGo[Nuclear Fusion]
Plan: Extract useful URLs from the search results.
#E2 = URLExtractor[#E1]
Plan: Load the content of the extracted URLs for more details.
#E3 = SiteLoader[#E2]
Plan: Summarize the loaded text to get key points about nuclear fusion.
#E4 = SummaryMaker[#E3]
Plan: Use KnowledgeBase to understand how nuclear fusion works.
#E5 = KnowledgeBase[How does nuclear fusion work? Given context: #E4]
Plan: Use KnowledgeBase again to find out the applications of nuclear fusion.
#E6 = KnowledgeBase[What are the applications of nuclear fusion? Given context: #E4]
Final Answer: #E5 and #E6

System: A chat.


Instruction:
Develop a plan to respond to the following question using the listed tools. For each step in your plan, provide an evidence value which corresponds to the output of one of the available functions.

Available Tools:
AskJeeves[input]: A tool that allows you to ask direct questions and receive succinct answers. Useful for obtaining quick facts and figures.
DeepDive[input]: A tool that delves into comprehensive resources to retrieve detailed information on a topic. Input is a search term or phrase.
TextAnalyzer[input]: Analyzes a body of text and extracts key points and summaries.
QAModel[input]: Question answering language model that provides answers based on a provided text passage. It uses an :evidence[n]: variable as input.

Output Format:
Plan: [First action to take based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action to take, based on result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which may refer to previous evidence, e.g., "Given context :evidence0:"]
...
Answer: [:evidence[n]: Containing the final answer.]

Question: How did Amazon get its start and what were some early challenges it faced?

Response:
Plan: Begin by asking a direct question to find out how Amazon started.
:evidence0: = AskJeeves[How did Amazon start?]
Plan: Use DeepDive to gather more detailed information about Amazon's early years.
:evidence1: = DeepDive[Amazon's early years]
Plan: Apply TextAnalyzer to summarize the detailed information gathered.
:evidence2: = TextAnalyzer[:evidence1:]
Plan: Finally, use QAModel to identify and describe the early challenges faced by Amazon.
:evidence3: = QAModel[What were some early challenges faced by Amazon? Given :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Please develop a step-by-step plan to generate an ideal response to the user instruction, using a set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a 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. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
Parser[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.
LinkHarvester[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, e.g. What color is the cat, given :evidence1:?

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

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

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

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

Response:
Plan: Start by conducting a web search to find out who won the 2022 Nobel Prize in Physics.
:evidence0: = Bing[2022 Nobel Prize in Physics winner]
Plan: Use a language model to interpret the search results and find the name of the laureate.
:evidence1: = QAModel[Who won the 2022 Nobel Prize in Physics, given :evidence0:?]
Plan: Conduct another web search to find the key contributions made by the identified laureate.
:evidence2: = Bing[:evidence1: + ' Nobel prize contribution']
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkHarvester[:evidence2:]
Plan: Use a parser tool to extract information from the relevant links.
:evidence4: = Parser[:evidence3:]
Plan: Finally, use 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:
Construct a systematic plan to address the following query. Make use of the tools provided and save the output of each tool into a variable $Evidence[index] that can be referred to later.

Tools Available:
YahooSearch[input]: A search engine tool used to gather information from the internet.
TextCleaner[input]: Takes a block of text as input and removes any irrelevant information or noise, leaving only important details.
HyperlinkGatherer[input]: Gathers all hyperlinks present within a block of text.
InfoBot[input]: A tool designed to answer questions based on common knowledge or specific context provided to it.

Format your response as follows:
Plan: [Initial action based on input question]
$Evidence1 = [Call to function with appropriate input]
Plan: [Subsequent action based on $Evidence1]
$Evidence2 = [Next function call with suitable input, potentially referring back to $Evidence1]
...
Final Answer: $Evidence[n]

Question: Who is the current president of Brazil and what are some significant policies they have implemented?

Response:
Plan: Start by searching for the current president of Brazil.
$Evidence1 = YahooSearch[Current president of Brazil]
Plan: Use InfoBot to extract the name of the president from the search results.
$Evidence2 = InfoBot[Who is the current president of Brazil? Given context: $Evidence1]
Plan: Carry out another search to find significant policies implemented by the identified president.
$Evidence3 = YahooSearch[Significant policies implemented by $Evidence2]
Plan: Clean up the search results to remove any irrelevant information.
$Evidence4 = TextCleaner[$Evidence3]
Plan: Extract relevant links from the cleaned-up text for further investigation.
$Evidence5 = HyperlinkGatherer[$Evidence4]
Plan: Scrape the contents of the extracted links.
$Evidence6 = WebScraper[$Evidence5]
Plan: Lastly, use InfoBot to identify and summarize the significant policies implemented by the president from the scraped information.
$Evidence7 = InfoBot[What are some significant policies implemented by $Evidence2? Given context: $Evidence6]
Final Answer: $Evidence7

System: A chat.


Instruction:
Develop a sequential plan to address the user's query, making use of the provided tools. Each plan should have a corresponding evidence value, which is the output of one of the functions given an input string.

Here are the tools available to be called:
YahooSearch[input]: A tool that lets the user search for information through the Yahoo search engine. It's useful for locating a variety of sites that could hold the answer to the user's question.
HyperlinkFinder[input]: Finds hyperlinks from plain text and delivers a plain text, newline separated response of links.
SiteLoader[input]: Loads one or more websites from the input string containing newline-separated links, where input is one or more links, and yields plain text output containing the content of the links.
QAModel[input]: A question-answering model powered by artificial intelligence, highly efficient at answering questions based on an input passage of text. The input has to be a text question that refers to a :evidence[n]: variable.

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

Question: How did the Great Depression impact the global economy?

Response:
Plan: Initiate a web search to collect data about the Great Depression.
:evidence0: = YahooSearch[Great Depression]
Plan: Apply HyperlinkFinder to pull out relevant links from the search outcome.
:evidence1: = HyperlinkFinder[:evidence0:]
Plan: Use SiteLoader to fetch details from the obtained links.
:evidence2: = SiteLoader[:evidence1:]
Plan: Eventually, employ QAModel to analyze the fetched details and understand how the Great Depression impacted the global economy.
:evidence3: = QAModel[How did the Great Depression impact the global economy, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
Generate a step-by-step plan to answer the following question using the tools provided. Assign an evidence variable to each step.

Tools Available:
NetSearch[input]: Searches the internet for websites containing information related to the input.
SiteScraper[input]: Scrapes the website at the provided URL and returns its text content.
LinkCollector[input]: Collects all URLs contained within the provided text.
InfoAssistant[input]: Answers questions using the context provided in the input.

Output Format:
Plan: [first action]
$Evidence1 = [tool with input]
Plan: [next action]
$Evidence2 = [next tool with input]
...
Final Answer: $EvidenceN

Question: What are some famous paintings by Vincent van Gogh?

Response:
Plan: Begin by conducting an internet search for famous paintings by Vincent van Gogh.
$Evidence1 = NetSearch[Famous paintings by Vincent van Gogh]
Plan: Collect URLs from the search results for further exploration.
$Evidence2 = LinkCollector[$Evidence1]
Plan: Scrape the sites for their textual content.
$Evidence3 = SiteScraper[$Evidence2]
Plan: From the scraped site content, identify some famous paintings by Vincent van Gogh.
$Evidence4 = InfoAssistant[What are some famous paintings by Vincent van Gogh? Given context: $Evidence3]
Final Answer: $Evidence4

System: A chat.


Instruction:
Generate a step-by-step plan to solve the following problem using the provided tools. Each step should have a corresponding evidence variable (#E[index]), which will be the output of a specific function given an input string (which could be the user's question, previous evidence variables, or a mix).

Available tools:
Bing[input]: Allows users to search for information on the internet via Bing. Useful for locating sites potentially containing the answer.
Readability[input]: Takes a URL as input and returns a simplified version of the webpage’s text.
LinkCollector[input]: From a block of text, extracts URLs and provides them as newline-separated output.
FactoidQA[input]: Answers factual questions based on an input passage of text. The input should be a text question referencing a #E[n] variable, like “What is the tallest mountain, given #E1?”

Ensure only one evidence output per plan step.

Output format:
Plan: [First action based on input question]
#E1 = [Function to call with input]
Plan: [Next action, based on #E1]
#E2 = [Next function to call with input, possibly referencing prior evidence]
…
Final Answer: #E[n]

Question: Where was Nikola Tesla born and what notable inventions did he make?

Response:
Plan: Begin by searching for information about Nikola Tesla's birthplace.
#E1 = Bing[Nikola Tesla birthplace]
Plan: Use FactoidQA to determine his birthplace from the search results.
#E2 = FactoidQA[Where was Nikola Tesla born? Given context: #E1]
Plan: Search for information about Nikola Tesla's notable inventions.
#E3 = Bing[Nikola Tesla notable inventions]
Plan: Extract relevant links from the search results.
#E4 = LinkCollector[#E3]
Plan: Retrieve readable versions of the linked pages.
#E5 = Readability[#E4]
Plan: Use FactoidQA to identify and summarize Nikola Tesla's notable inventions from the page contents.
#E6 = FactoidQA[What notable inventions did Nikola Tesla make? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a comprehensive plan to solve the user query using the provided tools. For each step in the plan, assign an evidence value corresponding to the output of the called function.

Available Tools:
DuckDuckGo[input]: Allows users to conduct a web search using DuckDuckGo search engine. Useful for generating a list of potential sources containing answers.
PageLoader[input]: Loads one or more webpages from an input string containing newline separated URLs and returns plain text output containing the webpage contents.
URLGrabber[input]: Extracts URLs from a block of plain text and outputs them as a newline-separated list.
AskAI[input]: An AI-powered tool capable of answering questions based on a supplied context. The input should be a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Initial action based on the input question]
:evidence0: = [Function to call with its input]
Plan: [Subsequent action depending on the outcome of :evidence0:]
:evidence1: = [Next function to call with its input, possibly referencing earlier evidence]
...
Final Answer: [:evidence[n]: Containing the ultimate solution]

Question: Who invented the telephone and what were the key developments leading to its invention?

Response:
Plan: Initiate a web search to discover who invented the telephone.
:evidence0: = DuckDuckGo[Who invented the telephone]
Plan: Employ AskAI to interpret the search results and determine the inventor of the telephone.
:evidence1: = AskAI[Who invented the telephone, given :evidence0:?]
Plan: Perform another web search to find out about the key developments leading to the invention of the telephone.
:evidence2: = DuckDuckGo[Key developments leading to the invention of the telephone]
Plan: Use URLGrabber to isolate relevant links from the search results.
:evidence3: = URLGrabber[:evidence2:]
Plan: Deploy PageLoader to fetch data from the isolated links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, use AskAI to analyze the fetched data and summarize the key developments leading to the invention of the telephone.
:evidence5: = AskAI[What were the key developments leading to the invention of the telephone, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.