Instruction:
Develop a strategy to respond to the following query by making use of the tools given below. Each step in your strategy should have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Available Tools:
BingSearch[input]: This tool lets you perform a search on Bing's search engine.
WikiScanner[input]: This tool scans Wikipedia articles and returns a summary of the article.
URLCollector[input]: Collects URLs from a block of text.
PageReader[input]: Reads the contents of a webpage.
QuerySolver[input]: A tool that answers questions based on an input passage of text.

Output Format:
Plan: [First step based on input question]
#Evidence1 = [Function to call with input parameter]
Plan: [Next step based on result of #Evidence1]
#Evidence2 = [Next function to call and input parameter, possibly referencing previous evidence]
...
Final Response: #Evidence[n]

Question: What is the population of Tokyo and what is its GDP?

Response:
Plan: Perform a search to find out the population of Tokyo.
#Evidence1 = BingSearch[Population of Tokyo]
Plan: Utilize QuerySolver to interpret the search results and find the population.
#Evidence2 = QuerySolver[What is the population of Tokyo? Given context: #Evidence1]
Plan: Conduct another search to find the GDP of Tokyo.
#Evidence3 = BingSearch[GDP of Tokyo]
Plan: Extract the relevant links from the Bing search results for more detailed information.
#Evidence4 = URLCollector[#Evidence3]
Plan: Use PageReader to read the content of the relevant links.
#Evidence5 = PageReader[#Evidence4]
Plan: Finally, utilize QuerySolver to identify and summarize the GDP of Tokyo from the read content.
#Evidence6 = QuerySolver[What is the GDP of Tokyo? Given context: #Evidence5]
Final Response: #Evidence6

System: A chat.


Instruction:
Create a plan to solve the problem presented in the question below. Each step in your plan should have a corresponding evidence value, which will be the output of one of the available tools given an input string that could be the user question, one or more previous evidence values, or a mixture of both.

Available tools:
BingSearch[input]: A tool that uses Bing's search engine to find information related to the input query.
URLExtractor[input]: Extracts URLs from the provided plain text.
SiteLoader[input]: Loads the contents of one or more websites from the input string, which contains newline-delimited links.
KnowledgeModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that refers to 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 result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which may refer to previous evidence]
...
Answer: [:evidence[n]: Containing the final answer]

Question: Who was the director of the movie "Inception" and what other movies has he directed?

Response:
Plan: Begin by searching the web to find out who the director of "Inception" is.
:evidence0: = BingSearch[Director of Inception]
Plan: Use the KnowledgeModel to interpret the search results and determine the director's name.
:evidence1: = KnowledgeModel[Who is the director of "Inception", given :evidence0:?]
Plan: Conduct another web search to find other movies directed by the identified person.
:evidence2: = BingSearch[Movies directed by :evidence1:]
Plan: Extract the relevant links from the Bing search results for further investigation.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use SiteLoader to retrieve information from the selected links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Lastly, use the KnowledgeModel to identify and summarise the other movies directed by this individual from the gathered information.
:evidence5: = KnowledgeModel[What other movies were directed by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to respond to the following user query utilizing the provided tools. Each step of your plan should correspond to an evidence value which represents the output of a function given its input.

Tools Available:
InfoSeeker[input]: A tool that uses a general search engine to retrieve potentially relevant websites.
TextParser[input]: Parses a block of text and extracts key pieces of information.
URLCollector[input]: Gathers all URLs contained within a given piece of text.
KnowledgeProcessor[input]: Answers questions based on a provided context.

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

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

Response:
Plan: Initiate a search to find who won the 2020 Nobel Prize in Literature.
#E1 = InfoSeeker[2020 Nobel Prize in Literature winner]
Plan: Use KnowledgeProcessor to determine the winner from the search results.
#E2 = KnowledgeProcessor[Who won the 2020 Nobel Prize in Literature? Given context: #E1]
Plan: Conduct a new search to find the most notable work of the identified author.
#E3 = InfoSeeker[Most notable work of #E2]
Plan: Extract the URLs from the search results for further analysis.
#E4 = URLCollector[#E3]
Plan: Scrape the contents of the URLs for detailed information.
#E5 = TextParser[#E4]
Plan: Determine the most notable work of the author from the parsed text.
#E6 = KnowledgeProcessor[What is the most notable work of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a detailed plan to respond to the user instruction, making use of the available tools. Each plan should have a corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more prior evidence values, or a combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is helpful in finding a suitable list of sites that may or may not contain the answer to the user's question. The function does not directly answer the question but finds a list of sites that may have the answer.
SiteScraper[input]: Load one or more websites from the input string containing newline-delimited links, where the input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extract links from plain text and produces a plain text, newline-delimited response of links.
ALICE[input]: Question-answering language model, especially useful in answering questions based on an input passage of text. The input must be a text question that references a :fact[n]: variable, e.g., How tall is the Eiffel Tower, given :fact1:?

The input to each function should just be a plain string, without quotes or "+" to concatenate a string with a fact variable, e.g., ALICE[Who won the 2020 presidential election, given :fact3:?]

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

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

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

Response:
Plan: Begin by conducting a web search to understand the process of photosynthesis.
:fact0: = DuckDuckGo[Process of photosynthesis]
Plan: Use the language model to interpret the search results and describe the process of photosynthesis.
:fact1: = ALICE[What is the process of photosynthesis, given :fact0:?]
Plan: Conduct another web search to understand why photosynthesis is important for life on Earth.
:fact2: = DuckDuckGo[Importance of photosynthesis for life on Earth]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:fact3: = URLExtractor[:fact2:]
Plan: Use the SiteScraper tool to extract information from the relevant links.
:fact4: = SiteScraper[:fact3:]
Plan: Finally, utilize the language model to explain why photosynthesis is important for life on Earth from the extracted information.
:fact5: = ALICE[Why is photosynthesis important for life on Earth, given :fact4:?]
Final Answer: :fact5:

System: A chat.


Instruction:
Please provide a step-by-step plan to generate an appropriate response to the user instruction, making use of a set of available tools. Each plan will have a corresponding evidence value, which is the output of one of the available functions given an input string that can be the user question, one or more previous evidence values, or a 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 contain the answer to the user's question.
TextParser[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkHarvester[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly effective in answering questions based on an input passage of text. The input must be a text question that references a :data[n]: variable, e.g. What color is the dog, given :data1:?

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

Question: Who invented the electric guitar and what were their main contributions to music?

Response:
Plan: Start by conducting a web search to find out who invented the electric guitar.
:data0: = Bing[Inventor of the electric guitar]
Plan: Use a language model to interpret the search results and identify the inventor.
:data1: = SAM[Who invented the electric guitar, given :data0:?]
Plan: Conduct another web search to find the main contributions to music made by the identified inventor.
:data2: = Bing[Main contributions to music by :data1:]
Plan: Extract the relevant links from the Bing search results for a deeper investigation.
:data3: = LinkHarvester[:data2:]
Plan: Use a text parser tool to extract information from the relevant links.
:data4: = TextParser[:data3:]
Plan: Finally, utilize the language model to identify and summarize the main contributions to music made by the inventor from the extracted information.
:data5: = SAM[What were the main contributions to music by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
Create a plan to solve the following question using these available tools. Each tool will generate an evidence value that can be used in subsequent steps.

Here are the tools available to be called:
WebSearch[input]: This tool allows you to search for information on the web, providing a list of websites that may contain relevant information.
TextAnalyzer[input]: Analyzes a given text and provides key points or summaries from it.
QAEngine[input]: A tool that answers questions based on common knowledge or given context.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response containing those links.
WebsiteScraper[input]: Scrapes content from one or more websites provided as newline delimited links.

The output should follow this 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]
...
Final answer: #E[n]

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

Response:
Plan: Conduct a web search about the history of Bitcoin.
#E1 = WebSearch[History of Bitcoin]
Plan: Use TextAnalyzer to summarize the search results.
#E2 = TextAnalyzer[#E1]
Plan: Identify the creator of Bitcoin.
#E3 = QAEngine[Who created Bitcoin? Given context: #E2]
Plan: Search for more detailed information about the creator of Bitcoin.
#E4 = WebSearch[#E3]
Plan: Extract useful links from the search results.
#E5 = LinkExtractor[#E4]
Plan: Scrape the content from the extracted links.
#E6 = WebsiteScraper[#E5]
Plan: Summarize the scraped content to get detailed information about the creator of Bitcoin.
#E7 = TextAnalyzer[#E6]
Final answer: #E7

System: A chat.


Instruction:
Create a detailed execution plan using the following tools to solve the problem presented in the user's query. Each step in your plan should produce some form of evidence, which will be stored in a variable #E[index].

Available Tools:
Encyclopedia[input]: A tool that provides factual information about a wide range of topics.
QA[input]: A tool that answers questions directly based on common sense and world knowledge. It can also answer questions when provided with a context that contains the answer.
NewsArchive[input]: A tool that searches through historical news articles for specific information.
ImageAnalyzer[input]: A tool that analyzes images and returns descriptions of them.

Output Format:
Plan: [First action based on the user's query]
#E1 = [Function to call with appropriate input]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call with appropriate input, possibly referencing #E1]
...
Final Answer: #E[n]

Question: How did the tradition of Christmas trees start and what do the decorations symbolize?

Response:
Plan: Look up the history of Christmas trees.
#E1 = Encyclopedia[History of Christmas trees]
Plan: Find out how the tradition of Christmas trees started.
#E2 = QA[How did the tradition of Christmas trees start? Given context: #E1]
Plan: Look up the symbolism of Christmas tree decorations.
#E3 = Encyclopedia[Symbolism of Christmas tree decorations]
Plan: Determine what the decorations on a Christmas tree symbolize.
#E4 = QA[What do the decorations on a Christmas tree symbolize? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Develop a systematic plan to address the user's query using the available tools. Remember to assign an evidence number to each step of your plan.

Tools at your disposal:
BookFinder[input]: A tool for finding books online.
MusicBrainz[input]: A tool for finding music albums and tracks.
MovieDB[input]: A tool for finding information about films.
FoodFacts[input]: A tool for finding nutritional information about food items.
AskMe[input]: A tool that answers questions based on common knowledge or provided context.

Output Format:
Plan: First step based on the input question
#Evidence1 = Function to execute with the necessary input
Plan: Subsequent step depending on the outcome of #Evidence1
#Evidence2 = Next function to run with its input, possibly referring back to prior evidence like "Considering #Evidence1"
...
Final Response: #EvidenceN

Question: Can you recommend a book, a song, a movie, and a healthy snack all related to space exploration?

Response:
Plan: First, find a book related to space exploration.
#Evidence1 = BookFinder["space exploration"]

Plan: Next, find a song related to space exploration.
#Evidence2 = MusicBrainz["space exploration"]

Plan: Then, look for a movie related to space exploration.
#Evidence3 = MovieDB["space exploration"]

Plan: Finally, identify a healthy snack that could be somehow linked to space or astronauts.
#Evidence4 = AskMe["What is a healthy snack associated with space?"]

Final Response: #Evidence1 for the book recommendation, #Evidence2 for the song suggestion, #Evidence3 for the movie recommendation, and #Evidence4 for the healthy snack.

System: A chat.


Instruction:
Please generate a plan to respond to the user's instruction using the following tools. Each plan will have a corresponding evidence value.

Tools Available:
1. BingSearch[input]: Tool that uses Bing to search for information online. Input is a string representing the search query.
2. TextAnalyzer[input]: Analyzes a piece of text and extracts key information. Can be used to answer questions when provided with relevant context.
3. PageLoader[input]: Loads a webpage and retrieves its text content. Input is a URL or list of URLs.
4. UrlFinder[input]: Finds URLs in a piece of text. Input is a string of text.

Output Format:
Plan: [First action]
:Evidence0: = [Function call with input]
Plan: [Next action]
:Evidence1: = [Next function call with input, possibly referencing previous evidence]
...
Answer: :EvidenceN:

Question: Who won the Nobel Prize in Literature in 2018?

Response:
Plan: Start by conducting a Bing search to find out who won the Nobel Prize in Literature in 2018.
:Evidence0: = BingSearch[Nobel Prize in Literature 2018 winner]
Plan: Use TextAnalyzer to interpret the search results and identify the winner.
:Evidence1: = TextAnalyzer[Who won the Nobel Prize in Literature in 2018, given :Evidence0:?]
Answer: :Evidence1:

Continue this process for additional examples as needed.

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.
WebReader[input]: Load one website from the input string containing newline delimited links, where input is one link, and produces plain text output containing the content of the link.
HyperlinkFinder[input]: Extract hyperlinks from plain text and produces a plain text, newline delimited response of links.
InfoModel[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 input to each function just just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g. InfoModel[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 was Nikola Tesla and what were his major contributions to science?

Response:
Plan: Begin by conducting a web search to find out who Nikola Tesla was.
:evidence0: = DuckDuckGo[Nikola Tesla]
Plan: Utilize InfoModel to interpret the search results and find information about Nikola Tesla.
:evidence1: = InfoModel[Who was Nikola Tesla, given :evidence0:?]
Plan: Conduct another web search to find the major contributions made by Nikola Tesla to science.
:evidence2: = DuckDuckGo[Nikola Tesla major contributions to science]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = HyperlinkFinder[:evidence2:]
Plan: Use WebReader tool to extract information from the relevant link.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, utilize the InfoModel to identify and summarize the major contributions made by Nikola Tesla to science from the extracted information.
:evidence5: = InfoModel[What were the major contributions of Nikola Tesla to science, given :evidence4:?]
Answer: :evidence1: and :evidence5:

System: A chat.


Instruction:
Generate a plan to solve the problem below using the provided tools. For each step, specify which tool to use along with its input. Store the result into a variable #E[index] that can be referenced by later tools.

Tools Available:
Bing[input]: Tool that allows users to perform a Bing search. The input should be a search string.
WikiLookup[input]: Looks up a Wikipedia page based on the input string.
QA[input]: Can answer questions based on general knowledge or given context.
Translate[input]: Translates the input text to English.

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

Question: What is the significance of the Rosetta Stone and why was it important?

Response:
Plan: Look up the Rosetta Stone on Wikipedia.
#E1 = WikiLookup[Rosetta Stone]
Plan: Find out the significance of the Rosetta Stone.
#E2 = QA[What is the significance of the Rosetta Stone? Given context: #E1]
Plan: Find out why the Rosetta Stone was important.
#E3 = QA[Why was the Rosetta Stone important? Given context: #E1]
Final Answer: #E2 and #E3

System: A chat.


Instruction:
Formulate a thorough plan to answer the following user query using the provided tools. Each plan will match an evidence value, which will be the output of one of the available functions given an input string that might be the user's question, one or more previous evidence values, or a blend of both.

You can use the following tools:
Yahoo[input]: This tool permits users to carry out information searches through the Yahoo search engine.
LinkLifter[input]: This function extracts links from plain text and returns a plain text list of links.
PagePicker[input]: This tool retrieves one or more websites from an input string containing newline-separated links, where the input is one or more links, and produces plain text content from those links.
KnowledgeBase[input]: This tool executes a search on Knowledge Base for related articles based on the input string.
QuerySolver[input]: This is a question-answering language model skilled at answering questions based on an input text passage. The input must be a text question that refers to a #G[index] variable.

Output format:
Plan: [Initial action taken based on input question]
#G1 = [Function to invoke with input parameter]
Plan: [Following action taken based on the outcome of #G1]
...
Final Solution: #G[n]

Question: What is the Pythagorean theorem and how is it used in geometry?

Response:
Plan: Start by performing a Knowledge Base search to understand the Pythagorean theorem.
#G1 = KnowledgeBase[Pythagorean theorem]
Plan: Use QuerySolver to define the Pythagorean theorem from the Knowledge Base article.
#G2 = QuerySolver[What is the Pythagorean theorem? Given context: #G1]
Plan: Perform a Yahoo search to learn how the Pythagorean theorem is applied in geometry.
#G3 = Yahoo[How is the Pythagorean theorem used in geometry?]
Plan: Lift the relevant links from the Yahoo search results for a more concentrated examination.
#G4 = LinkLifter[#G3]
Plan: Use PagePicker to extract information from these links.
#G5 = PagePicker[#G4]
Plan: Finally, use QuerySolver to outline how the Pythagorean theorem is utilized in geometry from the extracted information.
#G6 = QuerySolver[How is the Pythagorean theorem used in geometry? Given context: #G5]
Final Solution: #G6

System: A chat.


Instruction:
Develop a stepwise plan to respond to the following user command, employing the suite of tools available. Each part of your plan should align with an evidence value, which will be the output of one of the available functions when given an input string that could be the user's question, former evidence values, or both.

You can make use of these tools:
1. Baidu[input]: This tool permits the user to execute an internet search using the Baidu search engine. It generates a list of probable websites that may encompass the answer to the user's question.
2. WebExplorer[input]: This function loads one or more websites from the input string (comprising newline-separated links) and renders the textual content of these sites.
3. LinkFinder[input]: This tool sifts through plain text and outputs them as a newline-separated list of links.
4. DataInterpreter[input]: An AI-driven language model proficient at answering questions grounded on an input text passage. The input should be a question that references an :evidence[n]: variable.

The output should conform to the following template:
Plan: [Initial action rooted in the input question]
:evidence0: = [Function invocation with input parameter]
Plan: [Subsequent action hinged on the result of :evidence0:]
:evidence1: = [Next function invocation with input parameter, potentially alluding to previous evidence]
...
Final Answer: [:evidence[n]: containing the conclusive reply]

Question: Can you explain the concept of quantum entanglement and its implications in quantum computing?

Response:
Plan: Commence by executing a web search to amass information about the concept of quantum entanglement.
:evidence0: = Baidu[Concept of quantum entanglement]
Plan: Engage the DataInterpreter to scrutinize the search results and offer a concise explanation of quantum entanglement.
:evidence1: = DataInterpreter[What is quantum entanglement? Given context: :evidence0:?]
Plan: Run another web search to comprehend the implications of quantum entanglement in quantum computing.
:evidence2: = Baidu[Implications of quantum entanglement in quantum computing]
Plan: Sift out the relevant links from the search results for a more exhaustive examination.
:evidence3: = LinkFinder[:evidence2:]
Plan: Leverage the WebExplorer tool to pull information from the filtered links.
:evidence4: = WebExplorer[:evidence3:]
Plan: Finally, engage the DataInterpreter to encapsulate the implications of quantum entanglement in quantum computing from the pulled information.
:evidence5: = DataInterpreter[What are the implications of quantum entanglement in quantum computing? Given context: :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to solve the following problem step-by-step. For each step, indicate which tool you will use and what input you will provide to it. You can store the results of these tools in variables #E[index] for future reference.

Here are the available tools:

1. Bing[input]: This tool allows you to search for information using the Bing search engine. It is useful for finding sites that may contain answers to your question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
2. WebReader[input]: This tool reads one or more websites from an input string containing newline delimited links. Input should be one or more links, and produces plain text output containing the content of the links.
3. LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
4. QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?

The output should follow this format:
Plan: [first action]
#E0 = [function call with input parameter]
Plan: [next action based on result of #E0]
#E1 = [next function 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 is their most famous work?

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
#E0 = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the question answering model to identify the winner from the search results.
#E1 = QAModel[Who won the Nobel Prize in Literature in 2020? Given context: #E0]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E2 = Bing[Most famous work of #E1]
Plan: Extract relevant links from the search results for detailed information.
#E3 = LinkPicker[#E2]
Plan: Read the content of the extracted links.
#E4 = WebReader[#E3]
Plan: Finally, use the question answering model to identify the most famous work of the laureate from the read content.
#E5 = QAModel[What is the most famous work of #E1? Given context: #E4]
Final Answer: #E5

System: A chat.


Instruction:
Create a plan to identify the main ingredients in traditional Italian lasagna.

Available tools:
RecipeFinder[input]: Searches for recipes based on the dish name.
IngredientExtractor[input]: Extracts list of ingredients from a recipe.
GoogleTranslate[input]: Translates text from one language to another.
QA[input]: Answers questions using general world knowledge or given context.

Output format:
Plan: [first action]
:Evidence0: = [function call with input parameter]
Plan: [next action based on :Evidence0:]
:Evidence1: = [next function call with input parameter referencing previous evidence if necessary]
...
Answer: [:Evidence[n]: containing the final answer.]

Response:
Plan: Use RecipeFinder to search for a traditional Italian lasagna recipe.
:Evidence0: = RecipeFinder["traditional Italian lasagna"]
Plan: Extract the list of ingredients from the found recipe using IngredientExtractor.
:Evidence1: = IngredientExtractor[:Evidence0:]
Answer: :Evidence1:

System: A chat.


Instruction:
Please provide a step-by-step plan to solve the following question using the tools provided. For each step, indicate which tool you would use and what input you would give it. Store the output of each tool in a variable #E[index] that can be referenced later.

Here are the available tools:
1. GoogleSearch[input]: This tool allows users to search for information on Google. The input should be a query string.
2. TextExtractor[input]: This tool extracts text from web pages. The input should be one or more URLs.
3. QA[input]: This tool answers questions based on common sense, general world knowledge, or given context. The input should be a question string, optionally referencing previous evidence variables.
4. ImageSearch[input]: This tool searches for images related to the input query string.

The output format should be as follows:
Plan: [First action]
#E1 = [Tool with input parameter]
Plan: [Next action]
#E2 = [Next tool with input parameter]
...
Final answer: #E[n]

Question: What is the main diet of the African elephant and where can I find an image of this food?

Response:
Plan: Start by searching for information about the diet of the African elephant.
#E1 = GoogleSearch[African elephant diet]
Plan: Extract relevant text from the search results.
#E2 = TextExtractor[#E1]
Plan: Use the QA tool to identify the main diet from the extracted text.
#E3 = QA[What is the main diet of the African elephant? Given context: #E2]
Plan: Search for an image of the identified food.
#E4 = ImageSearch[#E3]
Final answer: #E4

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. For each step, provide an action and the tool used with its input parameter. Store the output of each tool in a variable :evidence[index]: that can be referenced by subsequent steps.

Here are the tools available:
Bing[input]: A search engine that provides a list of websites relevant to the input query.
ReadText[input]: Reads text from a given website URL and produces plain text output containing the content of the page.
LinkExtractor[input]: Extracts links from plain text and produces a newline-delimited response of links.
QA[input]: Answers questions based on common sense, general world knowledge, or given context that may contain the answer.

The output should follow this format:
Plan: [first action]
:evidence0: = [function call with input]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with input, possibly referencing previous evidence]
...
Final Answer: [:evidence[n]:]

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

Response:
Plan: Start by searching for information about the history of the Eiffel Tower.
:evidence0: = Bing[History of the Eiffel Tower]
Plan: Extract useful links from the search results.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Read the text from the extracted links.
:evidence2: = ReadText[:evidence1:]
Plan: Use the QA tool to find out the history behind the creation of the Eiffel Tower.
:evidence3: = QA[What is the history behind the creation of the Eiffel Tower? Given context: :evidence2:]
Plan: Use the QA tool again to identify the key people involved in the creation of the Eiffel Tower.
:evidence4: = QA[Who were the key people involved in the creation of the Eiffel Tower? Given context: :evidence2:]
Final Answer: The history behind the creation of the Eiffel Tower is detailed in :evidence3:. The key people involved are listed in :evidence4:.

System: A chat.


Instruction:
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:
GoogleSearch[input]: Tool that allows the user to search for information using Google. This tool is useful in finding websites that may contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAEngine[input]: Question answering engine, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

Question: What are some key achievements of Elon Musk and what companies he has founded?

Response:
Plan: Start by conducting a web search to find out about Elon Musk's key achievements.
:evidence0: = GoogleSearch[Elon Musk key achievements]
Plan: Use a language model to interpret the search results and list the key achievements.
:evidence1: = QAEngine[What are the key achievements of Elon Musk, given :evidence0:?]
Plan: Conduct another web search to find the companies founded by Elon Musk.
:evidence2: = GoogleSearch[Companies founded by Elon Musk]
Plan: Extract the relevant links from the Google search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the companies founded by Elon Musk from the extracted information.
:evidence5: = QAEngine[What are the companies founded by Elon Musk, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables users to search for information using the DuckDuckGo search engine. This tool assists in finding suitable sites that may hold the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and generates plain text output containing the content of the links.
HyperlinkGatherer[input]: Extracts links from plain text and delivers a plain text, newline delimited response of links.
Einstein[input]: Question answering language model, especially effective in answering questions based on an input passage of text. The input must be a text question that refers to 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: Who is the director of the movie "Inception" and what other movies has he directed?

Response:
Plan: Start by conducting a web search to find out who directed the movie "Inception".
:evidence0: = DuckDuckGo[Director of Inception]
Plan: Use Einstein to interpret the search results and identify the director.
:evidence1: = Einstein[Who is the director of Inception, given :evidence0:?]
Plan: Conduct another web search to find other movies directed by the identified person.
:evidence2: = DuckDuckGo[Movies directed by :evidence1:]
Plan: Extract the relevant links from the DuckDuckGo search results for detailed information.
:evidence3: = HyperlinkGatherer[:evidence2:]
Plan: Use SiteLoader to extract information from the selected links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, use Einstein to identify and summarize the other movies directed by the person from the extracted information.
:evidence5: = Einstein[What other movies has :evidence1: directed, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the following question using the available tools. Each step should have a corresponding evidence value, which will be the output of one of the available functions given an input string that can be either 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 from any search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
WebsiteScraper[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.
QAtool[input]: A question answering tool that can provide answers based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Ensure to include only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who won the 2018 FIFA World Cup.
:evidence0: = SearchEngine[2018 FIFA World Cup winner]
Plan: Use the QAtool to interpret the search results and identify the winning team.
:evidence1: = QAtool[Who won the 2018 FIFA World Cup, given :evidence0:?]
Plan: Conduct another web search to find the top scorer of the 2018 FIFA World Cup.
:evidence2: = SearchEngine[2018 FIFA World Cup top scorer]
Plan: Utilize the QAtool to interpret the search results and identify the top scorer.
:evidence3: = QAtool[Who was the top scorer of the 2018 FIFA World Cup, given :evidence2:?]
Answer: :evidence1: and :evidence3:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information from Bing. This tool is useful in finding appropriate sites that may contain the answer to the user's question.
URLLoader[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.
KLM[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

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

Response:
Plan: Start by conducting a web search to find out about the notable works of art at the Louvre Museum.
:evidence0: = Bing[Notable works of art at the Louvre Museum]
Plan: Use LinkCollector to extract relevant links from the search results.
:evidence1: = LinkCollector[:evidence0:]
Plan: Utilize URLLoader to load the contents of the extracted links.
:evidence2: = URLLoader[:evidence1:]
Plan: Finally, use KLM to identify and summarize the notable works of art at the Louvre Museum from the loaded contents.
:evidence3: = KLM[What are some of the notable works of art at the Louvre Museum? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction: [question formatted similarly to the example, including instructions, descriptions of functions, output format, etc.]

Response: [answer to the question, formatted according to the

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

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

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

Response:
Plan: Begin by conducting a web search to find out the population of Tokyo.
:evidence0: = BingSearch[Population of Tokyo]
Plan: Utilize AIQA to interpret the search results and find the population.
:evidence1: = AIQA[What is the population of Tokyo, given :evidence0:?]
Plan: Conduct another web search to find the popular tourist attractions in Tokyo.
:evidence2: = BingSearch[Popular tourist attractions in Tokyo]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use WebCrawler to extract information from the relevant links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, utilize AIQA to identify and summarize the popular tourist attractions in Tokyo from the extracted information.
:evidence5: = AIQA[What are the popular tourist attractions in Tokyo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a step-by-step plan to respond to the user query, utilizing a range of available tools. Each step will yield an evidence value, representing the output of a specific function given an input string - this could be the user's question, earlier evidence values, or a combination of both.

Available tools include:
DuckDuckGo[input]: A tool allowing users to perform searches via DuckDuckGo. Useful for locating potential sources of answers to the user's question.
WebReader[input]: Reads and extracts plain text from websites listed in the input string (links separated by newlines).
URLCollector[input]: Gathers URLs from plain text, producing a newline-separated list of links.
QueryMaster[input]: A language model capable of answering questions based on a provided text passage. Questions should reference an :evidence[n]: variable.

Output should follow this structure:
Plan: [initial action based on input question]
:evidence0: = [called function with input parameters]
Plan: [subsequent action based on :evidence0:'s outcome]
:evidence1: = [next function call with input parameters, potentially referencing prior evidence]
...
Final Answer: [:evidence[n]: holding the ultimate answer]

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

Response:
Plan: Initiate a web search to identify the first person to climb Mount Everest.
:evidence0: = DuckDuckGo[First person to climb Mount Everest]
Plan: Employ QueryMaster to interpret the search results and pinpoint the climber's name.
:evidence1: = QueryMaster[Who was the first person to climb Mount Everest? Given context: :evidence0:?]
Plan: Conduct another web search to discover the challenges faced by the identified climber during their ascent.
:evidence2: = DuckDuckGo[Challenges faced by :evidence1: climbing Mount Everest]
Plan: Use URLCollector to gather pertinent links from the search results.
:evidence3: = URLCollector[:evidence2:]
Plan: Utilize WebReader to retrieve information from these selected links.
:evidence4: = WebReader[:evidence3:]
Plan: Lastly, deploy QueryMaster to summarize the key challenges faced by the climber, based on the retrieved data.
:evidence5: = QueryMaster[What were the main challenges faced by :evidence1: while climbing Mount Everest? Given context: :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using DuckDuckGo's search engine. It finds a list of sites that may contain the answer to the user's question.
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.
URLExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
ASKER[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:]
...
Answer: [:evidence[n]: containing the final answer.]

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

Response:
Plan: Begin by conducting a web search to find out who Albert Einstein was.
:evidence0: = DuckDuckGo[Albert Einstein]
Plan: Utilize ASKER to interpret the search results and find information about Albert Einstein.
:evidence1: = ASKER[Who was Albert Einstein, given :evidence0:?]
Plan: Conduct another web search to find the major contributions of Albert Einstein to physics.
:evidence2: = DuckDuckGo[Major contributions of Albert Einstein to physics]
Plan: Extract the relevant links from the DuckDuckGo search results for more detailed information.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use SiteReader to extract information from the relevant links.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, utilize ASKER to identify and summarize the major contributions of Albert Einstein to physics from the extracted information.
:evidence5: = ASKER[What were the major contributions of Albert Einstein to physics, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a strategy to respond to the following inquiry using the resources provided. Each stage in your strategy should have a corresponding evidence value, which will be the product of one of the available operations given an input string. This could be the original question, earlier evidence values, or a combination of both.

Tools at your disposal include:
Bing[input]: A tool that enables users to conduct a Bing search for information. This tool is handy for locating websites that might contain the response to the user's question.
URLReader[input]: Reads the content of a website given its URL. The input should be a single link and the output will be plain text content of the page.
LinkSelector[input]: Selects the most pertinent links from a list of URLs based on the input query.
QuerySolver[input]: A tool capable of answering questions based on an input text passage. The input must be a textual question that refers to a #E[n] variable, such as What is the tallest mountain, given #E1?

Output format should look like this:
Plan: [initial action]
#E1 = [call to function with input parameter]
Plan: [subsequent action dependent on outcome of #E1]
#E2 = [next call to function with input parameter, potentially referencing prior evidence, e.g., "Given context #E1"]
...
Final Response: #E[n]

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

Response:
Plan: Begin by conducting a Bing search to determine the director of the movie Inception.
#E1 = Bing[Director of Inception]
Plan: Utilize QuerySolver to analyze the search results and identify the director.
#E2 = QuerySolver[Who is the director of Inception, given #E1?]
Plan: Perform another Bing search to discover other movies directed by the identified individual.
#E3 = Bing[Movies directed by #E2]
Plan: Choose the most relevant links from the search results for further investigation.
#E4 = LinkSelector[#E3]
Plan: Read the content of the chosen link(s) for additional information about the director's filmography.
#E5 = URLReader[#E4]
Plan: Lastly, utilize QuerySolver to identify and summarize other movies directed by the same person from the read content.
#E6 = QuerySolver[What other movies has #E2 directed, given #E5?]
Final Response: #E6

System: A chat.


Instruction:
Create a step-by-step plan to answer the user query using the available tools. Each tool will produce an evidence value, which can be used as input for subsequent steps.

Here are the tools that can be called:

WebSearch[input]: A tool that uses a search engine to find information on the web. The output is a list of websites that may contain the answer to the question.
TextExtractor[input]: Extracts plain text from one or more websites provided in the input string (newline separated links).
LinkParser[input]: Parses plain text and produces a newline-separated list of URLs.
AIAnswerer[input]: An AI model capable of answering questions based on an input passage of text. The input must reference an #E[n] variable, e.g., "What color is the cat, given #E1?"

The output should follow this format:
Plan: [first action]
#E0 = [function with input parameter]
Plan: [next action, based on result of #E0]
#E1 = [next function with input parameter, possibly referencing previous evidence like "#E0"]
...
Final Answer: [#En]

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

Response:
Plan: Start by searching the web to determine the current population of Tokyo.
#E0 = WebSearch[Current population of Tokyo]
Plan: Use the AIAnswerer to interpret the search results and provide the population number.
#E1 = AIAnswerer[What is the current population of Tokyo, given #E0?]
Plan: Conduct another web search to identify famous landmarks in Tokyo.
#E2 = WebSearch[Famous landmarks in Tokyo]
Plan: Parse the search results to extract relevant links for further investigation.
#E3 = LinkParser[#E2]
Plan: Extract textual content from the identified links.
#E4 = TextExtractor[#E3]
Plan: Finally, use the AIAnswerer to identify and summarize the famous landmarks in Tokyo from the extracted text.
#E5 = AIAnswerer[What are some famous landmarks in Tokyo, given #E4?]
Final Answer: #E5

System: A chat.


Instruction:
Please create a detailed 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. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
ALM[input]: Advanced 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. How old is the Eiffel Tower, 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. ALM[What is the population of New York City, 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: What is the history behind the construction of the Sydney Opera House and who were the key people involved?

Response:
Plan: Begin by conducting a web search to find out about the history of the Sydney Opera House.
:evidence0: = DuckDuckGo[History of Sydney Opera House]
Plan: Utilize the advanced language model to interpret the search results and provide a summary of the history.
:evidence1: = ALM[What is the history of the Sydney Opera House, given :evidence0:?]
Plan: Conduct another web search to find the key people involved in the construction of the Sydney Opera House.
:evidence2: = DuckDuckGo[Key people involved in the construction of Sydney Opera House]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, utilize the advanced language model to identify and summarize the key people involved in the construction of the Sydney Opera House from the extracted information.
:evidence5: = ALM[Who were the key people involved in the construction of the Sydney Opera House, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to solve the following question using the available tools. 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 the user's question, previous evidence values, or both.

Here are the tools you can use:
WebSearch[input]: This tool allows you to search for information on the web. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextExtractor[input]: Extracts text from websites and produces plain text output containing the content of the links.
LinkPicker[input]: Picks out relevant links from a list of URLs provided in the input.
KnowledgeEngine[input]: A powerful tool 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 is the capital of France, given #E1?"

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

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

Response:
Plan: Start by conducting a web search to find out who was the first person to climb Mount Everest without supplemental oxygen.
#E1 = WebSearch[First person to climb Mount Everest without supplemental oxygen]
Plan: Use KnowledgeEngine to interpret the search results and identify the climber.
#E2 = KnowledgeEngine[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: #E1]
Plan: Conduct another web search to find out why this person climbed Mount Everest without supplemental oxygen.
#E3 = WebSearch[Why did #E2 climb Mount Everest without supplemental oxygen?]
Plan: Extract the relevant links from the web search results.
#E4 = LinkPicker[#E3]
Plan: Use TextExtractor to get information from the chosen links.
#E5 = TextExtractor[#E4]
Plan: Finally, use KnowledgeEngine to summarize the reasons why the identified climber decided to climb Mount Everest without supplemental oxygen.
#E6 = KnowledgeEngine[Why did #E2 climb Mount Everest without supplemental oxygen? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Please develop a plan to answer the following question using the tools provided. For each step in your plan, provide an evidence variable that corresponds to the output of the tool you use.

The available tools are as follows:

WebSearch[input]: This tool uses a search engine to find information related to the input query. It provides a list of potential sources but does not directly answer the question.
ArticleReader[input]: This tool can read and summarize articles from the internet. The input should be a URL from one of the sources found by WebSearch.
LinkFinder[input]: This tool extracts URLs from the text provided in the input.
QAHelper[input]: This tool answers questions based on the context given in the input. The input must include a reference to an evidence variable.

Your response should follow this format:
Plan: [First action]
#E1 = [Tool to use with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next tool to use with input parameter, possibly referencing #E1]
...
Final Answer: #En

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

Response:
Plan: Use a web search to find information about the first person to climb Mount Everest without supplemental oxygen.
#E1 = WebSearch[First person to climb Mount Everest without supplemental oxygen]
Plan: Extract links from the search results for more detailed information.
#E2 = LinkFinder[#E1]
Plan: Read and summarize the article found in the search results.
#E3 = ArticleReader[#E2]
Plan: Identify the name of the first person to climb Mount Everest without supplemental oxygen from the summarized article.
#E4 = QAHelper[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: #E3]
Final Answer: #E4

System: A chat.


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

Here are the tools available to be called:
SearchEngine[input]: Tool that allows the user to search for information using a generic search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
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 the Eiffel Tower and who were the key people involved?

Response:
Plan: Start by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = SearchEngine[History of the Eiffel Tower]
Plan: Use a language model to interpret the search results and summarize the history of the Eiffel Tower.
:evidence1: = QAModel[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find the key people involved in the creation of the Eiffel Tower.
:evidence2: = SearchEngine[Key people involved in the creation of the Eiffel Tower]
Plan: Extract the relevant links from the search results for a more focused search.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the key people involved in the creation of the Eiffel Tower from the extracted information.
:evidence5: = QAModel[Who were the key people involved in the creation of the Eiffel Tower, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to answer the following question using the tools provided. Each step in your plan should be followed by an evidence variable, which will store the output of one of the available functions given its input string.

The available tools are as follows:

Bing[input]: A tool that allows you to search for information on Bing's search engine. This function is useful for finding websites that may contain the answer to the user's query. The function does not directly provide an answer; it generates a list of sites that might have the answer.
WebReader[input]: Reads and extracts plain text from one or more websites based on the input string containing newline separated links. Input can be one or multiple links and the output is plain text content of these links.
LinkPicker[input]: Picks out links from plain text and produces a plain text response with newline-separated links.
AnswerBot[input]: A language model capable of answering questions based on a passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., What color is the dog, given :evidence1:?

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

Ensure only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who the author of 'To Kill a Mockingbird' is.
:evidence0: = Bing['To Kill a Mockingbird' author]
Plan: Use the language model to interpret the search results and identify the author.
:evidence1: = AnswerBot[Who is the author of 'To Kill a Mockingbird', given :evidence0:?]
Plan: Conduct another web search to find other works published by the identified author.
:evidence2: = Bing[Other works by :evidence1:]
Plan: Extract relevant links from the Bing search results for detailed examination.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use the WebReader tool to extract information from the selected links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, use the language model to identify and summarize the other works published by the author from the extracted information.
:evidence5: = AnswerBot[What other works has :evidence1: published, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a sequential plan to respond optimally to the user instruction, utilizing a selection of available tools. Each step in the plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user's question, prior evidence values, or a mix of both.

Available tools for usage:
DuckDuckGo[input]: A tool enabling users to perform searches using the DuckDuckGo search engine. It helps in locating a range of sites that might hold the answer to the user's inquiry.
SiteScraper[input]: Loads one or more websites from the input string containing newline separated links, where input consists of one or more links, and yields plain text output comprising the content of the links.
URLExtractor[input]: Pulls out links from plain text and generates a plain text, newline separated response of links.
AIQA[input]: An artificial intelligence-based question-answering model, especially effective in responding to queries based on an input text passage. The input has to be a textual question referencing an :evidence[n]: variable, e.g., What is the height of the Eiffel Tower, given :evidence1:?

Output format:
Plan: [initial action based on input question]
:evidence0: = [function to invoke with input parameter]
Plan: [subsequent action based on outcome of :evidence0:]
:evidence1: = [next function to invoke and input parameter, potentially including reference to earlier evidence, e.g., "Considering context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

Question: Who invented the telephone and what were some major developments in its early history?

Response:
Plan: Initiate a web search to discover who invented the telephone.
:evidence0: = DuckDuckGo[Inventor of the telephone]
Plan: Deploy the AIQA model to interpret the search outcomes and identify the inventor.
:evidence1: = AIQA[Who invented the telephone, given :evidence0:?]
Plan: Execute another web search to learn about major developments in the early history of the telephone.
:evidence2: = DuckDuckGo[Early history of the telephone]
Plan: Extract pertinent links from the DuckDuckGo search results for a detailed investigation.
:evidence3: = URLExtractor[:evidence2:]
Plan: Employ the SiteScraper tool to pull information from the selected links.
:evidence4: = SiteScraper[:evidence3:]
Plan: Lastly, utilize the AIQA model to pinpoint and summarize the key developments from the obtained information.
:evidence5: = AIQA[What were some major developments in the early history of the telephone, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step plan to respond to the user instruction, making use of the available tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could 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. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
HTMLParser[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: 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 :info[n]: variable, e.g., What color is the cat, given :info1:?

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 :info3:?]

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

Question: What is the tallest mountain in Australia and how high is it?

Response:
Plan: Begin by conducting a web search to find out the tallest mountain in Australia.
:info0: = DuckDuckGo[Tallest mountain in Australia]
Plan: Utilize a language model to interpret the search results and find the name of the mountain.
:info1: = QAModel[What is the tallest mountain in Australia, given :info0:?]
Plan: Conduct another web search to find the height of the identified mountain.
:info2: = DuckDuckGo[Height of :info1:]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:info3: = URLExtractor[:info2:]
Plan: Use a HTML Parser tool to extract information from the relevant links.
:info4: = HTMLParser[:info3:]
Plan: Finally, utilize the language model to identify the height of the mountain from the extracted information.
:info5: = QAModel[How high is :info1:, given :info4:?]
Answer: :info5:

System: A chat.


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

Here are the tools you can use:
Bing[input]: A tool that lets you search for information on Bing. This function is useful in finding websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from web pages given a list of URLs separated by newlines. The output is plain text containing the content of the links.
LinkPicker[input]: Picks out links from plain text and gives a plain text response with newline-separated links.
QAModel[input]: Question answering model effective at providing answers based on an input passage of text. The input must be a question referencing a :data[n]: variable, e.g., What is the capital of France, given :data1:?

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

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

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

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

Response:
Plan: Start by conducting a Bing search to find out who won the Nobel Prize in Literature in 2020.
:data0: = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the QAModel to interpret the search results and identify the winner.
:data1: = QAModel[Who won the Nobel Prize in Literature in 2020, given :data0:?]
Plan: Conduct another Bing search to find the most famous work of the identified laureate.
:data2: = Bing[:data1: most famous work]
Plan: Extract relevant links from the Bing search results for more focused research.
:data3: = LinkPicker[:data2:]
Plan: Use TextExtractor to extract information from the relevant links.
:data4: = TextExtractor[:data3:]
Plan: Finally, use the QAModel to identify and summarize the most famous work of the laureate from the extracted information.
:data5: = QAModel[What is the most famous work of :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
Develop a detailed plan to solve the following problem, making use of the provided tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user query, one or more prior evidence values, or a combination of both.

Here are the tools available to be called:
WikiLookup[input]: Allows the user to look up information from Wikipedia. This tool is especially useful for gaining knowledge about people, places, corporations, historical events, and other types of factual information.
TextAnalyzer[input]: Analyzes a block of text and extracts key details, producing a summary as output.
HyperlinkCollector[input]: Collects hyperlinks from a body of text and provides them as a list.
AIResponder[input]: A language model capable of answering queries based on an input passage of text. The input must be a textual question referencing a #info[n] variable, such as 'What is the population of Tokyo, given #info1?'

Each function requires a simple string as input, without quotation marks or '+' symbols to join a string with an info variable, like AIResponder[What is the GDP of France, given #info3?].

Remember to provide only one evidence output for each planning step.

The output should follow this format:
Plan: [First action based on the input question]
#info0 = [Function to call with input parameter]
Plan: [Next action, based on the outcome of #info0]
#info1 = [Next function to call and input parameter, possibly referring to previous evidence, such as 'Given context #info0']
...
Final Answer: [#info[n], which contains the final answer.]

Question: What are some major accomplishments of Marie Curie and how did they impact the world?

Response:
Plan: Look up information about Marie Curie on Wikipedia.
#info0 = WikiLookup[Marie Curie]
Plan: Use the TextAnalyzer to extract major accomplishments of Marie Curie from the Wikipedia page.
#info1 = TextAnalyzer[Major accomplishments of Marie Curie. Given context: #info0]
Plan: Search again on Wikipedia for more detailed information about these accomplishments.
#info2 = WikiLookup[#info1]
Plan: Use the TextAnalyzer again to understand how these accomplishments impacted the world.
#info3 = TextAnalyzer[Impact of Marie Curie's accomplishments on the world. Given context: #info2]
Final Answer: #info3

System: A chat.


Instruction:
Generate a detailed plan to answer the following question using the provided tools. Each step of your plan should indicate which tool will be used and what input will be given to that tool. You can store the output of each tool into a variable :evidence[index]: for future references.

Available Tools:
WebSearch[input]: This tool enables users to perform an online search by providing a query string as input.
ArticleParser[input]: This tool takes a URL as input and returns a structured summary of the article at that URL.
LLM[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.
URLExtractor[input]: This tool extracts URLs from a given piece of text.

Output Format:
Plan: [First action based on the input question]
:evidence0: = [Tool to call with input parameters]
Plan: [Next action based on the result of :evidence0:]
:evidence1: = [Next tool to call with input parameters, possibly referencing prior evidence variables]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2020?

Response:
Plan: Perform a web search to find out who won the Nobel Prize in Literature in 2020.
:evidence0: = WebSearch[Nobel Prize in Literature 2020 winner]
Plan: Use LLM to identify the winner from the search results.
:evidence1: = LLM[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Conduct another web search to find a comprehensive article about the winner.
:evidence2: = WebSearch[:evidence1: biography]
Plan: Extract the most relevant link from the search results.
:evidence3: = URLExtractor[:evidence2:]
Plan: Parse the article to get a structured summary.
:evidence4: = ArticleParser[:evidence3:]
Plan: Use LLM to summarize the key points from the article.
:evidence5: = LLM[Tell me about :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please provide a step-by-step plan to answer the user's question, using the available tools. Each plan should have an associated 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 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. The function doesn't directly answer the question; it finds a list of sites that might have the answer.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AskJeeves[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 should just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g. AskJeeves[What is the capital of Michigan, given :evidence3:?]

Ensure only one evidence output per plan step.

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

Question: Who won the 2022 FIFA World Cup and what was their path to victory?

Response:
Plan: Start by conducting a web search to find out who won the 2022 FIFA World Cup.
:evidence0: = Bing[2022 FIFA World Cup winner]
Plan: Use a language model to interpret the search results and identify the winning team.
:evidence1: = AskJeeves[Who won the 2022 FIFA World Cup, given :evidence0:?]
Plan: Conduct another web search to find the path to victory of the identified team.
:evidence2: = Bing[:evidence1: + ' 2022 FIFA World Cup path to victory']
Plan: Extract relevant links from the Bing search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to summarize the path to victory of the winning team from the extracted information.
:evidence5: = AskJeeves[What was the path to victory for :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please create a plan to answer the following question using the available tools. Each step of your plan should correspond to 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 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. The function doesn't directly answer the question; it finds a list of sites that might have the answer.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

Ensure only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who the author of '1984' is.
:evidence0: = Bing['1984' book author]
Plan: Use a language model to interpret the search results and identify the author.
:evidence1: = QAModel[Who is the author of the book '1984', given :evidence0:?]
Plan: Conduct another web search to find other books written by the identified author.
:evidence2: = Bing[Books written by :evidence1:]
Plan: Extract relevant links from the Bing search results for a deeper search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the extracted links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the other books written by the author from the scraped information.
:evidence5: = QAModel[What other books has :evidence1: written, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools you can use:
WebSearch[input]: A tool that allows the user to search for information on the web. 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 a webpage given its URL. The input must be a URL and the output is plain text containing the content of the page.
LinkFinder[input]: Finds links within a block of text. The input is a string of text and the output is a list of URLs found within the text.
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 an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

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

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

System: A chat.


Instruction:
Please create a step-by-step plan to generate an answer 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.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
GPT3[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What are some of the most significant contributions made by Ada Lovelace in the field of computing?

Response:
Plan: Begin by conducting a web search to find out about Ada Lovelace's contributions in computing.
:evidence0: = Bing[Ada Lovelace contributions in computing]
Plan: Utilize a language model to interpret the search results and find the key contributions.
:evidence1: = GPT3[What are the contributions of Ada Lovelace in computing, given :evidence0:?]
Plan: Conduct another web search to find detailed information about these contributions.
:evidence2: = Bing[:evidence1: contributions in detail]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkCollector[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to summarize the key details of Ada Lovelace's contributions from the extracted information.
:evidence5: = GPT3[Summarize the contributions of Ada Lovelace in computing, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the question: "What is the average lifespan of an African elephant in the wild?" Use these tools:
- GoogleSearch[input]: Searches for information using Google.
- WikiData[input]: Retrieves structured data from Wikipedia.
- TextSummarizer[input]: Summarizes long text into shorter, more manageable text.
- FactChecker[input]: Checks facts against multiple sources.
- QA[input]: Answers questions based on general knowledge or given context.

The output should be in format:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action]
#E2 = [next function call and input parameter, referencing previous evidence if needed]
...
Final Answer: #E[n]

Response:
Plan: Start by searching for the information using Google.
#E1 = GoogleSearch["average lifespan of an African elephant in the wild"]

Plan: Retrieve structured data from Wikipedia to cross-check the information.
#E2 = WikiData["African elephant lifespan"]

Plan: Summarize the long text retrieved from both sources into shorter, more manageable text.
#E3 = TextSummarizer[#E1]
#E4 = TextSummarizer[#E2]

Plan: Check facts against multiple sources to ensure accuracy.
#E5 = FactChecker[#E3]
#E6 = FactChecker[#E4]

Plan: Answer question based on general knowledge or given context.
#E7 = QA["What is the average lifespan of an African elephant in the wild?", #E5 and #E6]

Final Answer: #E7

System: A chat.


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

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

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

Question: Who won the 2022 Oscar for Best Director and what was their previous work?

Response:
Plan: Begin by conducting a web search to find out who won the 2022 Oscar for Best Director.
:evidence0: = Bing[2022 Oscar winner for Best Director]
Plan: Utilize a language model to interpret the search results and find the name of the director.
:evidence1: = SAM[Who won the 2022 Oscar for Best Director, given :evidence0:?]
Plan: Conduct another web search to find the previous works of the identified director.
:evidence2: = Bing[Previous works of :evidence1:]
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:evidence3: = URLCollector[:evidence2:]
Plan: Use a web reader tool to extract information from the relevant URLs.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the previous works of the director from the extracted information.
:evidence5: = SAM[What are the previous works of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the user's question, using the following available tools. Each tool can be called with an input string and will produce an output that can be stored in a variable :evidence[n]: for use in subsequent steps.

Here are the tools available to be called:
SearchEngine[input]: This tool allows you to search for information on the internet. The input should be a query related to the information you're looking for.
TextAnalyzer[input]: Analyzes a text and extracts key pieces of information such as names, dates, places etc. It takes plain text as input.
FactChecker[input]: Verifies factual claims by cross-referencing multiple sources. Input is a statement or claim to be checked.
QA[input]: Can answer questions based on common sense, general world knowledge, and given context. Particularly useful when the answer is contained within a previous evidence 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: Who was the first person to climb Mount Everest without supplemental oxygen and what year did it happen?

Response:
Plan: Search for information about the first person to climb Mount Everest without supplemental oxygen.
:evidence0: = SearchEngine[First person to climb Mount Everest without supplemental oxygen]
Plan: Extract key details from the search results.
:evidence1: = TextAnalyzer[:evidence0:]
Plan: Use QA tool to identify the name of the climber and the year of the event from the extracted details.
:evidence2: = QA[Who was the first person to climb Mount Everest without supplemental oxygen and what year did it happen? Given context: :evidence1:]
Plan: Verify the obtained facts.
:evidence3: = FactChecker[:evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Develop a comprehensive plan to generate an ideal response to the user instruction, leveraging a variety of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: Allows the user to search for information using DuckDuckGo search engine. This tool finds a list of sites that may contain the answer to the user's question.
SiteScraper[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and outputs plain text containing the content of the links.
HyperlinkHarvester[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
InfoAI[input]: A question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

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

Question: Who invented the telephone and when was the first successful call made?

Response:
Plan: Start by conducting a web search to find out who invented the telephone.
#E0 = DuckDuckGo[Inventor of the telephone]
Plan: Use InfoAI to interpret the search results and identify the inventor.
#E1 = InfoAI[Who invented the telephone, given #E0?]
Plan: Conduct another web search to find when the first successful call was made.
#E2 = DuckDuckGo[First successful telephone call date]
Plan: Extract the relevant links from the search results for a deeper dive.
#E3 = HyperlinkHarvester[#E2]
Plan: Use SiteScraper to extract information from the relevant links.
#E4 = SiteScraper[#E3]
Plan: Finally, use InfoAI to identify and summarize when the first successful call was made from the extracted information.
#E5 = InfoAI[When was the first successful telephone call made, given #E4?]
Final answer: #E5

System: A chat.