Instruction:
Generate a systematic plan to solve the following problem using the specified tools. Each plan should correspond to an evidence value derived from the output of a specific function based on either the user query, prior evidence values, or both.

Available tools:
BingSearch[input]: Allows users to conduct online searches via Bing. Useful for obtaining a list of potentially helpful sites related to the user's inquiry.
URLParser[input]: Retrieves plaintext content from URLs provided in a newline-separated input string.
HyperlinkDetector[input]: Identifies hyperlinks within plaintext and returns them in a newline-separated format.
NLM[input]: Natural Language Model capable of answering queries based on supplied textual evidence. Queries should reference an :evidence[n]: variable (e.g., "What's the weather like, given :evidence1:?").

Output Format:
Plan: [Initial action based on input query]
:evidence0: = [Function to execute with input parameters]
Plan: [Subsequent action based on :evidence0:]
:evidence1: = [Next function to execute with input parameters, possibly referencing earlier evidence (e.g., "Context: :evidence0")]
...
Final Answer: [:evidence[n]: contains the ultimate solution]

Question: Which company developed the first smartphone and when was it released?

Response:
Plan: Initiate a web search to determine the company that developed the first smartphone.
:evidence0: = BingSearch[first smartphone developer]
Plan: Employ the NLM to analyze the search results and identify the company.
:evidence1: = NLM[Which company developed the first smartphone, given :evidence0:?]
Plan: Perform another web search to ascertain when this company released the first smartphone.
:evidence2: = BingSearch[:evidence1: first smartphone release date]
Plan: Identify pertinent links from the search results for further investigation.
:evidence3: = HyperlinkDetector[:evidence2:]
Plan: Utilize URLParser to extract data from the chosen links.
:evidence4: = URLParser[:evidence3:]
Plan: Lastly, apply the NLM to distill the release date of the first smartphone from the parsed data.
:evidence5: = NLM[When did :evidence1: release the first smartphone, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a step-by-step execution plan to respond to the following query, utilizing the listed tools. Each plan step will produce an evidence value, which is the output of a specific tool function given an input string that could be the original query, prior evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: A tool that enables users to perform searches using the DuckDuckGo search engine. It's helpful for identifying potential sources that might contain the answer to the user's query.
TextParser[input]: Takes one or more website URLs from the input string (separated by newlines) and outputs plain text containing the content of those pages.
HyperlinkHarvester[input]: Harvests hyperlinks from plain text and returns them as a newline-separated plain text response.
InfoBot[input]: A question-answering AI model adept at answering queries based on a provided context. The input should be a question referencing an :evidence[n]: variable.

Output format:
Plan: [Initial action based on input query]
:evidence0: = [Function to invoke with relevant parameters]
Plan: [Subsequent action based on outcome of :evidence0:]
:evidence1: = [Next function to invoke with its parameters, possibly referring to earlier evidence]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

Question: Who wrote "To Kill a Mockingbird" and what other works did they publish?

Response:
Plan: Start with a web search to identify the author of "To Kill a Mockingbird".
:evidence0: = DuckDuckGo["To Kill a Mockingbird" author]
Plan: Use InfoBot to extract the author's name from the search results.
:evidence1: = InfoBot[Who wrote "To Kill a Mockingbird", given :evidence0:?]
Plan: Perform another web search to discover other works published by this author.
:evidence2: = DuckDuckGo[:evidence1: other works]
Plan: Extract the relevant links from the search results for further examination.
:evidence3: = HyperlinkHarvester[:evidence2:]
Plan: Parse the textual content from these links.
:evidence4: = TextParser[:evidence3:]
Plan: Finally, employ InfoBot to summarize the other works published by the author from the parsed text.
:evidence5: = InfoBot[What other works were published by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Create a sequential plan to respond to the user query using the following tools. For each plan, indicate the tool and its input to gather evidence. Store the gathered evidence into a variable #E[index] that can be referenced later.

Available tools:
GoogleScholar[input]: A tool that allows users to search for academic papers and articles related to the input query.
PDFReader[input]: Reads PDF files from the provided link(s) and outputs plain text.
Summarizer[input]: Summarizes long texts into concise points.
AIQA[input]: An AI-powered tool that answers questions based on the provided 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 are the latest advancements in Quantum Computing according to recent research papers?

Response:
Plan: Search for recent research papers on Quantum Computing.
#E1 = GoogleScholar[Recent research papers on Quantum Computing]
Plan: Read the contents of the research papers.
#E2 = PDFReader[#E1]
Plan: Summarize the contents of the research papers.
#E3 = Summarizer[#E2]
Plan: Find out the latest advancements in Quantum Computing from the summarized contents.
#E4 = AIQA[What are the latest advancements in Quantum Computing? Given context: #E3]
Final answer: #E4

System: A chat.


Instruction:
Generate a plan to discover the distance between New York City and Los Angeles by road.

Available tools:
- MapSearch[input]: Searches for locations and provides geographical information.
- DistanceCalculator[input1, input2]: Calculates the distance between two points.
- RoutePlanner[input1, input2]: Provides the best route between two locations including the total distance.
- QA[input]: Answers questions using general world knowledge or provided context.
- VerificationTool[input]: Verifies the accuracy of a given piece of information.

Output format:
Plan: initial action based on the query
:Evidence0: = function to use with its parameters
Plan: subsequent action, considering the outcome of :Evidence0:
:Evidence1: = [next function to apply along with its parameters, possibly referring to prior evidence, like "Considering context :Evidence0"]
...
Answer: [:Evidence[n]: Containing the final response.]

Response:
Plan: Use the RoutePlanner tool to find the best route between New York City and Los Angeles, which will also provide the total distance.
:Evidence0: = RoutePlanner["New York City", "Los Angeles"]

Plan: Verify the accuracy of the provided information using VerificationTool.
:Evidence1: = VerificationTool[:Evidence0:]

Answer: [:Evidence1:]

System: A chat.


Instruction:
Create a comprehensive plan to respond to the user query, utilizing a variety of available tools. Each plan should correspond to an evidence value, representing the output of a specific function given an input string. The input string could be the user's question, prior evidence values, or a mix of both.

Available tools include:
WikiSearch[input]: Allows users to search Wikipedia for information. Useful for obtaining factual data about people, places, events, etc.
SiteScraper[input]: Loads one or more websites from an input string containing newline-separated links. Outputs plain text content from these links.
LinkDetector[input]: Detects links within plain text and outputs them as newline-separated strings.
QuerySolver[input]: A language model designed to answer questions based on an input text passage. References to previous evidence variables should be included in the input.

Each function requires a simple string as input. Concatenation of strings and evidence variables (like QuerySolver[What is the population of Brazil, given :evidence3:]?) is allowed but no quotes or "+" symbols should be used.

Only one evidence output should be included per plan step.

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

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

Response:
Plan: Begin by searching Wikipedia for the first woman to win a Nobel Prize.
:evidence0: = WikiSearch[First woman to win a Nobel Prize]
Plan: Use QuerySolver to identify the name of the woman from the Wikipedia page.
:evidence1: = QuerySolver[Who was the first woman to win a Nobel Prize, given :evidence0:?]
Plan: Search Wikipedia again to find details about her scientific contributions.
:evidence2: = WikiSearch[:evidence1:]
Plan: Extract the key points about her scientific contributions using QuerySolver.
:evidence3: = QuerySolver[What were the scientific contributions of :evidence1:, given :evidence2:?]
Final Answer: :evidence3:

System: A chat.


Instruction:
Develop a comprehensive plan to address the following user inquiry using the supplied tools. Each plan will correlate to an evidence value, which will be the output of one of the accessible functions given an input string that may be the user's question, one or more earlier evidence values, or a mix of both.

Tools you can use include:
DuckDuckGo[input]: This tool lets users conduct information searches via the DuckDuckGo search engine.
HyperlinkHarvester[input]: This function extracts hyperlinks from plain text and provides a plain text list of hyperlinks.
SiteLoader[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 generates plain text content from those links.
FactChecker[input]: This tool conducts a fact-checking search for relevant data based on the input string.
InquiryEngine[input]: This is a question-answering language model adept at responding to inquiries based on an input text passage. The input must be a text-based question referring to a #F[index] variable.

Output format:
Plan: [First action based on input question]
#F1 = [Function to call with input parameter]
Plan: [Next action based on the result of #F1]
...
Final Response: #F[n]

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

Response:
Plan: Initiate a fact-checking search to identify the first person to walk on the moon.
#F1 = FactChecker[first person to walk on the moon]
Plan: Use InquiryEngine to confirm the individual's name from the fact-checking search results.
#F2 = InquiryEngine[Who was the first person to walk on the moon? Given context: #F1]
Plan: Carry out a DuckDuckGo search to find out when this event occurred.
#F3 = DuckDuckGo[#F2 + ' moon landing date']
Plan: Harvest the relevant hyperlinks from the DuckDuckGo search results for a more targeted exploration.
#F4 = HyperlinkHarvester[#F3]
Plan: Apply SiteLoader to gather information from the relevant hyperlinks.
#F5 = SiteLoader[#F4]
Plan: Ultimately, employ InquiryEngine to pinpoint and summarize the moon landing date from the gathered information.
#F6 = InquiryEngine[When did #F2 walk on the moon? Given context: #F5]
Final Response: #F6

System: A chat.


Instruction:
Create a sequential plan to respond to the following query utilizing the below mentioned tools. Each step in your plan should correspond to an evidence variable, which will store the output of the function you choose to execute at that step.

Available Tools:
DuckDuckGo[input]: A tool that lets users perform internet searches via DuckDuckGo. It returns a list of potential resources but does not provide direct answers.
URLExtractor[input]: Pulls out URLs from a body of text provided as input.
SiteReader[input]: Reads the content of one or more websites whose URLs are provided as input.
ALEX[input]: An AI language model capable of answering questions when provided with context from a :data[n]: variable.

Output Format:
Plan: [First action based on the question]
:data0: = [Function to call with its input]
Plan: [Subsequent action based on the outcome of :data0:]
:data1: = [Next function to call with its input, potentially referencing prior data]
...
Final Answer: :data[n]:

Question: How did the Battle of Waterloo affect Europe's political landscape?

Response:
Plan: Begin by searching online for information regarding the Battle of Waterloo and its effects.
:data0: = DuckDuckGo[Battle of Waterloo effects on Europe]
Plan: Extract the URLs from the search results for further examination.
:data1: = URLExtractor[:data0:]
Plan: Read the content of the extracted URLs for detailed insights.
:data2: = SiteReader[:data1:]
Plan: Utilize the AI language model to analyze the gathered data and provide a summary of how the Battle of Waterloo affected Europe's political landscape.
:data3: = ALEX[How did the Battle of Waterloo affect Europe's political landscape? Given context: :data2:]
Final Answer: :data3:

System: A chat.


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

Here are the tools you have at your disposal:
SearchEngine[input]: This tool allows the user to search for information on the internet. It returns a list of websites that may contain the answer to the user's question.
WebScraper[input]: This tool takes as input one or more URLs and outputs plain text containing the content of these links.
LinkExtractor[input]: This tool extracts links from plain text and produces a newline delimited response of links.
AIQA[input]: An AI-based Question Answering tool that answers questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

The input to each function should be a plain string. Do not use quotes or "+" to concatenate a string with an evidence variable, e.g., AIQA[What is the capital of France, given #E3?]

Each plan step should only include one evidence output.

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

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

Response:
Plan: Start by searching online to find out who won the Nobel Prize in Literature in 2010.
#E1 = SearchEngine[Nobel Prize in Literature 2010 winner]
Plan: Use the AI-based QA tool to identify the winner from the search results.
#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 author.
#E3 = SearchEngine[Most famous work of #E2]
Plan: Extract relevant links from the search results for detailed information.
#E4 = LinkExtractor[#E3]
Plan: Scrape the content from the extracted links.
#E5 = WebScraper[#E4]
Plan: Finally, use the AI-based QA tool to determine the most famous work of the author from the scraped data.
#E6 = AIQA[What is the most famous work of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


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

Here are the tools available to you:
Bing[input]: A tool that allows users to search for information on Bing. This tool is useful for finding a list of sites that may contain the answer to the user's question.
WebScraper[input]: Loads websites from the input string containing newline-delimited links. The input is one or more links and produces plain text output with the content of these links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
QAModel[input]: A question-answering model that can answer questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the historical significance of the Battle of Waterloo?

Response:
Plan: Start by conducting a web search to find out about the Battle of Waterloo.
:evidence1: = Bing[Battle of Waterloo]
Plan: Use the LinkExtractor tool to get relevant links from the search results.
:evidence2: = LinkExtractor[:evidence1:]
Plan: Utilize the WebScraper tool to extract information from the relevant links.
:evidence3: = WebScraper[:evidence2:]
Plan: Finally, use the QAModel to interpret the extracted information and determine the historical significance of the Battle of Waterloo.
:evidence4: = QAModel[What is the historical significance of the Battle of Waterloo? Given context: :evidence3:]
Final Answer: :evidence4:

System: A chat.


Instruction:
Generate a step-by-step solution for the following problem using these tools:
BingSearch[input]: Searches Bing for information.
YouTubeSearch[input]: Searches YouTube for relevant videos.
Transcriber[input]: Transcribes video content into text.
InfoExtractor[input]: Extracts specific information from a large body of text.
IntelligentResponder[input]: Responds intelligently to queries based on input context.

Question: Explain the process of DNA replication.

Response:
Step 1: BingSearch["DNA replication process"]
This step will search for information about the DNA replication process on Bing. The result should provide a general overview of the topic.

Step 2: InfoExtractor[BingSearch Results]
The next step is to extract specific information from the large body of text obtained from the Bing search results. This tool will focus on extracting key details about the DNA replication process, such as its purpose, stages, and mechanisms involved.

Step 3: YouTubeSearch["DNA replication explained"]
In this step, we will search YouTube for videos that explain the DNA replication process. These videos can provide visual aids and detailed explanations that may not be present in the text-based search results from Bing.

Step 4: Transcriber[YouTubeSearch Results]
Next, transcribe the content of the selected YouTube video into text. This will allow us to extract precise information from the video, which might include additional or more detailed explanations of the DNA replication process.

Step 5: InfoExtractor[Transcribed YouTube Video Text]
Now, use the InfoExtractor tool again to pull out specific information from the transcribed text of the YouTube video. This might help fill in any gaps left by the initial Bing search.

Step 6: IntelligentResponder[InfoExtractor Results]
Finally, compile all the extracted information into an intelligent response that explains the DNA replication process. This response should be based on the context provided by both the Bing search results and the transcribed YouTube video.

System: A chat.


Instruction:
Please provide a detailed plan to solve the following problem using the tools provided. For each step, indicate the tool used along with its input to retrieve evidence. Store the evidence into a variable #E[index] that can be referred later.

Available Tools:
DuckDuckGo[input]: A tool that allows users to perform internet searches using DuckDuckGo search engine.
WebScraper[input]: Loads websites from the input string containing newline separated links and provides their content as plain text.
LinkFilter[input]: Filters relevant links from plain text and gives a plain text, newline separated list of links.
AIQA[input]: An AI-powered tool that answers questions using general world knowledge or context provided.

Output Format:
Plan: [action based on input question]
#E1 = [function to call with input parameter]
Plan: [subsequent action, based on result of #E1]
...
Final Answer: #E[n]

Question: Who won the Nobel Prize in Literature in 2020 and what was it awarded for?

Response:
Plan: Start by searching the internet to find who won the Nobel Prize in Literature in 2020.
#E1 = DuckDuckGo[Nobel Prize in Literature 2020 winner]
Plan: Use AIQA to identify the winner from the search results.
#E2 = AIQA[Who won the Nobel Prize in Literature in 2020? Given context: #E1]
Plan: Conduct another internet search to find why the identified person won the prize.
#E3 = DuckDuckGo[#E2 + " Nobel Prize in Literature 2020 reason"]
Plan: Filter out the relevant links from the search results.
#E4 = LinkFilter[#E3]
Plan: Extract the contents of the filtered links.
#E5 = WebScraper[#E4]
Plan: Lastly, use AIQA to determine the reason the identified person won the Nobel Prize in Literature in 2020.
#E6 = AIQA[Why did #E2 win the Nobel Prize in Literature in 2020? Given context: #E5]
Final Answer: #E6

Continue this process for additional eight unique instruction/response pairs.

System: A chat.


Instruction:
Please create a detailed plan to respond to the user's instruction using the set of tools provided. For each step in your plan, assign an evidence value corresponding to the output of one of the available functions. This output could be based on the user's question, prior evidence values, or a combination of both.

These are the tools you can use:
WebSearch[input]: This tool enables users to perform an internet search for information. While it does not provide direct answers, it helps locate websites that may contain the required information.
PageScraper[input]: This tool extracts text from one or more websites provided in the input string, which contains newline-delimited links. The input comprises one or more links, and the output is plain text containing the website contents.
URLFinder[input]: This tool extracts URLs from plain text and provides a plain text, newline-separated list of links.
QuerySolver[input]: This is a question-answering language model. It is particularly effective when asked to answer questions based on a specific text passage. The input should be a textual question referencing a :source[n]: variable (e.g., What color is the car, given :source1:?).

Each function requires a simple string as input—no need for quotation marks or concatenation operators (+) to combine a string with a source variable (e.g., QuerySolver[What is the population of Canada, given :source2:?]).

Make sure to generate only one evidence output for each plan step.

Your output should follow this structure:
Plan: [First action based on the input question]
:source0: = [Function to call with input parameter]
Plan: [Next action, based on the outcome of :source0:]
:source1: = [Next function to call and its input parameter, possibly referring to previous evidence (e.g., Given context :source0)]
...
Final Answer: [:source[n]: Containing the ultimate answer.]

Question: What is the main storyline of the movie 'Inception' and who are the primary actors?

Response:
Plan: Initiate a web search to find information about the movie 'Inception'.
:source0: = WebSearch['Inception movie plot']
Plan: Use the QuerySolver model to interpret the search results and outline the main storyline.
:source1: = QuerySolver[What is the main storyline of 'Inception', given :source0:?]
Plan: Perform another web search to discover the primary actors in 'Inception'.
:source2: = WebSearch['Inception cast']
Plan: Extract relevant links from the search results for further investigation.
:source3: = URLFinder[:source2:]
Plan: Employ the PageScraper tool to gather information from the selected links.
:source4: = PageScraper[:source3:]
Plan: Lastly, use the QuerySolver model to identify and list the primary actors in 'Inception' from the gathered information.
:source5: = QuerySolver[Who are the primary actors in 'Inception', given :source4:?]
Final Answer: :source5:

System: A chat.


Instruction:
Please generate a plan to answer the following question using the available tools. Each step in your plan should be followed by an evidence variable that can be referenced in later steps.

Available Tools:
WebSearch[input]: A tool that allows you to search for information on the internet. The input is a string query, and the output is a list of relevant websites.
TextExtractor[input]: Extracts plain text from a given website URL. The input is a single URL, and the output is the text content of the webpage.
QAEngine[input]: Can answer questions based on general knowledge or given context. The input must be a question string, which may reference previous evidence variables.
ImageAnalyzer[input]: Analyzes images from a given URL and provides descriptions of what it sees. The input is a single image URL, and the output is a description of the image.

Output Format:
Plan: [first action]
#E1 = [function call with input]
Plan: [next action]
#E2 = [function call with input, possibly referencing #E1]
...
Final Answer: #En

Question: What is the main ingredient in Tiramisu and where does it originate?

Response:
Plan: Conduct a web search about Tiramisu.
#E1 = WebSearch[Tiramisu]
Plan: Extract the text from the most relevant link found.
#E2 = TextExtractor[#E1]
Plan: Use the QA engine to find out the main ingredient in Tiramisu.
#E3 = QAEngine[What is the main ingredient in Tiramisu? Given context: #E2]
Plan: Use the QA engine again to find out where Tiramisu originates.
#E4 = QAEngine[Where does Tiramisu originate? Given context: #E2]
Final Answer: #E3 and #E4

System: A chat.


Instruction:
Provide a detailed plan to solve the following problem using the provided tools. For each step, indicate the tool used along with its input and store the output as evidence.

Tools available:
DuckDuckGo[input]: A tool that performs a web search using DuckDuckGo.
PageReader[input]: This tool loads a webpage and returns its textual content.
URLCollector[input]: This tool extracts URLs from a block of text.
ALEX[input]: An AI language model capable of answering questions based on provided context.

Output Format:
Plan: [Describe the first step]
#E1 = [Tool to use with input]
Plan: [Describe the next step based on #E1]
#E2 = [Next tool to use with input]
...
Final Answer: #En

Question: Who wrote the book '1984' and what are some notable works by the same author?

Response:
Plan: Begin by searching for the author of the book '1984'.
#E1 = DuckDuckGo['1984' book author]
Plan: Use the AI language model to determine the author from the search results.
#E2 = ALEX[Who is the author of the book '1984'? Given context: #E1]
Plan: Perform a new search to find other notable works by the same author.
#E3 = DuckDuckGo[Notable works by #E2]
Plan: Extract the URLs from the search results for further examination.
#E4 = URLCollector[#E3]
Plan: Read the contents of the pages linked in the URLs.
#E5 = PageReader[#E4]
Plan: Use the AI language model to summarize the notable works by the author from the page contents.
#E6 = ALEX[What are some notable works by #E2? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Create a plan to answer the following question using the tools provided. For each step in your plan, provide an evidence variable that corresponds to the output of the function used in that step.

Here are the tools available to be called:
GoogleSearch[input]: Tool that allows the user to search for information using Google's search engine.
TextAnalyzer[input]: Analyzes text and extracts key pieces of information such as names, dates, places, etc.
LinkExtractor[input]: Extracts links from plain text.
WebScraper[input]: Scrapes web pages for content.
AnswerBot[input]: Answers questions based on input context. The input must be a text question that references an #E[n] variable.

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

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

Response:
Plan: Search for the winner of the Nobel Prize in Literature in 2010.
#E1 = GoogleSearch[Nobel Prize in Literature 2010 winner]
Plan: Use TextAnalyzer to extract the name of the winner from the search results.
#E2 = TextAnalyzer[#E1]
Plan: Search for the most famous work of the identified author.
#E3 = GoogleSearch[Most famous work of #E2]
Plan: Extract the relevant links from the search results.
#E4 = LinkExtractor[#E3]
Plan: Scrape the content of the extracted links.
#E5 = WebScraper[#E4]
Plan: Identify the most famous work of the author from the scraped content.
#E6 = AnswerBot[What is the most famous work of #E2? Given context: #E5]
Final answer: #E6

System: A chat.


Instruction:
Develop a sequential plan to respond to the subsequent question utilizing the resources provided. Each step in the plan should lead to an evidence value, generated by invoking a function with an input string that can be the initial question, past evidence, or a blend of both.

These are the tools you have access to:
EncyclopediaSearch[input]: Allows the user to look up information from an online encyclopedia. While this tool may not provide direct answers, it often supplies useful background information.
DataParser[input]: Parses a chunk of text and condenses it into key points. This tool is especially helpful when dealing with extensive information.
QuerySolver[input]: Provides answers to questions based on common sense, general knowledge, or specific context gleaned from prior evidence.

Inputs to each function should be unadorned strings, without quotation marks or "+" signs for string concatenation, e.g., QuerySolver[Who invented the telephone, given :evidence2:?].

Ensure that each step in the plan corresponds to precisely one evidence output.

Output format:
Plan: [Initial action based on the question]
:evidence0: = [Invocation of function with input parameter]
Plan: [Following action, taking into account the result of :evidence0:]
:evidence1: = [Subsequent function invocation with input parameter, possibly referencing earlier evidence like "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate answer.]

Question: Who was Albert Einstein and what is he best known for?

Response:
Plan: Start by performing an EncyclopediaSearch for information about Albert Einstein.
:evidence0: = EncyclopediaSearch[Albert Einstein]
Plan: Use DataParser to distill the key points about Albert Einstein from the encyclopedia entry.
:evidence1: = DataParser[:evidence0:]
Plan: Leverage QuerySolver to ascertain who Albert Einstein was based on the parsed data.
:evidence2: = QuerySolver[Who was Albert Einstein, given :evidence1:?]
Plan: Carry out another EncyclopediaSearch to learn about Albert Einstein's most notable achievements.
:evidence3: = EncyclopediaSearch[Albert Einstein's accomplishments]
Plan: Apply DataParser to condense the main accomplishments of Albert Einstein.
:evidence4: = DataParser[:evidence3:]
Plan: Finally, use QuerySolver to outline what Albert Einstein is best known for based on the condensed information.
:evidence5: = QuerySolver[What is Albert Einstein best known for, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Devise a methodical plan to respond to the user request utilizing the tools at your disposal. Every step of the plan should correlate to an evidence value, representing the result of one of the functions when supplied with an input string. This string could be the user's question, previously obtained evidence values, or a mix of both.

Tools you can use:
YahooSearch[input]: Allows users to conduct searches via the Yahoo search engine. This tool helps locate potential websites that may contain answers to the user's inquiries.
HyperlinkExtractor[input]: Isolates hyperlinks from plain text and delivers a response comprising these hyperlinks in plain text, divided by newlines.
PageFetcher[input]: Accepts one or several websites from the input string (containing newline-separated links), fetches them, and yields plain text output covering the contents of these links.
Solver[input]: An AI model proficient in responding to questions based on a piece of input text. The input has to be a text-based question referring to a #E[n] variable, like 'What is the cat's age, given #E1?'.

Every function's input should be a simple, unadorned string, free of quotation marks or '+' signs used to combine a string with an evidence variable, such as Solver[What is Germany's official language, given #E3?].

Make sure each plan step includes only one evidence output.

The output format should be:
Plan: [First action predicated on the input question]
#E0 = [Function to execute with input parameter]
Plan: [Following action, based on the result of #E0]
#E1 = [Upcoming function to execute and its input parameter, possibly referencing preceding evidence, like 'Given context #E0']
...
Answer: [#E[n] containing the final solution.]

Question: Who is presently heading Amazon's drone delivery initiative and what notable progress have they achieved?

Response:
Plan: Kick off by running a web search to identify the head of Amazon's drone delivery initiative.
#E0 = YahooSearch[Head of Amazon's drone delivery initiative]
Plan: Apply the Solver model to parse the search results and ascertain the name of the initiative's head.
#E1 = Solver[Who heads Amazon's drone delivery initiative, given #E0?]
Plan: Execute another web search to unearth the notable progress made by the identified head of the initiative.
#E2 = YahooSearch[Notable progress of #E1]
Plan: Separate the relevant hyperlinks from the YahooSearch search results for deeper investigation.
#E3 = HyperlinkExtractor[#E2]
Plan: Use PageFetcher to obtain information from the separated hyperlinks.
#E4 = PageFetcher[#E3]
Plan: Ultimately, apply the Solver model to detect and summarize the head's notable progress from the obtained information.
#E5 = Solver[What is the notable progress of #E1, given #E4?]
Answer: #E5

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information from various websites. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a website link provided as input and produces a readable output containing the content of the link.
LinkFinder[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAEngine[input]: Question answering engine, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g. What color is the cat, given #E1?

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

Remember to only include one evidence output per plan step.

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

Question: Who won the 2022 World Series and what team do they play for?

Response:
Plan: Begin by conducting a web search to find out who won the 2022 World Series.
#E0 = WebSearch[2022 World Series winner]
Plan: Use the QAEngine to interpret the search results and find the name of the winning player.
#E1 = QAEngine[Who won the 2022 World Series, given #E0?]
Plan: Conduct another web search to find the team that the identified player plays for.
#E2 = WebSearch[#E1 + ' baseball team']
Plan: Utilize the QAEngine again to determine the team from the search results.
#E3 = QAEngine[What team does #E1 play for, given #E2?]
Answer: #E3

System: A chat.


Instruction:
Create a sequential plan to solve the following problem. For each step, specify the external tool to be used along with the input parameters. Store the outputs into variables #E[index] that can be referenced later.

Available Tools:
BingSearch[input]: Searches for information using Bing's search engine.
PDFReader[input]: Reads PDF files from provided URLs and extracts their text content.
URLFinder[input]: Finds URLs in the provided text.
KnowledgeBase[input]: Answers questions based on common knowledge and specific context provided as input.

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

Question: What are the safety precautions mentioned in the "XYZ Company Safety Manual" found online?

Response:
Plan: Search for the XYZ Company Safety Manual online.
#E1 = BingSearch[XYZ Company Safety Manual PDF]
Plan: Find the URL of the PDF file from the search results.
#E2 = URLFinder[#E1]
Plan: Read the PDF file to extract its text content.
#E3 = PDFReader[#E2]
Plan: Identify the safety precautions mentioned in the manual.
#E4 = KnowledgeBase[What are the safety precautions mentioned in the manual? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
Devise a thorough blueprint to decipher the upcoming query. Each segment should nominate a function to initiate with its respective input. Retain the product of each function in a marked :Proof[index]: variable, which can henceforth be cited in later segments.

At disposal Functions:
YandexSearch[input]: Initiates a Yandex search for the input expression and garners an aggregation of probable references.
UriSeparator[input]: Provided a mass of text (like the output from a YandexSearch), this function pinpoints all URLs nestled within the text.
PortalRetriever[input]: Navigates to the page at the indicated URL and translates its contents into plain text.
AlphaMind[input]: A cutting-edge AI-driven question-answering module proficient at offering immediate resolutions to a broad spectrum of inquiries. It can also concoct answers banking on supplementary details (e.g., the text from a webpage).

Output Draft:
Plan: [Depiction of the opening step]
:Proof0: = [Opening step function initiation]
Plan: [Depiction of the following step]
:Proof1: = [Following step function initiation]
... Uphold this succession until ...
Final Answer: :ProofN:

Question: Who authored 'Pride and Prejudice' and what other literary works are they acclaimed for?

Response:
Plan: Ignite a Yandex search to deduce who authored 'Pride and Prejudice'.
:Proof0: = YandexSearch[author of 'Pride and Prejudice']
Plan: Engage AlphaMind to filter through the search products and distinguish the author.
:Proof1: = AlphaMind[Who wrote 'Pride and Prejudice'? Given context: :Proof0:]
Plan: Implement another Yandex search to spot other literary works penned by the distinguished writer.
:Proof2: = YandexSearch[:Proof1: other literary works]
Plan: Disengage the URLs from the search yields for exhaustive inspection.
:Proof3: = UriSeparator[:Proof2:]
Plan: Obtain the content of the leading URL from the cluster.
:Proof4: = PortalRetriever[:Proof3[0]]
Plan: Eventually, deploy AlphaMind to inspect the webpage text and underscore the other esteemed literary works of the writer.
:Proof5: = AlphaMind[What other literary works is :Proof1: recognized for? Given context: :Proof4:]
Final Answer: :Proof5:

System: A chat.


Instruction:
Develop a plan to answer the following question using the provided tools. Each step in your plan should have a corresponding evidence value, which will be the output of one of the available functions given an input string, which could be the user's question, prior evidence values, or both.

Available tools:
DuckDuckGo[input]: Allows users to search for information using the DuckDuckGo search engine. It finds a list of sites that might contain the answer to the user's question.
PlainTextExtractor[input]: Extracts plain text from a webpage given its URL.
LinkPicker[input]: Picks up links from plain text and provides a list of newline-separated links.
AIQA[input]: An AI-based question-answering model. Particularly useful in answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

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

Question: What is the tallest building in New York City and when was it completed?

Response:
Plan: Begin by searching the web to find the tallest building in New York City.
:evidence0: = DuckDuckGo[Tallest building in New York City]
Plan: Use AIQA to analyze the search results and identify the building.
:evidence1: = AIQA[What is the tallest building in New York City? Given context: :evidence0:]
Plan: Search the web again to find out when the identified building was completed.
:evidence2: = DuckDuckGo[Completion date of :evidence1:]
Plan: Pick up the relevant links from the DuckDuckGo search results for more detailed information.
:evidence3: = LinkPicker[:evidence2:]
Plan: Extract plain text from the selected links to gather more data.
:evidence4: = PlainTextExtractor[:evidence3:]
Plan: Lastly, use AIQA to determine and summarize the completion date of the building from the gathered data.
:evidence5: = AIQA[When was :evidence1: completed? Given context: :evidence4:?]
Answer: :evidence5:

System: A chat.


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

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

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

Each plan should only include one evidence output.

The output format should be as follows:
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, referencing previous evidence if necessary]
...
Answer: [:evidence[n]: containing the final answer.]

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

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

System: A chat.


Instruction:
Formulate a comprehensive plan to address the following inquiry, utilizing the tools at your disposal. Each plan will correspond to an evidence value, which is the output of one of the available functions given an input string that could be the user query, one or more preceding evidence values, or a mix of both.

Here are the tools available to be called:
InternetSearch[input]: Enables the user to perform an internet search to locate websites that might contain the answer to the user's question.
DataScraper[input]: Loads one or more websites from the input string containing newline-delimited links, where the input consists of one or more links, and generates plain text output containing the link contents.
LinkHarvester[input]: Harvests links from plain text and delivers a plain text, newline-separated list of links.
QAModel[input]: A question-answering model adept at answering questions based on an input text passage. The input must be a text question that refers to a *evidence[n]* variable, e.g., What is the tallest mountain, given *evidence1*?

Each function simply needs a plain string as input, without quotation marks or '+' symbols to connect a string with an evidence variable, like QAModel[What is the longest river, given *evidence3*?].

Ensure you only include one evidence output per plan step.

The output should adhere to this format:
Plan: [Initial action based on the input question]
*evidence0 = [Function to call with input parameter]
Plan: [Subsequent action, based on the result of *evidence0]
*evidence1 = [Next function to call and input parameter, potentially referring to earlier evidence, such as 'Given context *evidence0']
...
Final Answer: [*evidence[n], holding the final answer.]

Question: Who designed the Sydney Opera House and what were the unique architectural features incorporated into its design?

Response:
Plan: Start by performing an internet search to determine who designed the Sydney Opera House.
*evidence0 = InternetSearch[Designer of Sydney Opera House]
Plan: Employ the QAModel to decipher the search results and ascertain the designer's name.
*evidence1 = QAModel[Who designed the Sydney Opera House, given *evidence0*?]
Plan: Carry out another internet search to uncover the unique architectural features of the Sydney Opera House.
*evidence2 = InternetSearch[Unique architectural features of Sydney Opera House]
Plan: Harvest the pertinent links from the search results for a more targeted investigation.
*evidence3 = LinkHarvester[*evidence2*]
Plan: Use the DataScraper tool to gather information from the harvested links.
*evidence4 = DataScraper[*evidence3*]
Plan: Lastly, apply the QAModel to identify and summarize the unique architectural features of the Sydney Opera House from the scraped data.
*evidence5 = QAModel[What are the unique architectural features of the Sydney Opera House, given *evidence4*?]
Final Answer: *evidence5*

System: A chat.


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

Here are the tools you can use:
WebSearch[input]: This tool allows users to search for information on the internet. The function doesn't directly provide answers; it finds sites that may contain the required information.
TextScraper[input]: Extracts text from websites provided in the input string containing newline-separated links. The input is one or more links and the output is plain text content from these links.
LinkExtractor[input]: Pulls out links from plain text and provides a response with newline-separated 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 :evidence[n]: variable, e.g., What is the population of Paris, given :evidence1:?

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

Each plan step should include only one evidence output.

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

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

Response:
Plan: Start by conducting a web search to identify the architect of the Sydney Opera House.
:evidence0: = WebSearch[Architect of Sydney Opera House]
Plan: Use the AnswerBot to interpret the search results and find the name of the architect.
:evidence1: = AnswerBot[Who designed the Sydney Opera House, given :evidence0:?]
Plan: Conduct another web search to find other notable structures designed by this architect.
:evidence2: = WebSearch[Notable buildings designed by :evidence1:]
Plan: Extract relevant links from the search results for detailed information.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Use the TextScraper tool to extract information from the selected links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, use the AnswerBot to summarize the key structures designed by the architect from the extracted information.
:evidence5: = AnswerBot[What are some notable buildings designed by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

Continue this process until you've generated 10 unique instruction/response pairs. Be sure to incorporate between 2 and 8 distinct, random tools in each pair. One of the tools must be a question-answering tool similar to "AnswerBot" but can bear a different name. Avoid referring to the examples in your output.

Response Format:

System: A chat.


Instruction:
Create a plan to find out which country won the most gold medals in the 2008 Summer Olympics and who their top performing athlete was, using the following tools. Store each piece of evidence in a variable #E[index].

Available Tools:
WikiLookup[input]: Searches Wikipedia for information related to the input query.
AthleteStats[input]: Retrieves statistical data about athletes, including their performance in various competitions.
CountryMedalTally[input]: Provides medal tally information for countries in different Olympic games.
QAModel[input]: Answers questions based on provided context.

Output Format:
Plan: [action]
#E1 = [tool(input)]
...
Final Answer: #En

Question: Which country won the most gold medals in the 2008 Summer Olympics and who was their top performing athlete?

Response:
Plan: Look up the 2008 Summer Olympics on Wikipedia.
#E1 = WikiLookup[2008 Summer Olympics]
Plan: Identify the country with the most gold medals.
#E2 = CountryMedalTally[#E1]
Plan: Find out the top performing athlete from this country.
#E3 = AthleteStats[#E2]
Plan: Validate the findings using QAModel.
#E4 = QAModel[Which country won the most gold medals in the 2008 Summer Olympics and who was their top performing athlete? Given context: #E1, #E2, #E3]
Final Answer: #E4

System: A chat.


Instruction:
Create a step-by-step plan to respond to the following query using the listed tools. Every plan should correspond to an evidence value produced by executing one of the provided functions with either the user’s question, previously obtained evidence, or a combination thereof as input.

Tools at your disposal:
DuckDuckGo[input]: A tool enabling users to perform searches via DuckDuckGo. It helps locate potentially helpful sites but does not directly provide answers.
PageLoader[input]: Loads one or multiple websites specified in the input string (which contains newline-separated links) and returns their textual content.
URLCollector[input]: Gathers URLs from plaintext and outputs them as newline-separated strings.
InfoProcessor[input]: An AI model capable of answering queries based on provided context. The input should be a question referencing an :evidence[n]: variable.

Output format:
Plan: [Initial course of action derived from the user’s question]
:evidence0: = [Function to execute along with input parameters]
Plan: [Subsequent course of action informed by :evidence0:]
:evidence1: = [Next function to run along with its inputs, possibly including prior evidence]
…
Final Answer: [:evidence[n]: holding the ultimate answer]

Question: Who wrote "War and Peace" and what other works did they author?

Response:
Plan: Begin by searching for the author of "War and Peace".
:evidence0: = DuckDuckGo["War and Peace" author]
Plan: Use InfoProcessor to parse the search results and identify the author.
:evidence1: = InfoProcessor[Who wrote "War and Peace", given :evidence0:?]
Plan: Perform another search to discover other works authored by this individual.
:evidence2: = DuckDuckGo[Other works by :evidence1:]
Plan: Extract pertinent links from the search results for further examination.
:evidence3: = URLCollector[:evidence2:]
Plan: Deploy PageLoader to retrieve information from these links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, employ InfoProcessor to compile a list of the author’s other works from the gathered data.
:evidence5: = InfoProcessor[What other works were written by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Please provide a step-by-step plan to answer the following question, using the tools provided. Each tool should be used at least once and each plan will have an associated evidence value which is the output of one of the available functions given an input string that can be the user's question, previous evidence values or both.

Here are the tools available to be called:
WebSearch[input]: This tool allows you to search for information from various sources on the internet. The input to this function should be a query string.
DocumentParser[input]: Extracts useful information from documents in text format. Input is plain text document content.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response with newline delimited links.
QAEngine[input]: A question answering engine that answers questions based on common sense, general world knowledge and context from previous evidence. The input must be a text question referencing 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 was the impact of the Spanish flu pandemic on the global economy?

Response:
Plan: Begin by conducting a web search to find information about the impact of the Spanish flu pandemic on the global economy.
:evidence0: = WebSearch[Impact of Spanish flu pandemic on global economy]
Plan: Extract relevant links from the search results for more detailed information.
:evidence1: = LinkExtractor[:evidence0:]
Plan: Use DocumentParser to extract useful information from the linked documents.
:evidence2: = DocumentParser[:evidence1:]
Plan: Finally, use QAEngine to summarize the impact of the Spanish flu pandemic on the global economy from the extracted information.
:evidence3: = QAEngine[What was the impact of the Spanish flu pandemic on the global economy? Given :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
Develop a detailed plan to respond to the user's inquiry using the tools at your disposal. 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:
DuckDuckGo[input]: A tool that enables the user to conduct a search for information using the DuckDuckGo search engine. It helps in locating a list of sites that might contain the answer to the user's question.
WebScraper[input]: Loads one or more websites from the input string, which contains newline-separated links. The input consists of one or more links, and the output is plain text containing the content of those links.
URLCollector[input]: Extracts links from plain text and generates a plain text, newline-separated list of links.
AIME[input]: A question-answering language model, especially effective at answering queries based on an input text passage. The input has to be a textual question that refers to an :evidence[n]: variable, such as 'What colour is the dog, given :evidence1:?'.

The output should follow this format:
Plan: [First action to undertake based on the input question]
:evidence0: = [Function to call with its input parameter]
Plan: [Next action to perform, based on the outcome of :evidence0:]
:evidence1: = [Next function to call and its input parameter, which might refer to previous evidence, e.g., 'Given context :evidence0']
...
Answer: [:evidence[n]: Containing the final answer.]

Question: Who invented the telephone and when was the first successful test conducted?

Response:
Plan: Initiate a web search to discover who invented the telephone.
:evidence0: = DuckDuckGo[Inventor of the telephone]
Plan: Employ a language model to parse the search results and determine the inventor's name.
:evidence1: = AIME[Who invented the telephone, given :evidence0:?]
Plan: Carry out another web search to ascertain when the first successful test of the telephone was conducted.
:evidence2: = DuckDuckGo[First successful test of the telephone]
Plan: Gather the pertinent links from the DuckDuckGo search results for a more targeted search.
:evidence3: = URLCollector[:evidence2:]
Plan: Utilize the WebScraper tool to extract data from the selected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Lastly, apply the language model to identify and summarise the date of the first successful telephone test from the gathered information.
:evidence5: = AIME[When was the first successful test of the telephone conducted, given :evidence4:?]
Answer: :evidence1: and :evidence5:

System: A chat.


Instruction:
Create a plan to solve the following problem using the available tools. For each step, provide the corresponding evidence value which will be the output of one of the functions given an input string.

Tools available:
DuckDuckGo[input]: A tool that enables users to perform internet searches using DuckDuckGo.
TextScraper[input]: Loads one or more websites from the input string (containing newline-delimited links) and returns the text content of those pages.
LinkFinder[input]: Extracts links from plaintext and returns them as a newline-delimited list.
InfoBot[input]: An AI model capable of answering questions based on provided context. It requires a text question referencing an :evidence[n]: variable.

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

Question: Who won the 2020 Nobel Prize in Literature and what are some of their notable works?

Response:
Plan: Perform an internet search to determine who won the 2020 Nobel Prize in Literature.
:evidence0: = DuckDuckGo[2020 Nobel Prize in Literature winner]
Plan: Use InfoBot to extract the name of the laureate from the search results.
:evidence1: = InfoBot[Who won the 2020 Nobel Prize in Literature? Given context: :evidence0:]
Plan: Perform another internet search to discover notable works by this author.
:evidence2: = DuckDuckGo[Notable works by :evidence1:]
Plan: Extract pertinent links from the search results for further examination.
:evidence3: = LinkFinder[:evidence2:]
Plan: Scrape textual data from the discovered links.
:evidence4: = TextScraper[:evidence3:]
Plan: Utilize InfoBot to discern and list the notable works by the laureate from the scraped text.
:evidence5: = InfoBot[What are the notable works by :evidence1:? Given context: :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to answer the following question using the provided tools. Each step should correspond to an evidence variable representing the output of a specific function, given an input string derived from the user's question, previous evidence variables, or both.

Available Tools:
1. GoogleScholar[input]: Searches academic papers and articles using Google Scholar. Provides a list of scholarly works that may contain the answer.
2. PaperReader[input]: Reads academic papers and extracts key findings and conclusions. Input is a URL or DOI of a paper.
3. AcademicQA[input]: Answers complex academic questions based on an input passage of text.

Output Format:
Plan: [Initial action based on input question]
#Evidence1 = [Function to call with input parameter]
Plan: [Subsequent action based on #Evidence1]
#Evidence2 = [Next function to call with input parameter, possibly referring to earlier evidence]
...
Final Answer: #Evidence[n]

Question: What are the main causes of climate change according to recent scientific studies?

Response:
Plan: Search for recent scientific studies on the causes of climate change.
#Evidence1 = GoogleScholar[Recent scientific studies on causes of climate change]
Plan: Read the most relevant papers and extract their key findings.
#Evidence2 = PaperReader[#Evidence1]
Plan: Identify the main causes of climate change as per these studies.
#Evidence3 = AcademicQA[What are the main causes of climate change according to these studies? Given context: #Evidence2]
Final Answer: #Evidence3

System: A chat.


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information on the web. This tool is useful in finding sites that may contain the answer to the user's question.
TextScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extracts relevant links from plain text and provides a plain text, newline delimited response of links.
KnowledgeBase[input]: Question answering model, particularly effective at answering questions based on an input passage of text. The input must be a text question that references a :data[n]: variable, e.g., What color is the dog, given :data1:?

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

Each plan step should only include one evidence output.

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

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

Response:
Plan: Start by conducting a web search to find out who designed the Eiffel Tower.
:data0: = WebSearch[Eiffel Tower architect]
Plan: Use the KnowledgeBase model to interpret the search results and identify the architect.
:data1: = KnowledgeBase[Who was the architect of the Eiffel Tower, given :data0:?]
Plan: Conduct another web search to find other significant structures designed by the identified architect.
:data2: = WebSearch[:data1: + ' significant structures']
Plan: Extract the relevant links from the search results for a more focused search.
:data3: = LinkPicker[:data2:]
Plan: Use the TextScraper tool to extract information from the selected links.
:data4: = TextScraper[:data3:]
Plan: Finally, use the KnowledgeBase model to summarize the key structures designed by the architect from the extracted information.
:data5: = KnowledgeBase[What are the significant structures designed by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
Please develop a plan to answer the following question using the tools provided. For each step, indicate which tool will be used and what input it will receive. The output of each tool should be stored in a variable #E[index] for use in subsequent steps.

The available tools are as follows:
SearchEngine[input]: A function that performs an internet search based on the input string. It returns a list of potential sources containing relevant information.
ArticleReader[input]: This tool reads articles from given URLs and extracts their text content.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAmodel[input]: A tool that can answer questions based on general knowledge or given context. The input must be a question referencing one or more :evidence[n]: variables.

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

Output format:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action based on result of #E1]
#E2 = [next function call with input parameter, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: What is the history of the Eiffel Tower and who were its main architects?

Response:
Plan: Start by searching for information about the Eiffel Tower's history.
#E1 = SearchEngine[Eiffel Tower History]
Plan: Extract useful links from the search results.
#E2 = LinkExtractor[#E1]
Plan: Read the articles found in the extracted links.
#E3 = ArticleReader[#E2]
Plan: Use the QA model to find out the history of the Eiffel Tower.
#E4 = QAmodel[What is the history of the Eiffel Tower? Given context: #E3]
Plan: Use the same QA model to identify the main architects of the Eiffel Tower.
#E5 = QAmodel[Who were the main architects of the Eiffel Tower? Given context: #E3]
Final Answer: #E4 and #E5

System: A chat.


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

Here are the tools you have at your disposal:

1. SearchEngine[input]: This tool allows users to search for information using a popular search engine. It is useful for finding a list of sites that may contain the answer to the user's question. The function doesn't directly provide an answer; it finds a list of websites that might have the answer.
2. TextExtractor[input]: This tool extracts plain text from one or more websites specified by the input string containing newline delimited links. Input is one or more URLs and produces plain text output containing the content of those pages.
3. LinkFinder[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
4. InfoBot[input]: A language model capable of answering questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., "What color is the cat, given #E1?"

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

Remember to include only one evidence output per plan step.

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

Question: Who is the current Prime Minister of Japan and what significant policies have they implemented?

Response:
Plan: Start by conducting a web search to find out who the current Prime Minister of Japan is.
#E0 = SearchEngine[Current Prime Minister of Japan]
Plan: Use the language model to interpret the search results and identify the name of the Prime Minister.
#E1 = InfoBot[Who is the current Prime Minister of Japan, given #E0?]
Plan: Conduct another web search to find significant policies implemented by the identified Prime Minister of Japan.
#E2 = SearchEngine[Significant policies implemented by #E1]
Plan: Extract relevant links from the search results for a more focused search.
#E3 = LinkFinder[#E2]
Plan: Use the text extraction tool to get information from the relevant links.
#E4 = TextExtractor[#E3]
Plan: Finally, use the language model to identify and summarize the significant policies implemented by the Prime Minister of Japan from the extracted information.
#E5 = InfoBot[What are the significant policies implemented by #E1, given #E4?]
Final Answer: #E5

System: A chat.


Instruction:
Develop a step-by-step plan to respond to the user's query using the available tools. Each stage of the plan will have an associated evidence value, which is the output from one of the available functions given an input string that could be the user's 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 a list of sites that may contain the answer to the user's question. The function doesn't directly answer the question; it finds a list of sites that might have the answer.
WebCrawler[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
NLPModel[input]: Natural Language Processing model that can answer questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable, e.g. What color is the 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: = Bing[Nobel Prize in Physics 2020 winner]
Plan: Use the NLP Model to interpret the search results and identify the winner.
:evidence1: = NLPModel[Who won the Nobel Prize in Physics in 2020, given :evidence0:?]
Plan: Conduct another web search to find the contributions made by the identified laureate.
:evidence2: = Bing[:evidence1: Nobel Prize contribution]
Plan: Extract the relevant URLs from the Bing search results for a more detailed search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Use the WebCrawler tool to extract information from the relevant URLs.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, use the NLP Model to summarize the key contributions made by the laureate from the extracted information.
:evidence5: = NLPModel[What were the contributions of :evidence1: that led to the Nobel Prize, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Develop a plan to answer the following question using the tools listed below. For each step in your plan, generate an evidence value, which corresponds to the output of one of the available functions given an input string that could be the user's question, prior evidence values, or a combination of both.

Available tools include:
DuckDuckGo[input]: Allows users to conduct an internet search via DuckDuckGo. Returns a list of potential websites that might contain the answer to the user's question.
WebReader[input]: Reads and extracts plain text from one or more websites when provided with a link(s).
HyperlinkDetector[input]: Detects hyperlinks within plain text and outputs them as a newline-separated list.
InfoBot[input]: An AI-powered question answering system that can provide answers based on a given context. The input must be a textual question that refers to an :evidence[n]: variable.

Each function accepts a simple string as input, without quotation marks or "+" symbols to concatenate a string with an evidence variable (for example, InfoBot[Who won the World Series in 2020, given :evidence4:?]).

The output should follow this structure:
Plan: [initial action]
:evidence0: = [function name with input parameter]
Plan: [subsequent action, dependent on the outcome of :evidence0:]
:evidence1: = [following function name and input parameter, potentially referring back to earlier evidence]
...
Answer: [:evidence[n]: contains the ultimate response].

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

Response:
Plan: Initiate a web search to discover who wrote "To Kill a Mockingbird".
:evidence0: = DuckDuckGo[Author of To Kill a Mockingbird]
Plan: Utilize InfoBot to interpret the search results and determine the author's name.
:evidence1: = InfoBot[Who is the author of To Kill a Mockingbird, given :evidence0:?]
Plan: Conduct another web search to uncover other works penned by the identified author.
:evidence2: = DuckDuckGo[Other works by :evidence1:]
Plan: Deploy HyperlinkDetector to extract pertinent links from the DuckDuckGo search results.
:evidence3: = HyperlinkDetector[:evidence2:]
Plan: Apply WebReader to gather information from the selected links.
:evidence4: = WebReader[:evidence3:]
Plan: Lastly, employ InfoBot to identify and summarize the other works authored by the writer of "To Kill a Mockingbird" using the gathered data.
:evidence5: = InfoBot[What other works has :evidence1: written, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Create a plan to answer the following query using the provided tools. Each step in your plan should correspond to an execution command that uses one of these tools, and each command should store its output into an Evidence variable (#E[index]).

Available Tools:
WikiSearch[input]: Searches Wikipedia for articles related to the input string.
TextAnalyzer[input]: Analyzes a body of text and answers questions about it.
LinkCollector[input]: Collects all URLs contained within a body of text.
SiteLoader[input]: Loads the full text of a website given its URL.

Your plan should follow this format:
Plan: [description of first step]
#E1 = [command using one of the tools]
Plan: [description of next step]
#E2 = [command using one of the tools, possibly referencing #E1]
...
Answer: [#E[n], representing the final answer]

Question: What is the origin story of Batman and who were his creators?

Response:
Plan: Search Wikipedia for information about Batman.
#E1 = WikiSearch[Batman]
Plan: Analyze the retrieved text to find Batman's origin story.
#E2 = TextAnalyzer[What is the origin story of Batman? Given context: #E1]
Plan: Analyze the same text again to find the creators of Batman.
#E3 = TextAnalyzer[Who created Batman? Given context: #E1]
Answer: #E2 and #E3

System: A chat.


Instruction:
Create a sequential plan to respond to the user query utilizing the following tools at your disposal. For each step, provide the necessary function call and store its output as evidence.

Tools:
DuckDuckGo[input]: A tool that enables users to conduct a general internet search via DuckDuckGo search engine.
SiteLoader[input]: Loads the content of a single website provided in the input.
URLFinder[input]: Finds URLs embedded within a block of text.
ALEX[input]: An AI-based question-answering system capable of interpreting context and providing answers.

Output Format:
Step: [action description]
#E[index] = [tool name and input]
...
Final Answer: #E[last index]

Question: When was the first iPhone released and what were its unique features?

Response:
Step: Search for the release date of the first iPhone.
#E1 = DuckDuckGo[first iPhone release date]
Step: Utilize ALEX to interpret the search results and determine the release date.
#E2 = ALEX[When was the first iPhone released? Given context: #E1]
Step: Perform a new search to find the unique features of the first iPhone.
#E3 = DuckDuckGo[first iPhone unique features]
Step: Extract relevant URLs from the search results for further examination.
#E4 = URLFinder[#E3]
Step: Load the content of the most promising site.
#E5 = SiteLoader[#E4]
Step: Use ALEX to analyze the loaded site content and identify the unique features of the first iPhone.
#E6 = ALEX[What were the unique features of the first iPhone? Given context: #E5]
Final Answer: #E6

System: A chat.


Instruction:
Develop a sequential plan to resolve the user's query using the tools listed below. Each step should yield an evidence value corresponding to the output of a specified function with its respective input string.

Available Tools:
1. YahooSearch[input]: Enables users to search for information through the Yahoo search engine. Ideal for identifying potential sources of information relating to the user's query.
2. PageLoader[input]: Accepts a string of newline-separated URLs and retrieves plain text content from these pages.
3. HyperlinkExtractor[input]: Gleans hyperlinks from plain text and presents them as newline-separated strings.
4. BOB[input]: A language model capable of answering queries based on a referenced passage of text. The input should pose a question referencing a :info[n]: variable, e.g., When was the Declaration of Independence signed, given :info1:?

Inputs to each function should merely consist of a plain string devoid of special characters used to concatenate it with an info variable, e.g., BOB[Who wrote Pride and Prejudice, given :info2:?]

Include just one evidence output per plan step.

Output Format:
Plan: [Initial action predicated on input question]
:info0: = [Function to invoke with input parameter]
Plan: [Subsequent action contingent on :info0:'s outcome]
:info1: = [Next function to invoke with input parameter, potentially referencing prior info, e.g., "In light of :info0"]
...
Final Answer: [:info[n]: Contains the conclusive answer.]

Question: Who invented the World Wide Web and what were the key developments leading to its creation?

Response:
Plan: Commence with a web search to identify the inventor of the World Wide Web.
:info0: = YahooSearch[Inventor of the World Wide Web]
Plan: Apply the language model to interpret the search results and pinpoint the inventor's name.
:info1: = BOB[Who invented the World Wide Web, given :info0:?]
Plan: Undertake another web search to discover the key developments preceding the creation of the World Wide Web.
:info2: = YahooSearch[Key developments leading to the creation of the World Wide Web]
Plan: Select relevant hyperlinks from the Yahoo search results for detailed scrutiny.
:info3: = HyperlinkExtractor[:info2:]
Plan: Leverage the PageLoader tool to extract information from the chosen hyperlinks.
:info4: = PageLoader[:info3:]
Plan: Ultimately, utilize the language model to identify and summarize the key developments leading to the creation of the World Wide Web from the extracted information.
:info5: = BOB[What were the key developments leading to the creation of the World Wide Web, given :info4:?]
Final Answer: :info5:

System: A chat.


Instruction:
Please formulate a comprehensive strategy to tackle the ensuing inquiry. Every stage should detail a function to execute alongside its input. Capture the result of each function in a designated :Info[index]: variable, which can then be referred to in subsequent stages.

Accessible Functions:
AskJeeves[input]: Performs an Ask Jeeves search for the input phrase and delivers a collection of possible sources.
HyperlinkExtractor[input]: When fed a block of text (like the output from an AskJeeves search), this function identifies all URLs embedded within the text.
PageLoader[input]: Accesses the page at the provided URL and converts its contents into plain text.
BrainNet[input]: A sophisticated AI-powered question-answering mechanism capable of delivering straightforward replies to a wide range of inquiries. It can also formulate answers based on contextual data (e.g., the text from a webpage).

Output Blueprint:
Plan: [Outline of the initial step]
:Info0: = [Initial step function execution]
Plan: [Outline of the subsequent step]
:Info1: = [Subsequent step function execution]
... Maintain this sequence until ...
Final Answer: :InfoN:

Question: Who painted 'The Starry Night' and what other artworks are they known for?

Response:
Plan: Kick off an Ask Jeeves search to find out who painted 'The Starry Night'.
:Info0: = AskJeeves[painter of 'The Starry Night']
Plan: Leverage BrainNet to sift through the search outcomes and ascertain the painter.
:Info1: = BrainNet[Who painted 'The Starry Night'? Given context: :Info0:]
Plan: Execute another Ask Jeeves search to locate other artworks created by the determined artist.
:Info2: = AskJeeves[:Info1: other artworks]
Plan: Isolate the URLs from the search findings for closer examination.
:Info3: = HyperlinkExtractor[:Info2:]
Plan: Download the content of the top URL from the assortment.
:Info4: = PageLoader[:Info3[0]]
Plan: Ultimately, utilize BrainNet to scan the webpage text and single out the other notable artworks of the artist.
:Info5: = BrainNet[What other artworks is :Info1: known for? Given context: :Info4:]
Final Answer: :Info5:

System: A chat.


Instruction:
Create a step-by-step plan to solve the problem below using the available tools. Each plan should correspond to an evidence value, which will be the output of one of the functions when given an input string.

Here are the tools you can use:
DuckDuckGo[input]: A tool that enables users to perform searches using DuckDuckGo's search engine. It finds potential sources of answers but doesn't directly answer the question.
PageScraper[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and the output is plain text containing the content of the links.
URLExtractor[input]: Extracts URLs from plain text and outputs a plain text, newline-delimited response of URLs.
QueryMaster[input]: A question-answering language model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., How tall is the Eiffel Tower, given :evidence1:?

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

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

The output should follow this 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, which may include reference to previous evidence, e.g., "Given context :evidence0"]
...
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: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2019.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2019 winner]
Plan: Use the language model to parse the search results and determine the winner.
:evidence1: = QueryMaster[Who won the Nobel Prize in Literature in 2019, given :evidence0:?]
Plan: Perform another web search to find the most famous work of the identified laureate.
:evidence2: = DuckDuckGo[Most famous work of :evidence1:]
Plan: Extract relevant URLs from the search results for further investigation.
:evidence3: = URLExtractor[:evidence2:]
Plan: Utilize the PageScraper tool to gather information from the selected URLs.
:evidence4: = PageScraper[:evidence3:]
Plan: Lastly, employ the language model to identify and summarize the most famous work of the laureate from the scraped data.
:evidence5: = QueryMaster[What is the most famous work of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


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

Available Tools:
1. DuckDuckGo[input]: A tool allowing users to search for information via the DuckDuckGo search engine. While it does not provide direct answers, it offers a list of potentially useful sites.
2. WebCrawler[input]: Loads one or more websites from the input string (containing newline delimited links) and outputs plain text content from these links.
3. URLExtractor[input]: Pulls out links from plain text, providing a plain text, newline delimited list of links.
4. AnswerBot[input]: A question-answering language model capable of answering queries based on a given passage of text. The input should be a textual question that references an :evidence[n]: variable.

Output Format:
Plan: [Initial Action]
:evidence0: = [Function Call With Input Parameter]
Plan: [Subsequent Action Based On Result Of :evidence0:]
:evidence1: = [Next Function Call And Input Parameter, Potentially Referring To Previous Evidence]
...
Final Response: [:evidence[n]: Containing The Final Answer]

Question: Who founded Amazon and what are some notable products they've launched?

Response:
Plan: Begin by performing a web search to determine the founder of Amazon.
:evidence0: = DuckDuckGo[Founder of Amazon]
Plan: Use the AnswerBot to interpret the search results and identify the founder.
:evidence1: = AnswerBot[Who is the founder of Amazon, given :evidence0:?]
Plan: Perform another web search to discover notable products launched by Amazon.
:evidence2: = DuckDuckGo[Notable products launched by Amazon]
Plan: Extract relevant links from the search results for further investigation.
:evidence3: = URLExtractor[:evidence2:]
Plan: Load the content of the extracted links.
:evidence4: = WebCrawler[:evidence3:]
Plan: Finally, use the AnswerBot to summarize the key products launched by Amazon from the loaded content.
:evidence5: = AnswerBot[What are some notable products launched by Amazon, given :evidence4:?]
Final Response: :evidence1:, :evidence5:

System: A chat.


Instruction:
Generate a plan to answer the user's question using the tools below. Each plan should have a corresponding evidence value.

Tools Available:
1. BingSearch[input]: Searches Bing for information.
2. DataInterpreter[input]: Interprets data and extracts useful information.
3. QABot[input]: Answers questions using AI technology.

Output Format:
Plan: [First Step]
$E1 = [Tool with Input]
Plan: [Second Step]
$E2 = [Next Tool with Input]
...
Final Answer: $En

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

Response:
Plan: Conduct a search to find the current population of Tokyo.
$E1 = BingSearch[Tokyo current population]
Plan: Interpret the search results to find the exact population.
$E2 = DataInterpreter[$E1]
Plan: Conduct another search to find information on Tokyo's population change over the past decade.
$E3 = BingSearch[Tokyo population change over the past decade]
Plan: Interpret the new search results to understand the population trend.
$E4 = DataInterpreter[$E3]
Plan: Combine the two pieces of information into a coherent answer.
$E5 = QABot[What is the current population of Tokyo and how has it changed over the past decade? Given context: $E2 and $E4]
Final Answer: $E5

System: A chat.


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

Here are the tools you can use:
Bing[input]: This tool allows users to search for information using Bing. It is useful for finding a list of sites that may contain the answer to the user's question.
TextScraper[input]: This function extracts text from one or more websites provided as newline-separated links in the input string.
LinkCollector[input]: This tool extracts links from plain text and produces a plain text response with newline-separated links.
KnowledgeBase[input]: A question answering model capable of providing answers 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 dog, given :evidence1:?

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

Remember to include only one evidence output per plan step.

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

Question: 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: = Bing[Nobel Prize in Literature 2019 winner]
Plan: Use the KnowledgeBase tool to interpret the search results and identify the winner.
:evidence1: = KnowledgeBase[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: = Bing[Most famous work of :evidence1:]
Plan: Extract relevant links from the Bing search results for further investigation.
:evidence3: = LinkCollector[:evidence2:]
Plan: Utilize the TextScraper tool to extract information from the extracted links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, use the KnowledgeBase tool to identify and summarize the most famous work of the laureate from the scraped information.
:evidence5: = KnowledgeBase[What is the most famous work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
Please generate a plan to answer the following question using the available tools. Each step of your plan should be followed by an evidence variable that will store the output of the function used in that step.

Available Tools:
Bing[input]: A tool that uses Bing search engine to find relevant websites for the input query.
TextAnalyzer[input]: This tool can analyze a given text and extract key information from it.
LinkPicker[input]: Picks out links from a provided text.
KnowledgeBase[input]: A tool that can answer questions based on general knowledge or specific context provided as input.

Output Format:
Plan: [first action]
#Evidence1 = [function with input parameter]
Plan: [next action]
#Evidence2 = [function with input parameter, possibly referencing previous evidence]
...
Final Answer: #Evidence[n]

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

Response:
Plan: Use Bing to find webpages related to the history of the Eiffel Tower's construction.
#Evidence1 = Bing[History of Eiffel Tower construction]
Plan: Extract links from the Bing search results for more detailed information.
#Evidence2 = LinkPicker[#Evidence1]
Plan: Analyze the content of these links to get detailed information about the Eiffel Tower's construction.
#Evidence3 = TextAnalyzer[#Evidence2]
Plan: Ask KnowledgeBase to identify the main architects involved in the construction of the Eiffel Tower using the analyzed text.
#Evidence4 = KnowledgeBase[Who were the main architects involved in the construction of the Eiffel Tower? Given context: #Evidence3]
Final Answer: #Evidence4

System: A chat.


Instruction:
Create a plan to respond to the user's query using the tools at your disposal. For each step in your plan, indicate the corresponding evidence value, which will be the output of a function given an input string (the user's question, prior evidence values, or both).

Available tools include:
DuckDuckGo[input]: Allows users to conduct searches via DuckDuckGo. Useful for identifying potential sources of information.
WebReader[input]: Reads the contents of a web page when provided with a URL. Outputs the plain text found on the page.
URLPicker[input]: Identifies URLs within a block of text and returns a list of these.
AskJeeves[input]: An AI language model capable of answering questions when provided with a context. Inputs should reference an :evidence[n]: variable.

The output should follow this structure:
Plan: [initial action]
:evidence0: = [call to function with appropriate input]
Plan: [subsequent action, influenced by outcome of :evidence0:]
:evidence1: = [next function call with input parameters, potentially referencing earlier evidence]
...
Final Response: [:evidence[n]: providing the final answer.]

Question: What does the company SpaceX do and what notable achievements have they had?

Response:
Plan: Start by searching DuckDuckGo for information about SpaceX.
:evidence0: = DuckDuckGo[SpaceX]
Plan: Use AskJeeves to determine what SpaceX does based on the search results.
:evidence1: = AskJeeves[What does SpaceX do, given :evidence0:?]
Plan: Search DuckDuckGo again to find information about SpaceX's notable achievements.
:evidence2: = DuckDuckGo[SpaceX notable achievements]
Plan: Extract the URLs from the search results.
:evidence3: = URLPicker[:evidence2:]
Plan: Read the content of the first link from the extracted URLs.
:evidence4: = WebReader[:evidence3:]
Plan: Lastly, use AskJeeves to summarize SpaceX's notable achievements based on the read content.
:evidence5: = AskJeeves[What are the notable achievements of SpaceX, given :evidence4:?]
Final Response: :evidence5:

System: A chat.