Instruction:
Develop a methodical plan to generate an ideal response to the user instruction, leveraging 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:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine. This tool is useful in finding a suitable list of sites that may or may not include the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline separated links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkSelector[input]: Selects links from plain text and produces a plain text, newline separated response of links.
QAModel[input]: Question answering language model, especially useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., How tall is the Eiffel Tower, 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., QAModel[Who invented the telephone, given :evidence2:?]

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

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

Question: Who discovered penicillin and what were its initial uses?

Response:
Plan: Begin by conducting a web search to find out who discovered penicillin.
:evidence0: = YahooSearch[Who discovered penicillin]
Plan: Use the QA model to identify the discoverer of penicillin from the search results.
:evidence1: = QAModel[Who discovered penicillin, given :evidence0:?]
Plan: Conduct another web search to find out the initial uses of penicillin.
:evidence2: = YahooSearch[Initial uses of penicillin]
Plan: Select the relevant links from the Yahoo search results.
:evidence3: = HyperlinkSelector[:evidence2:]
Plan: Read the selected websites to extract detailed information.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, use the QA model to summarize the initial uses of penicillin from the read data.
:evidence5: = QAModel[What were the initial uses of penicillin, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please develop a plan to respond to the following user query utilizing the tools provided. For each plan, indicate the external tool along with its input to retrieve evidence. You can store the retrieved evidence into a variable #E[index] that can be referenced later.

Available Tools:
WikiSearch[input]: A tool that searches Wikipedia for information related to the input string.
QAAssistant[input]: A tool capable of answering questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Response:
Plan: Begin by searching Wikipedia for information about the first woman to win a Nobel Prize.
#E1 = WikiSearch[First woman to win a Nobel Prize]
Plan: Use the QAAssistant to determine who the first woman to win a Nobel Prize was.
#E2 = QAAssistant[Who was the first woman to win a Nobel Prize? Given context: #E1]
Plan: Search Wikipedia again for more detailed information about this person and their achievements.
#E3 = WikiSearch[#E2]
Plan: Utilize the QAAssistant to determine what the individual won the Nobel Prize for.
#E4 = QAAssistant[What did #E2 win the Nobel Prize for? Given context: #E3]
Final Answer: #E4

System: A chat.


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

Here are the tools you have at your disposal:
1. WebSearch[input]: A tool that allows users to search for information on the internet. This tool is useful in finding sites that may contain answers to the user's query.
2. TextScraper[input]: A tool that extracts text from websites provided as newline separated links in the input string.
3. LinkExtractor[input]: A tool that pulls out links from plain text and produces a list of these links.
4. QAModel[input]: A language model designed to answer questions based on a given context. The input must be a text question referencing an :evidence[n]: variable.

Each function takes a simple string as input without any quotes or "+" signs used for concatenation with an evidence variable (e.g., QAModel[What is the capital of France, given :evidence1:?]).

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

Question: Who is the author of the book "To Kill a Mockingbird" and what other books did they write?

Response:
Plan: Start by conducting a web search to find out who wrote "To Kill a Mockingbird".
:evidence0: = WebSearch["Author of To Kill a Mockingbird"]
Plan: Use the QAModel to extract the name of the author from the search results.
:evidence1: = QAModel[Who is the author of "To Kill a Mockingbird", given :evidence0:?]
Plan: Conduct another web search to find other books written by this author.
:evidence2: = WebSearch[:evidence1: + " bibliography"]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Scrape the content of the extracted links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, use the QAModel to identify and summarize the other books written by the author.
:evidence5: = QAModel[What other books were written by :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a comprehensive plan to solve the following user instruction using the available tools. For each step, indicate the corresponding evidence value which will be the output of one of the available tools given an input string that could be the user question, one or more prior evidence values, or a mixture of both.

Available tools:
DuckDuckGo[input]: A tool allowing users to perform searches via DuckDuckGo search engine. It helps in identifying potential sources that might have answers to the user's query.
SiteReader[input]: Loads one or multiple websites from the input string consisting of newline separated links. Input includes one or more links and outputs plain text comprising the content of these links.
URLPicker[input]: Picks URLs from plain text and provides a plain text, newline-separated response of URLs.
QAEngine[input]: A question-answering language model effective at answering queries based on an input text passage. The input needs to be a textual question referencing an :evidence[n]: variable, like What is the population of Paris, given :evidence1:?

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

Question: Which company developed the Hubble Space Telescope and what were its major contributions to astronomy?

Response:
Plan: Begin by performing a web search to determine the company that developed the Hubble Space Telescope.
:evidence0: = DuckDuckGo[Hubble Space Telescope developer]
Plan: Use QAEngine to parse the search results and identify the developing company.
:evidence1: = QAEngine[Which company developed the Hubble Space Telescope, given :evidence0:?]
Plan: Perform another web search to discover the major contributions of the Hubble Space Telescope to astronomy.
:evidence2: = DuckDuckGo[Major contributions of Hubble Space Telescope to astronomy]
Plan: Extract pertinent links from the DuckDuckGo search results for more detailed information.
:evidence3: = URLPicker[:evidence2:]
Plan: Employ SiteReader to pull information from the selected links.
:evidence4: = SiteReader[:evidence3:]
Plan: Lastly, utilize QAEngine to outline the Hubble Space Telescope's major contributions to astronomy from the gathered data.
:evidence5: = QAEngine[What were the major contributions of the Hubble Space Telescope to astronomy, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Devise a methodical plan to address the user's inquiry, employing a selection of accessible tools. Each plan should correspond to an evidence value, signifying the output of a designated function given an input string. This input string might be the user's question, preceding evidence values, or a blend of both.

The following tools are at your disposal:
InternetExplorer[input]: Enables users to browse the internet for information. Particularly useful for locating lists of websites that may hold answers to the user's question.
PageReader[input]: Reads one or more websites from an input string containing newline-separated URLs. It generates plain text output containing the content of these pages.
URLCollector[input]: Collects URLs from plain text and outputs them as newline-separated strings.
InquiryResponder[input]: A language model engineered to answer questions based on an input text passage. Inputs should include references to earlier evidence variables.

Each function necessitates a straightforward string as input. Merging of strings and evidence variables (like InquiryResponder[What is the GDP of China, given :evidence3:]?) is permissible but no quotation marks or "+" symbols should be used.

Include only one evidence output per plan step.

The output format should adhere to the following structure:
Plan: [Initial action based on input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action based on outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, potentially citing earlier evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n] containing the final answer]

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

Response:
Plan: Initiate an internet search to identify the author of 'To Kill a Mockingbird'.
:evidence0: = InternetExplorer[Author of To Kill a Mockingbird]
Plan: Employ InquiryResponder to discern the author's name from the search results.
:evidence1: = InquiryResponder[Who is the author of To Kill a Mockingbird, given :evidence0:?]
Plan: Conduct another internet search to discover other works by the identified author.
:evidence2: = InternetExplorer[Other works by :evidence1:]
Plan: Gather the relevant URLs from the search results for further investigation.
:evidence3: = URLCollector[:evidence2:]
Plan: Use PageReader to extract information from the collected URLs.
:evidence4: = PageReader[:evidence3:]
Plan: Lastly, apply InquiryResponder to summarize the other works by the author from the extracted information.
:evidence5: = InquiryResponder[What other works has :evidence1: written, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Develop a step-by-step plan to respond to the user query, making use of the provided tools. Every plan should correspond to an evidence value, which will be the outcome of one of the accessible functions considering an input string that could be the user question, one or more prior evidence values, or a blend of both.

Available tools to be used:
DuckDuckGo[input]: A tool enabling users to look up information via the DuckDuckGo search engine. It assists in locating a suitable list of websites that might contain the answer to the user's query. The function does not directly provide the answer; instead, it identifies potential sites that may have the solution.
HTMLStripper[input]: Strips HTML tags from a website URL and generates a plain text output comprising the content of the link.
URLCollector[input]: Collects URLs from plain text and delivers a plain text, newline-separated response of URLs.
NLPModel[input]: Natural Language Processing model adept at responding to queries based on an input text passage. The input needs to be a textual question referring to an :evidence[n]: variable, such as What is the height of the Eiffel Tower, given :evidence1:?

Each function's input should simply be a plain string, devoid of quotes or "+" to concatenate a string with an evidence variable, for instance, NLPModel[What is the population of Tokyo, given :evidence3:?]

Ensure to incorporate only one evidence output for every plan step.

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

Question: Who designed the Sydney Opera House and what inspired their design?

Response:
Plan: Initiate by executing a web search to ascertain the designer of the Sydney Opera House.
:evidence0: = DuckDuckGo[Designer of Sydney Opera House]
Plan: Utilize the NLP Model to decipher the search outcomes and pinpoint the designer's name.
:evidence1: = NLPModel[Who designed the Sydney Opera House, given :evidence0:?]
Plan: Carry out another web search to discover the inspiration behind the identified designer's creation of the Sydney Opera House.
:evidence2: = DuckDuckGo[Inspiration behind :evidence1:'s design of Sydney Opera House]
Plan: Accumulate the pertinent URLs from the DuckDuckGo search results for a more comprehensive search.
:evidence3: = URLCollector[:evidence2:]
Plan: Deploy the HTML Stripper tool to derive information from the relevant URLs.
:evidence4: = HTMLStripper[:evidence3:]
Plan: Lastly, employ the NLP Model to recognize and encapsulate the inspiration behind the designer's creation from the derived information.
:evidence5: = NLPModel[What inspired :evidence1: to design the Sydney Opera House, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the question: "What is the highest peak in the Andes mountain range?"

Here are the tools available:
GeoSearch[input]: Tool that allows you to search for geographical information.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
MapTool[input]: Provides map related data based on the input query.
InfoExtract[input]: Extracts specific pieces of information from a larger text.
LLM[input]: Question answering language model.

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]

Response:
Plan: Use the QA tool to answer the question directly.
#E1 = QA["What is the highest peak in the Andes mountain range?"]

Final answer: #E1

System: A chat.


Instruction:
Construct a plan to solve the following problem using the listed tools. Each plan should correspond to an evidence value, which is the output of one of the available functions given an input string that could be the user's question, prior evidence values, or a combination of both.

Here are the tools available to be called:
Bing[input]: A tool that enables the user to perform an internet search using Bing. It provides a list of sites that might contain the answer to the user's question.
TextAnalyzer[input]: This tool analyzes a body of text and extracts key pieces of information such as names, dates, places, etc.
URLLoader[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and it generates plain text output containing the content of the links.
AskJeeves[input]: A question-answering tool that can provide answers based on common sense, general world knowledge, and given input context that may contain the answer.

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

Question: What is the population of Tokyo and when was the city founded?

Response:
Plan: Begin by conducting a web search to find out the current population of Tokyo.
#E1 = Bing[Current population of Tokyo]
Plan: Utilize AskJeeves to interpret the search results and find the population.
#E2 = AskJeeves[What is the current population of Tokyo? Given context: #E1]
Plan: Conduct another web search to find out when Tokyo was founded.
#E3 = Bing[Founding date of Tokyo]
Plan: Load the content of the top search results for more detailed information.
#E4 = URLLoader[#E3]
Plan: Analyze the loaded text to extract the founding date of Tokyo.
#E5 = TextAnalyzer[#E4]
Plan: Lastly, utilize AskJeeves to confirm the founding date of Tokyo from the analyzed text.
#E6 = AskJeeves[When was Tokyo founded? Given context: #E5]
Final answer: Population - #E2, Founding Date - #E6

System: A chat.


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

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

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

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

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

Response:
Plan: Search for more information about the Rosetta Stone.
#E1 = Britannica[Rosetta Stone]
Plan: Find out the significance of the Rosetta Stone.
#E2 = QAModel[What is the significance of the Rosetta Stone? Given context: #E1]
Plan: Determine the current location of the Rosetta Stone.
#E3 = QAModel[Where is the Rosetta Stone currently located? Given context: #E1]
Final answer: #E2 and #E3

System: A chat.


Instruction:
Develop a strategy to identify the primary components of a traditional Japanese tea ceremony.

Tools available:
- CultureBase[input]: Database containing information about different cultures around the world.
- QA[input]: Question answering tool that uses general knowledge or given context to provide answers.
- VideoAnalyzer[input]: Analyzes video content to extract key details.
- TextSummarizer[input]: Summarizes long text into concise points.
- ImageIdentifier[input]: Identifies objects and elements within an image.

Output format follows the same pattern as TSK 1 and TSK 2.

Response:
1. Use CultureBase[input] to gather initial information about the traditional Japanese tea ceremony. Query for "Japanese tea ceremony" and extract details such as its history, importance, components, and process.

2. From the data obtained from CultureBase[input], use TextSummarizer[input] to create a summarized version of the key points about the Japanese tea ceremony.

3. To further understand the primary components visually, search for videos on the internet that show an actual Japanese tea ceremony. Use VideoAnalyzer[input] to analyze these videos and identify the main elements involved in the ceremony.

4. Use ImageIdentifier[input] to identify objects and elements within images taken from the video or other sources showing a Japanese tea ceremony. This will help recognize the specific tools used during the ceremony, the attire worn by participants, and other visual aspects of the event.

5. Utilize QA[input] to clarify any uncertainties or ambiguities found during the previous steps. For example, if there's uncertainty about what a particular tool is used for, ask questions like "What is the purpose of [tool name] in a Japanese tea ceremony?"

6. Compile all the gathered information into a comprehensive list detailing the primary components of a traditional Japanese tea ceremony. The list should include both tangible items (like utensils) and intangible elements (like rituals or etiquette).

7. Output: A detailed list of the primary components of a traditional Japanese tea ceremony based on information gathered from various resources.

System: A chat.


Instruction:
Formulate a strategy to solve the problem below by using the listed tools. Each part of your plan must correspond to an evidence value, which will store the result of a function call.

Tools at your disposal:
WikiSearch[input]: A tool that searches Wikipedia for information related to the input query.
TextAnalyzer[input]: Analyzes a body of text and provides a summary or specific details based on the input question.
QA[input]: Answers questions using general knowledge or based on a given context.

Your output should follow this structure:
Plan: [first action to take]
#Evidence1 = [first function to call with its input]
Plan: [second action to take, considering the result of #Evidence1]
#Evidence2 = [second function to call with its input, possibly referencing #Evidence1]
...
Final Answer: #EvidenceN

Question: What is the main diet of the African elephant and where does it live?

Response:
Plan: Search Wikipedia for information about the African elephant's diet.
#Evidence1 = WikiSearch[African elephant diet]
Plan: From the obtained information, identify the main diet of the African elephant.
#Evidence2 = TextAnalyzer[What is the main diet of the African elephant? Given context: #Evidence1]
Plan: Perform another Wikipedia search to find out where the African elephant lives.
#Evidence3 = WikiSearch[African elephant habitat]
Plan: Identify the living area of the African elephant from the new information.
#Evidence4 = QA[Where does the African elephant live? Given context: #Evidence3]
Final Answer: #Evidence4

System: A chat.


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

Here are the tools available to be called:
GoogleMaps[input]: Tool that provides location-based information.
WeatherAPI[input]: Tool that provides weather data for a specified location.
TimezoneFinder[input]: Tool that determines the timezone of a specified location.
FlightTracker[input]: Tool that tracks flights and provides real-time status updates.
LLM[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 in input question
:evidence0: = function to call with input parameter
Plan: next action to take, based on result of :evidence0:
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What's the current temperature in Sydney, Australia and when is the next flight from New York to Sydney?

Response:
Plan: Identify the two parts of the question - one about temperature and another about flight.
:evidence0: = LLM["What's the current temperature in Sydney, Australia and when is the next flight from New York to Sydney?"]

Plan: Use WeatherAPI tool to get the current temperature in Sydney, Australia.
:evidence1: = WeatherAPI["Sydney, Australia"]

Plan: Use FlightTracker tool to find out the next flight from New York to Sydney.
:evidence2: = FlightTracker["New York to Sydney"]

Answer: [:evidence1: containing the temperature information, :evidence2: containing the flight information.]

System: A chat.


Instruction:
Develop a step-by-step execution plan to solve the following problem, making use of the provided tools. Each plan will correspond to an evidence value which will be the output of one of the available tools when supplied with an appropriate input string.

Available Tools:
WikiSearch[input]: A tool that lets you search Wikipedia for specific information related to your query.
QAEngine[input]: A question-answering tool that can provide answers based on common sense, general world knowledge, or context from previously gathered evidence.
MapTool[input]: A tool that provides geographical data and location-based information based on the input query.
WeatherAPI[input]: A tool that provides current weather conditions for a specified location.

Output Format:
Plan: [First action based on input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on #E1]
...
Final Answer: #E[n]

Question: Where is Mount Everest located and what is the current temperature there?

Response:
Plan: Search for information about Mount Everest on Wikipedia.
#E1 = WikiSearch[Mount Everest]
Plan: Determine the location of Mount Everest using the QA engine.
#E2 = QAEngine[Where is Mount Everest located? Given context: #E1]
Plan: Verify the location of Mount Everest using the MapTool.
#E3 = MapTool[#E2]
Plan: Find out the current temperature at Mount Everest.
#E4 = WeatherAPI[#E3]
Final Answer: #E4

And so on...

System: A chat.


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

Here are the available tools:
Bing[input]: A search engine tool that allows the user to find information on the internet.
ParseHTML[input]: This tool takes an HTML page as input and extracts plain text from it.
LinkCollector[input]: Extracts all URLs from a given piece of text.
AskJeeves[input]: A question answering tool that uses common sense and general world knowledge to answer questions. It can also answer questions based on a given context.

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

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

Question: What is the population of the capital city of Japan and what is its famous landmark?

Response:
Plan: Search for the capital city of Japan.
#E1 = Bing[Capital city of Japan]
Plan: Identify the name of the capital city of Japan.
#E2 = AskJeeves[What is the capital city of Japan? Given context: #E1]
Plan: Search for the population of the identified capital city.
#E3 = Bing[Population of #E2]
Plan: Determine the population of the capital city.
#E4 = AskJeeves[What is the population of #E2? Given context: #E3]
Plan: Search for the famous landmarks in the identified capital city.
#E5 = Bing[Famous landmarks in #E2]
Plan: Identify the famous landmark in the capital city.
#E6 = AskJeeves[What is a famous landmark in #E2? Given context: #E5]
Final answer: The population of #E2 is #E4 and its famous landmark is #E6

System: A chat.


Instruction:
Develop a step-by-step plan to answer the following user query, using the available tools. Each tool has an associated evidence value which is the output of that function given an input string. The input can be 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 web. It returns a list of websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from one or more websites provided in the input string (newline separated links). Outputs plain text containing the content of the pages.
LinkParser[input]: Extracts links from plain text and produces a newline-separated list of links.
AIAnswerer[input]: A language 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 color is the cat, given :evidence1:?"

Each function should receive a plain string as input without quotes or "+" for concatenating strings with evidence variables, e.g., AIAnswerer[What is the capital of France, given :evidence3:?]

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 and input parameter, potentially referencing previous evidence]
...
Final Answer: [:evidence[n]: containing the final answer.]

Question: Who won the Nobel Prize in Literature in 2019 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 2019.
:evidence0: = WebSearch[Nobel Prize in Literature 2019 winner]
Plan: Use the AIAnswerer to identify the winner from the search results.
:evidence1: = AIAnswerer[Who won the Nobel Prize in Literature in 2019, given :evidence0:?]
Plan: Conduct another web search to find the most famous work of the identified laureate.
:evidence2: = WebSearch[Most famous work of :evidence1:]
Plan: Extract relevant links from the search results for detailed information.
:evidence3: = LinkParser[:evidence2:]
Plan: Use TextExtractor to get the content from these links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Finally, use the AIAnswerer to identify and summarize the most famous work of the laureate from the extracted texts.
:evidence5: = AIAnswerer[What is the most famous work of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a comprehensive plan to solve the following query using the mentioned tools. Each step should correspond to an evidence number which stores the output of the respective function used.

Available Tools:
DuckDuckGo[input]: A search engine tool useful for obtaining general information related to the input query.
PageScraper[input]: Loads specific webpage(s) from the input link(s) and outputs the plain text content of the page(s).
LinkHarvester[input]: Gathers all the links present in the provided plain text.
GPT_QA[input]: An advanced language model capable of answering questions based on an input context. The input should be a question referencing an :evidence[n]: variable.

Output Format:
Plan: [Action based on the input question]
:evidence0: = [Function along with its input]
Plan: [Next action based on the outcome of :evidence0:]
:evidence1: = [Subsequent function and its input, possibly referring to prior evidence]
...
Final Response: :evidence[n]:

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

Response:
Plan: Initiate a web search to determine the winner of the 2019 Nobel Prize in Literature.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2019 winner]
Plan: Use GPT_QA to parse the search results and ascertain the winner's name.
:evidence1: = GPT_QA[Who won the Nobel Prize in Literature in 2019, given :evidence0:?]
Plan: Carry out another web search to discover the most acclaimed work of the determined laureate.
:evidence2: = DuckDuckGo[Most acclaimed work of :evidence1:]
Plan: Harvest pertinent links from the search results for further investigation.
:evidence3: = LinkHarvester[:evidence2:]
Plan: Deploy PageScraper to fetch data from the harvested links.
:evidence4: = PageScraper[:evidence3:]
Plan: Lastly, apply GPT_QA to identify and summarise the most acclaimed work of the laureate from the scraped data.
:evidence5: = GPT_QA[What is the most acclaimed work of :evidence1:, given :evidence4:?]
Final Response: :evidence5:

System: A chat.


Instruction:
Develop a strategy to respond to the user's query using the tools provided below. For each step, there should be a matching evidence value, derived from one of the functions' outputs given an input string.

Tools Available:
1. BingSearch[input]: A tool that uses the Bing search engine to locate information related to the input query.
2. SiteLoader[input]: Loads a website from the input URL and produces plain text content from the site.
3. UrlCollector[input]: Collects URLs from a given plain text input.
4. KnowledgeQnA[input]: Answers questions based on an input text. The input must be a question that refers to an :evidence[n]: variable.

Output Format:
Plan: [Initial action]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action]
:evidence1: = [Next function to call with input parameter, possibly referencing prior evidence]
...
Answer: [:evidence[n]:]

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

Response:
Plan: Begin with a Bing search to identify the winner of the 2019 Nobel Prize in Literature.
:evidence0: = BingSearch[Nobel Prize in Literature 2019 winner]
Plan: Use the KnowledgeQnA tool to interpret the search results and identify the laureate.
:evidence1: = KnowledgeQnA[Who won the Nobel Prize in Literature in 2019? Given context: :evidence0:?]
Plan: Conduct a Bing search to find the notable works of the identified laureate.
:evidence2: = BingSearch[Notable works of :evidence1:]
Plan: Extract the URLs from the Bing search results for a focused investigation.
:evidence3: = UrlCollector[:evidence2:]
Plan: Load the websites linked to gather more specific information.
:evidence4: = SiteLoader[:evidence3:]
Plan: Lastly, utilize the KnowledgeQnA tool to identify and summarize the notable work of the laureate from the loaded websites.
:evidence5: = KnowledgeQnA[What is the notable work of :evidence1:, given :evidence4:?]
Answer: :evidence1:, :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to provide an accurate response to the user query using the available tools. Each plan will produce an evidence value which will be the output of a specific function when fed with the right input string.

Available Tools:
NetSearch[input]: Searches the internet for information related to the input string.
SiteReader[input]: Reads all the text from a site whose URL is provided as the input.
HyperlinkGatherer[input]: Gathers all hyperlinks embedded within a piece of text provided as the input.
QASolver[input]: An AI model that solves queries based on a piece of text provided as the input. The input should be a question referencing a #E[n] variable.

Output Format:
Plan: [Initial action]
#E0 = [Function to use with input parameters]
Plan: [Subsequent action based on the outcome of #E0]
#E1 = [Next function to use with input parameters, possibly referring to earlier evidence]
...
Final Answer: [#En]

Question: How did the Great Depression impact the United States economy and who was the President during this period?

Response:
Plan: Start by searching the internet for information about the Great Depression.
#E0 = NetSearch[Great Depression]
Plan: Use QASolver to extract information about how the Great Depression impacted the United States economy.
#E1 = QASolver[How did the Great Depression impact the United States economy, given #E0?]
Plan: Use QASolver again to identify the President of the United States during the Great Depression.
#E2 = QASolver[Who was the President of the United States during the Great Depression, given #E0?]
Final Answer: #E1, #E2

System: A chat.


Instruction:
Create a step-by-step plan to respond to the user query utilizing the provided tools. Each step should correspond to an evidence value which would be the output of the chosen function. The input could be a user query, prior evidence values, or a combination of both.

Available tools:
WikiSearch[input]: A tool that lets users retrieve information from Wikipedia. It is handy when seeking knowledge about various topics such as historical events, personalities, places, etc.
ContextQA[input]: A tool that answers queries directly based on common sense, general world knowledge, or given context that might contain the answer.

Output Format:
Plan: [First action based on the input query]
#E1 = [Function to invoke with input parameters]
Plan: [Next action depending on #E1]
#E2 = [Subsequent function invocation with input parameters, possibly referencing earlier evidence like "Given context #E1"]
...
Final Answer: #E[n]

Question: Who founded Microsoft and what were their initial products?

Response:
Plan: Search for information about the founders of Microsoft.
#E1 = WikiSearch[Microsoft]
Plan: Identify the founders of Microsoft.
#E2 = ContextQA[Who founded Microsoft? Given context: #E1]
Plan: Search for information about the initial products of Microsoft.
#E3 = WikiSearch[#E2 + ' initial products']
Plan: Identify the initial products launched by the founders of Microsoft.
#E4 = ContextQA[What were the initial products launched by the founders of Microsoft? Given context: #E3]
Final Answer: #E4

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a general web search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts key pieces of text from a larger body of text. Useful for identifying names, dates, places, etc.
LinkParser[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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

Response:
Plan: Start by conducting a web search to find out about the history of the Eiffel Tower.
:evidence0: = WebSearch[History of the Eiffel Tower]
Plan: Use a language model to interpret the search results and extract the relevant historical details.
:evidence1: = QAModel[What is the history behind the creation of the Eiffel Tower, given :evidence0:?]
Plan: Conduct another web search to find the main architects involved in the construction of the Eiffel Tower.
:evidence2: = WebSearch[Main architects of the Eiffel Tower]
Plan: Utilize TextExtractor to identify the names of the architects from the search results.
:evidence3: = TextExtractor[:evidence2:]
Plan: Finally, utilize the language model to summarize the information gathered.
:evidence4: = QAModel[Who were the main architects involved in the creation of the Eiffel Tower and what is its history, given :evidence1: and :evidence3:?]
Answer: :evidence4:

System: A chat.


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

Here are the tools available to be called:
GoogleSearch[input]: Tool that allows the user to search for information using Google. This tool is useful in finding relevant websites.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KnowledgeBase[input]: Question answering model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

Question: What is the history behind the creation of Microsoft Corporation and who were its key founders?

Response:
Plan: Start by conducting a web search to find out about the history of Microsoft Corporation.
:evidence0: = GoogleSearch[History of Microsoft Corporation]
Plan: Use the LinkFinder tool to extract relevant links from the search results.
:evidence1: = LinkFinder[:evidence0:]
Plan: Utilize the WebScraper tool to extract information from the identified links.
:evidence2: = WebScraper[:evidence1:]
Plan: Employ the KnowledgeBase tool to interpret the extracted information and provide a summary of the history behind the creation of Microsoft Corporation.
:evidence3: = KnowledgeBase[What is the history behind the creation of Microsoft Corporation? Given :evidence2:]
Plan: Conduct another web search to identify the key founders of Microsoft Corporation.
:evidence4: = GoogleSearch[Key founders of Microsoft Corporation]
Plan: Extract the relevant links from the Google search results for a more focused search.
:evidence5: = LinkFinder[:evidence4:]
Plan: Use the WebScraper tool to extract information from the relevant links.
:evidence6: = WebScraper[:evidence5:]
Plan: Finally, utilize the KnowledgeBase tool to identify the key founders of Microsoft Corporation from the extracted information.
:evidence7: = KnowledgeBase[Who were the key founders of Microsoft Corporation? Given :evidence6:]
Answer: :evidence3: and :evidence7:

System: A chat.


Instruction:
Devise a comprehensive plan to address the following user query employing the specified tools. Each plan will correspond to an evidence value, which will be the output of one of the available functions given an input string that might be the user's question, one or more past evidence values, or a mix of both.

These are the tools you can use:
Yandex[input]: This tool lets users perform information searches via the Yandex search engine.
LinkLocator[input]: This function extracts links from plain text and offers a plain text list of links.
WebsiteRetriever[input]: This tool fetches one or more websites from an input string containing newline-separated links, where the input is one or more links, and creates plain text content from those links.
InfoBank[input]: This tool performs a search on Info Bank for pertinent articles based on the input string.
ProblemSolver[input]: This is a question-answering language model proficient at answering questions based on an input text passage. The input must be a text question that refers to a #I[index] variable.

Output format:
Plan: [Initial action based on input question]
#I1 = [Function to call with input parameter]
Plan: [Following action based on the outcome of #I1]
...
Final Resolution: #I[n]

Question: What is the theory of relativity and how has it impacted modern physics?

Response:
Plan: Kick off by carrying out an Info Bank search to understand the theory of relativity.
#I1 = InfoBank[theory of relativity]
Plan: Use ProblemSolver to explain the theory of relativity from the Info Bank article.
#I2 = ProblemSolver[What is the theory of relativity? Given context: #I1]
Plan: Conduct a Yandex search to recognize how the theory of relativity has influenced modern physics.
#I3 = Yandex[How has the theory of relativity impacted modern physics?]
Plan: Locate the relevant links from the Yandex search results for a more dedicated scrutiny.
#I4 = LinkLocator[#I3]
Plan: Engage WebsiteRetriever to derive information from these links.
#I5 = WebsiteRetriever[#I4]
Plan: Finally, use ProblemSolver to encapsulate how the theory of relativity has shaped modern physics from the derived information.
#I6 = ProblemSolver[How has the theory of relativity impacted modern physics? Given context: #I5]
Final Resolution: #I6

System: A chat.


Instruction:
Generate a detailed plan to address the user query utilizing the listed tools. Each step should correspond to an evidence value which is the outcome of a function given an input string that could be the user query, prior evidence values, or a combination of both.

Tools Available:
DuckDuckGo[input]: A tool that enables the user to conduct an internet search via DuckDuckGo search engine. Useful for locating sites that might contain the answer to the user's query.
SiteReader[input]: Loads one or more websites from the input string containing newline separated links. Input is one or more links and it outputs plain text containing the link contents.
URLCollector[input]: Extracts URLs from plain text and generates a plain text, newline separated response of URLs.
ZOE[input]: A question-answering language model. Particularly effective at answering queries based on an input text passage. The input needs to be a text question that refers to an #Evidence[n] variable.

Output Format:
Plan: [Initial action based on user query]
#Evidence0 = [Function call with input]
Plan: [Subsequent action based on #Evidence0]
#Evidence1 = [Next function call with input potentially referring to #Evidence0]
...
Final Answer: [#Evidencen]

Question: What are the main causes of global warming and their effects on marine life?

Response:
Plan: Initiate a web search to find out the main causes of global warming.
#Evidence0 = DuckDuckGo[Main causes of global warming]
Plan: Utilize ZOE to analyze the search results and determine the main causes.
#Evidence1 = ZOE[What are the main causes of global warming, given #Evidence0?]
Plan: Perform another web search to find the effects of these causes on marine life.
#Evidence2 = DuckDuckGo[Effects of #Evidence1 on marine life]
Plan: Extract the pertinent URLs from the DuckDuckGo search results for further analysis.
#Evidence3 = URLCollector[#Evidence2]
Plan: Employ SiteReader to pull information from the relevant URLs.
#Evidence4 = SiteReader[#Evidence3]
Plan: Lastly, use ZOE to identify and summarize the effects of global warming causes on marine life from the gathered data.
#Evidence5 = ZOE[What are the effects of #Evidence1 on marine life, given #Evidence4?]
Final Answer: #Evidence5

System: A chat.


Instruction:
Formulate a methodical plan to address the user query utilizing the listed tools. Every step in your plan should correspond to an evidence value, which will be the output of one of the available functions when supplied with an input string. This input string can be the user question, one or more previous evidence values, or a blend of both.

Tools at disposal:
YahooSearch[input]: A tool enabling users to look up information using Yahoo search engine. Useful in finding a list of sites potentially containing the answer to the user's query. Please note that this function doesn't directly respond to the question; instead, it locates a list of sites that might hold the answer.
URLReader[input]: Reads one or more websites from the input string comprising newline separated links. Input includes one or more links and output contains the plain text content of these links.
LinkPicker[input]: Identifies links from plain text and returns a plain text, newline separated collection of links.
QuerySolver[input]: Question answering language model, especially helpful in responding to questions based on an input text passage. The input must be a text question that refers to an :evidence[n]: variable, e.g., How tall is Mount Everest, given :evidence3:?

The input to each function simply needs to be a plain string, without quotation marks or "+" to concatenate a string with an evidence variable, e.g., QuerySolver[Who is the president of USA, given :evidence2:?]

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

The output should adhere to this format:
Plan: [primary action rooted in input question]
:evidence0: = [function to call with input parameter]
Plan: [consecutive action derived from the result of :evidence0:]
:evidence1: = [next function to call and input parameter, which might refer to preceding evidence, e.g., "In light of context :evidence0"]
...
Final Response: [:evidence[n]: encompassing the definitive answer.]

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

Response:
Plan: Begin with a web search to find out the tallest building in Dubai.
:evidence0: = YahooSearch[Tallest building in Dubai]
Plan: Use a language model to interpret the search results and pinpoint the name of the building.
:evidence1: = QuerySolver[What is the tallest building in Dubai, given :evidence0:?]
Plan: Perform another web search to ascertain the number of floors in the identified building.
:evidence2: = YahooSearch[Number of floors in :evidence1:]
Plan: Extract the relevant links from the Yahoo search results for a thorough examination.
:evidence3: = LinkPicker[:evidence2:]
Plan: Utilize the URL reader tool to fetch information from the chosen links.
:evidence4: = URLReader[:evidence3:]
Plan: Finally, employ the language model to deduce the number of floors in the building from the fetched information.
:evidence5: = QuerySolver[How many floors does :evidence1: have, given :evidence4:?]
Final Response: :evidence5:

System: A chat.


Instruction:
Create a detailed plan to answer the following question using the tools at your disposal. Each step in your plan should correspond to an evidence value, which represents the output of a function given an input string.

Tools available:
InfoSearch[input]: Allows the user to search for information online.
URLReader[input]: Reads the contents of a specified URL.
QAMachine[input]: A tool capable of answering questions based on given context.

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

Question: How did Albert Einstein contribute to the field of quantum mechanics?

Response:
Plan: Conduct an initial search for information on Albert Einstein's contributions to quantum mechanics.
:evidence0: = InfoSearch[Albert Einstein contribution to quantum mechanics]
Plan: Read the contents of the first URL returned by the search.
:evidence1: = URLReader[:evidence0:]
Plan: Use QAMachine to identify Einstein's contributions from the read content.
:evidence2: = QAMachine[How did Albert Einstein contribute to quantum mechanics? Given context: :evidence1:]
Answer: :evidence2:

System: A chat.


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

Here are the tools you can use:
SearchEngine[input]: This tool allows users to search for information online. The function doesn't directly provide answers but finds sites that may contain the required information.
WebScraper[input]: Loads websites from the input string containing newline separated links and produces plain text output with the content of these sites.
LinkExtractor[input]: Extracts links from plain text and returns a list of links.
QAModel[input]: A language model capable of answering questions based on an input passage of text. The input must be a question that references an :evidence[n]: variable.

Each function accepts a plain string as input without quotes or "+" to concatenate a string with an evidence variable (e.g., QAModel[What is the capital of France, given :evidence3:?]). Only include one evidence output per plan step.

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

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

Response:
Plan: Start by conducting an online search about the history of the Eiffel Tower.
:evidence0: = SearchEngine[Eiffel Tower history]
Plan: Use a web scraper to extract detailed information from the relevant links.
:evidence1: = WebScraper[:evidence0:]
Plan: Utilize the QA Model to interpret the extracted information and summarize the history of the Eiffel Tower.
:evidence2: = QAModel[What is the history of the Eiffel Tower, given :evidence1:?]
Plan: Conduct another online search to find out the materials used in the construction of the Eiffel Tower.
:evidence3: = SearchEngine[Materials used in Eiffel Tower construction]
Plan: Again, use the web scraper to get detailed information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the QA Model to identify and summarize the materials used in the construction of the Eiffel Tower from the extracted information.
:evidence5: = QAModel[What materials were used in the construction of the Eiffel Tower, given :evidence4:?]
Answer: :evidence2: and :evidence5:

System: A chat.


Instruction:
Create a plan to answer the following question using these tools. Each tool should be used at least once and each step in your plan should have an associated evidence value.

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextAnalyzer[input]: Analyzes a block of text and identifies key pieces of information such as names, dates, places, etc.
LinkCollector[input]: Collects all URLs from a given piece of text.
InfoExtractor[input]: Extracts specific information from a webpage given a URL.
KnowledgeBase[input]: A question answering tool that can provide answers based on common knowledge or context provided by previous evidence.

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 won the Nobel Prize in Literature in 2005 and what was their most famous work?

Response:
Plan: Use Bing to find out who won the Nobel Prize in Literature in 2005.
#E1 = Bing[Nobel Prize in Literature 2005 winner]
Plan: Use TextAnalyzer to identify the name of the winner from the search results.
#E2 = TextAnalyzer[#E1]
Plan: Use Bing again to search for the most famous work of the identified author.
#E3 = Bing[Most famous work of #E2]
Plan: Use LinkCollector to gather links related to the author's most famous work.
#E4 = LinkCollector[#E3]
Plan: Use InfoExtractor to extract information about the author's most famous work from one of the collected links.
#E5 = InfoExtractor[#E4]
Plan: Finally, use KnowledgeBase to confirm the name of the author's most famous work.
#E6 = KnowledgeBase[What is the most famous work of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Please generate a plan to solve the following problem, using the tools provided. Each step in your plan should correspond to an evidence value that will be the output of one of the available functions given an input string. The input can be the user question, one or more previous evidence values, or a combination of both.

Here are the tools you can use:
GoogleSearch[input]: This tool allows you to search for information on Google. It's useful for finding sites that may contain the answer to the user's question.
WebsiteReader[input]: This tool loads websites from the input string containing newline delimited links. Input is one or more links and produces plain text output containing the content of the links.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QuestionAnswerer[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What are some popular dishes in Italian cuisine and what ingredients do they typically require?

Response:
Plan: Start by conducting a web search to find out about popular dishes in Italian cuisine.
:evidence0: = GoogleSearch[Popular dishes in Italian cuisine]
Plan: Use the QuestionAnswerer to interpret the search results and identify the popular dishes.
:evidence1: = QuestionAnswerer[What are some popular dishes in Italian cuisine, given :evidence0:?]
Plan: Conduct another web search to find the typical ingredients required for these dishes.
:evidence2: = GoogleSearch[Ingredients for :evidence1:]
Plan: Extract relevant links from the Google search results for detailed recipes.
:evidence3: = LinkFinder[:evidence2:]
Plan: Use WebsiteReader to extract information from the identified recipe links.
:evidence4: = WebsiteReader[:evidence3:]
Plan: Finally, use the QuestionAnswerer to identify and summarize the typical ingredients for each dish from the extracted information.
:evidence5: = QuestionAnswerer[What are the typical ingredients for :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Develop a systematic plan to address the user's request utilizing the following tools. Each step will yield an evidence value that can be utilized in the next steps.

Tools Available:
1. WebCrawler[input]: Searches the web for specific information related to the input string.
2. TextAnalyzer[input]: Analyzes a body of text and extracts key points.
3. FactChecker[input]: Checks facts against reliable sources.
4. QASystem[input]: Answers questions based on provided context.

Output Format:
Plan: [Initial action based on the question]
:Evidence0: = [Tool to use with input parameters]
Plan: [Subsequent action based on :Evidence0:]
:Evidence1: = [Next tool to use with input parameters, may reference prior evidence]
...
Answer: [:EvidenceN:, containing the final response.]

Question: Are polar bears endangered and what are some reasons for their endangerment?

Response:
Plan: Start by searching the web for information on the status of polar bears.
:Evidence0: = WebCrawler[Polar bear status]
Plan: Use the fact checker to verify the status of polar bears.
:Evidence1: = FactChecker[:Evidence0:]
Plan: If polar bears are indeed endangered, look up reasons for their endangerment.
:Evidence2: = WebCrawler[Reasons for polar bear endangerment]
Plan: Extract key points from the gathered information.
:Evidence3: = TextAnalyzer[:Evidence2:]
Plan: Formulate a clear and concise answer to the question.
:Evidence4: = QASystem[Are polar bears endangered and why? Given context: :Evidence1: and :Evidence3:]
Answer: :Evidence4:

System: A chat.


Instruction:
Provide a detailed execution plan to respond to the user's request using the set of tools at your disposal. Each step must correspond to an evidence value, which will be the result of calling a function with an appropriate input string.

Available tools include:
1. WikiSearch[input]: Searches Wikipedia for articles matching the input query.
2. WebScraper[input]: Retrieves the content of a webpage specified by the input URL.
3. LinkFinder[input]: Identifies links within a body of text provided as input.
4. AnswerBot[input]: Answers questions based on its internal knowledge base or given context. Input should be a question string, possibly referring to earlier evidence variables.

Output format:
Plan: [First action]
:Evidence0: = [Function call with input]
Plan: [Subsequent action]
:Evidence1: = [Next function call with input]
...
Answer: [:EvidenceN:]

Question: Who was Albert Einstein's first wife and what were her notable works?

Response:
Plan: Begin by conducting a Wikipedia search to find out who Albert Einstein's first wife was.
:Evidence0: = WikiSearch[Albert Einstein's first wife]
Plan: Use AnswerBot to extract the name of Albert Einstein's first wife from the Wikipedia article.
:Evidence1: = AnswerBot[Who was Albert Einstein's first wife? Given :Evidence0:]
Plan: Conduct another Wikipedia search to find notable works of Albert Einstein's first wife.
:Evidence2: = WikiSearch[:Evidence1: notable works]
Plan: Finally, use AnswerBot to summarize the notable works of Albert Einstein's first wife from the Wikipedia article.
:Evidence3: = AnswerBot[What were the notable works of :Evidence1:? Given :Evidence2:]
Answer: :Evidence3:

System: A chat.


Instruction:
Develop a plan to answer the question: "What is the population of Tokyo, Japan?"

Here are the tools available:
PopData[input]: Tool that provides population data for cities around the world.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
CityFacts[input]: Provides facts about different cities worldwide.
StatExtractor[input]: Extracts statistical data from a larger body of text.
LLM[input]: Question answering language model.

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]

Response:
Plan: First action to take based on input question
#E1 = PopData["Tokyo, Japan"]

Plan: If #E1 does not provide the required information, use another tool.
#E2 = QA["What is the population of Tokyo, Japan?"]

Plan: If #E2 still doesn't provide an answer, try a different approach.
#E3 = CityFacts["Tokyo, Japan"]

Plan: If the data from #E3 contains relevant information but isn't explicit, extract it.
#E4 = StatExtractor[#E3]

Plan: As a last resort, if all other tools fail, use LLM.
#E5 = LLM["What is the population of Tokyo, Japan?"]

Final Answer: #E1 or #E2 or #E4 or #E5

System: A chat.


Instruction:
Create a detailed plan to answer this query with the help of these tools:
AskJeeves[input]: Search engine tool.
RedditSearch[input]: Searches Reddit threads for relevant discussions.
ContentParser[input]: Parses content from a webpage.
FactChecker[input]: Checks the validity of a statement.
AIAnswer[input]: AI model that answers questions based on input context.

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

Response:
Plan:

1. Use AskJeeves to search for "Nikola Tesla biography" and "Nikola Tesla major contributions to science". This will provide a general overview of who Nikola Tesla was and his significant scientific contributions.

2. Extract the most relevant links from the search results, focusing on reputable sources like educational websites or well-known encyclopedias.

3. Use ContentParser on these selected webpages to extract detailed information about Nikola Tesla's life and his main scientific achievements.

4. Compile this information into a comprehensive answer, making sure to highlight key points such as his birthplace, education, career, and specific inventions or theories he is known for.

5. Use RedditSearch to find discussions related to Nikola Tesla and his contributions to science. This can provide additional insights or perspectives that may not be covered in standard biographical sources.

6. Parse the content from the relevant Reddit threads using ContentParser to identify any unique or notable points raised by users.

7. Incorporate these findings into the overall answer, ensuring they add value and are not simply repeating previously mentioned facts.

8. Run the final draft of the answer through FactChecker to verify all statements made are accurate and true. Correct any inaccuracies identified during this process.

9. Once the answer has been fact-checked and verified, input it into AIAnswer. The AI model will ensure the response is coherent, engaging, and answers the question fully.

10. Review the final output from AIAnswer, make any necessary adjustments for clarity or flow, then submit the completed response.

System: A chat.


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

Here are the tools available to be called:
GoogleSearch[input]: This tool allows you to search for information on Google. It is useful for finding sites that may contain answers to your questions.
TextScraper[input]: This tool extracts text from websites. The input should be one or more URLs separated by commas.
LinkExtractor[input]: This tool extracts links from plain text and produces a list of links as output.
QAModel[input]: This tool 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 should be in format:
Plan: [first action to take based in input question]
:evidence0: = [function to call with input parameter]
Plan: [next action to take, based on result of :evidence0:]
:evidence1: = [next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

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

Response:
Plan: Start by conducting a web search to find out who won the Nobel Prize in Physics in 2020.
:evidence0: = GoogleSearch[Nobel Prize in Physics 2020 winner]
Plan: Use the QAModel to identify 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 contribution of the identified laureate.
:evidence2: = GoogleSearch[:evidence1: Nobel Prize contribution]
Plan: Extract the relevant links from the Google search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the TextScraper tool to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, use the QAModel to summarize the laureate's contribution from the extracted information.
:evidence5: = QAModel[What was the contribution of :evidence1: in Physics, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Generate a step-by-step execution plan to solve the following problem using the given tools. For each step, indicate the tool you would use along with the input parameters. Store the output into a variable named :evidence[index]:

Available Tools:
FactFinder[input]: Searches for factual information related to the input query.
DataAnalyzer[input]: Analyzes data from a given context and provides insights or answers to queries.
WikiReader[input]: Retrieves comprehensive information from Wikipedia based on the input query.
QAModel[input]: Answers questions based on a given context.

Output Format:
Plan: [Description of the first step]
:evidence0: = [Tool to use with input parameters]
Plan: [Description of the next step based on the outcome of the previous step]
:evidence1: = [Next tool to use with input parameters, referencing previous evidence if necessary]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who was Albert Einstein and what contributions did he make to science?

Response:
Plan: Search for comprehensive information about Albert Einstein.
:evidence0: = WikiReader[Albert Einstein]
Plan: Analyze the retrieved information to get a brief biography of Albert Einstein.
:evidence1: = DataAnalyzer[Who was Albert Einstein? Given context: :evidence0:]
Plan: Find factual information about Albert Einstein's contributions to science.
:evidence2: = FactFinder[Albert Einstein scientific contributions]
Plan: Analyze the facts to summarize Albert Einstein's contributions to science.
:evidence3: = QAModel[What contributions did Albert Einstein make to science? Given context: :evidence2:]
Answer: Albert Einstein's biography is summarized in :evidence1: and his contributions to science are detailed in :evidence3:.

System: A chat.


Instruction:
Create a sequential plan to respond to the user's query utilizing the following tools. Each step in the plan should correspond to an evidence value, which represents the output of a function given an input string. This input could be the user's question, previous evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: Allows users to perform searches using the DuckDuckGo search engine. Useful for locating potential sources of answers.
WebScraper[input]: Pulls content from specified websites provided via input links.
URLCollector[input]: Gathers URLs from plain text and outputs a list of these links.
KnowledgeBot[input]: A QA language model capable of answering queries based on a supplied passage of text. It requires a textual question referencing a #Evidence[n] variable as input.

Each function's input should be a simple string, without any concatenation operators like '+' or quotation marks. For instance, KnowledgeBot[What's the tallest mountain, given #Evidence3?].

Only one evidence output should be allowed per plan step.

Output format should be:
Plan: [initial action based on the input question]
#Evidence0 = [chosen function along with its input parameter]
Plan: [subsequent action, contingent upon the outcome of #Evidence0]
#Evidence1 = [the next function to invoke, including its input parameter, which might refer back to prior evidence (e.g., "In light of #Evidence0")]
...
Final Answer: [#EvidenceN contains the ultimate solution.]

Question: Who authored 'War and Peace' and what other notable works did they write?

Response:
Plan: Begin by executing a web search to ascertain the author of 'War and Peace'.
#Evidence0 = DuckDuckGo[Author of War and Peace]
Plan: Deploy the language model to parse the search findings and determine the book's author.
#Evidence1 = KnowledgeBot[Who wrote War and Peace, given #Evidence0?]
Plan: Initiate another web search to discover other prominent works penned by this author.
#Evidence2 = DuckDuckGo[Notable works by #Evidence1]
Plan: Gather pertinent links from the search results for a more targeted inquiry.
#Evidence3 = URLCollector[#Evidence2]
Plan: Utilize the WebScraper tool to glean data from the selected links.
#Evidence4 = WebScraper[#Evidence3]
Plan: Lastly, engage the language model to pinpoint and condense the noteworthy writings of the author from the scraped data.
#Evidence5 = KnowledgeBot[What are some notable works written by #Evidence1, given #Evidence4?]
Final Answer: #Evidence5

System: A chat.


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

Here are the tools available to be called:
Google[input]: Tool that allows the user to search for information using the Google search engine.
LinkParser[input]: Extracts all URLs from a block of text.
PageReader[input]: Reads the contents of a webpage given its URL.
QAEngine[input]: Question answering tool that uses AI to provide answers based on a given context.

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

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

Response:
Plan: Search for the current population of Tokyo.
#E1 = Google[Current population of Tokyo]
Plan: Use QAEngine to extract the population figure from the search results.
#E2 = QAEngine[What is the current population of Tokyo? Given context: #E1]
Plan: Search for historical population data of Tokyo over the past decade.
#E3 = Google[Tokyo population change over the past decade]
Plan: Extract relevant links from the search results.
#E4 = LinkParser[#E3]
Plan: Read the contents of the most relevant link.
#E5 = PageReader[#E4]
Plan: Use QAEngine to understand how the population of Tokyo has changed over the past decade.
#E6 = QAEngine[How has the population of Tokyo changed over the past decade? Given context: #E5]
Final answer: #E2 and #E6

System: A chat.


Instruction:
Construct a plan to solve: "Explain the process of photosynthesis and its importance to life on Earth."

Tools available:
ScienceExplainer[input]: Provides detailed explanations of scientific processes.
EarthLife[input]: Gives information about life on Earth and its dependencies.
DiagramGenerator[input]: Generates diagrams based on the input topic.
QA[input]: Answers questions based on common sense and general world knowledge.
VideoTutorial[input]: Finds video tutorials related to the input topic.

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 = ScienceExplainer["photosynthesis"]

Plan: Next action
#E2 = DiagramGenerator["photosynthesis process"]

Plan: Third action
#E3 = EarthLife["importance of photosynthesis to life on Earth"]

Plan: Fourth action
#E4 = VideoTutorial["photosynthesis and its importance"]

Final Answer: #E1, #E2, #E3, #E4

System: A chat.


Instruction:
Generate a step-by-step plan to answer the question: "What is the population of Tokyo and what are some popular tourist attractions there?"

Here are the tools available:
WikiSearch[input]: Tool that allows you to search for information from Wikipedia.
QA[input]: Tool that can answer questions based on common sense and general world knowledge.
TouristAttractionFinder[input]: Tool that finds popular tourist spots in a given location.
PopulationFinder[input]: Tool that provides the current population of a specified city or country.

Output format:
Plan: first action
#E1 = function with input parameter
Plan: next action, based on #E1
#E2 = next function with input parameter (may reference previous evidence)
...
Final Answer: #E[n]

Response:
Plan: Use the PopulationFinder tool to find out the population of Tokyo.
#E1 = PopulationFinder["Tokyo"]
Plan: Next, use the TouristAttractionFinder tool to identify popular tourist attractions in Tokyo.
#E2 = TouristAttractionFinder["Tokyo"]
Final Answer: The population of Tokyo is #E1. Some popular tourist attractions there are #E2.

System: A chat.


Instruction:
Generate a plan to find out the steps involved in the water cycle.

Available tools:
WebCrawler[input]: Searches the web for information related to the input.
ImageIdentifier[input]: Identifies images related to the input query.
StepByStepGuideMaker[input]: Creates a step-by-step guide based on the input context.
QAModel[input]: Answers questions based on general knowledge or given context.
InfoOrganizer[input]: Organizes information into a structured format.

Output format:
Plan: Initial action
#Evidence1 = Function with input parameter
Plan: Subsequent action
#Evidence2 = Next function with input parameter
...
Final Response: #Evidence[n]

Response:
Plan: Initial action
#Evidence1 = WebCrawler["Water Cycle Steps"]

Plan: Subsequent action
#Evidence2 = ImageIdentifier["Water Cycle Diagram"]

Plan: Analyze the information gathered from web and images.
#Evidence3 = InfoOrganizer[#Evidence1, #Evidence2]

Plan: Generate a step-by-step guide of the water cycle.
#Evidence4 = StepByStepGuideMaker[#Evidence3]

Plan: Validate and answer any questions about the steps involved in the water cycle.
#Evidence5 = QAModel["Questions about Water Cycle Steps"]

Final Response: #Evidence4, #Evidence5

System: A chat.


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

The available tools are as follows:

Bing[input]: This tool allows you to search for information on Bing. It's useful for finding lists of websites that may contain answers to your questions.
WebReader[input]: This tool loads one or more websites from an input string containing newline delimited links. The input is one or more links, and the output is plain text content from those links.
LinkCollector[input]: This tool extracts links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: This is a question answering AI model. It can answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the dog, given #E1?

Output should be formatted as follows:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action, based on result of #E1]
#E2 = [next function call and input parameter, referencing previous evidence if necessary]
...
Final Answer: #E[n]

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

Response:
Plan: Start by searching online to find out who won the Nobel Prize in Literature in 2010.
#E1 = Bing[Nobel Prize in Literature 2010 winner]
Plan: Use the AIQA tool to interpret the search results and identify the winner.
#E2 = AIQA[Who won the Nobel Prize in Literature in 2010? Given context: #E1]
Plan: Conduct another web search to find the most famous work of the identified laureate.
#E3 = Bing[#E2 most famous work]
Plan: Extract relevant links from the Bing search results for detailed information.
#E4 = LinkCollector[#E3]
Plan: Load the content of the extracted links for further analysis.
#E5 = WebReader[#E4]
Plan: Finally, use the AIQA tool to determine the most famous work of the laureate from the loaded content.
#E6 = AIQA[What is the most famous work of #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a detailed execution plan to find out the population of New York City and its major tourist attractions.

Available Tools:
DuckDuckGo[input]: A search engine tool that retrieves information about a specific topic.
URLParser[input]: A tool that extracts URLs from a given text.
SiteReader[input]: Reads the contents of the sites from the URL list and outputs plain text.
AIQA[input]: An AI-powered Question Answering tool that answers queries based on given context.

Output Format:
Step 1: [Action]
Evidence1 = [Tool to use + Input]
Step 2: [Action]
Evidence2 = [Tool to use + Input]
...
Answer: Evidence[N]

Response:
Step 1: Perform a search to find out the population of New York City.
Evidence1 = DuckDuckGo[Population of New York City]
Step 2: Use AIQA to interpret the search results and find the population.
Evidence2 = AIQA[What is the population of New York City? Given context: Evidence1]
Step 3: Perform another search to find the major tourist attractions in New York City.
Evidence3 = DuckDuckGo[Tourist attractions in New York City]
Step 4: Extract the URLs from the search results for further exploration.
Evidence4 = URLParser[Evidence3]
Step 5: Read the contents of the sites from the URL list.
Evidence5 = SiteReader[Evidence4]
Step 6: Use AIQA to identify and summarize the major tourist attractions in New York City from the site contents.
Evidence6 = AIQA[What are the major tourist attractions in New York City? Given context: Evidence5]
Answer: Evidence6

System: A chat.


Instruction:
Create a detailed execution plan to respond to the user's inquiry, leveraging the provided tools. Each step corresponds to an evidence value, representing the output of a function when fed an input string that could be the user's question, earlier evidence values, or a combination thereof.

These are the tools at your disposal:
Bing[input]: This tool enables users to perform searches online via Bing. It yields a list of potentially helpful sites but doesn't offer direct answers.
URLExtractor[input]: Pulls URLs from plain text, providing a plaintext list of URLs separated by newlines.
SiteLoader[input]: Loads one or multiple websites from an input string comprising newline-separated URLs, producing plaintext output featuring the content of the URLs.
AnswerBot[input]: An AI model capable of answering queries based on a supplied passage of text. The input has to be a textual question referencing a #Evidence[n] variable, like "What is the population of Tokyo, given #Evidence1?"

Input strings for each function should be simple, devoid of quotes or "+" used to merge a string with an evidence variable, such as AnswerBot[What is the population of Tokyo, given #Evidence1?]

Ensure every plan step includes only one evidence output.

Your output should follow this structure:
Plan: [Initial action derived from the input question]
#Evidence1 = [Function to invoke with input parameter]
Plan: [Subsequent action informed by the outcome of #Evidence1]
#Evidence2 = [Next function to invoke and input parameter, possibly referring to prior evidence, e.g., "In light of #Evidence1"]
...
Final Response: #Evidence[n]

Question: Who invented the telephone and what were their other notable inventions?

Response:
Plan: Initiate a Bing search to discover who invented the telephone.
#Evidence1 = Bing[Who invented the telephone]
Plan: Deploy AnswerBot to parse the search results and pinpoint the inventor of the telephone.
#Evidence2 = AnswerBot[Who invented the telephone, given #Evidence1?]
Plan: Perform another Bing search to uncover other significant inventions by the identified individual.
#Evidence3 = Bing[Other inventions by #Evidence2]
Plan: Extract pertinent URLs from the Bing search results for further investigation.
#Evidence4 = URLExtractor[#Evidence3]
Plan: Load the content of these URLs using SiteLoader.
#Evidence5 = SiteLoader[#Evidence4]
Plan: Finally, employ AnswerBot to summarize the other notable inventions by the inventor of the telephone from the extracted data.
#Evidence6 = AnswerBot[What are the other notable inventions by #Evidence2, given #Evidence5?]
Final Response: #Evidence6

System: A chat.


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

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

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

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

Response:
Plan: Begin by conducting a web search to find out who won the 2018 FIFA World Cup.
:evidence0: = Bing[2018 FIFA World Cup winner]
Plan: Utilize a language model to interpret the search results and find the name of the winning team.
:evidence1: = LMQA[Who won the 2018 FIFA World Cup, given :evidence0:?]
Plan: Conduct another web search to find the top scorer of the identified team in the 2018 FIFA World Cup.
:evidence2: = Bing[Top scorer of :evidence1: in 2018 FIFA World Cup]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use a web scraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the language model to identify and summarize the top scorer of the winning team from the extracted information.
:evidence5: = LMQA[Who was the top scorer of :evidence1: in the 2018 FIFA World Cup, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step plan to answer the user's question using the following tools. Each tool can be called with an input string, and each plan should generate an evidence value which will be the output of one of the available functions.

Here are the tools you can use:

Bing[input]: This tool allows users to search for information on Bing. It is useful in finding a list of sites that may contain the answer to the user's query. The function does not directly provide answers; it generates a list of potential sources.
WebReader[input]: Load one or more websites from the input string containing newline delimited links. Input should be one or more links, and the output is plain text content of the links.
URLExtractor[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of links.
AnswerBot[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing an #E[n] variable, e.g., What color is the cat, given #E1?

The output format should be as follows:
Plan: [first action]
#E0 = [function call with input parameter]
Plan: [next action, based on result of #E0]
#E1 = [next function call with input parameter, possibly referencing previous evidence like "Given context #E0"]
...
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 searching for the first woman to win a Nobel Prize.
#E0 = Bing[First woman to win a Nobel Prize]
Plan: Use AnswerBot to identify the name of the first female Nobel laureate from the search results.
#E1 = AnswerBot[Who was the first woman to win a Nobel Prize? Given context: #E0]
Plan: Conduct another web search to find out about her contributions to science.
#E2 = Bing[#E1's contribution to science]
Plan: Extract relevant links from the search results for further investigation.
#E3 = URLExtractor[#E2]
Plan: Scrape information from the extracted links.
#E4 = WebReader[#E3]
Plan: Finally, use AnswerBot to summarize her scientific contributions from the scraped information.
#E5 = AnswerBot[What were the scientific contributions of #E1? Given context: #E4]
Final Answer: #E5

System: A chat.


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.
PageLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
UrlExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
AIM[input]: Artificial Intelligence Model for answering questions based on an input passage of text.

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 won the Nobel Prize in Literature in 2020 and what was their most famous work?

Response:
Plan: Begin by searching for the winner of the 2020 Nobel Prize in Literature.
#E1 = DuckDuckGo[Nobel Prize in Literature 2020 winner]
Plan: Use the AI model to determine the name of the winner from the search results.
#E2 = AIM[Who won the Nobel Prize in Literature in 2020? Given context: #E1]
Plan: Search for the most famous work of the identified author.
#E3 = DuckDuckGo[Most famous work of #E2]
Plan: Extract relevant URLs from the search results for a deeper dive into the topic.
#E4 = UrlExtractor[#E3]
Plan: Load the content of the extracted pages for analysis.
#E5 = PageLoader[#E4]
Plan: Finally, use the AI model to determine the most famous work of the author from the loaded page contents.
#E6 = AIM[What is the most famous work of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Outline a methodical plan to address the upcoming question using the prescribed tools. Each segment of the plan should yield an evidence value, produced by triggering a function with an input string that can be the initial question, antecedent evidence, or a combination of both.

These are the tools at your disposal:
NetExplorer[input]: Runs a comprehensive online search based on the input string. While it doesn't furnish direct answers, it compiles a catalogue of potential information sources.
SiteScanner[input]: Scans content from one or more URLs contained in the input string (links separated by newlines) and delivers it as plain text.
URLHarvester[input]: Harvests URLs from any submitted plain text and returns them as newline-separated plain text.
SolutionProvider[input]: An advanced AI model proficient in answering questions using universal knowledge or specific context derived from prior evidence.

Function inputs should be bare strings, sans quotation marks or "+" symbols used for string concatenation, e.g., SolutionProvider[What is the longest river, given :evidence3:?]

Ensure that each plan segment corresponds to exactly one evidence output.

Output format:
Plan: [Primary action based on the question]
:evidence0: = [Triggering of function with input parameter]
Plan: [Secondary action, dependent on the outcome of :evidence0:]
:evidence1: = [Triggering of subsequent function with input parameter, possibly referencing previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is artificial intelligence and where is it mainly applied?

Response:
Plan: Initiate a NetExplorer search to grasp what artificial intelligence is.
:evidence0: = NetExplorer[What is artificial intelligence]
Plan: Enlist the SolutionProvider to interpret the search results and clarify the concept of artificial intelligence.
:evidence1: = SolutionProvider[What is artificial intelligence, given :evidence0:?]
Plan: Run another NetExplorer search to discover where artificial intelligence is chiefly applied.
:evidence2: = NetExplorer[Main applications of artificial intelligence]
Plan: Command URLHarvester to segregate pertinent links from the search results for closer scrutiny.
:evidence3: = URLHarvester[:evidence2:]
Plan: Instruct SiteScanner to acquire textual content from the segregated links.
:evidence4: = SiteScanner[:evidence3:]
Plan: Finally, task the SolutionProvider to locate and summarize the main applications of artificial intelligence from the procured data.
:evidence5: = SolutionProvider[Where is artificial intelligence mainly applied, given :evidence4:?]
Answer: :evidence5:

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may contain the answer to the user's question.
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]: Extracts links from plain text and produces a plain text, newline delimited response of links.
ALM[input]: Answer Language Model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the dog, given :evidence1:?

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

Question: Who is the current president of Harvard University and what are their notable achievements?

Response:
Plan: Start by conducting a web search to find out who the current president of Harvard University is.
:evidence0: = Bing[Current President of Harvard University]
Plan: Use the language model to interpret the search results and identify the name of the president.
:evidence1: = ALM[Who is the current president of Harvard University, given :evidence0:?]
Plan: Conduct another web search to find the notable achievements of the identified president of Harvard University.
:evidence2: = Bing[Notable achievements of :evidence1:]
Plan: Extract the relevant links from the Bing search results for a more focused search.
:evidence3: = LinkCollector[:evidence2:]
Plan: Use the WebScraper tool to extract information from the relevant links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use the language model to identify and summarize the notable achievements of the president of Harvard University from the extracted information.
:evidence5: = ALM[What are the notable achievements of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.