Instruction:
A chat. As an AI agent, select the best function and parameters from the list of available functions below based on the user's input. The response should be formatted in JSON.

Input: I want to find all documents that mention "climate change" between 2010 and 2020.

Available functions:
pdf_analytics:
  description: This tool is useful for extracting specific information from PDF files.
  params:
    action: The action we want to perform on the data, such as "extract_text", "search_term", etc.
    filters:
      term: The keyword or phrase we want to search for.
document_search:
  description: Helps users locate specific documents by converting their query into a series of search terms and filters.
  parameters:
    search_terms: List of keywords and/or phrases that are important to the user's query.
    date_range:
      begin: Limit results to items with a date greater than or equal to this value.
      end: Limit results to items with a date less than or equal to this value.
csv_parser:
  description: Parses CSV data for various operations like filtering, counting, grouping, etc.
  params:
    action: The operation we want to perform on the data, such as "count", "filter", "grouped_count", etc.
    filters:
      column: The column we want to filter on.
      value: Explicit value to filter on.


Instruction:
A chat. As an AI agent, select the most suitable function and parameters from the list of available functions below based on the user input. Provide your response in JSON format.

Input: I want to know how many times 'AI' is mentioned in my document.

Available functions:
- word_count:
    description: This tool counts the frequency of a specific word or phrase in a text.
    parameters:
      word: The word or phrase we want to count its occurrence.
- document_search:
    description: Helps users find information within their documents by converting the query into search terms.
    parameters:
      search_terms: List of keywords that are important to the input.
      alternatives: List of alternative keywords which are variations of the actual input keywords.
- data_extraction:
    description: Extracts specific data from a given source.
    parameters:
      data_type: Type of data to extract (e.g., email addresses, phone numbers).
      source: Source from where to extract the data.


Instruction:
A chat. As an AI assistant, please select the most suitable function and parameters from the list of available functions below, based on the user input. Provide your response in JSON format.

Input: I want to find articles about climate change published between 2010 and 2020.

Available functions:
data_visualization:
  description: This tool helps visualize data in various forms such as bar charts, pie charts, etc.
  params:
    chart_type: The type of chart we want to generate (e.g., "bar", "pie").
    data_source: The source of the data for the chart.
article_search:
  description: Helps users find articles by converting their query into search terms and filters.
  parameters:
    keywords: List of important keywords/phrases from the user's query.
    date_range:
      start: Limit results to articles with a publication date greater than or equal to this value.
      end: Limit results to articles with a publication date less than or equal to this value.
text_analysis:
  description: Analyzes text for sentiment, key phrases, entities, etc.
  params:
    action: The specific analysis action to perform (e.g., "sentiment_analysis", "entity_recognition").


Instruction:
A chat. As an agent, choose the best-suited function and parameters from the given options according to the user's request. Your answer should be formatted in YAML.

Input: I need to count how many times each product category appears in my sales data CSV file.

Available functions:
search:
  description: Help the user find information by converting the input query into a series of search terms and filters that may help pinpoint the location of the information.
  parameters:
    search_terms: List of keywords and/or phrases that are of high importance to the input.
    alternatives: List of alternative keywords and/or phrases that are of high importance to the input, which are variations of the actual input keywords/phrases. For example, acronyms, common alternate synonyms, etc.
  date_range:
    begin: Limit results to items with date greater than or equal to this value, if provided in input query.
    end: Limit results to items with date less than or equal to this value, if provided in input query.
csv_analytics:
  description: This tool is useful in performing various aggregations, counts, etc. from CSV data.
  params:
    action: The action we want to perform on the data, such as "count", "filter", "grouped_count", etc.
    filters:
      column: The column we want to filter on.
      value: Explicit value to filter on.
      expression: Expression value to filter on.


Instruction:
A chat. As an AI assistant, pick the fitting function and parameters from the list based on the user input. Answer in YAML format.

Input: Generate a pie chart from the sales data.

Available functions:
data_visualization:
  description: Visualize data in various forms like graphs, charts, etc.
  params:
    chart_type: Type of chart to generate.
    data_source: Source of data to visualize.
csv_analytics:
  description: Perform aggregations, counts, etc. from CSV data.
  params:
    action: Action to perform on the data, such as "count", "filter", "grouped_count", etc.
    filters:
      column: Column to filter on.
text_analytics:
  description: Analyze text data for insights.
  params:
    action: What you want to do with the text, such as "sentiment_analysis", "keyword_extraction", etc.
    filters:
      language: Language of the text.


Instruction:
A chat. As an AI assistant, select the best-suited function and parameters from the list of available functions given below, based on the user's command. Deliver your response in JSON format.

Input: I need to know the average temperature for July from the weather dataset.

Available functions:
weather_analysis:
  description: Perform different analyses on weather data.
  params:
    action: What we want to do with the data, like "average", "min", "max", etc.
    month: Month for which we want to perform the analysis.
data_visualization:
  description: Generate visualizations such as graphs, charts etc. from provided data.
  params:
    chart_type: Type of chart to generate (e.g., bar, line, pie).
    data_source: Source of data to use for the visualization.
csv_export:
  description: Export data into CSV format.
  params:
    file_name: Name of the exported file.
    data_source: Source of data to export.


Instruction:
A chat. Please choose the most suitable function and its parameters from the given list based on the user input. Your answer should be formatted in YAML.

Input: Find articles about climate change published between January and March 2020.

Available functions:
- article_search:
    description: Finds articles based on user-defined criteria.
    parameters:
      topic: Topic of interest.
      date_range:
        start: Beginning of the time range.
        end: End of the time range.
- csv_analytics:
    description: Performs various operations on CSV data.
    params:
      action: Action to be performed on the data ("count", "filter", "grouped_count").
      filters:
        column: Column to filter on.
        value: Value to filter on.
        expression: Expression to filter on.
- text_analysis:
    description: Analyzes text for sentiment, key phrases, entities, etc.
    parameters:
      text: Text to analyze.
      language: Language of the text.


Instruction:
A chat. Acting as an AI agent, choose the best-suited function and parameters from the list of available functions given the user's request. Please provide your answer in YAML format.

Input: I need to extract information from the 'name' and 'address' columns of my database.

Available functions:
text_analysis:
  description: Analyzes text for sentiment, key phrases, language, and entities.
  parameters:
    text: The text to analyze.
database_query:
  description: Executes SQL queries on a database.
  parameters:
    sql_query: The SQL query to execute.
data_extraction:
  description: Extracts data from specified columns in a database.
  params:
    column_names: Names of the columns from which data is to be extracted.


Instruction:
A chat. As an AI assistant, choose the right function and parameters from the provided list based on the user's requirement. Please provide your response in JSON format.

Input: Count the number of times 'pandemic' appears in the document.

Available functions:
- word_counter:
    description: Counts the occurrence of a particular word in a document.
    parameters:
      word: The word whose occurrences need to be counted.
- text_search:
    description: Finds specific phrases or keywords within a body of text.
    parameters:
      search_phrase: The phrase or keyword that needs to be found.
- document_filter:
    description: Filters out documents based on certain criteria.
    parameters:
      filter_criteria: The criteria upon which to filter the documents.


Instruction:
A chat. As an AI agent, please select the most suitable function and parameters from the list of available functions below, based on the provided user input. Provide your response in JSON format.

Input: I want to find articles about climate change published between 2010 and 2020.

Available functions:
content_filtering:
  description: This tool helps users filter out unwanted content by using specific keywords or phrases.
  parameters:
    keywords: List of words that are important to the user's query.
    exclude: List of words that should be excluded from the results.
date_filtering:
  description: This tool allows users to narrow down their search results within a certain date range.
  parameters:
    start_date: Start of the date range.
    end_date: End of the date range.
search:
  description: Help the user find information by converting the input query into a series of search terms and filters that may help pinpoint the location of the information.
  parameters:
    search_terms: List of keywords and/or phrases that are of high importance to the input.
    alternatives: List of alternative keywords and/or phrases that are of high importance to the input, which are variations of the actual input keywords/phrases.  For example, acronyms, common alternate synonyms, etc.
  date_range:
    begin: Limit results to items with date greater than or equal to this value, if provided in input query.
    end: Limit results to items with date less than or equal to this value, if provided in input query.


Instruction:
A chat. You're acting as an intelligent agent. Please choose the appropriate function and its parameters from the following list based on the given user input. Your response should be formatted in YAML.

Input: Filter out rows from the dataset where the 'age' column is less than 18.

Available functions:
filter_data:
  description: Filters data based on certain conditions.
  parameters:
    column: The column name to apply the filter on.
    condition: The condition to meet for the filter (e.g., 'greater_than', 'less_than', 'equal_to').
    value: The value to compare against when applying the filter.
sort_data:
  description: Sorts data based on a specified column.
  parameters:
    column: The column name to sort the data on.
    order: The order to sort the data in ('asc' for ascending, 'desc' for descending).


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.

Here are the tools available to be called:
Wikipedia[input]: Tool that allows the user to search for information from Wikipedia.
GoogleScholar[input]: Tool that allows the user to search for academic papers and articles.
QRCodeGenerator[input]: Tool that generates QR codes for any input text.
URLShortener[input]: Tool that shortens long URLs.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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

Question: I need a shortened URL and a QR code for the Wikipedia page of Quantum Computing and also find me some recent research papers on the same topic.


Instruction:
A chat. Please provide a step-by-step plan to answer the following user query using the tools available. For each step, indicate which tool will be used and what input it will take. Store the output of each tool in a variable :evidence[n]: that can be referred to by subsequent steps.

The tools available are:
1. WikiSearch[input]: A tool that allows users to search for information from Wikipedia.
2. QAModel[input]: A tool that answers questions based on general knowledge or given context.
3. GoogleNews[input]: A tool that fetches latest news articles related to the input string.
4. PatentDB[input]: A tool that retrieves patent details for a specific person or company.
5. GeoInfo[input]: A tool that provides geographical information about a location.

Output should follow this format:
Plan: [action to be taken]
:evidence0: = [tool to use with its input]
...
Answer: [:evidence[n]: containing the final answer]

Question: What is the highest peak in the Andes mountain range and who was the first person to climb it?


Instruction:
A chat. Formulate a comprehensive plan to answer the user's question using the tools provided. Each step in the plan should be followed by a piece of evidence generated by one of the tools.

Tools:
YahooSearch[input]: Performs a Yahoo search and returns the results.
WebReader[input]: Reads the contents of a webpage and returns the text.
LinkGatherer[input]: Gathers all links contained within a text.
JARVIS[input]: An advanced AI model that can answer questions based on provided context.

Output Format:
Action: [description of action]
:EvidenceN: = [ToolName[Input]]
...
Final Response: :EvidenceN:

Question: What is the average lifespan of a Giant Tortoise and where do they typically live?


Instruction:
A chat. Generate a detailed execution plan to respond to the following user query using the listed tools. Each step in your plan should correspond to an evidence value, which will be the output of one of the provided functions after processing an input string. This string could be the user's question, a previously obtained evidence value, or a combination of both.

Tools at your disposal:
Encyclopedia[input]: A tool that searches for information within an online encyclopedia. It's great for learning about historical events, biographical details, geographical facts, etc.
QA_Tool[input]: A tool capable of answering questions directly based on common knowledge or using provided context that might contain the answer.
ImageFinder[input]: A tool that finds images related to the input query.
ImageAnalyzer[input]: A tool that analyzes images and provides descriptions of them.

Your output should follow this structure:
Plan: [First action based on the user's question]
#E1 = [Function to call along with the necessary input]
Plan: [Subsequent action based on #E1's result]
#E2 = [Next function to call with required input, possibly referencing prior evidence like "Given context #E1"]
...
Final Answer: #E[n]

Question: Who was Leonardo da Vinci and what were some of his famous works?


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

Available Tools:
SearchEngine[input]: A tool that allows you to search for information on the internet. The input should be a query string and the output is a list of links that may contain relevant information.
WebScraper[input]: This tool extracts text from one or more websites provided as newline separated links in the input string.
LinkExtractor[input]: Extracts all links from plain text and produces a plain text, newline delimited response of links.
TextAnalyzer[input]: Analyzes the given text and provides useful insights about it.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

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 some of the popular dishes in Italian cuisine and what ingredients do they require?


Instruction:
A chat. Formulate a step-by-step plan to answer the user's question using the provided tools. Each plan should correspond to an evidence value.

Tools Available:
YahooSearch[input]: Searches Yahoo for information related to the input. Can help locate possible sources of answers.
SiteLoader[input]: Loads the content of one or more websites provided as newline-delimited links in the input string.
LinkGatherer[input]: Extracts links from plain text and provides a plain text, newline-delimited list of links.
NLM[input]: A question-answering language model. Particularly useful for answering questions based on a given passage of text.

Output Format:
Plan: [First action based on input question]
:Evidence1: = [Function to call with input parameter]
Plan: [Next action based on result of :Evidence1:]
:Evidence2: = [Next function to call with input parameter, possibly referencing previous evidence]
...
Answer: [:Evidence[n]: Containing the final answer]

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


Instruction:
A chat. Create a plan to answer the following question using the available tools. For each step, provide an action and corresponding tool input that will help solve the problem. Store the output of each tool in a variable #E[index] for reference in later steps.

Here are the tools you can use:
SearchEngine[input]: This tool allows you to search for information on the internet. The input should be a string containing your query.
DocumentReader[input]: This tool reads documents or web pages and extracts relevant information based on the given context.
QA[input]: This tool answers questions using common sense, general world knowledge, or from provided context.
DataExtractor[input]: Extracts structured data such as tables or lists from a document or webpage.

The final output should look like this:
Plan: [action]
#E1 = [tool with input parameter]
Plan: [next action]
#E2 = [next tool with input parameter referencing previous evidence if necessary]
...
Final Answer: #E[n]

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


Instruction:
A chat. Create a systematic approach to solve the problem presented below using the tools provided. For each step, indicate the external tool along with the tool input required to retrieve the necessary evidence. You can store the evidence into a variable #E[index] that can be referenced later.

Available Tools:
FactChecker[input]: Tool that verifies factual statements. Useful for checking dates, names, places, etc.
WebSearch[input]: Searches the internet for information related to the input query.
LinkCollector[input]: Collects all the URLs present in the input text.
TextScraper[input]: Scrapes the text from the websites whose URLs are provided as input.
InfoAnalyzer[input]: Answers questions using the context provided in the input.

Each plan should be followed by 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, which may include reference to previous evidence, e.g., "Given context #E1"]
...
Final answer: #E[n]

Question: When was the Eiffel Tower completed and how tall is it?


Instruction:
A chat. Devise a systematic plan to address the following inquiry utilizing the enumerated tools. Each part of the plan corresponds to an evidence value yielded by running one of the designated functions with the user’s question, earlier evidence, or a mix of both as input.

Available Tools:
YahooSearch[input]: Allows users to conduct searches through Yahoo. Useful for locating potential sources but doesn’t offer direct answers.
SiteReader[input]: Reads one or several websites specified in the input string (containing newline-separated links) and provides their text content.
HyperlinkGatherer[input]: Collects hyperlinks from plaintext and delivers them as newline-separated strings.
QuerySolver[input]: An AI model adept at answering questions based on supplied context. The input needs to be a question referencing an :evidence[n]: variable.

Required Output Format:
Plan: [First step determined by the user’s question]
:evidence0: = [Function to invoke with associated input parameters]
Plan: [Next step guided by :evidence0:]
:evidence1: = [Following function to trigger with its inputs, which might incorporate preceding evidence]
…
Final Response: [:evidence[n]: containing the conclusive answer]

Question: What is the tallest mountain in North America and how high is it?


Instruction:
A chat. Create a plan to determine the author and summary of the book "War and Peace".

Available tools:
Goodreads[input]: Retrieves information about books including authors, summaries, and reviews.
BookSummary[input]: Provides a brief summary of a specified book.
AuthorBio[input]: Gives biographical information about a specified author.
QA[input]: Can answer questions using common sense or given context.
GoogleBooks[input]: Searches Google Books database for information about a particular book.

Output format:
Plan: First action
:Evidence0: = function with input parameter
Plan: Next action based on :Evidence0:
:Evidence1: = next function with input parameter referencing previous evidence if necessary
...
Answer: [:Evidence[n]: containing the final answer.]


Instruction:
A chat. Generate a step-by-step plan to respond to the following user query, utilizing the provided tools. Each plan step will correspond to an evidence value, which will be the output of a specific function given an input string that could be the user's question, prior evidence values, or a combination thereof.

Available tools:
DuckDuckGo[input]: A tool enabling users to perform searches via the DuckDuckGo search engine. Useful for locating potential sources of answers to the user's question.
TextExtractor[input]: Extracts textual content from one or more websites specified in the input string, which contains newline-separated links.
HyperlinkHarvester[input]: Gathers hyperlinks from plain text, producing a plaintext, newline-separated list of links.
InquiryEngine[input]: A language model designed to answer questions based on a provided text passage. The input should be a text-based question referencing an :evidence[n]: variable.

Output format:
Plan: [initial action based on input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action, informed by :evidence0:]
:evidence1: = [following function to call and input parameter, potentially referring to earlier evidence]
...
Final Answer: [:evidence[n]: - the final answer]

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


Instruction:
A chat. Generate a step-by-step plan to find out the average lifespan of an African elephant in the wild.

Here are the tools available:
InfoSearch[input]: Tool that allows you to search for information from various online sources.
QA[input]: A 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.
AnimalDatabase[input]: Search database specifically for animal related information.
FactChecker[input]: Verifies the accuracy of the provided statement or fact.

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


Instruction:
A chat. Create a sequential plan to address the following user query using the provided tools. Each stage of your plan should produce an evidence value, derived from the output of a specific tool given its input parameters.

Available Tools:
DuckDuckGo[input]: A tool that enables users to conduct online searches via DuckDuckGo. It generates a list of potentially helpful sites related to the input query.
SiteReader[input]: Loads the contents of one or more websites provided as newline-separated links in the input string.
HyperlinkGatherer[input]: Pulls out links embedded within a body of plain text, producing a newline-separated list of these links.
TextualQA[input]: A question-answering tool that works best when supplied with a textual context. The input should be a question referencing an :EvidenceX: variable.

Output Format:
Plan: [Initial action based on input question]
:Evidence0: = [Tool used with input parameters]
Plan: [Subsequent action influenced by :Evidence0:]
:Evidence1: = [Next tool used with input parameters, possibly referring back to prior Evidence]
...
Final Answer: :EvidenceN:

Question: Who won the 2020 US Presidential Election and what were their main campaign promises?


Instruction:
A chat. Develop a plan to answer the following query utilizing the tools provided. For every step in your plan, assign an evidence value corresponding to the output of a function given an input string. This string could be the user's question, prior evidence values, or a mix of both.

These are the tools you can use:
FactChecker[input]: Searches the internet for facts related to the input string. Useful for verifying factual information.
PageLoader[input]: Loads a webpage from a given URL and outputs the page's text content.
URLFinder[input]: Finds URLs within a block of text and outputs them as a newline-separated list.
KnowledgeQA[input]: A question answering tool that provides answers based on a given text. The input should be a question referencing an :evidence[n]: variable, such as "Who wrote Pride and Prejudice, given :evidence1:?"

Each function should receive a simple string as input, without any quotation marks or "+" symbols to join the string with an evidence variable, like KnowledgeQA[What is the tallest mountain, given :evidence2:?].

Make sure each plan step has just one associated evidence output.

The output should follow this structure:
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, possibly referring to earlier evidence, e.g., "Given context :evidence0"]
...
Final Answer: [:evidence[n]: containing the ultimate response.]

Question: Who was the first person to climb Mount Everest and when did it happen?


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.
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.
AIM[input]: Artificial Intelligence Model for 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 cat, given :data1:?

The output should be in format:
Plan: [first action to take based in 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 data, e.g. "Given context :data0"]
...
Answer: [:data[n]: containing the final answer.]

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


Instruction:
A chat. Create a step-by-step plan to generate an answer for the following user query, 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 :evidence[n]: which can then be used as input for subsequent tools.

The available tools are:

Bing[input]: This tool allows you to search for information using the Bing search engine. It's useful for finding a list of websites that may contain the answer to your question.
LinkCollector[input]: Extracts links from plain text and produces a plain text response containing newline delimited links.
WebReader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
FactFinder[input]: A question answering 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:?

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

Ensure only one evidence output per plan step.

Output format:
Plan: [first action]
:evidence0: = [function call with input parameter]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function 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 2019 and what is their most famous work?


Instruction:
A chat. Develop a plan to answer the following question: "What is the history of the Eiffel Tower and who was its architect?" Here are the tools you can use:

1. WebSearch[input]: This tool allows you to search for information on the web. The input should be a query string.
2. TextExtractor[input]: Extracts text from the webpage given in the input.
3. QA[input]: Tool that answers questions based on common sense, general world knowledge or provided context.

The output format should be as follows:
Plan: [First action]
#E1 = [Function call with input parameter]
Plan: [Next action]
#E2 = [Next function call with input parameter, which may include reference to previous evidence, e.g., "Given context #E1"]
...
Final Answer: #E[n]


Instruction:
A chat. Generate a step-by-step plan to solve the following problem. Use the available tools and assign their outputs to variables :evidence[index]: for future reference.

Available Tools:
DuckDuckGo[input]: A web search tool useful for finding information online.
WebScraper[input]: Tool that loads websites from an input string containing newline separated links and produces plain text content.
URLExtractor[input]: Extracts links from plain text and provides a newline-separated list of links.
SageAI[input]: An AI model capable of answering questions based on an input passage of text.

Output Format:
Plan: [First action]
:evidence0: = [Function call with input]
Plan: [Next action based on :evidence0:]
:evidence1: = [Next function call with input possibly referencing :evidence0:]
...
Answer: [:evidenceN: containing final answer.]

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


Instruction:
A chat. Create a detailed execution plan to solve the following problem. For each step, indicate the external tool to be used along with its input to gather evidence. You can store the gathered evidence into a variable #E[index] that can be referenced later.

Available Tools:
Encyclopedia[input]: A tool that fetches comprehensive information from an online encyclopedia. It accepts a search string as input.
QAEngine[input]: A tool capable of answering queries directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

Output Format:
Plan: [Action to be taken]
#E1 = [Tool to be used with input parameter]
Plan: [Next action, based on result of #E1]
#E2 = [Next tool to be used and input parameter, possibly referencing previous evidence]
...
Final Answer: #E[n]

Question: How does the process of photosynthesis work and what role do chloroplasts play in it?


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.
PageLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkPicker[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
QAModel[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

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


Instruction:
A chat. Generate a plan to solve the following problem using these tools:
Bing[input]: A tool that allows you to search for information using Bing. This function can find a list of sites related to your query, but it doesn't directly answer questions.
WebReader[input]: Load one or more websites from an input string containing newline delimited links and produces plain text output with the content of the pages.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIML[input]: An AI model that answers questions based on an input passage of text. The input must be a question that references a :data[n]: variable.

The format should be as follows:
Plan: [first action]
:data0: = [function call with input parameter]
Plan: [next action based on result of :data0:]
:data1: = [next function call with input parameter referencing previous data if necessary]
...
Answer: [:data[n]: with final answer]

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


Instruction:
A chat. Create a plan that uses the following tools to 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 used later.

Tools:
DuckDuckGo[input]: A tool that allows users to search for information via DuckDuckGo search engine. Useful for general queries about people, places, events, etc.
URLReader[input]: Loads the content of a webpage given its URL. Input is a URL and output is the text content of the page.
HyperlinkFinder[input]: Extracts all hyperlinks from a given text. Input is a block of text and output is a list of URLs found within the text.
ELIZA[input]: An AI language model capable of answering questions when provided with a specific context. It takes as input a question that references a previously stored piece of evidence (e.g., "What is the population of city X, given #E1?").

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

Question: What is the highest peak in the Alps and how high is it?


Instruction:
A chat. Create a step-by-step plan to answer the following question using the tools provided. Each tool should be used in sequence, and each output will serve as evidence for the next step. The evidence can be stored in a variable :E[index]: which can be referred by subsequent tools.

Here are the available tools:
WebSearch[input]: This tool allows you to search the web for information related to the input query.
TextExtractor[input]: Extracts key points from a large body of text, given an input string.
LinkScraper[input]: Scrapes links from a webpage, given an input URL.
InfoAnalyzer[input]: Analyzes information from a given context and answers questions based on that context.

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

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


Instruction:
A chat. Develop a sequential plan to respond to the following query using the provided tools. Every plan should correspond to an evidence value, which would be the output of a specified function given an input string that could be the user's question, one or more 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 is effective in locating a variety of sites that might contain the answer to the user's question.
TextScraper[input]: Loads one or more websites from the input string containing newline separated links. The input is one or more links, and it generates plain text output containing the link contents.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-separated response of URLs.
AskMe[input]: A question-answering language model that excels at answering queries based on an input text passage. The input needs to be a text question that refers to an :evidence[n]: variable.

Output format:
Plan: [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]
...
Final Answer: [:evidence[n]: contains the final answer]

Question: Who is the current Prime Minister of Canada and what are their key policies?


Instruction:
A chat. Develop a step-by-step plan to address the user's request, making use of the available tools. Each step in your plan should correlate with an evidence value, which will be the output of one of the provided functions when supplied with an input string that can be the user's question, previous evidence values, or both.

Here are the tools you can use:
YahooSearch[input]: A tool that enables users to search for information through Yahoo's search engine. This tool helps in locating potential sites that may hold the answer to the user's question. The function doesn't provide a direct answer to the question but finds a list of sites that might contain the answer.
SiteReader[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 featuring the content of these links.
URLExtractor[input]: Extracts URLs from plain text and provides a plain text, newline-delimited response of URLs.
InfoModel[input]: A question-answering language model, especially useful in answering queries based on an input text passage. The input must be a textual question referencing an :evidence[n]: variable, e.g., How tall is Mount Everest, given :evidence1:?

Each function merely requires a straightforward string as input, without any need for quotation marks or "+" to join a string with an evidence variable, e.g., InfoModel[Who is the president of the United States, given :evidence3:?]

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

The output should conform to the following format:
Plan: [Initial action to take based on the input question]
:evidence0: = [Function to call with input parameter]
Plan: [Subsequent action to take, based on the outcome of :evidence0:]
:evidence1: = [Next function to call and input parameter, which may refer to prior evidence, e.g., "Given context :evidence0"]
...
Final Answer: [:evidence[n]: Carrying the final answer.]

Question: Who invented the light bulb and what were some of his other inventions?


Instruction:
A chat. Generate a plan to solve the following query utilizing the tools listed below. Each step in your plan should be associated with 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 a combination of both.

Tools Available:
1. BingSearch[input]: Tool allowing users to conduct a search using the Bing search engine. Useful for identifying potential sources of information related to the user's question.
2. 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.
3. InfoSummarizer[input]: Summarizes large amounts of text into concise points. Input must be a long-form text.
4. FactChecker[input]: Answers factual questions based on an input passage of text.

Output Format:
Plan: [First action based on input question]
#E1 = [Function to call with input parameter]
Plan: [Next action based on #E1's result]
#E2 = [Next function to call with input parameter, potentially referring to prior evidence]
...
Final Answer: #E[n]

Question: Who won the Nobel Prize in Literature in 2019?


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.
LinkGrabber[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 was the impact of the Great Fire of London?


Instruction:
A chat. Draft a progressive plan to fulfill the user directive, employing the supplied collection of tools. Each plan will align with an evidence value, which is the return of one of the enumerated functions after providing an input string that could be the user's question, past evidence values, or both combined.

Provided tools:
ExciteSearch[input]: Tool enabling the user to probe for information via Excite search engine. This tool is beneficial in tracking down a variety of sites that might house the answer to the user's question.
WebRetriever[input]: Grabs one or more websites from the input string featuring newline-split links. The input is one or more links, resulting in plain text output enclosing the content of the links.
LinkSelector[input]: Snags links from plain text, yielding a plain text, newline-separated roster of links.
QAMachine[input]: Question-answering language model, notably efficient in replying to questions founded on an input text passage. The input must be a text-based question that points to an :evidence[n]: variable.

Output format:
Plan: [Commencing action anchored in input question]
:evidence0: = [Function to launch with input parameter]
Plan: [Following action dependent on result of :evidence0:]
:evidence1: = [Next function to launch and input parameter, possibly hinting at previous evidence, e.g., "In relation to :evidence0:"]
...
Terminal Response: [:evidence[n]: possessing the final answer]

Question: Who directed the film 'The Godfather' and what other films have they directed?


Instruction:
A chat. You have been asked to create a plan to solve the following problem using the tools at your disposal. Each step in your plan should specify which tool will be used and what its input will be. You can save the output of each tool into a variable #E[index] for use in subsequent steps.

Here are the tools available to be called:
WikiSearch[input]: This tool performs a Wikipedia search for the specified term.
URLCollector[input]: This tool collects all URLs from a block of text.
PageReader[input]: This tool reads the content of a webpage from a specified URL.
InfoFinder[input]: This tool finds specific pieces of information within a block of text. It can answer questions when provided with a context in the form of a previously saved evidence variable (e.g., "What is the population of Paris? Given context: #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 Leonardo da Vinci and what are some of his most famous works?


Instruction:
A chat. Develop a step-by-step plan to respond to the user query below, making use of the available tools. Each plan step should correspond to an evidence value, representing 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 thereof.

Available tools include:
WikiSearch[input]: A tool allowing users to search Wikipedia for information. Particularly useful for obtaining knowledge about people, places, events, etc. The input should be a search string helping locate the right page.
QAEngine[input]: A tool able to answer questions based on common sense, general world knowledge, or given input context containing the answer.
FactChecker[input]: A tool designed to verify facts by cross-referencing multiple sources.

Remember to limit yourself to one evidence output per plan step.

Your output should follow this format:
Plan: [initial action based on input question]
#Evidence1 = [function to call with input parameter]
Plan: [subsequent action, based on outcome of #Evidence1]
#Evidence2 = [next function to call with input parameter, potentially referring back to prior evidence, e.g., "Given context #Evidence1"]
...
Final Answer: #EvidenceN (where N represents the final piece of evidence)

Question: What was Albert Einstein's contribution to quantum theory and how has it been verified?


Instruction:
A chat. Question: Who was the architect behind the construction of the Sydney Opera House?

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine.
ArchitectDB[input]: This tool provides access to a comprehensive database of architects and their works.
HistoricalRecords[input]: This tool gives access to historical records and documents.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
BuildingFacts[input]: This tool provides factual information about buildings around the world.

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


Instruction:
A chat. Formulate a step-by-step execution plan to address the following query using the provided tools. Each plan will correspond to an evidence value derived from the output of a specific function given an input string.

Available tools:
DuckDuckGo[input]: A tool that enables users to conduct searches via DuckDuckGo search engine. It provides a list of potential sources that might contain answers to the user's query.
PageLoader[input]: Loads one or multiple websites from an input string consisting of newline separated links. Produces plain text output containing the content of these links.
URLExtractor[input]: Retrieves URLs from plain text and generates a plain text, newline-separated list of links.
ELIZA[input]: An AI-based Q&A model adept at answering queries based on an input text passage. Input must be a textual question referencing an :evidence[n]: variable.

Output format:
Plan: [Initial action based on input query]
:evidence0: = [Function to invoke with input parameter]
Plan: [Subsequent action based on outcome of :evidence0:]
:evidence1: = [Next function to invoke with input parameter possibly referencing prior evidence]
...
Final Answer: [:evidence[n]: containing the conclusive answer]

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


Instruction:
A chat. Develop a step-by-step execution plan to respond to the following user inquiry:

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

Here are the tools available to be called:
ScienceDirect[input]: A tool that searches scientific articles for relevant information.
BioTerms[input]: Identifies biological terms and provides brief definitions.
DiagramGenerator[input]: Generates diagrams based on the input parameters.
QA[input]: Tool that can answer questions either directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
TextSummarizer[input]: Summarizes long texts into shorter versions.

Follow the same planning and output format as TSK 1.


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.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
TextAnalyzer[input]: Question answering language model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the most populated city in Australia and what is its main economic activity?


Instruction:
A chat. Please create a step-by-step plan to generate an optimal response to the user instruction, using the set of available tools. Each plan will have a corresponding evidence value, which is the output of one of the functions given an input string that can be the user 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 helps in finding appropriate sites that may contain the answer to the user's query.
WebsiteReader[input]: Loads and reads out content from websites provided as input links.
LinkExtractor[input]: Extracts links from plain text and produces a list of links.
AskJeeves[input]: A question answering language model, 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., AskJeeves[What is the capital of Michigan, given #E3?]

Ensure to include only one evidence output per plan step.

The output should be in format:
Plan: [first action to take based on input question]
#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 invented the telephone and what were their most significant contributions to science?


Instruction:
A chat. Create a plan to answer the following question using the available tools. Each step of your plan should have corresponding evidence 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]: A tool that allows users to search for information on the internet. This function is useful in finding sites that may contain answers 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 links from plain text and provides a plain text, newline delimited response of links.
InfoExtractor[input]: Question answering language model, particularly effective in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

The format of the output 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: What are some notable achievements of the current president of Microsoft?


Instruction:
A chat. Create a plan to respond to the user instruction using the available tools. Store the output of each tool in a variable :evidence[n:].

Tools Available:
WebSearch[input]: Conducts a web search for the input query.
LinkGrabber[input]: Grabs links from the search results.
SiteReader[input]: Reads the contents of a website from a given link.
AIAssistant[input]: Answers a question given a context. Input should include a question and reference to an :evidence[n]: variable for context.

Output Format:
Plan: [First action]
:evidence0: = [Tool and input]
Plan: [Next action based on :evidence0:]
:evidence1: = [Next tool and input, potentially referencing :evidence0:]
...
Answer: [:evidence[n]: containing final answer]

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


Instruction:
A chat. Generate a plan to answer the following question using the tools at your disposal. For each step in your plan, create an evidence variable to capture the output of the tool used in that step.

Available tools:
1. WikiSearch[input]: This tool performs a Wikipedia search using the input string. It returns a verbose output that might contain the required information.
2. QAEngine[input]: This tool can answer questions directly or using a given context. The input should be a question that refers to an #E[index] variable, such as "Who wrote Pride and Prejudice, given context #E1?"
3. SiteScraper[input]: This tool scrapes the content of one or more websites specified by newline-separated URLs in the input.

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

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


Instruction:
A chat. Craft a full-fledged stratagem to crack the looming query. Each sector should earmark a function to jump-start with its coupled input. Conserve the quotient of each function in a denoted :Hint[index]: variable, which can thereupon be invoked in successive sectors.

On-tap Functions:
DogpileSearch[input]: Fires up a Dogpile search for the input vernacular and amasses a heap of likely repositories.
LinkDetector[input]: Furnished a bundle of text (like the output from a DogpileSearch), this function identifies all URLs cocooned within the text.
WebpageMiner[input]: Pilots to the page at the assigned URL and transmutes its contents into plain text.
ZetaSolver[input]: A futuristic AI-infused question-answering apparatus competent at delivering swift solutions to an extensive range of inquiries. It can also contrive answers hinging on ancillary particulars (e.g., the text from a webpage).

Output Layout:
Plan: [Illustration of the premier step]
:Hint0: = [Premier step function jump-start]
Plan: [Illustration of the subsequent step]
:Hint1: = [Subsequent step function jump-start]
... Adhere to this sequence until ...
Final Answer: :HintN:

Question: Who sculpted 'David' and what other masterpieces are they venerated for?


Instruction:
A chat. Create a step-by-step plan to determine the average temperature in July for London over the past decade and compare it to the global average temperature for the same period.

Available tools:
WeatherHistory[input]: Tool that retrieves historical weather data for a specified location and time frame.
GlobalAverageTemperature[input]: Tool that provides the global average temperature for a specific month and year.
CompareNumbers[input]: Tool that compares two numbers and provides a comparison statement.
QA[input]: Tool that answers questions using general world knowledge.

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


Instruction:
A chat. Develop a strategy to respond to the following query by making use of the tools given below. Each step in your strategy should have a corresponding evidence value, which will be the output of one of the available functions given an input string.

Available Tools:
BingSearch[input]: This tool lets you perform a search on Bing's search engine.
WikiScanner[input]: This tool scans Wikipedia articles and returns a summary of the article.
URLCollector[input]: Collects URLs from a block of text.
PageReader[input]: Reads the contents of a webpage.
QuerySolver[input]: A tool that answers questions based on an input passage of text.

Output Format:
Plan: [First step based on input question]
#Evidence1 = [Function to call with input parameter]
Plan: [Next step based on result of #Evidence1]
#Evidence2 = [Next function to call and input parameter, possibly referencing previous evidence]
...
Final Response: #Evidence[n]

Question: What is the population of Tokyo and what is its GDP?


Instruction:
A chat. Create a plan to solve the problem presented in the question below. Each step in your plan should have a corresponding evidence value, which will be the output of one of the available tools given an input string that could be the user question, one or more previous evidence values, or a mixture of both.

Available tools:
BingSearch[input]: A tool that uses Bing's search engine to find information related to the input query.
URLExtractor[input]: Extracts URLs from the provided plain text.
SiteLoader[input]: Loads the contents of one or more websites from the input string, which contains newline-delimited links.
KnowledgeModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that refers to an :evidence[n]: variable.

Output format:
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 may refer to previous evidence]
...
Answer: [:evidence[n]: Containing the final answer]

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


Instruction:
A chat. Create a plan to respond to the following user query utilizing the provided tools. Each step of your plan should correspond to an evidence value which represents the output of a function given its input.

Tools Available:
InfoSeeker[input]: A tool that uses a general search engine to retrieve potentially relevant websites.
TextParser[input]: Parses a block of text and extracts key pieces of information.
URLCollector[input]: Gathers all URLs contained within a given piece of text.
KnowledgeProcessor[input]: Answers questions based on a provided context.

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

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


Instruction:
A chat. Create a detailed plan to respond to the user instruction, making use of the available tools. Each plan should have a corresponding evidence value, which will be the output of one of the available functions given an input string that could be the user's question, one or more prior evidence values, or a combination of both.

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is helpful in finding a suitable list of sites that may or may not contain the answer to the user's question. The function does not directly answer the question but finds a list of sites that may have the answer.
SiteScraper[input]: Load one or more websites from the input string containing newline-delimited links, where the input is one or more links, and produces plain text output containing the content of the links.
URLExtractor[input]: Extract links from plain text and produces a plain text, newline-delimited response of links.
ALICE[input]: Question-answering language model, especially useful in answering questions based on an input passage of text. The input must be a text question that references a :fact[n]: variable, e.g., How tall is the Eiffel Tower, given :fact1:?

The input to each function should just be a plain string, without quotes or "+" to concatenate a string with a fact variable, e.g., ALICE[Who won the 2020 presidential election, given :fact3:?]

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 input question]
:fact0: = [function to call with input parameter]
Plan: [next action to take, based on result of :fact0:]
:fact1: = [next function to call and input parameter, which may include reference to previous evidence, e.g., "Given context :fact0"]
...
Final Answer: [:fact[n]: containing the final answer.]

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


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may contain the answer to the user's question.
TextParser[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 effective in answering questions based on an input passage of text. The input must be a text question that references a :data[n]: variable, e.g. What color is the dog, given :data1:?

The output should be in format:
Plan: [first action to take based in 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 data, e.g. "Given context :data0"]
...
Answer: [:data[n]: containing the final answer.]

Question: Who invented the electric guitar and what were their main contributions to music?


Instruction:
A chat. Create a plan to solve the following question using these available tools. Each tool will generate an evidence value that can be used in subsequent steps.

Here are the tools available to be called:
WebSearch[input]: This tool allows you to search for information on the web, providing a list of websites that may contain relevant information.
TextAnalyzer[input]: Analyzes a given text and provides key points or summaries from it.
QAEngine[input]: A tool that answers questions based on common knowledge or given context.
LinkExtractor[input]: Extracts links from plain text and produces a plain text response containing those links.
WebsiteScraper[input]: Scrapes content from one or more websites provided as newline delimited links.

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

Question: What is the history of Bitcoin and who was its creator?


Instruction:
A chat. Create a detailed execution plan using the following tools to solve the problem presented in the user's query. Each step in your plan should produce some form of evidence, which will be stored in a variable #E[index].

Available Tools:
Encyclopedia[input]: A tool that provides factual information about a wide range of topics.
QA[input]: A tool that answers questions directly based on common sense and world knowledge. It can also answer questions when provided with a context that contains the answer.
NewsArchive[input]: A tool that searches through historical news articles for specific information.
ImageAnalyzer[input]: A tool that analyzes images and returns descriptions of them.

Output Format:
Plan: [First action based on the user's query]
#E1 = [Function to call with appropriate input]
Plan: [Next action based on the result of #E1]
#E2 = [Next function to call with appropriate input, possibly referencing #E1]
...
Final Answer: #E[n]

Question: How did the tradition of Christmas trees start and what do the decorations symbolize?


Instruction:
A chat. Develop a systematic plan to address the user's query using the available tools. Remember to assign an evidence number to each step of your plan.

Tools at your disposal:
BookFinder[input]: A tool for finding books online.
MusicBrainz[input]: A tool for finding music albums and tracks.
MovieDB[input]: A tool for finding information about films.
FoodFacts[input]: A tool for finding nutritional information about food items.
AskMe[input]: A tool that answers questions based on common knowledge or provided context.

Output Format:
Plan: First step based on the input question
#Evidence1 = Function to execute with the necessary input
Plan: Subsequent step depending on the outcome of #Evidence1
#Evidence2 = Next function to run with its input, possibly referring back to prior evidence like "Considering #Evidence1"
...
Final Response: #EvidenceN

Question: Can you recommend a book, a song, a movie, and a healthy snack all related to space exploration?


Instruction:
A chat. Please generate a plan to respond to the user's instruction using the following tools. Each plan will have a corresponding evidence value.

Tools Available:
1. BingSearch[input]: Tool that uses Bing to search for information online. Input is a string representing the search query.
2. TextAnalyzer[input]: Analyzes a piece of text and extracts key information. Can be used to answer questions when provided with relevant context.
3. PageLoader[input]: Loads a webpage and retrieves its text content. Input is a URL or list of URLs.
4. UrlFinder[input]: Finds URLs in a piece of text. Input is a string of text.

Output Format:
Plan: [First action]
:Evidence0: = [Function call with input]
Plan: [Next action]
:Evidence1: = [Next function call with input, possibly referencing previous evidence]
...
Answer: :EvidenceN:

Question: Who won the Nobel Prize in Literature in 2018?


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]: Tool that allows the user to search for information using the DuckDuckGo search engine.  This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebReader[input]: Load one website from the input string containing newline delimited links, where input is one link, and produces plain text output containing the content of the link.
HyperlinkFinder[input]: Extract hyperlinks from plain text and produces a plain text, newline delimited response of links.
InfoModel[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 just just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g. InfoModel[What is the capital of Michigan, given :evidence3:?]

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

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

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


Instruction:
A chat. Generate a plan to solve the problem below using the provided tools. For each step, specify which tool to use along with its input. Store the result into a variable #E[index] that can be referenced by later tools.

Tools Available:
Bing[input]: Tool that allows users to perform a Bing search. The input should be a search string.
WikiLookup[input]: Looks up a Wikipedia page based on the input string.
QA[input]: Can answer questions based on general knowledge or given context.
Translate[input]: Translates the input text to English.

Output Format:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action]
#E2 = [function call with input parameter]
...
Final Answer: #E[n]

Question: What is the significance of the Rosetta Stone and why was it important?


Instruction:
A chat. Formulate a thorough plan to answer the following user query using the provided tools. Each plan will match an evidence value, which will be the output of one of the available functions given an input string that might be the user's question, one or more previous evidence values, or a blend of both.

You can use the following tools:
Yahoo[input]: This tool permits users to carry out information searches through the Yahoo search engine.
LinkLifter[input]: This function extracts links from plain text and returns a plain text list of links.
PagePicker[input]: This tool retrieves one or more websites from an input string containing newline-separated links, where the input is one or more links, and produces plain text content from those links.
KnowledgeBase[input]: This tool executes a search on Knowledge Base for related articles based on the input string.
QuerySolver[input]: This is a question-answering language model skilled at answering questions based on an input text passage. The input must be a text question that refers to a #G[index] variable.

Output format:
Plan: [Initial action taken based on input question]
#G1 = [Function to invoke with input parameter]
Plan: [Following action taken based on the outcome of #G1]
...
Final Solution: #G[n]

Question: What is the Pythagorean theorem and how is it used in geometry?


Instruction:
A chat. Develop a stepwise plan to respond to the following user command, employing the suite of tools available. Each part of your plan should align with an evidence value, which will be the output of one of the available functions when given an input string that could be the user's question, former evidence values, or both.

You can make use of these tools:
1. Baidu[input]: This tool permits the user to execute an internet search using the Baidu search engine. It generates a list of probable websites that may encompass the answer to the user's question.
2. WebExplorer[input]: This function loads one or more websites from the input string (comprising newline-separated links) and renders the textual content of these sites.
3. LinkFinder[input]: This tool sifts through plain text and outputs them as a newline-separated list of links.
4. DataInterpreter[input]: An AI-driven language model proficient at answering questions grounded on an input text passage. The input should be a question that references an :evidence[n]: variable.

The output should conform to the following template:
Plan: [Initial action rooted in the input question]
:evidence0: = [Function invocation with input parameter]
Plan: [Subsequent action hinged on the result of :evidence0:]
:evidence1: = [Next function invocation with input parameter, potentially alluding to previous evidence]
...
Final Answer: [:evidence[n]: containing the conclusive reply]

Question: Can you explain the concept of quantum entanglement and its implications in quantum computing?


Instruction:
A chat. Create a plan to solve the following problem step-by-step. For each step, indicate which tool you will use and what input you will provide to it. You can store the results of these tools in variables #E[index] for future reference.

Here are the available tools:

1. Bing[input]: This tool allows you to search for information using the Bing search engine. It is useful for finding sites that may contain answers to your question. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
2. WebReader[input]: This tool reads one or more websites from an input string containing newline delimited links. Input should be one or more links, and produces plain text output containing the content of the links.
3. LinkPicker[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
4. QAModel[input]: A language model designed to answer questions based on an input passage of text. The input must be a text question that references a #E[n] variable, e.g., What color is the cat, given #E1?

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

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


Instruction:
A chat. Create a plan to identify the main ingredients in traditional Italian lasagna.

Available tools:
RecipeFinder[input]: Searches for recipes based on the dish name.
IngredientExtractor[input]: Extracts list of ingredients from a recipe.
GoogleTranslate[input]: Translates text from one language to another.
QA[input]: Answers questions using general world knowledge or given context.

Output format:
Plan: [first action]
:Evidence0: = [function call with input parameter]
Plan: [next action based on :Evidence0:]
:Evidence1: = [next function call with input parameter referencing previous evidence if necessary]
...
Answer: [:Evidence[n]: containing the final answer.]


Instruction:
A chat. Please provide a step-by-step plan to solve the following question using the tools provided. For each step, indicate which tool you would use and what input you would give it. Store the output of each tool in a variable #E[index] that can be referenced later.

Here are the available tools:
1. GoogleSearch[input]: This tool allows users to search for information on Google. The input should be a query string.
2. TextExtractor[input]: This tool extracts text from web pages. The input should be one or more URLs.
3. QA[input]: This tool answers questions based on common sense, general world knowledge, or given context. The input should be a question string, optionally referencing previous evidence variables.
4. ImageSearch[input]: This tool searches for images related to the input query string.

The output format should be as follows:
Plan: [First action]
#E1 = [Tool with input parameter]
Plan: [Next action]
#E2 = [Next tool with input parameter]
...
Final answer: #E[n]

Question: What is the main diet of the African elephant and where can I find an image of this food?


Instruction:
A chat. Create a plan to answer the following question using the tools provided. For each step, provide an action and the tool used with its input parameter. Store the output of each tool in a variable :evidence[index]: that can be referenced by subsequent steps.

Here are the tools available:
Bing[input]: A search engine that provides a list of websites relevant to the input query.
ReadText[input]: Reads text from a given website URL and produces plain text output containing the content of the page.
LinkExtractor[input]: Extracts links from plain text and produces a newline-delimited response of links.
QA[input]: Answers questions based on common sense, general world knowledge, or given context that may contain the answer.

The output should follow this format:
Plan: [first action]
:evidence0: = [function call with input]
Plan: [next action based on result of :evidence0:]
:evidence1: = [next function call with input, possibly referencing previous evidence]
...
Final Answer: [:evidence[n]:]

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


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:
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: What are some key achievements of Elon Musk and what companies he has founded?


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables users to search for information using the DuckDuckGo search engine. This tool assists in finding suitable sites that may hold the answer to the user's question.
SiteLoader[input]: Loads 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.
HyperlinkGatherer[input]: Extracts links from plain text and delivers a plain text, newline delimited response of links.
Einstein[input]: Question answering language model, especially effective in answering questions based on an input passage of text. The input must be a text question that refers to an :evidence[n]: variable.

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

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


Instruction:
A chat. Please generate a step-by-step plan to answer the following question using the available tools. Each step should have a corresponding 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 available to be called:
SearchEngine[input]: Tool that allows the user to search for information from any search engine. This tool is useful in finding relevant sites that may contain the answer to the user's question.
WebsiteScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkExtractor[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QAtool[input]: A question answering tool that can provide answers based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Ensure to include only one evidence output per plan step.

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

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


Instruction:
A chat. Please generate a step-by-step plan to solve the user instruction, using the available tools. Each plan should be followed by 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]: Tool that allows the user to search for information from Bing. This tool is useful in finding appropriate sites that may contain the answer to the user's question.
URLLoader[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
KLM[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 are some of the notable works of art housed at the Louvre Museum?


Instruction: A chat. [question formatted similarly to the example, including instructions, descriptions of functions, output format, etc.]


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:
BingSearch[input]: Tool that allows the user to search for information using the Bing search engine.
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.
LinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
AIQA[input]: Artificial Intelligence Question answering model, particularly useful in answering questions based on an input passage of text.

The 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 there?


Instruction:
A chat. Develop a step-by-step plan to respond to the user query, utilizing a range of available tools. Each step will yield an evidence value, representing the output of a specific function given an input string - this could be the user's question, earlier evidence values, or a combination of both.

Available tools include:
DuckDuckGo[input]: A tool allowing users to perform searches via DuckDuckGo. Useful for locating potential sources of answers to the user's question.
WebReader[input]: Reads and extracts plain text from websites listed in the input string (links separated by newlines).
URLCollector[input]: Gathers URLs from plain text, producing a newline-separated list of links.
QueryMaster[input]: A language model capable of answering questions based on a provided text passage. Questions should reference an :evidence[n]: variable.

Output should follow this structure:
Plan: [initial action based on input question]
:evidence0: = [called function with input parameters]
Plan: [subsequent action based on :evidence0:'s outcome]
:evidence1: = [next function call with input parameters, potentially referencing prior evidence]
...
Final Answer: [:evidence[n]: holding the ultimate answer]

Question: Who was the first person to climb Mount Everest and what challenges did they face?


Instruction:
A chat. Create a step-by-step plan to respond to the user instruction using the set of available tools. Each plan will have a corresponding evidence value, which will be the output of one of the available functions given an input string.

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

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

Question: Who was Albert Einstein and what were his major contributions to physics?


Instruction:
A chat. Develop a strategy to respond to the following inquiry using the resources provided. Each stage in your strategy should have a corresponding evidence value, which will be the product of one of the available operations given an input string. This could be the original question, earlier evidence values, or a combination of both.

Tools at your disposal include:
Bing[input]: A tool that enables users to conduct a Bing search for information. This tool is handy for locating websites that might contain the response to the user's question.
URLReader[input]: Reads the content of a website given its URL. The input should be a single link and the output will be plain text content of the page.
LinkSelector[input]: Selects the most pertinent links from a list of URLs based on the input query.
QuerySolver[input]: A tool capable of answering questions based on an input text passage. The input must be a textual question that refers to a #E[n] variable, such as What is the tallest mountain, given #E1?

Output format should look like this:
Plan: [initial action]
#E1 = [call to function with input parameter]
Plan: [subsequent action dependent on outcome of #E1]
#E2 = [next call to function with input parameter, potentially referencing prior evidence, e.g., "Given context #E1"]
...
Final Response: #E[n]

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


Instruction:
A chat. Create a step-by-step plan to answer the user query using the available tools. Each tool will produce an evidence value, which can be used as input for subsequent steps.

Here are the tools that can be called:

WebSearch[input]: A tool that uses a search engine to find information on the web. The output is a list of websites that may contain the answer to the question.
TextExtractor[input]: Extracts plain text from one or more websites provided in the input string (newline separated links).
LinkParser[input]: Parses plain text and produces a newline-separated list of URLs.
AIAnswerer[input]: An AI model capable of answering questions based on an input passage of text. The input must reference an #E[n] variable, e.g., "What color is the cat, given #E1?"

The output should follow this format:
Plan: [first action]
#E0 = [function with input parameter]
Plan: [next action, based on result of #E0]
#E1 = [next function with input parameter, possibly referencing previous evidence like "#E0"]
...
Final Answer: [#En]

Question: What is the current population of Tokyo and what are some famous landmarks there?


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. 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.
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.
HyperlinkExtractor[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
ALM[input]: Advanced Language Model, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. How old is the Eiffel Tower, given :evidence1:?

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

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

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

Question: What is the history behind the construction of the Sydney Opera House and who were the key people involved?


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

Here are the tools you can use:
WebSearch[input]: This tool allows you to search for information on the web. The function doesn't directly answer the question; it finds a list of sites that may have the answer.
TextExtractor[input]: Extracts text from websites and produces plain text output containing the content of the links.
LinkPicker[input]: Picks out relevant links from a list of URLs provided in the input.
KnowledgeEngine[input]: A powerful 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 capital of France, given #E1?"

The output format should be as follows:
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 was the first person to climb Mount Everest without supplemental oxygen and what were his reasons?