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

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

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

Each plan should have only one evidence output.

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

Remember to only include one evidence output per plan step.

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

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


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

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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

Ensure only one evidence output per plan step.

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

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


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

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

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

Ensure that each plan step includes only one evidence output.

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

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


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

Here are the tools that can be used:

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

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

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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

Question: What are some notable achievements of Ada Lovelace?


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

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

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

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


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

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

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

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


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

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

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

Ensure that every plan step includes just one evidence output.

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

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


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

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

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

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

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

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


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

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

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

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


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine. It finds a list of sites that may have the answer.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkGatherer[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIAnswerBot[input]: A question-answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

Here are the tools you can use:
WebSearch[input]: This tool allows the user to search for information on the internet. The function doesn't directly answer the question; it finds a list of sites that may contain the answer.
PageScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: A language model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

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

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


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

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

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

Ensure only one evidence output per plan step.

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

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


Instruction:
A chat. Formulate a step-by-step plan to address the following user request, making use of the available tools. Each stage of your plan should be associated with an evidence value, which will represent the output of one of the available functions given an input string that could be the user's question, earlier evidence values, or both.

These are the tools you can employ:
1. AskJeeves[input]: This tool allows the user to perform an internet search using the Ask Jeeves search engine. It provides a list of potential websites that may contain the answer to the user's query.
2. ContentScraper[input]: This function loads one or more websites from the input string (which contains newline-separated links) and returns the textual content of these sites.
3. LinkMiner[input]: This tool extracts links from plain text and outputs them as a newline-separated list.
4. InfoProcessor[input]: An AI-powered language model capable of answering questions based on an input text passage. The input should be a question that references an :evidence[n]: variable.

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

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


Instruction:
A chat. Create a step-by-step plan to answer the user's question, using the available tools. Each tool has its own unique function and input parameters. The output of each tool can be stored in a variable named :evidence[n]: which can then be used as an input for other tools.

Here are the tools that you can use:

1. WebSearch[input]: This tool allows users to search for information on the internet. It returns a list of websites that may contain the answer to the user's query.
2. TextExtractor[input]: This tool extracts text from a given website link. The input should be one or more links separated by newlines.
3. LinkFinder[input]: This tool finds all the hyperlinks present in a given piece of text.
4. KnowledgeBase[input]: A powerful question answering tool that can provide answers based on common sense, world knowledge, or context provided through an :evidence[n]: variable.

The output format should be as follows:
Plan: [First action]
:evidence0: = [Tool with input parameter]
Plan: [Next action based on result of :evidence0:]
:evidence1: = [Next tool with input parameter, possibly referencing previous evidence]
...
Answer: [:evidence[n]: containing the final answer]

Question: Who is the author of the book "To Kill a Mockingbird" and what are some of their other works?


Instruction:
A chat. Develop a comprehensive plan to respond to the user instruction below, utilizing the set of available tools. Each plan should correlate with an evidence value, which will be the outcome of one of the available functions when provided with an input string that could be the user question, prior evidence values, or a combination of both.

Available tools to use:
DuckDuckGo[input]: Tool allowing users to search for information via the DuckDuckGo search engine. Useful for locating potential sources that may contain the user's desired answer. The function does not directly deliver the answer but identifies possible sources.
URLReader[input]: Loads one or more websites from the input string containing newline-delimited links. The input consists of one or more links, and the output is plain text containing the content of these links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and returns a plain text, newline-delimited list of links.
ELIZA[input]: An AI-based language model proficient at answering queries based on an input text passage. The input needs to be a textual question referring to an :evidence[n]: variable, such as What is the dog's breed, given :evidence1:?

Each function requires a simple string as input, devoid of quotes or "+" to concatenate a string with an evidence variable, like ELIZA[What is France's capital city, given :evidence3:?]

Remember to include only one evidence output per plan step.

Your output should follow this structure:
Plan: [First action to take based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Next action to take, based on the result of :evidence0:]
:evidence1: = [Next function to call and input parameter, which may include references to prior evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

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


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

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

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

Question: What are some notable achievements of Marie Curie?


Instruction:
A chat. Generate a systematic plan to answer the user's query utilizing the following resources. Every plan should have a corresponding evidence value, which will be the output of one of the accessible functions given an input string that could be the user's question, one or more prior evidence values, or a combination of both.

Tools at your disposal:
DuckDuckGo[input]: A tool that enables users to conduct internet searches using the DuckDuckGo search engine. It does not directly provide answers but offers a list of sites that might contain the needed information.
TextExtractor[input]: Retrieves all text from the supplied URL(s), where the input is one or more URLs, and generates a plaintext output containing the site's content.
HyperlinkDetector[input]: Identifies hyperlinks within plaintext and returns a plaintext, newline-separated list of links.
AIML[input]: An AI-driven language model adept at answering queries based on a provided text passage. The input should be a textual question referencing an :evidence[n]: variable, such as What is the dog's breed, given :evidence1:?

Output format:
Plan: [initial action based on the input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action, based on the outcome of :evidence0:]
:evidence1: = [next function to call and input parameter, potentially referring to prior evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the ultimate answer.]

Question: Who wrote the book 'To Kill a Mockingbird' and what other books did they write?


Instruction:
A chat. Please generate a step-by-step plan to answer the user query, making use of available tools. Each plan will be associated with an evidence value which is the output from one of the functions given an input string that can be the user question, previous evidence values or both.

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

The input to each function should just be a plain string, without quotes or "+" to concatenate a string with an evidence variable.

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

Question: What are some famous works by the author who wrote "To Kill a Mockingbird"?


Instruction:
A chat. Formulate a detailed execution plan to address the user's inquiry using the below-mentioned tools. Each step in the plan corresponds to an evidence value, derived from the output of one of the accessible functions. The input string to these functions can either be the user's question, prior evidence values, or a mix of both.

Tools at disposal:
YahooSearch[input]: Allows users to conduct online searches through Yahoo. Helpful in identifying possible sources containing the required information.
SiteLoader[input]: Retrieves the textual content from the websites mentioned in the input string.
HyperlinkExtractor[input]: Processes a text string and returns all the hyperlinks contained within it.
QuerySolver[input]: An artificial intelligence model adept at answering queries when supplied with contextual information. The input needs to be a text question that refers to a :evidence[n]: variable.

Output structure:
Plan: [Initial action]
:evidence0: = [Function to call along with input]
Plan: [Following action dependent on :evidence0:'s outcome]
:evidence1: = [Subsequent function to invoke with input, possibly referring to :evidence0:]
...
Answer: [:evidence[n]: embodying the final response.]

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


Instruction:
A chat. Formulate a step-by-step plan to solve the problem using the tools at your disposal. You need to store the outcome of each tool in a variable named :evidence[n]: that can be used in subsequent steps.

Available Tools:
DuckDuckGo[input]: Searches DuckDuckGo for general information related to the input query.
SiteScraper[input]: Scrapes the contents of a website from the provided link(s).
HyperlinkHarvester[input]: Harvests all hyperlinks from the provided text.
AIAnswerer[input]: An AI-powered tool that provides answers to questions based on the provided context.

Format:
Plan: [Initial action]
:evidence0: = [Chosen tool with input]
Plan: [Subsequent action based on :evidence0:]
:evidence1: = [Next chosen tool with input, potentially referring to :evidence0:]
...
Answer: [:evidence[n]: containing the final answer]

Question: Who invented the internet and what was their primary motivation?


Instruction:
A chat. For the following tasks, make plans that can solve the problem step-by-step. For each plan, indicate which external tool together with tool input to retrieve evidence. You can store the evidence into a variable #E[index] that can be called by later tools.

Here are the tools available to be called:
WikiSearch[input]: Tool that allows the user to search for information from Wikipedia.
AskJeeves[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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

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

Question: Who was responsible for inventing the telephone and what were their main motivations?


Instruction:
A chat. Construct a systematic plan to resolve the ensuing question using the specified tools. Each phase of the plan should culminate in an evidence value, created by executing a function with an input string that can be the original question, previous evidence, or a mixture of both.

You can make use of the following tools:
InfoFinder[input]: Performs a wide-ranging online search based on the input string. Although it doesn't deliver direct answers, it generates a collection of potential information sources.
ContentExtractor[input]: Retrieves text from one or more URLs included in the input string (separated by newlines) and outputs it as plain text.
HyperlinkCollector[input]: Gathers hyperlinks from any given plain text and presents them as newline-separated plain text.
AnswerGenerator[input]: A sophisticated AI model designed to answer questions using general global knowledge or specific context sourced from prior evidence.

Function inputs should consist of basic strings, free of quotation marks or "+" symbols used for string concatenation, e.g., AnswerGenerator[What is the largest ocean, given :evidence3:?]

Make certain that each plan phase aligns with exactly one evidence output.

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

Question: What is quantum computing and where is it primarily being developed?


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

Here are the tools available to be called:
Bing[input]: A tool that allows the user to search for information on Bing. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from a website link and produces plain text containing the content of the link.
LinkGatherer[input]: Gathers links from plain text and generates a plain text response of links.
AIML[input]: An AI model capable of 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 inputs should be plain strings without quotes or "+" to concatenate a string with an evidence variable, e.g., AIML[What is the capital of France, given :data3:?]

Ensure only one evidence output per plan step.

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

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


Instruction:
A chat. Design a plan to respond to the user's instruction utilizing the below tools. Every plan should come with an associated evidence value, which is the output of one of the available functions when provided with an input string.

The tools available are:
NetSurfer[input]: Allows the user to search for information online. This tool finds a list of sites that could potentially contain the answer to the user's question.
PageReader[input]: Loads one or more websites from the input string containing newline-separated links. The input is one or more links, and it produces plain text output containing the content of the links.
HyperlinkGatherer[input]: Extracts links from plain text and produces a plain text, newline-separated response of links.
InfoAnalyzer[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 a :info[n]: variable, e.g., What breed is the dog, given :info1:?

Each function's input should simply be a plain string, without quotes or "+" to concatenate a string with an info variable, e.g., InfoAnalyzer[What is the population of Tokyo, given :info3:?]

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

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

Question: Who is the founder of Microsoft and what are some of the key products they have developed?


Instruction:
A chat. Please generate a step-by-step plan to answer the user's question, using the available 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 that can be the user question, one or more previous evidence values, or a combination of both.

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

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

Question: Who designed the Eiffel Tower and what were some of their other notable works?


Instruction:
A chat. Develop a step-by-step execution plan to respond to the user's inquiry, making use of the available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more previous evidence values, or a combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables the user to search for information using the DuckDuckGo search engine. It helps in locating suitable sites that might contain the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and generates plain text output containing the content of the links.
UrlExtractor[input]: Extracts URLs from plain text and produces a plain text, newline delimited response of URLs.
ALM[input]: An advanced language model for answering questions based on an input passage of text. The input should be a text question that refers to a :doc[n]: variable, e.g., How tall is the Eiffel Tower, given :doc1:?

Each function's input should just be a plain string, without quotes or "+" to concatenate a string with a doc variable, e.g., ALM[Who is the author of War and Peace, given :doc3:?]

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

The output should be in this format:
Plan: [First action to take based on the input question]
:doc0: = [Function to call with input parameter]
Plan: [Next action to take, based on the result of :doc0:]
:doc1: = [Next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :doc0"]
...
Final Answer: [:doc[n]: Containing the final answer.]

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


Instruction:
A chat. Please provide a detailed plan to answer the following question using the available tools. Each step of your plan should be followed by an evidence value, which will represent 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 have at your disposal:
WebSearch[input]: A tool that allows users to search for information on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from web pages given a list of URLs separated by newlines. The function produces plain text output containing the content of the links.
LinkCollector[input]: Collects all links present in a block of text and outputs them as a newline-separated list.
QAEngine[input]: A tool that answers questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

Question: What is the main ingredient in a traditional Greek moussaka and what does it taste like?


Instruction:
A chat. Create a step-by-step plan to generate an appropriate response to the user's query, using the available tools. Each plan should be followed by one 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:
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.
HTMLParser[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
NLPModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable.

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

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


Instruction:
A chat. Create a detailed plan to respond to the following query using the listed tools. Each plan step should correspond to an evidence value, which will be the output of a specific function provided an input string.

Available tools:
DuckDuckGo[input]: A tool that enables users to perform searches using DuckDuckGo. It provides a list of potentially relevant sites but does not directly answer the query.
PageParser[input]: Takes one or more URLs (separated by newlines) as input and outputs the plaintext contents of those pages.
URLExtractor[input]: Outputs a plaintext list of URLs extracted from the input text.
ALICE[input]: A language model designed to answer questions based on an input text passage. Questions must refer to an :evidence[n]: variable, such as "What is the main theme of the book, given :evidence1:?"

Output format:
Plan: [First action based on the input question]
:evidence0: = [Function to call with its input]
Plan: [Next action, based on the outcome of :evidence0:]
:evidence1: = [Next function to call with its input, possibly referencing prior evidence like "Given :evidence0:"]
...
Final Answer: [:evidence[n]: containing the ultimate answer]

Question: Who wrote the novel '1984' and what are some of his other works?


Instruction:
A chat. Provide a detailed execution plan to answer the following question, utilizing the set of available tools. For each plan, indicate which external tool along with its input to gather evidence. You can store the evidence into a variable #E[index] that can be referred later.

Here are the tools available to be called:
Bing[input]: A tool that lets you perform searches using Bing search engine. It provides a list of sites that might contain the answer to your query.
PageLoader[input]: Loads one or more websites from the input string containing newline delimited links. Input is one or more links, and it produces plain text output containing the content of the links.
URLExtractor[input]: Extracts URLs from plain text and gives a plain text, newline delimited response of URLs.
KnowledgeAI[input]: A question-answering AI model that answers questions based on an input passage of text. The input must be a text question that refers to a #E[n] variable.

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

Question: What is the primary diet of the Giant Panda and where is it commonly found?


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

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

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

Question: What is the most popular dish in Italy and what are its main ingredients?


Instruction:
A chat. Create a sequential plan to address the user's request using the available tools. Each step in the plan corresponds to an evidence value, which will be the outcome of one of the accessible functions given an input string. This string could be the user's question, one or more preceding evidence values, or a mix of both.

Available tools are as follows:
YahooSearch[input]: Allows users to retrieve information via the Yahoo search engine. This tool is effective at generating a list of potential sites that may hold the answer to the user's inquiry. It does not directly answer the question but identifies a list of sites that might contain the answer.
SiteReader[input]: Takes one or more website URLs from the input string (separated by newlines) and outputs plain text content from those sites.
URLExtractor[input]: From plain text, extracts URL links and generates a plain text response with newline-separated links.
InfoProcessor[input]: A question-answering language model adept at providing answers based on a supplied text passage. The input needs to be a textual question referencing a :data[n]: variable, such as "What is the capital of France, given :data1:?"

The output should follow this format:
Plan: [initial action based on the input question]
:data0: = [function to call with input parameter]
Plan: [subsequent action based on the result of :data0:]
:data1: = [the next function to call and input parameter, possibly referring to earlier data, like "Given context :data0"]
...
Answer: [:data[n]: contains the final answer.]

Question: Which architect designed the Guggenheim Museum Bilbao and what other notable buildings did they design?


Instruction:
A chat. Generate a step-by-step plan to solve the following problem using these available tools. Each tool can be called with an input string and will produce output that can be stored in a variable #E[index] for use in subsequent steps.

Available Tools:
WebSearch[input]: This tool uses a search engine to find relevant websites based on the input query.
TextExtractor[input]: This tool extracts all text from a webpage given its URL.
QA[input]: This tool answers questions using general knowledge or specific context provided as part of the input.
LinkFilter[input]: This tool filters out irrelevant links from a list of URLs, leaving only those likely to contain useful information.
PageReader[input]: This tool reads webpages and produces a summary of their content.

The output should follow this format:
Plan: [description of first action]
#E1 = [first function call with input]
Plan: [description of next action]
#E2 = [next function call with input]
...
Final Answer: #E[n]

Question: What are some common symptoms of diabetes?


Instruction:
A chat. Please generate a strategy to respond to the user's instruction by utilizing the set of available tools. Each stage of the plan should correspond to one piece of evidence, which will be the result of one of the functions given an input string.

Here are the tools at your disposal:
WebCrawler[input]: A tool that crawls the web for information related to the input string.
TextAnalyzer[input]: A tool that analyzes text and extracts key points based on the input context.
LLM[input]: A language model that answers questions based on an input passage of text.
LinkExtractor[input]: Extracts links from plain text and produces a list of links.

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

Remember to include only one evidence output per plan step.

The output format should be:
Plan: [first action]
:evidence0: = [function with input parameter]
Plan: [next action]
:evidence1: = [next function with input parameter, possibly referring to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who invented the telephone and what were their other significant contributions?


Instruction:
A chat. Please provide a detailed execution plan to solve the following problem. For each step of the plan, indicate which external tool along with its input would be used to gather evidence. You can store the evidence into a variable named :info[index] that can be referred to later.

Available tools:
YahooSearch[input]: Allows users to search for information on Yahoo. It helps in finding suitable sites that might contain the answer to the user's query.
PageReader[input]: Reads one or more webpages from an input string containing newline-separated links. The output is plain text containing the contents of the links.
HyperlinkFinder[input]: Finds hyperlinks from plain text and outputs a plain text, newline-separated list of links.
IntelliAnswer[input]: An intelligent language model capable of answering questions based on an input text passage.

Output format:
Plan: [First action based on input question]
:info1: = [Function to call with input parameter]
Plan: [Next action based on result of :info1:]
:info2: = [Next function to call and input parameter, which may include reference to previous evidence, e.g. "Given context :info1"]
...
Final Answer: :info[n]:

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