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

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

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

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2020.
#E1 = GoogleSearch[Nobel Prize in Literature 2020 winner]
Plan: Utilize a language model to interpret the search results and find the name of the laureate.
#E2 = AnswerGenerator[Who won the Nobel Prize in Literature in 2020? Given context: #E1]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E3 = GoogleSearch[Most famous work of #E2]
Plan: Extract the relevant links from the Google search results for a more focused search.
#E4 = ExtractLinks[#E3]
Plan: Use a site reader tool to extract information from the relevant links.
#E5 = SiteReader[#E4]
Plan: Finally, utilize the language model to identify and summarize the most famous work of the laureate from the extracted information.
#E6 = AnswerGenerator[What is the most famous work of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Create a detailed action plan to address the user's request by leveraging the listed tools. Every plan must correspond to an evidence output.

Tools available:
LinkedIn[input]: Tool that retrieves professional profiles and company information.
Glassdoor[input]: Tool that provides company reviews and salary information.
Indeed[input]: Tool that fetches job postings based on location and job title.
ResumeParser[input]: Tool that extracts information from a resume document.
JobMatch[input]: Tool that matches skills extracted from a resume with job requirements.

Question: Find out more about the company 'Microsoft', check if there are any software engineer job openings in Seattle, extract skills from my resume, and see if they match the job requirements.

Response:
Action Plan:

1. Use LinkedIn:
   - Search for the company 'Microsoft' on LinkedIn.
   - Review the information provided about the company, such as its size, location, industry, and specialties.
   - Output: Detailed profile of Microsoft from LinkedIn.

2. Use Glassdoor:
   - Look up 'Microsoft' on Glassdoor to find reviews and salary information.
   - Analyze the reviews to understand the company culture, work environment, benefits, and employee satisfaction level.
   - Check the salary range for software engineers at Microsoft in Seattle.
   - Output: A report summarizing the reviews and salary information found on Glassdoor.

3. Use Indeed:
   - Search for job postings for a Software Engineer position at Microsoft in Seattle using Indeed.
   - Go through the job descriptions to understand the roles and responsibilities, required qualifications, and experience needed.
   - Output: List of current job openings for a Software Engineer at Microsoft in Seattle with detailed job descriptions.

4. Use ResumeParser:
   - Upload your resume into the ResumeParser tool.
   - Extract key skills, experiences, and qualifications from your resume.
   - Output: Detailed list of skills, experiences, and qualifications extracted from your resume.

5. Use JobMatch:
   - Input the skills extracted from your resume into the JobMatch tool.
   - Compare these skills with the requirements listed in the job descriptions obtained from Indeed.
   - Output: Report showing how well your skills match with the job requirements for the Software Engineer positions at Microsoft in Seattle.

System: A chat.


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

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

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

Question: 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: = GoogleSearch[History of Bitcoin]
Plan: Use the Knowledge Model to interpret the search results and extract key points about the history of Bitcoin.
:evidence1: = KnowledgeModel[What is the history of Bitcoin, given :evidence0:?]
Plan: Conduct another web search to find out who were the people involved in the creation of Bitcoin.
:evidence2: = GoogleSearch[People involved in the creation of Bitcoin]
Plan: Extract relevant links from the Google search results for further investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the Web Scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the Knowledge Model to identify and summarize the people involved in the creation of Bitcoin from the extracted information.
:evidence5: = KnowledgeModel[Who were the people involved in the creation of Bitcoin, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from websites provided as newline delimited links in the input string.
LinkPicker[input]: Picks out links from plain text and produces a plain text response with newline separated links.
ALM[input]: An advanced language model designed to answer questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

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

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

System: A chat.


Instruction:
Develop a sequential plan to respond to the user query utilizing the provided tools. Each step in the plan should generate an evidence value which corresponds to the output of one of the available functions when supplied with an appropriate input string (which could be the original query, prior evidence values, or a mix).

Available tools:
BingSearch[input]: A tool enabling users to conduct informational searches via Bing. It provides a list of potentially relevant websites but does not directly provide answers.
URLLoader[input]: Loads one or multiple websites from an input string consisting of newline-separated URLs. Outputs plaintext content from these sites.
HyperlinkHarvester[input]: Extracts hyperlinks from plaintext and returns them as a newline-separated plaintext list.
QueryBot[input]: A question-answering language model adept at generating responses based on a textual context. Input must be a question referencing an :evidence[n]: variable.

Output format:
Plan: [initial action based on input query]
:evidence0: = [function call with input parameters]
Plan: [subsequent action based on :evidence0:]
:evidence1: = [next function call with input parameters, possibly referencing earlier evidence]
...
Final Answer: [:evidence[n]: - contains the ultimate answer]

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

Response:
Plan: Initiate a Bing search to identify the architect of the Sydney Opera House.
:evidence0: = BingSearch[Architect of Sydney Opera House]
Plan: Utilize QueryBot to parse the search results and pinpoint the architect's name.
:evidence1: = QueryBot[Who designed the Sydney Opera House, given :evidence0:?]
Plan: Perform another Bing search to discover other notable buildings designed by this architect.
:evidence2: = BingSearch[Notable buildings designed by :evidence1:]
Plan: Harvest pertinent links from the Bing search results for deeper investigation.
:evidence3: = HyperlinkHarvester[:evidence2:]
Plan: Deploy URLLoader to glean information from the harvested links.
:evidence4: = URLLoader[:evidence3:]
Plan: Lastly, engage QueryBot to summarize the notable buildings designed by the architect from the gathered data.
:evidence5: = QueryBot[What are some notable buildings designed by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.  This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.  The function doesn't directly answer the question; it finds a list of sites that may have the answer.
SiteLoader[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.
URLGrabber[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text.  The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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

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

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

Response:
Plan: Begin by conducting a web search to find out who the director of 'Inception' is.
:evidence0: = DuckDuckGo[Director of Inception]
Plan: Utilize an AI model to interpret the search results and find the name of the director.
:evidence1: = AIQA[Who is the director of the movie 'Inception', given :evidence0:?]
Plan: Conduct another web search to find the other movies directed by the identified director.
:evidence2: = DuckDuckGo[Movies directed by :evidence1:]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence3: = URLGrabber[:evidence2:]
Plan: Use a website loader tool to extract information from the relevant links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, utilize the AI model to identify and summarize the other movies directed by the director from the loaded information.
:evidence5: = AIQA[What other movies has :evidence1: directed, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
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.
HyperlinkFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question Answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the car, given :evidence1:?

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

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

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

Question: Who was the first person to walk on the moon and when did this happen?

Response:
Plan: Start by conducting a web search to find out who the first person to walk on the moon was.
:evidence0: = YahooSearch[First person to walk on the moon]
Plan: Use the AIQA model to interpret the search results and identify the astronaut.
:evidence1: = AIQA[Who was the first person to walk on the moon, given :evidence0:?]
Plan: Conduct another web search to find when the identified astronaut walked on the moon.
:evidence2: = YahooSearch[When did :evidence1: walk on the moon]
Plan: Extract relevant links from the Yahoo search results for a more detailed search.
:evidence3: = HyperlinkFinder[:evidence2:]
Plan: Use the WebScraper tool to get information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the AIQA model to identify and summarize when the astronaut walked on the moon from the extracted information.
:evidence5: = AIQA[When did :evidence1: walk on the moon, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Devise a structured plan to tackle the following query using the designated tools. Every stage of the plan should result in an evidence value, formed by calling a function with an input string that could be the first question, former evidence, or a blend of both.

Here are the tools you can utilize:
LibrarySearch[input]: Searches an online library database for information related to the input string. While it may not offer direct answers, it frequently yields valuable contextual information.
TextCondenser[input]: Condenses a piece of text into its essential points. Especially beneficial when handling voluminous information.
InquiryResponder[input]: Responds to inquiries using ordinary wisdom, general awareness, or particular context derived from previous evidence.

Inputs to each function should be uncomplicated strings, void of quotation marks or "+" signs for string concatenation, e.g., InquiryResponder[Who wrote Pride and Prejudice, given :evidence2:?].

Ensure that every stage in the plan matches up with precisely one evidence output.

Output format:
Plan: [Initial action based on the question]
:evidence0: = [Call to function with input parameter]
Plan: [Subsequent action, bearing in mind the result of :evidence0:]
:evidence1: = [Call to next function with input parameter, possibly referring to earlier evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

Question: Who was Jane Austen and what are her most famous works?

Response:
Plan: Start by conducting a LibrarySearch for information about Jane Austen.
:evidence0: = LibrarySearch[Jane Austen]
Plan: Use TextCondenser to distill the key points about Jane Austen from the library search results.
:evidence1: = TextCondenser[:evidence0:]
Plan: Utilize InquiryResponder to identify who Jane Austen was based on the condensed information.
:evidence2: = InquiryResponder[Who was Jane Austen, given :evidence1:?]
Plan: Perform another LibrarySearch to uncover Jane Austen's most renowned works.
:evidence3: = LibrarySearch[Jane Austen's famous works]
Plan: Apply TextCondenser to shorten the list of Jane Austen's notable works.
:evidence4: = TextCondenser[:evidence3:]
Plan: Finally, use InquiryResponder to highlight Jane Austen's most famous works based on the condensed list.
:evidence5: = InquiryResponder[What are Jane Austen's most famous works, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Please create a detailed plan to answer the following question using the tools provided. Each step in your plan should be accompanied by an evidence variable, representing the output of a particular function when given appropriate inputs.

Available Tools:
YahooSearch[input]: Allows users to conduct a Yahoo search. While it doesn't offer direct answers, it provides a list of potential sources of information.
SiteScraper[input]: Fetches content from one or multiple websites specified in an input string containing newline-separated URLs.
LinkCollector[input]: Pulls out links from a chunk of plain text and presents them in a newline-separated manner.
DataAnalyzer[input]: An AI language model capable of answering queries based on supplied text. The input needs to be a question that refers to a :data[n]: variable.

Output Format:
Plan: [First action based on the question]
:data0: = [Function to run with input parameters]
Plan: [Following action considering :data0:]
:data1: = [Next function to run with input parameters, possibly referencing earlier data such as "With respect to :data0:"]
...
Answer: [:data[n]: contains the final answer.]

Question: Who wrote the novel '1984' and what are some notable works they produced?

Response:
Plan: Start off by running a Yahoo search to discover who wrote '1984'.
:data0: = YahooSearch[Author of 1984]
Plan: Apply DataAnalyzer to sift through the search results and identify the author.
:data1: = DataAnalyzer[Who wrote 1984? With respect to :data0:]
Plan: Execute another Yahoo search to find other notable works by the author.
:data2: = YahooSearch[Notable works by :data1:]
Plan: Extract relevant links from the search results for closer examination.
:data3: = LinkCollector[:data2:]
Plan: Scrape the content of the selected links using SiteScraper.
:data4: = SiteScraper[:data3:]
Plan: Finally, use DataAnalyzer to distill the notable works of the author from the scraped content.
:data5: = DataAnalyzer[What are some notable works by :data1:? With respect to :data4:]
Answer: :data5:

System: A chat.


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

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

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

Question: What is the highest peak in the Andes mountain range and what is its elevation?

Response:
Plan: Start by conducting a web search to find out the highest peak in the Andes mountain range.
:evidence0: = DuckDuckGo[Highest peak in the Andes mountain range]
Plan: Use the QAModel to interpret the search results and identify the name of the peak.
:evidence1: = QAModel[What is the highest peak in the Andes mountain range, given :evidence0:?]
Plan: Conduct another web search to find the elevation of the identified peak.
:evidence2: = DuckDuckGo[Elevation of :evidence1:]
Plan: Extract the relevant links from the DuckDuckGo search results for detailed information.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use the WebReader tool to extract information from the relevant links.
:evidence4: = WebReader[:evidence3:]
Plan: Finally, use the QAModel to determine the elevation of the peak from the extracted information.
:evidence5: = QAModel[What is the elevation of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to solve the following problem using the tools provided. Every plan needs to have a corresponding evidence value which is the result of calling a function with an appropriate input string.

Tools Available:
DuckDuckGo[input]: Allows users to perform a web search using DuckDuckGo. It returns a list of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from the input string containing newline delimited links. Input is one or more links, and it outputs plain text content of the links.
LinkGatherer[input]: Extracts links from plain text and provides a plain text, newline separated list of links.
ALICE[input]: A language model that answers questions based on an input text passage. The input should be a text question referencing an :evidence[n]: variable.

Output Format:
Plan: [First Action]
:evidence0: = [Function call with input]
Plan: [Next Action]
:evidence1: = [Next Function call with input]
...
Final Answer: :evidence[n]:

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

Response:
Plan: Initiate a web search to find out who was the first person to climb Mount Everest without supplemental oxygen.
:evidence0: = DuckDuckGo[First person to climb Mount Everest without supplemental oxygen]
Plan: Use ALICE to interpret the search results and identify the climber.
:evidence1: = ALICE[Who was the first person to climb Mount Everest without supplemental oxygen, given :evidence0:?]
Plan: Conduct another web search to find the motivations of the identified climber.
:evidence2: = DuckDuckGo[Motivations of :evidence1: for climbing Mount Everest without supplemental oxygen]
Plan: Extract relevant links from the DuckDuckGo search results for deeper analysis.
:evidence3: = LinkGatherer[:evidence2:]
Plan: Use SiteReader to extract information from the relevant links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, use ALICE to summarize the motivations of the climber from the extracted information.
:evidence5: = ALICE[What were the motivations of :evidence1: for climbing Mount Everest without supplemental oxygen, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: A tool that allows the user to search for information from Bing. This tool is useful in finding relevant sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites given one or more links as input and produces plain text containing the content of the links.
LinkFilter[input]: Filters out irrelevant links from a list of links and produces a newline delimited response of relevant links.
AIM[input]: An artificial intelligence model capable of answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable, e.g., What is the capital of France, given :evidence1:?

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

Each plan should have only one evidence output.

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

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

Response:
Plan: Conduct a web search to find out who won the Nobel Prize in Literature in 2020.
:evidence0: = Bing[Nobel Prize in Literature 2020 winner]
Plan: Use the AI model to interpret the search results and identify the winner.
:evidence1: = AIM[Who won the Nobel Prize in Literature in 2020, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = Bing[Most famous work of :evidence1:]
Plan: Filter out the irrelevant links from the Bing search results.
:evidence3: = LinkFilter[:evidence2:]
Plan: Extract text from the relevant links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the AI model to identify the most famous work of the laureate from the extracted text.
:evidence5: = AIM[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a plan to determine the distance between New York City and London. Available tools include:
- GeoLocator[input]: Provides geographical information.
- DistanceCalculator[input]: Calculates distances between two locations.
- MapAPI[input]: Accesses map data and services.
- InfoGatherer[input]: Gathers general information from various sources.
- QuestionAnsweringSystem[input]: Answers questions based on general knowledge or specific context.

Follow this format:
Plan: [first action]
#E1 = [function call with input]
Plan: [next action]
#E2 = [next function call and input, which may reference previous evidence]
...
Final Answer: #E[n]

Response:
Plan: Use GeoLocator to get the coordinates of New York City.
#E1 = GeoLocator["New York City"]

Plan: Use GeoLocator again to get the coordinates of London.
#E2 = GeoLocator["London"]

Plan: Use DistanceCalculator to calculate the distance between the two sets of coordinates.
#E3 = DistanceCalculator[#E1, #E2]

Final Answer: #E3

System: A chat.


Instruction:
Create a step-by-step execution plan to answer the user's question using the available tools:
DuckDuckGo[input]: Search engine tool useful in finding relevant websites pertaining to the input query.
SiteScraper[input]: Tool that extracts text content from one or multiple websites provided in the input string.
URLExtractor[input]: Tool that extracts URLs from plain text.
NLPQA[input]: Natural Language Processing Question Answering tool that answers questions based on an input context. It requires a question that refers to a #Info[n] variable.

The output should follow this structure:
Plan: [First action]
#Info1 = [Function call with input]
Plan: [Next action based on #Info1]
#Info2 = [Next function call with input possibly referring to #Info1]
...
Final Answer: #Info[n]

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

Response:
Plan: Begin by conducting a web search to find out who was the first person to climb Mount Everest without supplemental oxygen.
#Info1 = DuckDuckGo[First person to climb Mount Everest without supplemental oxygen]
Plan: Extract the relevant links from the search results.
#Info2 = URLExtractor[#Info1]
Plan: Scrape the websites for information.
#Info3 = SiteScraper[#Info2]
Plan: Use NLPQA to identify the individual from the scraped information.
#Info4 = NLPQA[Who was the first person to climb Mount Everest without supplemental oxygen? Given context: #Info3]
Final Answer: #Info4

Continue generating similar pairs until there are 10 total.

System: A chat.


Instruction:
Create a detailed execution plan to solve the following query using the listed tools. Each plan should correspond to an evidence value generated by calling a function with an input string derived from the user's question or prior evidence values.

Available Tools:
Bing[input]: A tool that lets users conduct searches via Bing. It returns a list of potential sites that might contain answers to the user's query.
SiteReader[input]: Reads the contents of a site provided as an input link and generates plain text output.
HyperlinkHarvester[input]: Extracts hyperlinks from any plain text input and outputs them as newline-separated links.
QueryMaster[input]: A language model capable of answering questions based on an input context. The input must be a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Initial action based on user's question]
:evidence0: = [Function call with relevant input]
Plan: [Subsequent action based on outcome of :evidence0:]
:evidence1: = [Next function call with relevant input, possibly referring to earlier evidence]
...
Final Response: [:evidence[n]:]

Question: Who was Leonardo da Vinci and what were his major contributions to art and science?

Response:
Plan: Begin by searching for information on Leonardo da Vinci.
:evidence0: = Bing[Leonardo da Vinci]
Plan: Extract useful links from the search results.
:evidence1: = HyperlinkHarvester[:evidence0:]
Plan: Read the contents of the extracted links.
:evidence2: = SiteReader[:evidence1:]
Plan: Use the language model to determine who Leonardo da Vinci was based on the gathered data.
:evidence3: = QueryMaster[Who was Leonardo da Vinci? Given :evidence2:]
Plan: Also use the language model to identify Leonardo da Vinci's major contributions to art and science.
:evidence4: = QueryMaster[What were Leonardo da Vinci's major contributions to art and science? Given :evidence2:]
Final Response: :evidence3: and :evidence4:

System: A chat.


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

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

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

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

Response:
Plan: Start by conducting a web search to find out the current population of Tokyo.
:evidence0: = Bing[Current population of Tokyo]
Plan: Use the language model-based question answering system to interpret the search results and determine the population.
:evidence1: = LMQA[What is the current population of Tokyo, given :evidence0:?]
Plan: Conduct another web search to find popular tourist attractions in Tokyo.
:evidence2: = Bing[Popular tourist attractions in Tokyo]
Plan: Extract relevant links from the Bing search results for a deeper dive into the topic.
:evidence3: = LinkCollector[:evidence2:]
Plan: Use the WebScraper tool to extract detailed information from the collected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model-based question answering system to identify and summarize the popular tourist attractions in Tokyo from the extracted information.
:evidence5: = LMQA[What are some popular tourist attractions in Tokyo, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the question: "What is the process of photosynthesis in plants?"

Here are the tools available:
InfoSearch[input]: Tool that allows you to search for information from various sources.
TextSummarizer[input]: Summarizes long pieces of text into shorter, more digestible content.
DiagramFinder[input]: Finds diagrams related to the input query.
QA[input]: Can answer questions using common sense and general world knowledge.
ContextualAnswer[input]: Answers questions based on an input passage of text.

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 = InfoSearch["process of photosynthesis in plants"]

Plan: Next action
#E2 = TextSummarizer[#E1]

Plan: Third action
#E3 = DiagramFinder["photosynthesis process diagram"]

Final Answer: #E2, #E3

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextExtractor[input]: Extracts plain text from a webpage URL and produces a plain text output containing the content of the link.
LinkParser[input]: Parses links from plain text and produces a plain text, newline delimited response of links.
AIM[input]: An artificial intelligence model for answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable, e.g. What color is the dog, given :evidence1:?

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

Remember to only include one evidence output per plan step.

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

Question: Who was the first person to climb Mount Everest and what were some challenges they faced?

Response:
Plan: Start by conducting a web search to find out who the first person to climb Mount Everest was.
:evidence0: = Bing[First person to climb Mount Everest]
Plan: Use an AI model to interpret the search results and identify the name of the climber.
:evidence1: = AIM[Who was the first person to climb Mount Everest, given :evidence0:?]
Plan: Conduct another web search to find the challenges faced by the identified climber while climbing Mount Everest.
:evidence2: = Bing[Challenges faced by :evidence1: climbing Mount Everest]
Plan: Parse the relevant links from the Bing search results for a more detailed search.
:evidence3: = LinkParser[:evidence2:]
Plan: Use a text extractor tool to extract information from the relevant links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the AI model to identify and summarize the challenges faced by the climber from the extracted information.
:evidence5: = AIM[What were the challenges faced by :evidence1: while climbing Mount Everest, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Provide a detailed plan to solve the user's query using the following tools. For each plan, specify the external tool along with the tool input to gather evidence. Store the evidence into a variable #E[index] that can be referenced later.

Available Tools:
WikiLookup[input]: Tool that searches Wikipedia for information related to the input query. Useful for gaining knowledge about various topics.
QA_Bot[input]: Answers questions using common sense, general world knowledge, or given input context that contains the answer.

Each plan should correspond to exactly one evidence (#E[index]) value.

Output Format:
Plan: [First action based on input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on result of #E1]
#E2 = [Next function to call and input parameter, possibly referring to previous evidence, e.g., "Given context #E1"]
...
Final Answer: #E[n]

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

Response:
Plan: Look up information about photosynthesis on Wikipedia.
#E1 = WikiLookup[Photosynthesis]
Plan: Find out how photosynthesis works.
#E2 = QA_Bot[How does photosynthesis work? Given context: #E1]
Plan: Look up information about chloroplasts on Wikipedia.
#E3 = WikiLookup[Chloroplasts]
Plan: Determine the role of chloroplasts in photosynthesis.
#E4 = QA_Bot[What role do chloroplasts play in photosynthesis? Given context: #E3]
Final Answer: #E2 and #E4

System: A chat.


Instruction:
Plan how to identify the primary ingredients in traditional Italian lasagna. Tools at your disposal:
- RecipeFinder[input]: Finds recipes online.
- IngredientExtractor[input]: Identifies ingredients from recipe text.
- FoodPedia[input]: Searches for food-related information.
- WebCrawler[input]: Crawls the web for specified information.
- AIQA[input]: Artificial Intelligence-based tool that answers questions.

Format your output as follows:
Plan: [first action]
#Evidence1 = [function call with input]
Plan: [next action]
#Evidence2 = [next function call and input, possibly referring to previous evidence]
...
Final Answer: #Evidence[n]

Response:
Plan: Use RecipeFinder to find traditional Italian lasagna recipes.
#Evidence1 = RecipeFinder["traditional Italian lasagna"]

Plan: Extract the ingredients from the found recipes using IngredientExtractor.
#Evidence2 = IngredientExtractor[#Evidence1]

Plan: Analyze the most common ingredients across all recipes to identify primary ingredients.
#Evidence3 = AIQA["What are the most common ingredients in #Evidence2?"]

Plan: Validate the identified primary ingredients by searching for their relevance in traditional Italian lasagna using FoodPedia and WebCrawler.
#Evidence4 = FoodPedia[#Evidence3]
#Evidence5 = WebCrawler["primary ingredients in traditional Italian lasagna"]

Final Answer: #Evidence3, validated by #Evidence4 and #Evidence5

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information on the web. This tool is useful in finding websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from a website link and produces plain text output containing the content of the link.
LinkLister[input]: Extracts links from plain text and produces a plain text response of links.
AnswerBot[input]: A language model tool that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What is the population of London, given #E1?

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

Question: Who was the first woman to win a Nobel Prize and what was her contribution to science?

Response:
Plan: Start by conducting a web search to find out who was the first woman to win a Nobel Prize.
#E1 = WebSearch[First woman to win a Nobel Prize]
Plan: Use AnswerBot to interpret the search results and identify the name of the woman.
#E2 = AnswerBot[Who was the first woman to win a Nobel Prize? Given context: #E1]
Plan: Conduct another web search to find out about her contributions to science.
#E3 = WebSearch[#E2 + ' scientific contributions']
Plan: Extract the relevant links from the search results for more detailed information.
#E4 = LinkLister[#E3]
Plan: Use TextExtractor to get information from the relevant links.
#E5 = TextExtractor[#E4]
Plan: Finally, use AnswerBot to summarize her contributions to science from the extracted information.
#E6 = AnswerBot[What were the scientific contributions of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


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

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

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

Response:
Plan: Start by conducting a web search to find out who the architect of the Sydney Opera House is.
#E0 = Bing[Architect of Sydney Opera House]
Plan: Use a language model to interpret the search results and identify the name of the architect.
#E1 = SAM[Who is the architect of the Sydney Opera House, given #E0?]
Plan: Conduct another web search to find the key works done by the identified architect.
#E2 = Bing[Notable works by #E1]
Plan: Extract the relevant links from the Bing search results for a deeper investigation.
#E3 = LinkHarvester[#E2]
Plan: Use a web crawler tool to extract information from the relevant links.
#E4 = WebCrawler[#E3]
Plan: Finally, utilize the language model to identify and summarize the key works done by the architect from the extracted information.
#E5 = SAM[What are the notable works by #E1, given #E4?]
Answer: #E5

System: A chat.


Instruction:
Develop a sequential plan to respond to the following query using the provided tools. Each step in your plan should correspond to an evidence value, which represents the output of a specific function given its input.

Available Tools:
DuckDuckGo[input]: A tool allowing users to perform internet searches via DuckDuckGo. It provides a list of potential sources that might contain answers to the user's query.
PageLoader[input]: Loads one or more webpages from a newline-separated list of URLs provided as input, returning the full text contents of those pages.
URLCollector[input]: Extracts all URLs from a block of plain text, returning them as a newline-separated list.
AIQnA[input]: An AI-powered question-answering tool capable of providing direct responses to queries based on general knowledge or context provided in the form of prior evidence variables.

Output Format:
Plan: [Initial action based on the user's query]
#E1 = [Function to execute with specified input]
Plan: [Subsequent action dependent on #E1's outcome]
#E2 = [Next function to execute with specified input, potentially referencing earlier evidence]
...
Final Answer: #En

Question: What are some notable works by the author of "To Kill a Mockingbird"?

Response:
Plan: Start by searching the internet to identify the author of "To Kill a Mockingbird".
#E1 = DuckDuckGo[Author of To Kill a Mockingbird]
Plan: Use the AI question-answering tool to determine the author's name from the search results.
#E2 = AIQnA[Who is the author of "To Kill a Mockingbird"? Given context: #E1]
Plan: Perform another internet search to discover notable works by this author.
#E3 = DuckDuckGo[Notable works by #E2]
Plan: Extract useful URLs from the search results for further investigation.
#E4 = URLCollector[#E3]
Plan: Load the textual content of these URLs for analysis.
#E5 = PageLoader[#E4]
Plan: Finally, use the AI question-answering tool to compile a list of the author's notable works from the loaded webpage contents.
#E6 = AIQnA[What are some notable works by #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Generate a step-by-step execution plan to respond to the user query using the provided tools. Each step must correspond to an evidence variable which represents the output of the called function.

Available tools:
GoogleSearch[input]: Performs a Google search for the specified input and returns a list of potential websites.
ExtractText[input]: Retrieves the main body of text from a given website URL.
QAmodel[input]: Answers questions based on its training data or given context. It needs a question as input and can utilize prior evidence variables for contextual reference.
GetLinks[input]: Returns a list of URLs from a given block of text.

The final output should follow this structure:
Plan: [initial action]
:Evidence0: = [tool with corresponding input]
Plan: [subsequent action]
:Evidence1: = [next tool with corresponding input, potentially referencing :Evidence0:]
...
Answer: [:EvidenceN:, where N is the last evidence variable.]

Question: Who won the Nobel Prize in Literature in 2019 and what were their notable works?

Response:
Plan: Begin by conducting a Google search to find out who won the Nobel Prize in Literature in 2019.
:Evidence0: = GoogleSearch[Nobel Prize in Literature 2019 winner]
Plan: Use the QA model to extract the name of the winner from the search results.
:Evidence1: = QAmodel[Who won the Nobel Prize in Literature in 2019? Given context: :Evidence0:]
Plan: Conduct another Google search to find the notable works of the identified laureate.
:Evidence2: = GoogleSearch[:Evidence1: notable works]
Plan: Extract the relevant links from the Google search results for further investigation.
:Evidence3: = GetLinks[:Evidence2:]
Plan: Retrieve the text from the selected links.
:Evidence4: = ExtractText[:Evidence3:]
Plan: Lastly, use the QA model to identify and summarize the notable works of the laureate from the retrieved text.
:Evidence5: = QAmodel[What are the notable works of :Evidence1:? Given context: :Evidence4:]
Answer: :Evidence5:

System: A chat.


Instruction:
Formulate a plan to respond to the user instruction by employing the set of tools at hand. For every step in the plan, there should be an accompanying evidence value which is the outcome of a specific function based on an input string.

The available tools include:
1. DuckDuckGo[input]: A tool that allows users to conduct a search using the DuckDuckGo search engine. The result is a list of sites that may contain the answer to the user's query.
2. TextScraper[input]: Retrieves plain text from one or more websites given newline separated links.
3. LinkParser[input]: Parses plain text and generates a list of links.
4. AIQA[input]: An artificial intelligence-based question-answering model that provides answers based on a given passage of text.

The output should follow this structure:
Plan: [initial action]
:evidence0: = [function with corresponding input]
Plan: [subsequent action based on :evidence0:]
:evidence1: = [next function and input parameter, potentially referring to prior evidence]
...
Answer: [:evidence[n]: containing the ultimate response.]

Question: Who was Albert Einstein and what are his most significant contributions to physics?

Response:
Plan: Start by searching for general information about Albert Einstein.
:evidence0: = DuckDuckGo[Albert Einstein]
Plan: Parse the search results to extract relevant links.
:evidence1: = LinkParser[:evidence0:]
Plan: Utilize the TextScraper tool to gather text from the extracted links.
:evidence2: = TextScraper[:evidence1:]
Plan: Employ the AIQA model to identify who Albert Einstein was from the gathered text.
:evidence3: = AIQA[Who was Albert Einstein? Given context: :evidence2:]
Plan: Lastly, utilize the AIQA model again to identify Einstein's major contributions to physics from the same text.
:evidence4: = AIQA[What were Albert Einstein's major contributions to physics? Given context: :evidence2:]
Answer: :evidence4:

System: A chat.


Instruction:
Please generate a solution plan for the following question. In each step, mention the tool you'll use along with the input. You can save the results in variables named @Evidence[Index].

Tools Available:
1. YahooSearch[input]: Tool that searches for information via Yahoo Search Engine. It helps in finding potential sites that might contain the answer. However, it doesn't directly provide the answer.
2. TextScraper[input]: Takes one or more website links and fetches plain text content from those links.
3. HyperlinkGatherer[input]: Fetches hyperlinks from plain text and gives a newline-separated list of links.
4. QuerySolver[input]: A tool that answers queries based on a given context. The input needs to be a question referring to an @Evidence[n] variable.

Output Format:
Plan: [Initial Step]
@Evidence0 = [Tool Name with Input Parameter]
Plan: [Subsequent Steps]
@Evidence1 = [Next Tool Name with Input Parameter, possibly referencing previous evidence]
...
Final Answer: @Evidence[n]

Question: What's the tallest building in New York and when was it built?

Response:
Plan: Initiate a search to find the tallest building in New York.
@Evidence0 = YahooSearch[Tallest building in New York]
Plan: Utilize QuerySolver to get the name of the building from the search results.
@Evidence1 = QuerySolver[What is the tallest building in New York? Given context: @Evidence0]
Plan: Execute another search to find out when the identified building was constructed.
@Evidence2 = YahooSearch[Construction date of @Evidence1]
Plan: Gather all relevant links from the search results.
@Evidence3 = HyperlinkGatherer[@Evidence2]
Plan: Scrape the content from the gathered links.
@Evidence4 = TextScraper[@Evidence3]
Plan: Lastly, employ QuerySolver to ascertain the construction date of the building from the scraped content.
@Evidence5 = QuerySolver[When was @Evidence1 built? Given context: @Evidence4]
Final Answer: @Evidence5

System: A chat.


Instruction:
Please develop a sequential plan to generate an ideal response to the user's question using the available tools. Each step in your plan should correlate to an evidence value, which will be the output of one of the accessible functions when given an input string that could be the user's inquiry, previous evidence values, or both.

You have access to the following tools:
1. YahooSearch[input]: A tool that enables the user to conduct an online search via the Yahoo search engine. This tool is useful for finding a variety of sites that may contain the answer to the user's question.
2. WebCrawler[input]: Loads one or more websites from the input string, which includes newline separated links, and yields plain text output containing the site's content.
3. HyperlinkExtractor[input]: Extracts hyperlinks from plain text and produces a plain text, newline separated response of links.
4. QuerySolver[input]: A question-answering language model, particularly adept at providing answers based on an input text passage. The input needs to be a text question that refers to an :evidence[n]: variable.

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

Ensure only one evidence output per plan step.

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

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

Response:
Plan: Begin by conducting a web search to gather information about the Battle of Waterloo.
:evidence0: = YahooSearch[Battle of Waterloo]
Plan: Use the QuerySolver to analyze the search results and provide a brief summary of the Battle of Waterloo.
:evidence1: = QuerySolver[What is the Battle of Waterloo? Given context: :evidence0:?]
Plan: Perform another web search to understand the impact of the Battle of Waterloo on Europe.
:evidence2: = YahooSearch[Impact of Battle of Waterloo on Europe]
Plan: Extract the relevant links from the search results for further exploration.
:evidence3: = HyperlinkExtractor[:evidence2:]
Plan: Use the WebCrawler tool to obtain information from the selected links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Lastly, utilize the QuerySolver to summarize the impact of the Battle of Waterloo on Europe from the obtained information.
:evidence5: = QuerySolver[How did the Battle of Waterloo impact Europe? Given context: :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please create a detailed plan to respond to the user's instruction, making use of the provided tools. Each step in your plan should have a corresponding evidence value, which will be the output of one of the available functions when given an appropriate input string.

Here are the tools at your disposal:
DuckDuckGo[input]: This tool enables users to conduct searches using DuckDuckGo. It is helpful for locating a variety of sites that may contain the answer to the user's query. This function does not directly provide an answer but identifies potential sources of answers.
SiteReader[input]: This tool loads one or more websites from an input string containing newline-delimited links. The input consists of one or more links, and the output is plain text containing the content of these links.
URLExtractor[input]: This tool extracts URLs from plain text and generates a plain text, newline-delimited list of URLs.
LanguageModelQA[input]: This is a question-answering language model that excels at providing answers based on a given passage of text. The input should be a textual question referencing a :evidence[n]: variable, such as 'What is the dog's breed, given :evidence1:?'.

Inputs to these functions should be plain strings without quotation marks or '+' symbols used to concatenate a string with an evidence variable, e.g., LanguageModelQA[What is the population of New York City, given :evidence2:?].

Ensure that each plan step includes only one evidence output.

Your output should follow this structure:
Plan: [First action based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Next function to call with input parameter, possibly referring to previous evidence, like 'Given context :evidence0']
...
Final Answer: [:evidence[n]: containing the final answer]

Question: What was the impact of Gutenberg's printing press on the Renaissance period?

Response:
Plan: Initiate a web search to gather general information about Gutenberg's printing press.
:evidence0: = DuckDuckGo[Gutenberg's printing press]
Plan: Utilize the language model to understand the basic facts about Gutenberg's printing press from the search results.
:evidence1: = LanguageModelQA[What is Gutenberg's printing press, given :evidence0:?]
Plan: Perform another web search to uncover details about the impact of Gutenberg's printing press on the Renaissance period.
:evidence2: = DuckDuckGo[Impact of Gutenberg's printing press on the Renaissance]
Plan: Extract pertinent links from the search results for a deeper investigation.
:evidence3: = URLExtractor[:evidence2:]
Plan: Employ the SiteReader tool to glean information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, apply the language model to identify and summarize the impact of Gutenberg's printing press on the Renaissance period from the gathered information.
:evidence5: = LanguageModelQA[What was the impact of Gutenberg's printing press on the Renaissance period, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the following question, using the available tools. Each tool has its own unique function and can be used in conjunction with others. For each step of your plan, store the output of the tool you use as evidence in a variable #E[index].

Here are the tools that can be used:

1. WikiSearch[input]: This tool allows users to search for information from Wikipedia. It is useful for obtaining factual data about various topics such as historical events, geographical locations, individuals, etc.

2. AskJeeves[input]: A tool that answers questions based on common knowledge or given context.

3. GoogleMaps[input]: A tool that provides geographic information about places around the world.

4. WeatherApp[input]: Provides weather conditions of a specified location.

The format of the output should be as follows:
Plan: [First action]
#E1 = [Tool name and input parameter]
Plan: [Second action]
#E2 = [Next tool name and input parameter, which may include reference to previous evidence]
...
Final Answer: #E[n]

Question: What is the climate like in the city where the headquarters of Microsoft Corporation is located?

Response:
Plan: Find out where the headquarters of Microsoft Corporation is located.
#E1 = WikiSearch[Microsoft Corporation]
Plan: Extract the city's name from the obtained information.
#E2 = AskJeeves[Where is the headquarters of Microsoft Corporation located? Given context: #E1]
Plan: Get the current weather condition of the city.
#E3 = WeatherApp[#E2]
Final Answer: #E3

System: A chat.


Instruction:
Design a methodical plan to resolve this inquiry using these tools:
AcademicDatabaseSearch[input]: Searches academic databases for relevant studies.
JournalScan[input]: Scans scientific journals for pertinent articles.
StudyBreakdown[input]: Breaks down studies into key findings.
ValidityChecker[input]: Checks the validity of claims.
InterpretiveResponder[input]: Interprets context to provide responses.

Question: What is quantum entanglement and how has it been experimentally verified?

Response:
Plan:

1. Use AcademicDatabaseSearch["quantum entanglement"] to find relevant studies on the topic of quantum entanglement.
2. Use JournalScan["quantum entanglement"] to scan scientific journals for articles related to quantum entanglement.
3. From the results obtained from steps 1 and 2, select a few key studies and articles that seem most relevant to the question.
4. Use StudyBreakdown[input] on each selected study or article to break them down into their key findings about what quantum entanglement is and how it has been experimentally verified.
5. Use ValidityChecker[input] on these key findings to ensure they are valid claims and not based on faulty research or misinterpretations.
6. Once we have a set of validated key findings, use InterpretiveResponder[input] to interpret these findings in the context of the original question: "What is quantum entanglement and how has it been experimentally verified?" This will provide a comprehensive answer based on the collected and validated information.

System: A chat.


Instruction:
Develop a step-by-step plan to generate an optimal response to the user's request, using a selection of available tools.

Here are the tools available to be called:
YahooSearch[input]: Tool that enables the user to search for information using the Yahoo search engine.
PageParser[input]: Loads one or multiple websites from the input string containing newline separated links, producing plain text output containing the content of the pages.
URLUnearth[input]: Extracts URLs from plain text and generates a plain text, newline separated list of URLs.
InfoBot[input]: An AI-powered tool capable of answering questions based on an input passage of text.

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

Question: Who is the current president of France and what is his educational background?

Response:
Plan: Start by performing a web search to determine the current president of France.
#Fact1 = YahooSearch[Current president of France]
Plan: Use InfoBot to analyze the search results and identify the name of the president.
#Fact2 = InfoBot[Who is the current president of France? Given context: #Fact1]
Plan: Perform another web search to find details about the educational background of the identified president.
#Fact3 = YahooSearch[Educational background of #Fact2]
Plan: Extract the pertinent links from the Yahoo search results for a more detailed search.
#Fact4 = URLUnearth[#Fact3]
Plan: Use PageParser to gather information from the relevant links.
#Fact5 = PageParser[#Fact4]
Plan: Lastly, employ InfoBot to recognize and summarize the educational background of the French president from the gathered information.
#Fact6 = InfoBot[What is the educational background of #Fact2? Given context: #Fact5]
Final Answer: #Fact6

System: A chat.


Instruction:
Please create a detailed execution plan to respond to the following user query. You must make use of all available tools and assign an evidence variable to each step of the plan.

Tools Available:
1. BingSearch[input]: Searches the internet for information related to the input query.
2. ReadabilityTool[input]: Processes a block of text and identifies the main points.
3. QAEngine[input]: Answers questions based on general knowledge or given context.
4. HyperlinkExtractor[input]: Pulls out all hyperlinks from a given text.

Output Format:
Step: [First action]
$Evidence1 = [Function call with input]
Step: [Next action]
$Evidence2 = [Function call with input]
...
Answer: $EvidenceN

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

Response:
Step: Begin by searching for information on the history of the Eiffel Tower.
$Evidence1 = BingSearch[Eiffel Tower history]
Step: Extract the main points from the search results.
$Evidence2 = ReadabilityTool[$Evidence1]
Step: Use the question answering tool to determine why the Eiffel Tower was built from the extracted main points.
$Evidence3 = QAEngine[Why was the Eiffel Tower built? Given context: $Evidence2]
Step: Conduct another search to gain more insight into the history of the Eiffel Tower.
$Evidence4 = BingSearch[Eiffel Tower construction history]
Step: Extract the hyperlinks from the search results for further investigation.
$Evidence5 = HyperlinkExtractor[$Evidence4]
Step: Analyze the contents of these links to gather more historical facts about the Eiffel Tower.
$Evidence6 = ReadabilityTool[$Evidence5]
Step: Lastly, use the question answering tool to summarize the history of the Eiffel Tower from the analyzed link contents.
$Evidence7 = QAEngine[What is the history of the Eiffel Tower? Given context: $Evidence6]
Answer: $Evidence7

System: A chat.


Instruction:
Generate a plan to answer the following question using the tools provided. Each step should have corresponding evidence stored in a variable #E[index], which can be referenced in later steps.

Available Tools:
WikiSearch[input]: Searches Wikipedia for a page matching the input string.
ReadPage[input]: Reads the full text of a specified Wikipedia page.
LangModel[input]: Answers a question based on a given passage of text. Input must reference an #E[n] variable for context.
TranslateToEnglish[input]: Translates a non-English text to English.

Output Format:
Plan: [First action]
#E1 = [Tool and input]
Plan: [Next action based on #E1]
#E2 = [Next tool and input, potentially referencing #E1]
...
Answer: [#E[n] containing final answer]

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

Response:
Plan: Start by searching Wikipedia for a page on the Eiffel Tower.
#E1 = WikiSearch[Eiffel Tower]
Plan: Read the full text of the Eiffel Tower Wikipedia page.
#E2 = ReadPage[#E1]
Plan: Use the Language Model to extract information about the history of the Eiffel Tower and why it was built.
#E3 = LangModel[What is the history of the Eiffel Tower and why was it built? Given context: #E2]
Answer: #E3

System: A chat.


Instruction:
Please generate a step-by-step plan to answer the following question, using the tools provided. Each tool can be called with an input string and will produce an output that can be stored in a variable for later use.

Here are the tools available to be called:
Bing[input]: This tool allows you to search for information on Bing. It is useful for finding websites that may contain the answer to your question.
TextParser[input]: Extracts key pieces of information from a large block of text.
LinkCollector[input]: Collects all links found within a given piece of text.
AIAnswerer[input]: A powerful AI tool capable of answering questions based on context provided by previous evidence variables.

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

Question: What are some notable achievements of Ada Lovelace?

Response:
Plan: Start by searching for information about Ada Lovelace on Bing.
#E1 = Bing[Ada Lovelace]
Plan: Extract the relevant links from the search results.
#E2 = LinkCollector[#E1]
Plan: Load the content of the extracted links.
#E3 = TextParser[#E2]
Plan: Use the AIAnswerer to find out about Ada Lovelace's notable achievements.
#E4 = AIAnswerer[What are some notable achievements of Ada Lovelace? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Create a plan to respond to the following query using the tools provided. For each step, provide the tool you would use and the expected output.

Tools Available:
DuckDuckGo[input]: A search engine tool that provides a list of websites related to the input query.
TextAnalyzer[input]: Analyzes a block of text and extracts key details.
HyperlinkGatherer[input]: Gathers all hyperlinks from a block of text.
JARVIS[input]: An AI tool capable of answering specific questions when provided with a context.

Output Format:
Plan: [Action based on the question]
#E1 = [Tool used with its input]
Plan: [Next action based on #E1]
#E2 = [Next tool used with its input]
...
Final Answer: #E[n]

Question: What is the history of Bitcoin and how has its price changed over time?

Response:
Plan: Search for the history of Bitcoin.
#E1 = DuckDuckGo[History of Bitcoin]
Plan: Analyze the search results to gather key details about Bitcoin's history.
#E2 = TextAnalyzer[#E1]
Plan: Ask JARVIS to summarize the history of Bitcoin based on the analyzed text.
#E3 = JARVIS[Summarize the history of Bitcoin. Given context: #E2]
Plan: Search for the price changes of Bitcoin over time.
#E4 = DuckDuckGo[Bitcoin price change over time]
Plan: Gather hyperlinks from the search results for further analysis.
#E5 = HyperlinkGatherer[#E4]
Plan: Analyze the gathered hyperlinks to get detailed information about Bitcoin's price changes.
#E6 = TextAnalyzer[#E5]
Plan: Ask JARVIS to summarize the price changes of Bitcoin over time based on the analyzed text.
#E7 = JARVIS[Summarize the price changes of Bitcoin over time. Given context: #E6]
Final Answer: #E3 and #E7

System: A chat.


Instruction:
Create a detailed plan to respond to the following user query: "Who won the Nobel Prize in Literature in 2000 and what was their most famous work?" Utilize the available tools:

1. WikiSearch[input]: Tool that searches Wikipedia for information related to the input string.
2. LinkExtractor[input]: Extracts links from plain text.
3. WebScraper[input]: Loads websites from the input string containing newline delimited links and produces plain text output containing the content of the links.
4. QAModel[input]: Question answering model that provides answers based on an input passage of text.

Each plan must have a corresponding evidence variable (:evidence[index]:). Output should be formatted as follows:

Plan: [first action]
:evidence0: = [function call with input]
Plan: [next action]
:evidence1: = [function call with input, possibly referencing previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Response:
Plan: Start by searching Wikipedia for the winner of the Nobel Prize in Literature in 2000.
:evidence0: = WikiSearch[Nobel Prize in Literature 2000]
Plan: Use the question answering model to extract the name of the laureate from the Wikipedia page.
:evidence1: = QAModel[Who won the Nobel Prize in Literature in 2000? Given :evidence0:]
Plan: Conduct another Wikipedia search to learn more about the laureate's works.
:evidence2: = WikiSearch[:evidence1:]
Plan: Extract the laureate's most famous work using the question answering model.
:evidence3: = QAModel[What is the most famous work of :evidence1:? Given :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Provide a systematic plan to address the user query making use of the provided tools. Each step of the plan should correspond to an evidence value, which is the outcome of one of the functions given an input string that could be the user query, earlier evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: A tool enabling users to perform searches using the DuckDuckGo search engine. It aids in locating suitable websites that might hold answers to the user's queries.
LinkPicker[input]: Picks out links from plain text and generates a response consisting of these links in plain text, separated by newlines.
SiteLoader[input]: Takes one or multiple websites from the input string (which contains newline-separated links), loads them, and provides plain text output encompassing the content of these links.
Inquirer[input]: A language model adept at answering questions based on an input text segment. The input needs to be a textual question referring to an :evidence[n]: variable, like 'What breed is the dog, given :evidence1:?'.

Each function's input should simply be a plain string, devoid of quotes or '+' symbols used to merge a string with an evidence variable, such as Inquirer[What is Spain's capital city, given :evidence3:?].

Ensure that every plan step includes just one evidence output.

Output format should be:
Plan: [Initial action based on input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action, based on the outcome of :evidence0:]
:evidence1: = [Next function to invoke and its input parameter, potentially referencing prior evidence, like 'Given context :evidence0']
...
Final Answer: [:evidence[n]: holding the ultimate answer.]

Question: Who is currently leading Google's Quantum Computing project and what significant achievements have they made?

Response:
Plan: Initiate by executing a web search to discover the leader of Google's Quantum Computing project.
:evidence0: = DuckDuckGo[Leader of Google's Quantum Computing project]
Plan: Employ the Inquirer model to decipher the search outcomes and determine the project leader's name.
:evidence1: = Inquirer[Who leads Google's Quantum Computing project, given :evidence0:?]
Plan: Perform another web search to uncover the significant achievements made by the determined project leader.
:evidence2: = DuckDuckGo[Significant achievements of :evidence1:]
Plan: Select the pertinent links from the DuckDuckGo search results for further examination.
:evidence3: = LinkPicker[:evidence2:]
Plan: Utilize SiteLoader to retrieve data from the selected links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Lastly, employ the Inquirer model to pinpoint and summarize the key achievements of the project leader from the retrieved data.
:evidence5: = Inquirer[What are the significant achievements of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Formulate a comprehensive plan to address the following inquiry using the tools listed below. Each stage of the plan should correspond to an evidence value, resulting from a function call with an input string that could be the initial question, preceding evidence, or a mix thereof.

Tools you can use:
InternetSearch[input]: Executes a broad web search based on the input string. It does not provide direct answers but generates a list of potential sources of information.
PageReader[input]: Reads content from one or more URLs provided in the input string (newline-separated links) and produces plain text output.
LinkGatherer[input]: Extracts links from any supplied plain text and returns them as newline-separated plain text.
KnowledgeProcessor[input]: An advanced AI model capable of answering queries based on general world knowledge or specific context drawn from previous evidence.

Function inputs should be straightforward strings, devoid of quotes or "+" signs used for string concatenation, e.g., KnowledgeProcessor[What is the tallest mountain, given :evidence3:?]

Make sure to associate just one evidence output with each plan step.

Output format:
Plan: [First action based on the question]
:evidence0: = [Call to function with input parameter]
Plan: [Subsequent action depending on the result of :evidence0:]
:evidence1: = [Next function call with input parameter, possibly making reference to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: How do solar panels work and where are they most commonly installed?

Response:
Plan: Initiate an InternetSearch to understand how solar panels work.
:evidence0: = InternetSearch[How do solar panels work]
Plan: Employ the KnowledgeProcessor to interpret the search results and explain the working of solar panels.
:evidence1: = KnowledgeProcessor[How do solar panels work, given :evidence0:?]
Plan: Execute another InternetSearch to find out where solar panels are most commonly installed.
:evidence2: = InternetSearch[Most common installation locations for solar panels]
Plan: Use LinkGatherer to pull out pertinent links from the search results for deeper exploration.
:evidence3: = LinkGatherer[:evidence2:]
Plan: Deploy PageReader to retrieve textual content from the extracted links.
:evidence4: = PageReader[:evidence3:]
Plan: Finally, engage the KnowledgeProcessor to identify and summarize the most common installation locations for solar panels from the gathered information.
:evidence5: = KnowledgeProcessor[Where are solar panels most commonly installed, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Formulate a step-by-step plan to answer the user's question using the tools provided. The result of each tool must be stored in a variable called :evidence[index]:

Tools Available:
1. WebCrawler[input]: Scans the web for specific information related to the input.
2. TextSummarizer[input]: Summarizes large chunks of text into concise summaries.
3. QuestionAnswerer[input]: Can answer questions based on general knowledge or given context.

Output Format:
Plan: [First action]
:evidence0: = [Tool to call with input parameters]
Plan: [Second action]
:evidence1: = [Next tool to call with input parameters, possibly referring to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who invented the telephone and what other significant contributions did they make?

Response:
Plan: Begin by searching the web for who invented the telephone.
:evidence0: = WebCrawler[Who invented the telephone]
Plan: Use a question answering tool to identify the inventor from the crawled data.
:evidence1: = QuestionAnswerer[Who invented the telephone, given :evidence0:?]
Plan: Conduct a second web crawl to find more information about the inventor's other significant contributions.
:evidence2: = WebCrawler[:evidence1: + ' significant contributions']
Plan: Finally, summarize the findings about the inventor's other significant contributions.
:evidence3: = TextSummarizer[:evidence2:]
Answer: :evidence3:

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine. It finds a list of sites that may have the answer.
SiteLoader[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.
HyperlinkGatherer[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIAnswerBot[input]: A question-answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

Question: What are the benefits and drawbacks of nuclear energy?

Response:
Plan: Start by conducting a web search to find out the benefits of nuclear energy.
:evidence0: = DuckDuckGo[Benefits of nuclear energy]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence1: = HyperlinkGatherer[:evidence0:]
Plan: Use SiteLoader to extract information from the relevant links.
:evidence2: = SiteLoader[:evidence1:]
Plan: Utilize AIAnswerBot to interpret the extracted information and summarize the benefits of nuclear energy.
:evidence3: = AIAnswerBot[What are the benefits of nuclear energy? Given context: :evidence2:]
Plan: Conduct another web search to find out the drawbacks of nuclear energy.
:evidence4: = DuckDuckGo[Drawbacks of nuclear energy]
Plan: Extract the relevant links from the DuckDuckGo search results for a more focused search.
:evidence5: = HyperlinkGatherer[:evidence4:]
Plan: Use SiteLoader to extract information from the relevant links.
:evidence6: = SiteLoader[:evidence5:]
Plan: Finally, utilize AIAnswerBot to interpret the extracted information and summarize the drawbacks of nuclear energy.
:evidence7: = AIAnswerBot[What are the drawbacks of nuclear energy? Given context: :evidence6:]
Answer: :evidence3: and :evidence7:

System: A chat.


Instruction:
Generate a step-by-step plan to respond to the following user instruction, utilizing the set of tools available. Each step should correspond to an evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more prior evidence values, or a combination of both.

Here are the tools you can use:
1. DuckDuckGo[input]: This tool lets the user perform an internet search using the DuckDuckGo search engine. It generates a list of potential sites that might include the answer to the user's question.
2. SiteLoader[input]: This function loads one or more websites from the input string (which contains newline-separated links) and returns the textual content of these sites.
3. LinkGrabber[input]: This tool extracts links from plain text and outputs them as a newline-separated list.
4. AIML[input]: An AI-powered language model capable of answering questions based on an input text passage. The input should be a question that references an :evidence[n]: variable.

The output should adhere to the following structure:
Plan: [initial action based on input question]
:evidence0: = [function call with input parameter]
Plan: [subsequent action based on the outcome of :evidence0:]
:evidence1: = [next function call with input parameter, potentially referring back to previous evidence]
...
Final Answer: [:evidence[n]: containing the ultimate response]

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

Response:
Plan: Initiate a web search to identify the winner of the 2020 Nobel Prize in Physics.
:evidence0: = DuckDuckGo[2020 Nobel Prize in Physics winner]
Plan: Apply the AI language model to interpret the search results and find out who won the prize.
:evidence1: = AIML[Who won the 2020 Nobel Prize in Physics? Given context: :evidence0:?]
Plan: Conduct another web search to learn about the laureate's notable contributions.
:evidence2: = DuckDuckGo[:evidence1: Nobel Prize contribution]
Plan: Extract pertinent links from the search results for a more detailed investigation.
:evidence3: = LinkGrabber[:evidence2:]
Plan: Utilize the SiteLoader tool to retrieve information from the extracted links.
:evidence4: = SiteLoader[:evidence3:]
Plan: Finally, apply the AI language model to summarize the laureate's significant contributions from the retrieved data.
:evidence5: = AIML[What were the contributions of :evidence1: that led to winning the Nobel Prize in Physics? Given context: :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Develop a systematic plan to address the user's inquiry using the provided tools. Each step should correspond to an evidence value (:info[n]:), which will be the outcome of one of the accessible functions given an input string that could be the user's question, prior evidence values, or both.

Available tools:
DuckDuckGo[input]: A tool that enables users to perform a web search using DuckDuckGo. Useful for locating potential resources that might hold answers to the user's query.
SiteLoader[input]: Takes one or more website URLs from the input string (newline separated) and outputs plain text containing the content of those pages.
URLGrabber[input]: Extracts URLs from plain text and yields a plain text, newline-separated list of URLs.
BotQnA[input]: An AI-driven question-answering model, skilled at providing responses based on an input text excerpt. The input needs to be a textual question that refers to an :info[n]: variable, such as "What is the tallest mountain, given :info1:?"

Output format:
Plan: [Initial action based on the input question]
:info1: = [Function to invoke with input parameter]
Plan: [Subsequent action, depending on the outcome of :info1:]
:info2: = [Next function to invoke and input parameter, potentially referring to earlier evidence like "Given context :info1:"]
...
Final Answer: :info[n]:

Question: Who invented the Rubik's Cube and what were their motivations?

Response:
Plan: Begin with a web search to find out who invented the Rubik's Cube.
:info1: = DuckDuckGo[Rubik's Cube inventor]
Plan: Use BotQnA to analyze the search results and determine the inventor's name.
:info2: = BotQnA[Who invented the Rubik's Cube? Given context: :info1:]
Plan: Perform another web search to understand the inventor's motivations.
:info3: = DuckDuckGo[:info2: + ' motivations']
Plan: Extract pertinent URLs from the search results for further analysis.
:info4: = URLGrabber[:info3:]
Plan: Utilize SiteLoader to obtain information from the chosen URLs.
:info5: = SiteLoader[:info4:]
Plan: Finally, employ BotQnA to summarize the inventor's motivations from the obtained information.
:info6: = BotQnA[What were the motivations of :info2: when inventing the Rubik's Cube? Given context: :info5:]
Final Answer: :info6:

System: A chat.


Instruction:
Please create a detailed plan to solve the following problem using the tools provided. For each step in your plan, indicate the external tool used along with its input. Store the output of each tool into a variable #E[index] that can be referenced later.

Available Tools:
DuckDuckGo[input]: A tool that uses the DuckDuckGo search engine to find information online.
TextExtractor[input]: Takes one or more URLs as input and returns the textual content of those pages.
LinkGatherer[input]: Parses a block of text and extracts any URLs it contains.
AIDA[input]: An AI-powered question-answering system. It takes a question and some context (which could come from a previous #E[index]) and provides an answer.

Output Format:
Plan: [describe the first step]
#E1 = [tool to use with input]
Plan: [describe the next step based on the result of #E1]
#E2 = [next tool to use with input, possibly referencing #E1]
...
Final Answer: #E[n]

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

Response:
Plan: Start by searching for information about the Battle of Waterloo.
#E1 = DuckDuckGo[Battle of Waterloo]
Plan: Use the AI question-answering system to understand the significance of the Battle of Waterloo.
#E2 = AIDA[What is the significance of the Battle of Waterloo? Given context: #E1]
Plan: Search for information about the impact of the Battle of Waterloo on Europe.
#E3 = DuckDuckGo[Impact of Battle of Waterloo on Europe]
Plan: Extract URLs from the search results for further investigation.
#E4 = LinkGatherer[#E3]
Plan: Extract the text from the gathered URLs.
#E5 = TextExtractor[#E4]
Plan: Use the AI question-answering system to understand how the Battle of Waterloo impacted Europe.
#E6 = AIDA[How did the Battle of Waterloo impact Europe? Given context: #E5]
Final Answer: #E6

System: A chat.


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

Here are the tools you can use:
WebSearch[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.
PageScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A language model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = WebSearch[Nobel Prize in Physics 2020 winner]
Plan: Use the QAModel to extract the name of the winner from the search results.
:evidence1: = QAModel[Who won the Nobel Prize in Physics in 2020, given :evidence0:?]
Plan: Conduct another web search to find the contributions made by the identified laureate.
:evidence2: = WebSearch[:evidence1: Nobel Prize contribution]
Plan: Extract the relevant links from the search results for further investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the PageScraper tool to gather information from the extracted links.
:evidence4: = PageScraper[:evidence3:]
Plan: Finally, use the QAModel to summarize the key contributions made by the laureate from the scraped information.
:evidence5: = QAModel[What were the contributions of :evidence1: that led to the Nobel Prize, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the user's question using available tools. Each tool execution will generate an evidence value that can be used in subsequent steps.

The following tools are at your disposal:
WebSearch[input]: This tool performs a web search and returns a list of relevant links. It doesn't provide direct answers but provides resources that may contain the answer.
TextScraper[input]: Given one or more URLs, this tool extracts plain text from these websites.
LinkFilter[input]: Filters out irrelevant links from a given set of links based on input keywords.
InfoExtractor[input]: A language model capable of answering questions when provided with context. The input should be a question referencing an :evidence[n]: variable.

Each function requires a simple string as input without quotes or "+" for concatenation. For example: InfoExtractor[What is the capital of France, given :evidence2:?]

Ensure only one evidence output per plan step.

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, possibly referencing previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

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

Response:
Plan: Start by conducting a web search about the Rosetta Stone.
:evidence0: = WebSearch[Rosetta Stone history]
Plan: Filter out irrelevant links from the search results.
:evidence1: = LinkFilter[:evidence0: Rosetta Stone history]
Plan: Extract information from the filtered links.
:evidence2: = TextScraper[:evidence1:]
Plan: Use the extracted information to find out the historical significance of the Rosetta Stone.
:evidence3: = InfoExtractor[What is the historical significance of the Rosetta Stone? Given :evidence2:]
Plan: Conduct another web search to find out where the Rosetta Stone is currently located.
:evidence4: = WebSearch[Current location of Rosetta Stone]
Plan: Filter out irrelevant links from the new search results.
:evidence5: = LinkFilter[:evidence4: Current location of Rosetta Stone]
Plan: Extract information from the filtered links.
:evidence6: = TextScraper[:evidence5:]
Plan: Use the extracted information to find out the current location of the Rosetta Stone.
:evidence7: = InfoExtractor[Where is the Rosetta Stone currently located? Given :evidence6:]
Answer: Historical Significance: :evidence3:, Current Location: :evidence7:

This pattern continues for 9 more unique instruction/response pairs.

System: A chat.