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

Here are the tools you have at your disposal:

Bing[input]: A tool that allows users to search for information via Bing's search engine. This tool is useful for finding a list of sites that may contain the answer to the user's query. The function doesn't directly provide answers; it finds a list of websites that might contain the necessary information.
WebReader[input]: Load one or more websites from the input string containing newline delimited links. The input should consist of one or more links and produces plain text output containing the content of these links.
LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
SAM[input]: Question answering language model, particularly effective in providing answers 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 input to each function should just be a plain string without quotes or "+" to concatenate a string with a data variable, e.g., SAM[What is the capital of France, given :data2:?]

Ensure only one evidence output per plan step.

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

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

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

System: A chat.


Instruction:
Create a plan to find out: "Who composed the music for the movie 'Inception' and list some other movies they have worked on."

Available tools:
IMDbLookup[input]: Tool that retrieves data about films, including cast, crew, and trivia.
ComposerFilmography[input]: Tool that lists all the movies a certain composer has worked on.
QA[input]: Tool that answers questions using general world knowledge.

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

Response:
Plan: initial action
:Evidence0: = IMDbLookup['Inception']
Plan: subsequent action, referencing :Evidence0:
:Evidence1: = QA[Who composed the music for the movie mentioned in :Evidence0:?]
Plan: final action, referencing :Evidence1:
:Evidence2: = ComposerFilmography[:Evidence1:]
Answer: [:Evidence1: composed the music for 'Inception'. Some other movies they have worked on include :Evidence2:.]

System: A chat.


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

The tools you have at your disposal are as follows:
1. Bing[input]: This tool allows users to search for information on the internet using the Bing search engine. It provides a list of websites that may contain the answer to the user's query.
2. TextParser[input]: This function takes in text and extracts key pieces of information such as names, dates, locations etc.
3. URLReader[input]: This tool loads the content of a website from a given URL and produces plain text output.
4. QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a question referencing an :evidence[n]: variable.

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

Question: What is the history behind the creation of Microsoft Corporation?

Response:
Plan: Start by searching for information about the creation of Microsoft Corporation.
:evidence0: = Bing[History of Microsoft Corporation]
Plan: Extract relevant URLs from the search results.
:evidence1: = TextParser[:evidence0:]
Plan: Load the content of the most relevant URL.
:evidence2: = URLReader[:evidence1:]
Plan: Use the QA Model to extract specific details about the creation of Microsoft Corporation.
:evidence3: = QAModel[What is the history behind the creation of Microsoft Corporation? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Create a detailed execution plan to respond to the following user query using the tools provided. Every plan should be associated with an evidence value generated by one of the tools provided as per the input string which could be the user query itself, any prior evidence value or a combination of both.

Available Tools:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to find potential answers to the user's query.
LinkHarvester[input]: A tool that extracts all URLs from a given piece of text.
PageReader[input]: A tool that fetches the contents of a webpage given its URL.
NLPModel[input]: A natural language processing model that can answer questions based on an input text. The input should be a question referencing a #info[n] variable, like "What is the population of Tokyo, given #info1?"

Output Format:
Plan: [First step based on the user query]
#info0 = [Tool to use with input parameters]
Plan: [Next step based on the outcome of #info0]
#info1 = [Next tool to use with input parameters possibly including reference to previous info like "#info0"]
...
Final Answer: [#info[n] that contains the final answer]

Question: When was the Eiffel Tower built and what materials were used in its construction?

Response:
Plan: Start by searching for when the Eiffel Tower was built.
#info0 = DuckDuckGo[Eiffel Tower construction date]
Plan: Use NLPModel to determine the construction date from the search results.
#info1 = NLPModel[When was the Eiffel Tower built? Given context: #info0]
Plan: Search for the materials used in the construction of the Eiffel Tower.
#info2 = DuckDuckGo[Eiffel Tower construction materials]
Plan: Extract the URLs from the search results for further analysis.
#info3 = LinkHarvester[#info2]
Plan: Read the contents of the pages linked in the search results.
#info4 = PageReader[#info3]
Plan: Use NLPModel to determine the materials used in the construction from the page contents.
#info5 = NLPModel[What materials were used in the construction of the Eiffel Tower? Given context: #info4]
Final Answer: #info5

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the user's question using the available tools. Each tool should be used at least once and 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 on the internet. This tool is useful in finding websites 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.
QAModel[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an #E[n] variable, e.g. What color is the cat, given #E1?

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

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

Response:
Plan: Start by searching the internet to find out who won the Nobel Prize in Literature in 2018.
#E0 = SearchEngine[Nobel Prize in Literature 2018 winner]
Plan: Use the QAModel to extract the name of the winner from the search results.
#E1 = QAModel[Who won the Nobel Prize in Literature in 2018? Given context: #E0]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E2 = SearchEngine[Most famous work of #E1]
Plan: Extract relevant links from the search results for further investigation.
#E3 = LinkExtractor[#E2]
Plan: Scrape the content from the extracted links.
#E4 = WebsiteScraper[#E3]
Plan: Finally, use the QAModel to identify the most famous work of the laureate from the scraped content.
#E5 = QAModel[What is the most famous work of #E1? Given context: #E4]
Answer: #E5

System: A chat.


Instruction:
Generate a step-by-step plan to answer the user query using the following tools. Each tool can be called with an input string and will return an output that can be stored in a variable :evidence[n]: for future reference.

The available tools are:
Bing[input]: This function allows you to search for information on Bing, which may include websites, articles, images, etc.
TextAnalyzer[input]: This tool extracts key points from a large amount of text.
LinkCollector[input]: Extracts all links from a given piece of text.
WebReader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
QAEngine[input]: A question answering tool that can provide answers based on general knowledge or specific context provided in the form of previous evidence variables.

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 :evidence0:]
...
Answer: [:evidence[n]: containing final answer]

Question: What's the history behind the creation of Bitcoin and who was involved?

Response:
Plan: Start by searching for information about the creation of Bitcoin.
:evidence0: = Bing[Creation of Bitcoin]
Plan: Extract relevant links from the search results for further exploration.
:evidence1: = LinkCollector[:evidence0:]
Plan: Load the contents of the extracted links for detailed information.
:evidence2: = WebReader[:evidence1:]
Plan: Analyze the loaded text to extract key points about the creation of Bitcoin.
:evidence3: = TextAnalyzer[:evidence2:]
Plan: Use QA engine to identify who was involved in the creation of Bitcoin.
:evidence4: = QAEngine[Who was involved in the creation of Bitcoin? Given context: :evidence3:]
Answer: :evidence4:

System: A chat.


Instruction:
Create a plan to answer the following question using these available tools. For each step, indicate which tool you will use and what input you will provide it with. You can store the results of each tool in a variable :evidence[n]: that can be used as input for subsequent steps.

Here are the tools available to be called:
Bing[input]: A search engine tool that provides a list of websites related to the input query.
TextExtractor[input]: Extracts plain text from one or more websites provided as newline delimited links.
LinkCollector[input]: Collects all links present in the given plain text.
AskJeeves[input]: A language model tool capable of answering questions based on an input passage of text. The input must be a question that references an :evidence[n]: variable.

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

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

Response:
Plan: Start by searching for information about the history of the Eiffel Tower.
:evidence0: = Bing[History of the Eiffel Tower]
Plan: Use LinkCollector to gather relevant links from the search results.
:evidence1: = LinkCollector[:evidence0:]
Plan: Extract text from the collected links using TextExtractor.
:evidence2: = TextExtractor[:evidence1:]
Plan: Use AskJeeves to find out about the history of the Eiffel Tower.
:evidence3: = AskJeeves[What is the history of the Eiffel Tower? Given :evidence2:]
Plan: Search again for specific information about the construction of the Eiffel Tower.
:evidence4: = Bing[Construction of the Eiffel Tower]
Plan: Gather relevant links from the new search results.
:evidence5: = LinkCollector[:evidence4:]
Plan: Extract text from the newly gathered links.
:evidence6: = TextExtractor[:evidence5:]
Plan: Finally, use AskJeeves to learn about the construction process of the Eiffel Tower.
:evidence7: = AskJeeves[How was the Eiffel Tower constructed? Given :evidence6:]
Answer: :evidence3: and :evidence7:

Repeat this process 9 more times with different questions and execution plans.

System: A chat.


Instruction:
Create a step-by-step plan to solve the user's query using the following tools. Each tool will provide an evidence value which can be used in subsequent steps.

Available Tools:
1. WikiSearch[input]: This tool allows you to search for information on Wikipedia. The input should be a string that would help find the appropriate page.
2. QAEngine[input]: A question answering tool that uses common sense and general world knowledge, as well as context from previous evidences to answer questions.
3. GoogleMaps[input]: Tool that provides geographical information about places around the world.
4. WeatherAPI[input]: Provides current weather conditions of a given location.

The output format should be:
Plan: [First action based on the input]
#E1 = [Function call with input parameter]
Plan: [Next action based on result of #E1]
#E2 = [Next function call with input parameter referencing previous evidence if necessary]
...
Final Answer: #E[n]

Question: What is the historical significance of London Bridge and what is the current weather there?

Response:
Plan: Search for more information about London Bridge.
#E1 = WikiSearch[London Bridge]
Plan: Find out the historical significance of London Bridge.
#E2 = QAEngine[What is the historical significance of London Bridge? Given context: #E1]
Plan: Get the geographical coordinates of London Bridge.
#E3 = GoogleMaps[London Bridge]
Plan: Check the current weather at London Bridge.
#E4 = WeatherAPI[#E3]
Final Answer: Historical Significance: #E2, Current Weather: #E4

System: A chat.


Instruction:
Create a comprehensive plan to respond to the user query, making use of the provided tools. For every plan, there should be corresponding evidence which would be the output of a function taking an input string that could be the user query, previous evidence values, or both.

Available tools:
DuckDuckGo[input]: Tool allowing users to search for information via DuckDuckGo search engine. It helps in locating potential sites having answers to the user's query. The function does not directly answer but locates possible sources.
TextParser[input]: Parses one or more websites from the input string comprising newline separated links. Input includes one or more links, and the output contains the textual content of these links.
URLExtractor[input]: Pulls out URLs from plain text and gives a plain text, newline-separated list of URLs.
BrainyQA[input]: Language model for answering queries based on a text passage. The input has to be a question referencing an :evidence[n]: variable, like What is the dog's breed, given :evidence1:?

Inputs to functions should be simple strings, devoid of quotes or "+" for concatenating a string with an evidence variable, like BrainyQA[What is New York's population, given :evidence3:?]

Remember to include only one evidence output per plan step.

Output format:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action, based on :evidence0:'s outcome]
:evidence1: = [Next function to call and its input parameter, possibly referring to prior evidence, like "Considering context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

Question: What are some notable works of J.K. Rowling besides Harry Potter and how were they received?

Response:
Plan: Initiate a web search to discover other notable works by J.K. Rowling apart from Harry Potter.
:evidence0: = DuckDuckGo[J.K. Rowling notable works]
Plan: Utilize BrainyQA to interpret the search results and list the works.
:evidence1: = BrainyQA[What are some notable works of J.K. Rowling besides Harry Potter, given :evidence0:?]
Plan: Conduct a separate web search for each work to gather reception details.
:evidence2: = DuckDuckGo[:evidence1: + ' reception']
Plan: Extract relevant URLs from the DuckDuckGo search results for detailed insights.
:evidence3: = URLExtractor[:evidence2:]
Plan: Employ TextParser to extract information from the selected URLs.
:evidence4: = TextParser[:evidence3:]
Plan: Lastly, apply BrainyQA to summarize the reception of each work from the parsed information.
:evidence5: = BrainyQA[How were the works :evidence1: received, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Please create a 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.
KnowledgeBaseQA[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 2018 FIFA World Cup and who was their top scorer?

Response:
Plan: Begin by conducting a web search to find out who won the 2018 FIFA World Cup.
:evidence0: = GoogleSearch[2018 FIFA World Cup winner]
Plan: Utilize a knowledge base QA model to interpret the search results and find the name of the winning team.
:evidence1: = KnowledgeBaseQA[Who won the 2018 FIFA World Cup, given :evidence0:?]
Plan: Conduct another web search to find the top scorer of the identified winning team of the 2018 FIFA World Cup.
:evidence2: = GoogleSearch[Top scorer of :evidence1: in 2018 FIFA World Cup]
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 knowledge base QA model to identify and summarize the top scorer of the winning team from the extracted information.
:evidence5: = KnowledgeBaseQA[Who was the top scorer of :evidence1: in the 2018 FIFA World Cup, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to use:
SearchEngine[input]: A tool that allows you to search for information on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a webpage link provided as input and produces a plain text output containing the content of the page.
LinkLister[input]: Extracts links from plain text and produces a plain text response of links.
InfoBot[input]: A question answering model that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What is the capital of France, given #E1?

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

Remember to include only one evidence output per plan step.

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

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

Response:
Plan: Begin by conducting an online search to find out who the architect of the Sydney Opera House is.
#E1 = SearchEngine[Architect of Sydney Opera House]
Plan: Use the InfoBot to interpret the search results and identify the name of the architect.
#E2 = InfoBot[Who is the architect of the Sydney Opera House, given #E1?]
Plan: Conduct another online search to find other notable buildings designed by the identified architect.
#E3 = SearchEngine[Notable buildings designed by #E2]
Plan: Extract the relevant links from the search results for more focused research.
#E4 = LinkLister[#E3]
Plan: Use the TextExtractor tool to extract information from the relevant links.
#E5 = TextExtractor[#E4]
Plan: Finally, use the InfoBot to identify and summarize the other notable buildings designed by the architect from the extracted information.
#E6 = InfoBot[What are the other notable buildings designed by #E2, given #E5?]
Final Answer: #E6

System: A chat.


Instruction:
Please create a step-by-step plan to generate an ideal response to the user instruction, making use of a set of available tools.

Here are the tools available to be called:
GoogleSearch[input]: Allows the user to search for information using Google.
TextParser[input]: Parses a large body of text into smaller, more manageable chunks.
LinkCollector[input]: Collects all URLs from a given piece of text.
InfoFinder[input]: A tool that answers questions when provided with a specific piece of text as context.

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

Question: How did Apple Inc. become successful and what were some major obstacles they faced?

Response:
Plan: Begin by searching for general information about Apple Inc.'s success.
#E1 = GoogleSearch[Apple Inc. success story]
Plan: Parse the search results into smaller pieces of text.
#E2 = TextParser[#E1]
Plan: Find detailed information about how Apple Inc. became successful.
#E3 = InfoFinder[How did Apple Inc. become successful? Given context: #E2]
Plan: Search for information about major obstacles faced by Apple Inc.
#E4 = GoogleSearch[Major obstacles faced by Apple Inc.]
Plan: Collect links from the search results for further investigation.
#E5 = LinkCollector[#E4]
Plan: Scrape the contents of the collected links.
#E6 = WebScraper[#E5]
Plan: Identify the major obstacles faced by Apple Inc. from the scraped data.
#E7 = InfoFinder[What were the major obstacles faced by Apple Inc.? Given context: #E6]
Final Answer: #E3 and #E7

System: A chat.


Instruction:
Develop a plan to answer the following question using the available tools. For each step in your plan, provide an evidence variable that will store the output of the tool you use.

Here are the tools at your disposal:

1. SearchEngine[input]: This tool allows you to search for information on the internet. The input should be a string containing the query.
2. TextAnalyzer[input]: Analyzes text and extracts key points from it. It can be used with the context provided by previous steps as input.
3. KnowledgeBase[input]: A tool that answers questions based on a large database of general knowledge. The input must be a question.
4. WebScraper[input]: Extracts text content from websites given their URLs. The input is one or more URLs separated by newlines.
5. LinkFinder[input]: Finds relevant links within a piece of text. The input is any text that may contain URLs.

Your response should follow this format:
Plan: [describe the first action]
#E1 = [tool to use with its input]
Plan: [describe the next action based on #E1's result]
#E2 = [next tool to use with its input, which could include reference to #E1]
...
Final Answer: #En

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

Response:
Plan: Use the search engine to find out who directed the movie "Inception".
#E1 = SearchEngine[Director of Inception]
Plan: Utilize the KnowledgeBase to interpret the search results and identify the director.
#E2 = KnowledgeBase[Who directed the movie Inception? Given context: #E1]
Plan: Conduct another search to find other movies directed by the identified person.
#E3 = SearchEngine[Movies directed by #E2]
Plan: Extract relevant links from the search results for further analysis.
#E4 = LinkFinder[#E3]
Plan: Scrape the web pages linked in the search results to gather more detailed information.
#E5 = WebScraper[#E4]
Plan: Finally, analyze the scraped data to compile a list of movies directed by the same person.
#E6 = TextAnalyzer[List of movies directed by #E2. Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a step-by-step execution plan to respond to the following user query, utilizing the available tools. Each step should produce an evidence value which corresponds to the output of a tool function given an appropriate input string. This input could be the original user query, a prior evidence value, or a combination of these.

Available Tools:
BingSearch[input]: A tool allowing users to find information via Bing's search engine.
PageReader[input]: Loads one or more webpages specified by newline separated URLs in the input string, returning plain text content from those pages.
URLCollector[input]: Gathers URLs from provided plain text, producing a newline-separated list of URLs.
KnowledgeBase[input]: A tool for retrieving factual information from a large database of common knowledge.
InferenceEngine[input]: A tool capable of answering questions based on provided textual context. Input should be a question referencing an :evidenceN: variable, such as 'What is the main ingredient in :evidence3:?'

Output Format:
Plan: [First action based on user query]
:evidence0: = [Tool function call with relevant input]
Plan: [Subsequent action, considering outcome of :evidence0:]
:evidence1: = [Next tool function call, potentially referencing earlier evidence]
...
Answer: [:evidenceN:, containing final response.]

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

Response:
Plan: Begin by querying the KnowledgeBase for the architect of the Sydney Opera House.
:evidence0: = KnowledgeBase[Architect of Sydney Opera House]
Plan: Using the name of the architect, perform a Bing search for other buildings designed by them.
:evidence1: = BingSearch[:evidence0: + " other designs"]
Plan: Extract relevant URLs from the Bing search results for further examination.
:evidence2: = URLCollector[:evidence1:]
Plan: Read the content of the extracted URLs to gather detailed information.
:evidence3: = PageReader[:evidence2:]
Plan: Finally, use the InferenceEngine to summarize the notable buildings designed by the architect from the gathered information.
:evidence4: = InferenceEngine[What other notable buildings were designed by :evidence0:, given :evidence3:?]
Answer: :evidence4:

System: A chat.


Instruction:
Construct a plan to find out the height of Mount Everest and compare it to the height of K2.

Tools available:
MountainHeight[input]: Tool that provides the height of a specified mountain.
CompareNumbers[input]: Tool that compares two numbers and provides a comparison statement.
QA[input]: Tool that answers questions using general world knowledge.

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

Response:
Plan: Get the height of Mount Everest
#E1 = MountainHeight["Mount Everest"]
Plan: Get the height of K2
#E2 = MountainHeight["K2"]
Plan: Compare the heights of Mount Everest and K2
#E3 = CompareNumbers[#E1, #E2]
Final Answer: #E3

System: A chat.


Instruction:
Develop a plan to find out when the Eiffel Tower was built and who designed it.

Available tools:
HistoricalEvents[input]: Provides information about historical events.
ArchitectInfo[input]: Provides information about architects and their works.
QA[input]: Can answer questions using common sense or given context.
LandmarkFacts[input]: Provides facts about famous landmarks.
Wikipedia[input]: Allows searching for information from Wikipedia.

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

Response:
Plan: First action
#E1 = Wikipedia["Eiffel Tower"]

Plan: Next action based on #E1
#E2 = HistoricalEvents[E1]

Plan: Third action based on #E2
#E3 = ArchitectInfo[E2]

Final Answer: #E3

System: A chat.


Instruction:
Create a step-by-step plan to respond to the user's query using the following tools. Every plan should correspond to an evidence value.

Available tools:

1. DuckDuckGo[input]: Allows users to search for information using the DuckDuckGo search engine.
2. TextExtractor[input]: Extracts plain text from a list of newline-separated links.
3. LinkParser[input]: Parses plain text to extract newline-separated links.
4. AnswerBot[input]: Can answer questions using general knowledge or context from previously generated evidence.

Output format:
Plan: [First action]
#E1 = [Function with input parameter]
Plan: [Next action based on #E1]
#E2 = [Next function with input parameter, which may refer to previous evidence]
...
Final answer: #E[n]

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

Response:
Plan: Begin by searching for information about Nikola Tesla using DuckDuckGo.
#E1 = DuckDuckGo[Nikola Tesla]
Plan: Parse the search results to find relevant links.
#E2 = LinkParser[#E1]
Plan: Extract the text from the found links.
#E3 = TextExtractor[#E2]
Plan: Use AnswerBot to identify who Nikola Tesla was from the extracted text.
#E4 = AnswerBot[Who was Nikola Tesla? Given context: #E3]
Plan: Next, use AnswerBot again to determine Tesla's major contributions to science.
#E5 = AnswerBot[What were the major contributions of Nikola Tesla to science? Given context: #E3]
Final answer: Combine #E4 and #E5

System: A chat.


Instruction:
Develop a detailed plan to address the user's query utilizing the tools at your disposal. For each step, provide the corresponding evidence value.

Tools Available:
WikiLookup[input]: Searches Wikipedia for information related to the input string.
QAEngine[input]: Answers questions based on common knowledge or given context. The input must be a question that references a #E[index] variable.
GoogleMaps[input]: Provides geographical data related to the input location.
WeatherAPI[input]: Gives current weather conditions for the input location.

Output Format:
Plan: [Initial action]
#E1 = [Tool with input parameters]
Plan: [Subsequent action, based on outcome of #E1]
#E2 = [Next tool with input parameters, possibly referencing prior evidence]
...
Final Answer: #E[n]

Question: What is the population of the capital city of France and what is its current weather condition?

Response:
Plan: Look up information about the capital city of France using WikiLookup.
#E1 = WikiLookup[Capital city of France]
Plan: Use QAEngine to determine the name of the capital city from the obtained information.
#E2 = QAEngine[What is the capital city of France? Given context: #E1]
Plan: Search for the population of the capital city using WikiLookup.
#E3 = WikiLookup[Population of #E2]
Plan: Determine the population from the retrieved information using QAEngine.
#E4 = QAEngine[What is the population of #E2? Given context: #E3]
Plan: Get the current weather condition of the capital city using WeatherAPI.
#E5 = WeatherAPI[#E2]
Plan: Interpret the weather condition using QAEngine.
#E6 = QAEngine[What is the current weather condition in #E2? Given context: #E5]
Final Answer: The population of #E2 is #E4 and the current weather condition is #E6.

System: A chat.


Instruction:
Design a step-by-step plan to answer the following user query using the tools provided. Each tool can be invoked with an input string and provides an output that can be stored in a variable #E[index]. Subsequent tools can reference these variables.

Here are the tools available:
DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to find potential sources of information.
URLPicker[input]: This tool extracts URLs from a block of text and returns them as a newline-separated list.
SiteLoader[input]: This tool loads the content of one or more websites specified by newline-separated URLs.
InfoExtractor[input]: A question-answering tool that generates answers based on a given context. The input should be a question that refers to a #E[index] variable.

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

Question: Who was the first woman to win a Nobel Prize and what did she discover?

Response:
Plan: Search for the first woman to win a Nobel Prize.
#E1 = DuckDuckGo[First woman to win a Nobel Prize]
Plan: Extract the name of the woman from the search results.
#E2 = InfoExtractor[Who was the first woman to win a Nobel Prize? Given context: #E1]
Plan: Search for the discovery made by the woman.
#E3 = DuckDuckGo[Discoveries made by #E2]
Plan: Extract the URLs from the search results for further investigation.
#E4 = URLPicker[#E3]
Plan: Load the content of the websites found in the previous step.
#E5 = SiteLoader[#E4]
Plan: Extract the information about the discovery from the loaded website content.
#E6 = InfoExtractor[What did #E2 discover? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Develop a plan to determine the life cycle of a butterfly.

Tools at your disposal:
Encyclopedia[input]: Searches for detailed information about the input topic.
IllustrationLocator[input]: Locates illustrations related to the input.
LifecycleDescriber[input]: Describes the lifecycle of an organism based on the input context.
KnowledgeBaseQA[input]: Answers questions using a vast database of knowledge.
DataCompiler[input]: Compiles data into a comprehensive report.

Output format:
Plan: Starting action
#Fact1 = Function with input parameter
Plan: Following action
#Fact2 = Next function with input parameter
...
Final Conclusion: #Fact[n]

Response:
Plan: Start by gathering general information about butterflies.
#Fact1 = Encyclopedia['Butterfly']

Plan: Next, find illustrations related to the butterfly's life cycle.
#Illustration1 = IllustrationLocator['Butterfly Life Cycle']

Plan: Now, get a detailed description of the butterfly's lifecycle.
#Lifecycle1 = LifecycleDescriber['Butterfly']

Plan: Use KnowledgeBaseQA to answer any specific questions or fill in gaps in our understanding of the butterfly's life cycle.
#Fact2 = KnowledgeBaseQA['What are the stages of a butterfly's life cycle?']
#Fact3 = KnowledgeBaseQA['How long does each stage of a butterfly's life cycle last?']
#Fact4 = KnowledgeBaseQA['What happens during each stage of a butterfly's life cycle?']

Plan: Finally, compile all gathered data into a comprehensive report on the butterfly's life cycle.
#Report1 = DataCompiler[#Fact1, #Illustration1, #Lifecycle1, #Fact2, #Fact3, #Fact4]

Final Conclusion: #Report1

System: A chat.


Instruction:
Construct a detailed plan to tackle the user inquiry employing the given tools. Each stage should align with an evidence value, which is the output of one of the accessible functions given an input string that might be the user question, earlier evidence values, or a blend of both.

Available tools are:
NetSearch[input]: Enables the user to search for information using a generic internet search engine. It helps in locating a variety of sites that may hold the answer to the user's query.
TextScrape[input]: Loads one or several websites from the input string holding newline separated links, where input comprises one or multiple links, and yields plain text including the content of the links.
URLExtractor[input]: Extracts URLs from plain text and delivers a plain text, newline separated response of URLs.
QuerySolver[input]: A question-answering language model, handy for answering queries based on an input text passage. The input needs to be a text question referring to an :evidence[n]: variable, e.g., What is the population of Tokyo, given :evidence1:?

The output should adhere to this structure:
Plan: [initial action to undertake based on input question]
:evidence0: = [function to invoke with input parameter]
Plan: [subsequent action to undertake, hinged on the outcome of :evidence0:]
:evidence1: = [following function to invoke and input parameter, which may allude to preceding evidence, e.g., "Considering context :evidence0"]
...
Answer: [:evidence[n]: carrying the ultimate answer.]

Question: What are the causes and effects of climate change according to recent studies?

Response:
Plan: Initiate by performing a net search to locate recent studies on the causes of climate change.
:evidence0: = NetSearch[recent studies on causes of climate change]
Plan: Apply QuerySolver to decipher the search outcomes and pinpoint the causes of climate change.
:evidence1: = QuerySolver[What are the causes of climate change according to recent studies? Given :evidence0:]
Plan: Carry out another net search to find recent studies on the effects of climate change.
:evidence2: = NetSearch[recent studies on effects of climate change]
Plan: Extract pertinent URLs from the search results for deeper exploration.
:evidence3: = URLExtractor[:evidence2:]
Plan: Employ TextScrape to collect data from the extracted URLs.
:evidence4: = TextScrape[:evidence3:]
Plan: Ultimately, use QuerySolver to identify and summarise the effects of climate change from the collected data.
:evidence5: = QuerySolver[What are the effects of climate change according to recent studies? Given :evidence4:]
Answer: Causes - :evidence1:. Effects - :evidence5:.

System: A chat.


Instruction:
Generate a step-by-step plan to solve the user's problem using the following tools. Each plan should produce an evidence value, which will be the output of a specific function given an input string.

Tools available:
YahooSearch[input]: Allows users to search for information through Yahoo. It helps in identifying a list of sites that could contain the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline separated links. The input is one or more links, and the output includes the content of those links.
HyperlinkCollector[input]: Collects hyperlinks from plain text and gives a plain text, newline separated list of links.
QuerySolver[input]: A language model used to answer questions based on an input text passage. The input must be a text question that refers to a $Evidence[n]$ variable, e.g., 'What is the capital of Italy, given $Evidence1$?'

Output format:
Plan: [Initial action]
$Evidence0$ = [Function call with input parameter]
Plan: [Next action, based on result of $Evidence0$]
$Evidence1$ = [Next function call with input parameter, which may reference previous evidence, e.g., "Given context $Evidence0$"]
...
Final Answer: $Evidence[n]$

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

Response:
Plan: Start by performing a web search to learn about the history of the Eiffel Tower.
$Evidence0$ = YahooSearch[Eiffel Tower history]
Plan: Use QuerySolver to interpret the search results and summarize the history of the Eiffel Tower.
$Evidence1$ = QuerySolver[What is the history of the Eiffel Tower? Given context: $Evidence0$]
Plan: Perform another web search to discover the height of the Eiffel Tower.
$Evidence2$ = YahooSearch[Eiffel Tower height]
Plan: Extract pertinent links from the search results for a deeper examination.
$Evidence3$ = HyperlinkCollector[$Evidence2$]
Plan: Use SiteReader to extract information from the chosen links.
$Evidence4$ = SiteReader[$Evidence3$]
Plan: Finally, use QuerySolver to determine the height of the Eiffel Tower from the extracted information.
$Evidence5$ = QuerySolver[How tall is the Eiffel Tower? Given context: $Evidence4$]
Final Answer: $Evidence5$

System: A chat.


Instruction:
Create a sequential plan to address the following question using the tools provided. Ensure each step has an associated evidence value.

Available Tools:
GoogleScholar[input]: Searches academic papers and scholarly articles related to the input query.
ArticleReader[input]: Reads and summarizes the content of academic articles.
DataAnalyzer[input]: Analyzes data sets and extracts meaningful insights.
QASystem[input]: Provides answers to questions based on the context provided in the input.

Output Format:
Plan: [First action based on the input question]
:Evidence1: = [Function to call with appropriate input]
Plan: [Subsequent action based on the outcome of :Evidence1:]
:Evidence2: = [Next function to call with appropriate input, referencing previous evidence if necessary]
...
Answer: [:EvidenceN:]

Question: What are the recent advancements in quantum computing?

Response:
Plan: Begin by searching for recent scholarly articles on quantum computing.
:Evidence1: = GoogleScholar[Recent advancements in quantum computing]
Plan: Read and summarize the content of the identified articles.
:Evidence2: = ArticleReader[:Evidence1:]
Plan: Analyze the summarized data to extract key advancements.
:Evidence3: = DataAnalyzer[:Evidence2:]
Plan: Finally, use the QA System to provide a concise summary of the recent advancements in quantum computing.
:Evidence4: = QASystem[What are the recent advancements in quantum computing, given :Evidence3:?]
Answer: :Evidence4:

System: A chat.


Instruction:
Generate a plan to solve the following problem using the available tools. For each step, provide an evidence value corresponding to the output of a specific function, given an input string that could be the user's query, previous evidence values, or a combination of both.

Available tools include:
DuckDuckGo[input]: Allows users to conduct searches via DuckDuckGo. Useful for identifying potential sources of answers.
SiteReader[input]: Takes one or more website URLs (newline separated) from the input string and outputs plain text content from these sites.
URLExtractor[input]: Pulls out URLs from a block of plain text, providing a newline-separated list of links.
InfoProcessor[input]: A question-answering language model that uses an input text passage to answer queries. The input should be a textual question that refers to a #E[n] variable, such as "What's the population of Rome, given #E1?"

Your output should follow this structure:
Plan: [initial action]
#E0 = [function call with input parameters]
Plan: [subsequent action based on #E0's outcome]
#E1 = [following function call and input parameters, possibly referring back to prior evidence like "Given context #E0"]
...
Final Answer: [#En containing the ultimate solution]

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

Response:
Plan: Start by searching online for information about the creation of the Eiffel Tower.
#E0 = DuckDuckGo[Creation of the Eiffel Tower]
Plan: Use InfoProcessor to parse the search results and outline the history of the Eiffel Tower's construction.
#E1 = InfoProcessor[What is the history behind the creation of the Eiffel Tower? Given context: #E0]
Plan: Search again online, this time specifically for the key individuals involved in the tower's construction.
#E2 = DuckDuckGo[Key people involved in the creation of the Eiffel Tower]
Plan: Extract any potentially informative links from the new search results.
#E3 = URLExtractor[#E2]
Plan: Use SiteReader to gather information from the chosen links.
#E4 = SiteReader[#E3]
Plan: Lastly, employ InfoProcessor to identify and summarise the key figures involved in the creation of the Eiffel Tower, based on the gathered data.
#E5 = InfoProcessor[Who were the key people involved in the creation of the Eiffel Tower? Given context: #E4]
Final Answer: #E5

System: A chat.


Instruction:
Formulate a systematic plan to respond to the user query making use of the set of 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 combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that enables the user to search for information using DuckDuckGo search engine. It finds a list of sites that might contain the answer to the user's question.
WebCrawler[input]: Loads one or more websites from the input string containing newline separated links, where input is one or more links, and generates plain text output containing the content of the links.
URLPicker[input]: Picks out links from plain text and generates a plain text, newline separated response of links.
SAM[input]: Question answering language model, particularly helpful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the dog, given :evidence1:?

The input to each function should be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g., SAM[What is the height of Mount Everest, 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: What are some notable achievements of Albert Einstein and when did he receive the Nobel Prize in Physics?

Response:
Plan: Start by conducting a web search to find out about Albert Einstein's notable achievements.
:evidence0: = DuckDuckGo[Notable achievements of Albert Einstein]
Plan: Utilize the language model to summarize the notable achievements of Albert Einstein from the search results.
:evidence1: = SAM[What are some notable achievements of Albert Einstein, given :evidence0:?]
Plan: Conduct another web search to find out when Albert Einstein received the Nobel Prize in Physics.
:evidence2: = DuckDuckGo[Albert Einstein Nobel Prize in Physics year]
Plan: Pick out the relevant links from the DuckDuckGo search results.
:evidence3: = URLPicker[:evidence2:]
Plan: Load the selected websites to extract detailed information.
:evidence4: = WebCrawler[:evidence3:]
Plan: Lastly, utilize the language model to determine the year Albert Einstein received the Nobel Prize in Physics from the crawled data.
:evidence5: = SAM[When did Albert Einstein receive the Nobel Prize in Physics, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Construct a systematic approach to answer the user query utilizing the below mentioned tools. Each step in the plan should correspond to an evidence value which will be the output of the invoked function. The function's input could be either the user query, prior evidence values, or a combination of both.

Tools at disposal:
YahooSearch[input]: This tool lets the user perform a search operation via Yahoo's search engine. It provides a list of potential sources that might contain the answer to the user's query.
PageScraper[input]: This tool fetches the content of one or more webpages whose URLs are supplied as the input.
HyperlinkExtractor[input]: This tool extracts hyperlinks from a given chunk of text.
JARVIS[input]: An AI-based language model adept at answering queries given a context. The input should be a question that refers to an :evidence[n]: variable, such as 'What is the capital of country Y, given :evidence1:?'.

Output Format:
Plan: [Initial step based on the user query]
:evidence0: = [Function invocation with suitable input]
Plan: [Following step(s), depending upon the outcome of :evidence0:]
:evidence1: = [Next function invocation with suitable input, potentially referring to prior evidence]
...
Answer: [:evidence[n]: encapsulating the final answer.]

Question: Who is the author of the book '1984' and what are his other notable works?

Response:
Plan: Kick-off with a web search to ascertain the author of '1984'.
:evidence0: = YahooSearch[Author of 1984]
Plan: Leverage JARVIS to decipher the search results and pinpoint the author.
:evidence1: = JARVIS[Who is the author of the book '1984', given :evidence0:?]
Plan: Perform another web search to uncover other significant works by the identified author.
:evidence2: = YahooSearch[Notable works by :evidence1:]
Plan: Isolate the pertinent hyperlinks from the search results for a concentrated exploration.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Deploy PageScraper to glean information from the chosen hyperlinks.
:evidence4: = PageScraper[:evidence3:]
Plan: Lastly, employ JARVIS to identify and provide a summary of the author's other noteworthy works from the scraped webpage data.
:evidence5: = JARVIS[What are the other notable works by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a systematic plan to respond to the following query using the provided tools. For each plan, indicate the associated evidence value which will be the outcome of one of the accessible functions considering an input string that could be the user's question, prior evidence values, or both.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that lets you search for data using the DuckDuckGo search engine. It aids in locating pertinent sites that might hold the answer to your inquiry.
SiteLoader[input]: Loads one or more websites from the input string consisting of newline separated links, where input comprises one or more links, and yields plain text output encompassing the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and generates a plain text, newline-separated list of links.
ELM[input]: An AI-powered question-answering model that excels at answering queries based on a supplied text passage. The input has to be a textual question referencing an :evidence[n]: variable, such as What is the height of the Eiffel Tower, given :evidence1:?

The output should follow this format:
Plan: [initial action to undertake based on the input question]
:evidence0: = [function to invoke with input parameter]
Plan: [subsequent action to undertake, depending on the outcome of :evidence0:]
:evidence1: = [next function to invoke and input parameter, which may refer to earlier evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the ultimate answer.]

Question: Who invented the World Wide Web and what were the primary reasons behind its creation?

Response:
Plan: Begin by executing a web search to discover who invented the World Wide Web.
:evidence0: = DuckDuckGo[Inventor of the World Wide Web]
Plan: Employ the ELM language model to decipher the search outcomes and ascertain the inventor's name.
:evidence1: = ELM[Who invented the World Wide Web, given :evidence0:?]
Plan: Perform another web search to uncover the main reasons behind the invention of the World Wide Web by the identified individual.
:evidence2: = DuckDuckGo[Primary reasons behind the invention of the World Wide Web by :evidence1:]
Plan: Extract the pertinent links from the DuckDuckGo search results for a more comprehensive search.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Utilize the SiteLoader tool to glean information from the pertinent links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Lastly, utilize the ELM language model to distill the principal reasons behind the invention of the World Wide Web by the identified individual from the gleansed information.
:evidence5: = ELM[What were the primary reasons behind the invention of the World Wide Web by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to answer the following question: "What is the history of the Eiffel Tower and how was it constructed?" Use the available tools as necessary.

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 can find relevant websites that may contain the answer to the user's query.
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.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KnowledgeEngine[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

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

Response:
Plan: Begin by conducting a web search to find out about the history of the Eiffel Tower.
#E1 = Bing[History of the Eiffel Tower]
Plan: Extract the relevant links from the Bing search results for further investigation.
#E2 = LinkCollector[#E1]
Plan: Use a web reader tool to extract information from the relevant links.
#E3 = WebReader[#E2]
Plan: Utilize the Knowledge Engine to interpret the extracted information and summarize the history of the Eiffel Tower.
#E4 = KnowledgeEngine[What is the history of the Eiffel Tower? Given context: #E3]
Plan: Conduct another web search to find out how the Eiffel Tower was constructed.
#E5 = Bing[Construction of the Eiffel Tower]
Plan: Extract the relevant links from the Bing search results for further investigation.
#E6 = LinkCollector[#E5]
Plan: Use a web reader tool to extract information from the relevant links.
#E7 = WebReader[#E6]
Plan: Finally, utilize the Knowledge Engine to interpret the extracted information and explain how the Eiffel Tower was constructed.
#E8 = KnowledgeEngine[How was the Eiffel Tower constructed? Given context: #E7]
Final Answer: #E4 and #E8

---

System: A chat.


Instruction:
Create a sequential plan to respond to the user instruction, utilizing the available tools. Each plan will correspond to an evidence value, which will be the outcome of one of the available functions given an input string that could be the user question, one or more previous evidence values, or a mix of both.

Available tools to be used:
DuckDuckGo[input]: A tool that enables the user to search for information using the DuckDuckGo search engine. It helps in locating a suitable list of sites that might contain the answer to the user's query.
WebScraper[input]: Loads one or more websites from the input string containing newline separated links, where input is one or more links, and generates plain text output containing the link contents.
URLCollector[input]: Gathers links from plain text and produces a plain text, newline separated response of links.
QAModel[input]: Question answering language model, especially useful in answering questions based on an input text passage. The input must be a text question that refers to an :evidence[n]: variable, e.g., What is the dog's breed, given :evidence1:?

The input to each function should simply be a plain string, without quotation marks or "+" to join a string with an evidence variable, e.g., QAModel[What is the tallest building in the world, given :evidence3:?]

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

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

Question: What is the population of Tokyo and how has it changed over the past decade?

Response:
Plan: Begin by performing a web search to determine the current population of Tokyo.
:evidence0: = DuckDuckGo[Current population of Tokyo]
Plan: Use the QA model to interpret the search results and establish the population figure.
:evidence1: = QAModel[What is the current population of Tokyo, given :evidence0:?]
Plan: Perform another web search to understand how Tokyo's population has changed over the past decade.
:evidence2: = DuckDuckGo[Tokyo population change over the past decade]
Plan: Extract pertinent links from the DuckDuckGo search results for a more thorough investigation.
:evidence3: = URLCollector[:evidence2:]
Plan: Utilize the WebScraper tool to gather information from the selected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Lastly, employ the QA model to identify and summarize the changes in Tokyo's population over the past decade from the collected data.
:evidence5: = QAModel[How has the population of Tokyo changed over the past decade, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to solve the following problem using the tools at your disposal. For each step of the plan, indicate the corresponding evidence value, which would be the output of one of the available functions given an input string.

Here are the tools you can use:
WebCrawler[input]: Tool that searches the internet for information. It provides a list of sites that might contain the answer but does not provide direct answers.
DataMiner[input]: Extracts text from one or multiple websites from the input string containing newline separated links.
LinkHarvester[input]: Finds links within plain text and outputs them as a newline-separated list.
InfoAI[input]: Language model designed to answer questions based on a given text. The input must be a question referencing an :info[n]: variable.

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

Question: When was the Eiffel Tower built and who were the architects involved?

Response:
Plan: Begin by conducting a web search to find out when the Eiffel Tower was built.
:info0: = WebCrawler[When was the Eiffel Tower built]
Plan: Utilize InfoAI to interpret the search results and find the construction date.
:info1: = InfoAI[When was the Eiffel Tower built, given :info0:?]
Plan: Conduct another web search to find the architects involved in building the Eiffel Tower.
:info2: = WebCrawler[Architects of the Eiffel Tower]
Plan: Extract the relevant links from the search results for a deeper dive.
:info3: = LinkHarvester[:info2:]
Plan: Use DataMiner to extract information from the relevant links.
:info4: = DataMiner[:info3:]
Plan: Finally, utilize InfoAI to identify the architects involved in the construction of the Eiffel Tower from the extracted information.
:info5: = InfoAI[Who were the architects involved in building the Eiffel Tower, given :info4:?]
Final Answer: :info5:

System: A chat.


Instruction:
Develop a plan to answer: "How does the stock market work and how can I get started investing?"

Tools available:
FinancialBasics[input]: Provides basic financial concepts and explanations.
InvestmentGuide[input]: Offers guidance on investment strategies and getting started.
StockMarketOverview[input]: Gives an overview of how the stock market works.
QA[input]: Answers questions based on common sense and general world knowledge.
WebSearch[input]: Searches the web for relevant information.

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

Response:
Plan: First action
#E1 = StockMarketOverview[input]: "How does the stock market work?"

Plan: Second action
#E2 = FinancialBasics[input]: "What are stocks and bonds?"

Plan: Third action
#E3 = FinancialBasics[input]: "What is a portfolio?"

Plan: Fourth action
#E4 = InvestmentGuide[input]: "How can I start investing in the stock market?"

Plan: Fifth action
#E5 = QA[input]: "What should beginners know about investing in the stock market?"

Final Answer: #E6 = WebSearch[input]: "Best platforms for beginners to invest in the stock market"

System: A chat.


Instruction:
Formulate a plan to discover when the Great Wall of China was built and who ordered its construction.

Tools available:
HistoricalEventInfo[input]: Tool that provides information about a specific historical event or landmark.
EntityExtractor[input]: Tool that extracts key entities from a text passage.
TimelineGenerator[input]: Tool that generates a timeline of events related to a specific entity or topic.
QA[input]: Tool that answers questions using general world knowledge.

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

Response:
Plan: First action to take based on input question
#E1 = HistoricalEventInfo["Great Wall of China"]

Plan: Next action to take, based on result of #E1
#E2 = EntityExtractor[E1]

Plan: Use the extracted entities to generate a timeline.
#E3 = TimelineGenerator[E2]

Plan: If necessary, ask specific questions about the construction of the Great Wall.
#E4 = QA["When was the Great Wall of China built?"]
#E5 = QA["Who ordered the construction of the Great Wall of China?"]

Final Answer: #E4 and #E5

System: A chat.


Instruction:
Create a step-by-step plan to solve the following problem using the available tools. Each tool should be used with an input parameter that can either be a user question, one or more previous evidence values, or a combination of both.

Here are the tools you can use:
1. Bing[input]: A search engine tool that allows users to find information online. This tool is useful for finding a list of websites that may contain answers to the user's questions.
2. SiteReader[input]: A tool that loads and reads the content from the website links provided in the input string.
3. LinkLister[input]: A tool that extracts links from plain text and produces a plain text response containing these links.
4. QAModel[input]: A language model tool designed to answer questions based on an input passage of text. The input must be a text question referencing a #E[n] variable.

Each step in your plan should have a corresponding evidence value which will be the output of one of the functions given an input string.

The output format should be as follows:
Plan: [First action]
#E1 = [Function call with input parameter]
Plan: [Next action based on result of #E1]
#E2 = [Next function call with input parameter, possibly referring to previous evidence]
...
Final Answer: #E[n]

Question: Who is the author of the book "War and Peace" and what other books has he written?

Response:
Plan: Use the Bing search engine to find out who wrote "War and Peace".
#E1 = Bing[Author of War and Peace]
Plan: Use the QAModel to extract the name of the author from the search results.
#E2 = QAModel[Who is the author of War and Peace? Given context: #E1]
Plan: Conduct another Bing search to find other books written by this author.
#E3 = Bing[Books written by #E2]
Plan: Extract relevant links from the Bing search results.
#E4 = LinkLister[#E3]
Plan: Use the SiteReader tool to read the content from the extracted links.
#E5 = SiteReader[#E4]
Plan: Finally, use the QAModel to identify and summarize the other books written by the author.
#E6 = QAModel[What other books were written by #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Formulate a plan to discover when the Eiffel Tower was constructed. You can use these tools:
- HistoricalEventsDatabase[input]: Searches for historical events.
- WebSearchEngine[input]: Searches the web for information.
- DateExtractor[input]: Extracts dates from text.
- LandmarkInfo[input]: Provides information about landmarks.
- GeneralKnowledgeQA[input]: Answers questions based on general knowledge or context.

Please provide output in this format:
Plan: [first action]
#E1 = [function call with input]
Plan: [next action]
#E2 = [next function call and input, perhaps citing previous evidence]
...
Final Answer: #E[n]

Response:
Plan: Use the GeneralKnowledgeQA tool to ask a direct question about when the Eiffel Tower was constructed.
#E1 = GeneralKnowledgeQA["When was the Eiffel Tower constructed?"]

Final Answer: #E1

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question using the tools provided. Each tool should be used at least once and each plan must 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]: A tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
NLPModel[input]: Natural Language Processing 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 was the architect behind the Sydney Opera House and what other famous buildings did they design?

Response:
Plan: Start by conducting a web search to find out who the architect of the Sydney Opera House is.
:evidence0: = Bing[Architect of Sydney Opera House]
Plan: Use the NLP Model to interpret the search results and identify the name of the architect.
:evidence1: = NLPModel[Who is the architect of the Sydney Opera House, given :evidence0:?]
Plan: Conduct another web search to find other famous buildings designed by the identified architect.
:evidence2: = Bing[Famous buildings designed by :evidence1:]
Plan: Extract relevant links from the Bing search results for further analysis.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Utilize the Web Scraper tool to extract detailed information from the selected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the NLP Model to summarize the key buildings designed by the architect from the extracted information.
:evidence5: = NLPModel[What are the famous buildings designed by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Available Tools:
WebSearch[input]: This tool allows you to search for information on the web. The input is a string and it returns a list of websites that may contain the answer.
TextExtractor[input]: Extracts plain text from one or more websites provided as newline delimited links.
LinkParser[input]: Parses plain text and produces a list of links.
QAModel[input]: A question answering model that answers questions based on given context. The input should be a question referencing an :evidence[n]: variable, e.g., "What color is the cat, given :evidence1:?"

The output format should be as follows:
Plan: [First action]
:evidence0: = [Function with input parameter]
Plan: [Next action, based on result of :evidence0:]
:evidence1: = [Next function with input parameter, which might reference previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

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

Response:
Plan: Use WebSearch to find out who wrote 'Pride and Prejudice'.
:evidence0: = WebSearch['Author of Pride and Prejudice']
Plan: Use QAModel to extract the name of the author from the search results.
:evidence1: = QAModel[Who is the author of 'Pride and Prejudice', given :evidence0:?]
Plan: Conduct another WebSearch to find notable works by this author.
:evidence2: = WebSearch[Notable works by :evidence1:]
Plan: Parse the links from the search results using LinkParser.
:evidence3: = LinkParser[:evidence2:]
Plan: Extract the text from these links using TextExtractor.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use QAModel to identify and summarize the notable works by the author from the extracted texts.
:evidence5: = QAModel[What are the notable works by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step plan to find out the population of New York City in 1920 and how it compares to its current population.

Here are the tools available to be called:
HistoricalData[input]: Tool that allows the user to search for historical data about cities, countries, etc.
CurrentPopulation[input]: Tool that provides the current population of a given city or country.
CompareNumbers[input]: Tool that compares two numbers and gives an output as to which is larger/smaller and by what percentage.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge.

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

Response:
Plan: Find out the population of New York City in 1920.
#E1 = HistoricalData["New York City population in 1920"]

Plan: Once we have the historical data, find out the current population of New York City.
#E2 = CurrentPopulation["New York City"]

Plan: After obtaining both populations, compare them to see how they differ.
#E3 = CompareNumbers[#E1, #E2]

Final answer: #E3

System: A chat.


Instruction:
Formulate a comprehensive plan to resolve the user request using the provided tools. Each phase should match with an evidence value, which is the return of one of the usable functions given an input string that can be the user question, earlier evidence values, or a combination of both.

You can use these tools:
InfoSeek[input]: Allows the user to search for information from a broad database of resources. Useful for gathering diverse information.
DataHarvester[input]: Loads one or multiple websites from the input string featuring newline separated links, where input includes one or more links, and gives plain text output containing the content of the links.
LinkRetriever[input]: Retrieves links from plain text and produces a plain text, newline separated response of links.
QueryHandler[input]: A question-answering language model, effective for handling queries based on an input text passage. The input must be a text question indicating an :evidence[n]: variable, e.g., What is the height of Mount Everest, given :evidence1:?

The output should follow this layout:
Plan: [initial action to perform based on input question]
:evidence0: = [function to apply with input parameter]
Plan: [subsequent action to perform, based on the effect of :evidence0:]
:evidence1: = [next function to apply and input parameter, which may suggest previous evidence, e.g., "Bearing in mind context :evidence0"]
...
Answer: [:evidence[n]: containing the conclusive answer.]

Question: How did the Industrial Revolution impact society and economy?

Response:
Plan: Commence by executing an InfoSeek search to find information about the societal impacts of the Industrial Revolution.
:evidence0: = InfoSeek[societal impacts of the Industrial Revolution]
Plan: Utilize QueryHandler to analyze the search results and summarize the societal impacts.
:evidence1: = QueryHandler[What were the societal impacts of the Industrial Revolution? Given :evidence0:]
Plan: Execute another InfoSeek search to find information about the economic impacts of the Industrial Revolution.
:evidence2: = InfoSeek[economic impacts of the Industrial Revolution]
Plan: Retrieve the appropriate links from the search results for a thorough examination.
:evidence3: = LinkRetriever[:evidence2:]
Plan: Deploy DataHarvester to extract information from the retrieved links.
:evidence4: = DataHarvester[:evidence3:]
Plan: Eventually, use QueryHandler to identify and condense the economic impacts of the Industrial Revolution from the harvested data.
:evidence5: = QueryHandler[What were the economic impacts of the Industrial Revolution? Given :evidence4:]
Answer: Societal Impacts - :evidence1:. Economic Impacts - :evidence5:.

System: A chat.


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

Here are the tools you can use:
Bing[input]: A tool that enables users to search for information using Bing search engine. This tool is handy in finding a list of sites that may contain the answer to the user's question. The function doesn't directly provide the answer; it finds a list of sites that might have the solution.
TextExtractor[input]: Extracts plain text from websites provided in the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkGrabber[input]: Extracts links from plain text and provides a plain text, newline delimited response of links.
NLP[input]: Natural Language Processing model useful 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 input to each function should just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g., NLP[What is the capital of France, given :data3:?]

Remember to include only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out who the author of '1984' is.
:data0: = Bing[Author of 1984]
Plan: Use the Natural Language Processing model to interpret the search results and identify the author.
:data1: = NLP[Who is the author of the book '1984', given :data0:?]
Plan: Conduct another web search to find other notable works by the identified author.
:data2: = Bing[Notable works by :data1:]
Plan: Extract relevant links from the Bing search results for a more detailed search.
:data3: = LinkGrabber[:data2:]
Plan: Use the TextExtractor tool to get information from the relevant links.
:data4: = TextExtractor[:data3:]
Plan: Finally, use the Natural Language Processing model to identify and summarize the other notable works by the author from the extracted information.
:data5: = NLP[What are the other notable works by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
Generate a detailed plan to solve the following query using the described tools. Each step should involve executing a command with one of the tools and storing the result in an Evidence variable (#E[index]).

Tools Available:
NetSearch[input]: Executes a broad internet search based on the input string.
URLExtractor[input]: Pulls all URLs from a block of text.
PageParser[input]: Retrieves the full text of a webpage given its URL.
AIQA[input]: Uses AI to answer questions based on a provided context.

Format your plan as follows:
Plan: [description of first step]
#E1 = [execution command for one of the tools]
Plan: [description of next step]
#E2 = [execution command for one of the tools, potentially referencing #E1]
...
Answer: [#E[n], which contains the final answer]

Question: How did Apple Inc. get its name and who were its founders?

Response:
Plan: Perform an internet search for information about the founding of Apple Inc.
#E1 = NetSearch[Apple Inc. founding]
Plan: Extract URLs from the search results for further investigation.
#E2 = URLExtractor[#E1]
Plan: Retrieve the full text of the most promising webpage.
#E3 = PageParser[#E2]
Plan: Use AI to determine how Apple Inc. got its name from the page text.
#E4 = AIQA[How did Apple Inc. get its name? Given context: #E3]
Plan: Use AI to determine the founders of Apple Inc. from the same page text.
#E5 = AIQA[Who founded Apple Inc.? Given context: #E3]
Answer: #E4 and #E5

System: A chat.


Instruction:
Create a step-by-step plan to solve the user's query, making use of available tools. Each step in your plan should have an associated evidence value which will be the output of one of the given functions with its input string.

Here are the tools you can call upon:
1. Bing[input]: A tool that lets users search for information using the Bing search engine. It is useful for finding sites that may contain answers to the user's question.
2. WebReader[input]: This function loads websites from the input string containing newline delimited links and produces plain text output containing the content of those links.
3. LinkPicker[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
4. SAM[input]: Question answering language model. The input must be a text question that references a :data[n]: variable, e.g., What color is the dog, given :data1:?

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

Each plan should only include one evidence output.

Output format:
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 reference previous data, e.g., "Given context :data0"]
...
Answer: [:data[n]: containing the final answer.]

Question: Who is the current president of Microsoft and what are their major achievements?

Response:
Plan: Start by conducting a web search to find out who the current president of Microsoft is.
:data0: = Bing[Current president of Microsoft]
Plan: Use the language model to interpret the search results and identify the name of the president.
:data1: = SAM[Who is the current president of Microsoft, given :data0:?]
Plan: Conduct another web search to find the major achievements of the identified president of Microsoft.
:data2: = Bing[Major achievements of :data1:]
Plan: Extract relevant links from the Bing search results for more focused research.
:data3: = LinkPicker[:data2:]
Plan: Use the WebReader tool to extract information from the relevant links.
:data4: = WebReader[:data3:]
Plan: Finally, use the language model to identify and summarize the major achievements of the president of Microsoft from the extracted information.
:data5: = SAM[What are the major achievements of :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
Create a detailed execution plan to respond to the following query, using the tools provided. For each plan, specify the tool you would use along with its input to gather evidence. Store the gathered evidence into a variable #E[index] that can be referenced later.

Tools available:
GoogleScholar[input]: A tool that searches Google Scholar for academic papers and articles related to the input query.
AbstractReader[input]: Reads the abstracts of academic papers and generates a summary.
LinkCollector[input]: Collects all the links present in the input text.
QAModel[input]: A question-answering tool that uses machine learning to provide answers based on the context provided.

Output Format:
Plan: [First action]
#E1 = [Tool to use with input]
Plan: [Next action based on #E1]
#E2 = [Next tool to use with input, possibly referencing #E1]
...
Final Answer: #E[n]

Question: How does climate change affect biodiversity?

Response:
Plan: Search for academic papers on how climate change affects biodiversity.
#E1 = GoogleScholar[Climate change effects on biodiversity]
Plan: Collect all the links from the search results for further analysis.
#E2 = LinkCollector[#E1]
Plan: Read the abstracts of the collected academic papers.
#E3 = AbstractReader[#E2]
Plan: Use the QAModel to summarize the effects of climate change on biodiversity based on the read abstracts.
#E4 = QAModel[How does climate change affect biodiversity? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Develop a systematic plan to respond to the following user query utilizing the listed tools. Each plan should result in an evidence value, derived from the output of a function call.

Tools Available:
NetSearch[input]: Executes an internet search based on the input query.
DocParser[input]: Parses documents or webpages and extracts key points.
QueryMaster[input]: Answers questions based on a mix of general knowledge and specific context provided as input.
URLHarvester[input]: Gathers all URLs from a specified text.

Output Format:
Strategy: [Initial action]
#Fact1 = [Function invocation with input]
Strategy: [Subsequent action based on #Fact1]
#Fact2 = [Next function invocation with input, potentially referring to #Fact1]
...
Solution: [#FactN containing the ultimate answer.]

Question: Who wrote the novel "To Kill a Mockingbird" and what awards did it win?

Response:
Strategy: Initiate an internet search to discover who wrote "To Kill a Mockingbird".
#Fact1 = NetSearch[Author of To Kill a Mockingbird]
Strategy: Utilize QueryMaster to interpret the search results and identify the author.
#Fact2 = QueryMaster[Who wrote To Kill a Mockingbird? Given context: #Fact1]
Strategy: Execute another internet search to find out what awards "To Kill a Mockingbird" won.
#Fact3 = NetSearch[Awards won by To Kill a Mockingbird]
Strategy: Extract the URLs from the search results for further investigation.
#Fact4 = URLHarvester[#Fact3]
Strategy: Parse the contents of the harvested URLs to get details about the awards.
#Fact5 = DocParser[#Fact4]
Strategy: Finally, utilize QueryMaster to identify and list the awards won by "To Kill a Mockingbird" from the parsed document.
#Fact6 = QueryMaster[What awards did To Kill a Mockingbird win? Given context: #Fact5]
Solution: #Fact2 and #Fact6

System: A chat.


Instruction:
Create a plan to solve the following problem using the available tools. Each plan should correspond to an evidence value, which will be the output of one of the available functions.

Available Tools:
DuckDuckGo[input]: A tool that uses DuckDuckGo search engine to retrieve information related to the input query.
SiteReader[input]: Loads one or more websites provided as newline-delimited links in the input string and returns the textual content of these sites.
LinkSelector[input]: Extracts links from a block of plain text and returns them as a newline-separated list.
KnowledgeModel[input]: Language model designed to answer questions based on a provided context. It requires a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Initial action based on the input question]
:evidence0: = [Function to call with input parameters]
Plan: [Subsequent action based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameters, possibly referring to prior evidence]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

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

Response:
Plan: Initiate a web search to gather information about Nikola Tesla.
:evidence0: = DuckDuckGo[Nikola Tesla]
Plan: Select relevant links from the search results for detailed examination.
:evidence1: = LinkSelector[:evidence0:]
Plan: Retrieve the textual content from the chosen links.
:evidence2: = SiteReader[:evidence1:]
Plan: Utilize the KnowledgeModel to identify who Nikola Tesla was and his major scientific contributions from the retrieved content.
:evidence3: = KnowledgeModel[Who was Nikola Tesla and what were his major contributions to science? Given context: :evidence2:]
Final Answer: :evidence3:

System: A chat.


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

Here are the tools you can use:
SearchEngine[input]: This tool allows the user to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
TextScraper[input]: This tool loads one or more websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
LinkExtractor[input]: This tool extracts links from plain text and produces a plain text, newline delimited response of links.
AIAnswerer[input]: This is a question answering AI model, useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

Question: What is the history behind the creation of Bitcoin and who was involved?

Response:
Plan: Start by conducting a web search to find out about the history of Bitcoin.
:evidence0: = SearchEngine[History of Bitcoin]
Plan: Use the AIAnswerer to interpret the search results and provide a summary of the history of Bitcoin.
:evidence1: = AIAnswerer[What is the history of Bitcoin, given :evidence0:?]
Plan: Conduct another web search to find out who was involved in the creation of Bitcoin.
:evidence2: = SearchEngine[Who created Bitcoin]
Plan: Extract the relevant links from the search results for further investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the TextScraper tool to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, use the AIAnswerer to identify and summarize who was involved in the creation of Bitcoin from the extracted information.
:evidence5: = AIAnswerer[Who was involved in the creation of Bitcoin, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the following user question using the tools provided. Each step 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's query, previous evidence values, or both.

Here are the tools you can use:
Bing[input]: A tool that allows users to search for information using Bing search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
TextParser[input]: Extracts key details from plain text and produces a structured response containing the extracted details.
LinkCollector[input]: Collects links from plain text and generates a list of links.
WebReader[input]: Loads one or more websites from the input string (containing newline delimited links) and produces plain text output with the content of these links.
AskMe[input]: Question answering language model that answers questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

Ensure only one evidence output per plan step.

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

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

Response:
Plan: Start by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = Bing[Eiffel Tower history]
Plan: Use a language model to interpret the search results and extract the history of the Eiffel Tower.
:evidence1: = AskMe[What is the history of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find out who designed the Eiffel Tower.
:evidence2: = Bing[Eiffel Tower designer]
Plan: Utilize the language model to identify the designer of the Eiffel Tower from the search results.
:evidence3: = AskMe[Who designed the Eiffel Tower, given :evidence2:?]
Answer: :evidence1: and :evidence3:

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question using the available tools. Each step should be followed by an evidence variable which will store the output of the function called in that step.

Available Tools:
Bing[input]: A tool that uses Bing search engine to find information related to the input query. It provides a list of websites that may contain the required information.
TextExtractor[input]: Extracts text from one or more web pages provided as newline delimited links in the input string and produces plain text output containing the content of these pages.
LinkCollector[input]: Collects all the links present in the given plain text and returns them as a newline separated list.
QAModel[input]: This is 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 output format should be:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action, based on result of :evidence0:]
:evidence1: = [next function call with input parameter, which might include reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who was the architect of the Sydney Opera House and what are some notable works they have done besides this?

Response:
Plan: Start by conducting a web search to identify the architect of the Sydney Opera House.
:evidence0: = Bing[Architect of Sydney Opera House]
Plan: Use the QAModel to extract the name of the architect from the search results.
:evidence1: = QAModel[Who was the architect of the Sydney Opera House, given :evidence0:?]
Plan: Conduct another web search to find other notable works done by the identified architect.
:evidence2: = Bing[Notable works by :evidence1:]
Plan: Extract the relevant links from the Bing search results for detailed information.
:evidence3: = LinkCollector[:evidence2:]
Plan: Use TextExtractor to get information from the extracted links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the QAModel to summarize the notable works done by the architect from the extracted information.
:evidence5: = QAModel[What are the notable works done by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to generate a solution to the user instruction using the following tools. For each plan, provide an evidence value which will be the output of one of the available functions given an input string.

These are the tools that can be utilized:
WebCrawler[input]: Tool that allows the user to search for information across the internet. It provides a list of sites that might contain the answer to the user's query.
ContentScraper[input]: Load one or more websites from the input string containing newline-delimited links. Input is one or more links, and it outputs plain text containing the content of the links.
URLExtractor[input]: Extracts links from plain text and generates a plain text, newline-delimited response of links.
QuerySolver[input]: Question-answering model, particularly effective at answering questions based on an input passage of text. The input must be a text question that refers to a #fact[n] variable, e.g., What color is the dog, 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., QuerySolver[What is the capital of Spain, given #fact3?]

Ensure to include only one evidence output per plan step.

The output should be in this format:
Plan: [first action to take based on the 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: Who is the director of the movie 'Inception' and what are some other movies they have directed?

Response:
Plan: Begin by conducting a web search to find out who directed the movie 'Inception'.
#fact0: = WebCrawler[Director of Inception]
Plan: Utilize QuerySolver to interpret the search results and find the name of the director.
#fact1: = QuerySolver[Who is the director of the movie 'Inception', given #fact0?]
Plan: Conduct another web search to find other movies directed by the identified director.
#fact2: = WebCrawler[Movies directed by #fact1]
Plan: Extract the relevant links from the search results for a more focused search.
#fact3: = URLExtractor[#fact2]
Plan: Use ContentScraper to extract information from the relevant links.
#fact4: = ContentScraper[#fact3]
Plan: Finally, utilize QuerySolver to identify and summarize the other movies directed by the director from the extracted information.
#fact5: = QuerySolver[What other movies were directed by #fact1, given #fact4?]
Final Answer: #fact5

System: A chat.