Instruction:
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 need to find articles about climate change published between 2010 and 2020.

Available functions:
data_filtering:
  description: This tool helps filter data according to specified criteria.
  params:
    column: The column we want to filter on.
    value: Explicit value to filter on.
    expression: Expression value to filter on.
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.

Response:
{
  "function": "search",
  "parameters": {
    "search_terms": ["climate change"],
    "date_range": {
      "begin": "2010",
      "end": "2020"
    }
  }
}

System: A chat.


Instruction:
As an AI assistant, please determine the appropriate function and its parameters from the list provided based on the user's query. Please provide your response in JSON format.

Input: Resize the image at path "/images/pic.jpg" to 500x500 pixels.

Available functions:
image_processing:
  description: Perform various operations on images such as resizing, cropping, etc.
  parameters:
    action: The operation to perform on the image.
    file_path: Path to the image file.
    size: New size for the image.
email_notifications:
  description: Send email notifications with specific content.
  parameters:
    recipient: The email address that will receive the notification.
    subject: The subject line for the email.
    body: The main content of the email.

Response:
{
  "function": "image_processing",
  "parameters": {
    "action": "resize",
    "file_path": "/images/pic.jpg",
    "size": "500x500"
  }
}

System: A chat.


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

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

Available functions:
1. data_sorting:
   description: This tool is useful for sorting data according to specified criteria.
   params:
     sort_by: The column we want to sort by.
     order: Order of sorting (ascending or descending).
2. 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.
3. 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.

Response:
{
  "function": "search",
  "parameters": {
    "search_terms": ["climate change"],
    "date_range": {
      "begin": "2010",
      "end": "2020"
    }
  }
}

System: A chat.


Instruction:
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.

Response:
{
  "function": "document_search",
  "parameters": {
    "search_terms": ["climate change"],
    "date_range": {
      "begin": "2010",
      "end": "2020"
    }
  }
}

System: A chat.


Instruction:
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.

Response:
{
  "function": "word_count",
  "parameters": {
    "word": "AI"
  }
}

System: A chat.


Instruction:
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").

Response:
{
  "function": "article_search",
  "parameters": {
    "keywords": ["climate change"],
    "date_range": {
      "start": "2010",
      "end": "2020"
    }
  }
}

System: A chat.


Instruction:
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.

Response:
function: csv_analytics
params:
  action: "grouped_count"
  filters:
    column: "product_category"

System: A chat.


Instruction:
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.

Response:
function: data_visualization
params:
  chart_type: "pie"
  data_source: "sales_data"

System: A chat.


Instruction:
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.

Response:
{
  "function": "weather_analysis",
  "params": {
    "action": "average",
    "month": "July"
  }
}

System: A chat.


Instruction:
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.

Response:
function: article_search
parameters:
  topic: "climate change"
  date_range:
    start: "January 2020"
    end: "March 2020"

System: A chat.


Instruction:
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.

Response:
function: data_extraction
params:
  column_names: ['name', 'address']

System: A chat.


Instruction:
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.

Response:
{
  "function": "word_counter",
  "parameters": {
    "word": "pandemic"
  }
}

System: A chat.


Instruction:
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.

Response:
{
  "function": "search",
  "parameters": {
    "search_terms": ["climate change"],
    "alternatives": [],
    "date_range": {
      "begin": "2010",
      "end": "2020"
    }
  }
}

System: A chat.


Instruction:
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).

Response:
function: filter_data
parameters:
  column: age
  condition: less_than
  value: 18

System: A chat.


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

Here are the tools available to be called:
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.

Response:
Plan: Search for the Wikipedia page of Quantum Computing.
:evidence0: = Wikipedia["Quantum Computing"]

Plan: Shorten the URL obtained from :evidence0:
:evidence1: = URLShortener[:evidence0:]

Plan: Generate a QR code for the shortened URL obtained from :evidence1:
:evidence2: = QRCodeGenerator[:evidence1:]

Plan: Search for recent research papers on Quantum Computing.
:evidence3: = GoogleScholar["Recent research papers on Quantum Computing"]

Answer: The shortened URL and QR code for the Wikipedia page of Quantum Computing are in :evidence1: and :evidence2: respectively. You can find some recent research papers on Quantum Computing in :evidence3:.

System: A chat.


Instruction:
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?

Response:
Plan: Search for information about the highest peak in the Andes.
:evidence0: = WikiSearch[Andes highest peak]
Plan: Use the question answering model to identify the name of the highest peak.
:evidence1: = QAModel[What is the highest peak in the Andes? Given context: :evidence0:]
Plan: Find out who was the first person to climb the highest peak.
:evidence2: = WikiSearch[:evidence1: first ascent]
Plan: Extract the name of the first climber from the obtained information.
:evidence3: = QAModel[Who was the first person to climb :evidence1:? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
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?

Response:
Action: Begin by searching for the average lifespan of a Giant Tortoise.
:Evidence1: = YahooSearch[Giant Tortoise average lifespan]
Action: Use JARVIS to interpret the search results and identify the average lifespan.
:Evidence2: = JARVIS[What is the average lifespan of a Giant Tortoise? Given :Evidence1:]
Action: Conduct a separate search to find out where Giant Tortoises typically live.
:Evidence3: = YahooSearch[Giant Tortoise habitat]
Action: Gather any links found within the search results for further investigation.
:Evidence4: = LinkGatherer[:Evidence3:]
Action: Read the contents of the most relevant link gathered.
:Evidence5: = WebReader[:Evidence4:]
Action: Finally, use JARVIS to analyze the read content and identify the typical habitat of Giant Tortoises.
:Evidence6: = JARVIS[Where do Giant Tortoises typically live? Given :Evidence5:]
Final Response: :Evidence6:

System: A chat.


Instruction:
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?

Response:
Plan: Begin by searching for information about Leonardo da Vinci.
#E1 = Encyclopedia[Leonardo da Vinci]
Plan: Use the QA tool to extract specific information about who Leonardo da Vinci was.
#E2 = QA_Tool[Who was Leonardo da Vinci? Given context: #E1]
Plan: Now, look for information about Leonardo da Vinci's famous works.
#E3 = Encyclopedia[Leonardo da Vinci famous works]
Plan: Utilize the QA tool again to identify some of these famous works.
#E4 = QA_Tool[What are some famous works of Leonardo da Vinci? Given context: #E3]
Plan: Find images related to these famous works.
#E5 = ImageFinder[#E4]
Plan: Analyze the found images to provide descriptions of them.
#E6 = ImageAnalyzer[#E5]
Final Answer: #E2 and #E6

System: A chat.


Instruction:
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?

Response:
Plan: Start by searching for popular dishes in Italian cuisine.
#E1 = SearchEngine[Popular dishes in Italian cuisine]
Plan: Extract the relevant links from the search results.
#E2 = LinkExtractor[#E1]
Plan: Scrape the web pages linked to find out more about these dishes.
#E3 = WebScraper[#E2]
Plan: Use TextAnalyzer to identify the names of the dishes.
#E4 = TextAnalyzer[#E3]
Plan: For each dish identified, use the SearchEngine to find recipes and their required ingredients.
#E5 = SearchEngine[Recipe for #E4]
Plan: Extract the relevant links from the search results.
#E6 = LinkExtractor[#E5]
Plan: Scrape the web pages linked to find out more about these recipes and their ingredients.
#E7 = WebScraper[#E6]
Plan: Use QA to extract the ingredients for each recipe.
#E8 = QA[What are the ingredients for #E4? Given context: #E7]
Final answer: #E8

System: A chat.


Instruction:
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?

Response:
Plan: Start by searching for who discovered penicillin.
:Evidence1: = YahooSearch[Who discovered penicillin]
Plan: Use NLM to interpret the search results and find the discoverer of penicillin.
:Evidence2: = NLM[Who discovered penicillin? Given context: :Evidence1:]
Plan: Conduct another search to find the initial uses of penicillin.
:Evidence3: = YahooSearch[Initial uses of penicillin]
Plan: Extract the relevant links from the search results for further examination.
:Evidence4: = LinkGatherer[:Evidence3:]
Plan: Use SiteLoader to extract information from the relevant links.
:Evidence5: = SiteLoader[:Evidence4:]
Plan: Finally, use NLM to identify and summarize the initial uses of penicillin from the extracted information.
:Evidence6: = NLM[What were the initial uses of penicillin? Given context: :Evidence5:]
Answer: :Evidence6:

System: A chat.


Instruction:
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?

Response:
Plan: Search for current population density of Tokyo.
#E1 = SearchEngine[Current population density of Tokyo]
Plan: Use QA tool to extract specific information from search results.
#E2 = QA[What is the current population density of Tokyo? Given context: #E1]
Plan: Search for historical population density data of Tokyo.
#E3 = SearchEngine[Historical population density of Tokyo]
Plan: Extract structured data from the search results.
#E4 = DataExtractor[#E3]
Plan: Analyze the extracted data to determine how the population density has changed over the past decade.
#E5 = QA[How has the population density of Tokyo changed over the past decade? Given context: #E4]
Final Answer: #E5

System: A chat.


Instruction:
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?

Response:
Plan: Begin by searching the web for when the Eiffel Tower was completed.
#E1 = WebSearch[Eiffel Tower completion date]
Plan: Verify the fact obtained from the web search.
#E2 = FactChecker[#E1]
Plan: Now, search the web for the height of the Eiffel Tower.
#E3 = WebSearch[Eiffel Tower height]
Plan: Verify the fact obtained from the second web search.
#E4 = FactChecker[#E3]
Final answer: #E2 and #E4

System: A chat.


Instruction:
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?

Response:
Plan: Initiate a search to identify the tallest mountain in North America.
:evidence0: = YahooSearch[Tallest mountain in North America]
Plan: Apply QuerySolver to interpret the search findings and pinpoint the mountain.
:evidence1: = QuerySolver[What is the tallest mountain in North America, given :evidence0:?]
Plan: Launch another search to determine the height of the discovered mountain.
:evidence2: = YahooSearch[Height of :evidence1:]
Plan: Isolate relevant links from the search outcome for additional scrutiny.
:evidence3: = HyperlinkGatherer[:evidence2:]
Plan: Use SiteReader to access information from these links.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, engage QuerySolver to ascertain the mountain’s height from the procured details.
:evidence5: = QuerySolver[How high is :evidence1:, given :evidence4:?]
Final Response: :evidence5:

System: A chat.


Instruction:
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.]

Response:
Plan: First action
:Evidence0: = Goodreads["War and Peace"]
Plan: If the author's name is not in :Evidence0:, use GoogleBooks to find it.
:Evidence1: = GoogleBooks["War and Peace"] if necessary
Plan: Once the author's name is found, use AuthorBio to get biographical information about them.
:Evidence2: = AuthorBio[author's name from :Evidence0: or :Evidence1:]
Plan: Use BookSummary to get a brief summary of "War and Peace".
:Evidence3: = BookSummary["War and Peace"]
Answer: [:Evidence2: containing the author's bio and :Evidence3: containing the book summary.]

System: A chat.


Instruction:
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?

Response:
Plan: Initiate a web search to discover who was the first person to walk on the moon.
:evidence0: = DuckDuckGo[First person to walk on the moon]
Plan: Deploy the InquiryEngine to interpret the search results and determine the individual's name.
:evidence1: = InquiryEngine[Who was the first person to walk on the moon, given :evidence0:?]
Plan: Conduct another web search to establish when this person walked on the moon.
:evidence2: = DuckDuckGo[:evidence1: walks on the moon date]
Plan: Harvest the pertinent links from the search results for further investigation.
:evidence3: = HyperlinkHarvester[:evidence2:]
Plan: Utilize the TextExtractor to gather information from these links.
:evidence4: = TextExtractor[:evidence3:]
Plan: Lastly, employ the InquiryEngine to ascertain the date this individual walked on the moon from the gathered data.
:evidence5: = InquiryEngine[When did :evidence1: walk on the moon, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
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]

Response:
Plan: Start by searching the specific animal database for information on African elephants.
#E1 = AnimalDatabase["African elephant lifespan"]

Plan: If #E1 does not provide a clear answer, use InfoSearch to look up more information about the average lifespan of an African elephant in the wild.
#E2 = InfoSearch["average lifespan of African elephant in the wild"]

Plan: Use QA tool to interpret and summarize the findings from #E1 and #E2
#E3 = QA["What is the average lifespan of an African elephant in the wild based on #E1 and #E2?"]

Plan: Finally, verify the accuracy of the information obtained using FactChecker.
#E4 = FactChecker[#E3]

Final Answer: #E4

System: A chat.


Instruction:
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?

Response:
Plan: Begin by conducting an online search to identify the winner of the 2020 US Presidential Election.
:Evidence0: = DuckDuckGo[2020 US Presidential Election winner]
Plan: Use TextualQA to parse the search results and identify the election winner.
:Evidence1: = TextualQA[Who won the 2020 US Presidential Election, given :Evidence0:?]
Plan: Perform another online search to gather information about the winner's main campaign promises.
:Evidence2: = DuckDuckGo[:Evidence1: 2020 campaign promises]
Plan: Use HyperlinkGatherer to pull out relevant links from the search results for further exploration.
:Evidence3: = HyperlinkGatherer[:Evidence2:]
Plan: Utilize SiteReader to load the contents of the identified websites.
:Evidence4: = SiteReader[:Evidence3:]
Plan: Lastly, employ TextualQA to analyze the loaded website contents and summarize the main campaign promises of the 2020 US Presidential Election winner.
:Evidence5: = TextualQA[What were the main campaign promises of :Evidence1:, given :Evidence4:?]
Final Answer: :Evidence5:

System: A chat.


Instruction:
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?

Response:
Plan: Begin by fact-checking who was the first person to climb Mount Everest.
:evidence0: = FactChecker[First person to climb Mount Everest]
Plan: Use the KnowledgeQA tool to determine the name of the first climber from the fact-checked data.
:evidence1: = KnowledgeQA[Who was the first person to climb Mount Everest, given :evidence0:?]
Plan: Now fact-check when the first successful ascent of Mount Everest occurred.
:evidence2: = FactChecker[First successful ascent of Mount Everest]
Plan: Utilize the KnowledgeQA tool again to extract the date of the first successful climb from the fact-checked data.
:evidence3: = KnowledgeQA[When was the first successful ascent of Mount Everest, given :evidence2:?]
Final Answer: :evidence1: climbed Mount Everest for the first time on :evidence3:.

System: A chat.


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

Here are the tools available to be called:
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?

Response:
Plan: Begin by conducting a web search to find out who the director of 'Inception' is.
:data0: = Bing[Director of Inception]
Plan: Utilize AIM to interpret the search results and find the name of the director.
:data1: = AIM[Who is the director of Inception, given :data0:?]
Plan: Conduct another web search to find the other movies directed by the identified director.
:data2: = Bing[Movies directed by :data1:]
Plan: Extract the relevant URLs from the Bing search results for a more focused search.
:data3: = URLExtractor[:data2:]
Plan: Use WebCrawler tool to extract information from the relevant URLs.
:data4: = WebCrawler[:data3:]
Plan: Finally, utilize AIM to identify and summarize the other movies directed by the director from the extracted information.
:data5: = AIM[What are the other movies directed by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
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?

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

System: A chat.


Instruction:
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]

Response:
Plan: Start by searching the web for information about the Eiffel Tower.
#E1 = WebSearch[Eiffel Tower]
Plan: Extract the relevant text from the search results.
#E2 = TextExtractor[#E1]
Plan: Use the extracted text to find out about the history of the Eiffel Tower.
#E3 = QA[What is the history of the Eiffel Tower? Given context: #E2]
Plan: Use the same extracted text to identify the architect of the Eiffel Tower.
#E4 = QA[Who was the architect of the Eiffel Tower? Given context: #E2]
Final Answer: #E3 and #E4

System: A chat.


Instruction:
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?

Response:
Plan: Conduct a web search to find out who won the Nobel Prize in Literature in 2019.
:evidence0: = DuckDuckGo[Nobel Prize in Literature 2019 winner]
Plan: Use SageAI to interpret the search results and identify the winner.
:evidence1: = SageAI[Who won the Nobel Prize in Literature in 2019? Given :evidence0:?]
Plan: Perform another web search to find the most notable work of the identified laureate.
:evidence2: = DuckDuckGo[Most notable work of :evidence1:]
Plan: Extract relevant links from the search results for more detailed information.
:evidence3: = URLExtractor[:evidence2:]
Plan: Scrape the extracted websites for content.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, use SageAI to identify and summarize the most notable work of the laureate from the scraped information.
:evidence5: = SageAI[What is the most notable work of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
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?

Response:
Plan: Search for information about photosynthesis.
#E1 = Encyclopedia[Photosynthesis]
Plan: Find out how the process of photosynthesis works.
#E2 = QAEngine[How does photosynthesis work? Given context: #E1]
Plan: Search for information about chloroplasts.
#E3 = Encyclopedia[Chloroplasts]
Plan: Determine the role of chloroplasts in photosynthesis.
#E4 = QAEngine[What role do chloroplasts play in photosynthesis? Given context: #E3]
Final Answer: #E4

System: A chat.


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

Here are the tools available to be called:
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?

Response:
Plan: Start by conducting a web search to find out about the Battle of Gettysburg.
:evidence0: = Bing[Battle of Gettysburg]
Plan: Use a link picker to extract relevant links from the search results.
:evidence1: = LinkPicker[:evidence0:]
Plan: Load the contents of the selected pages for further analysis.
:evidence2: = PageLoader[:evidence1:]
Plan: Finally, utilize the QAModel to interpret the loaded page contents and determine the historical significance of the Battle of Gettysburg.
:evidence3: = QAModel[What is the historical significance of the Battle of Gettysburg? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
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"?

Response:
Plan: Start by searching for the author of "To Kill a Mockingbird".
:data0: = Bing[Author of To Kill a Mockingbird]
Plan: Use AIML to identify the author's name from the search results.
:data1: = AIML[Who is the author of "To Kill a Mockingbird", given :data0:?]
Plan: Conduct another search to find notable works by this author.
:data2: = Bing[Notable works by :data1:]
Plan: Extract relevant links from the search results.
:data3: = LinkCollector[:data2:]
Plan: Use WebReader to extract information from these links.
:data4: = WebReader[:data3:]
Plan: Finally, use AIML to summarize the notable works by the author from the extracted information.
:data5: = AIML[What are the notable works by :data1:, given :data4:?]
Answer: :data5:

System: A chat.


Instruction:
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?

Response:
Plan: Search for the highest peak in the Alps.
#E1 = DuckDuckGo[Highest peak in the Alps]
Plan: Use ELIZA to extract the name of the peak from the search results.
#E2 = ELIZA[What is the highest peak in the Alps, given #E1?]
Plan: Search for detailed information about the peak.
#E3 = DuckDuckGo[#E2]
Plan: Extract the relevant links from the search results.
#E4 = HyperlinkFinder[#E3]
Plan: Read the content of the first link.
#E5 = URLReader[#E4[0]]
Plan: Use ELIZA to find the height of the peak from the webpage content.
#E6 = ELIZA[How high is #E2, given #E5?]
Final Answer: #E6

(Note: In this example, "#E4[0]" refers to the first link in the list of links extracted by HyperlinkFinder.)

System: A chat.


Instruction:
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?

Response:
Plan: Start by searching the web for information about the Eiffel Tower.
:E1: = WebSearch[Eiffel Tower]
Plan: Extract important details from the search results.
:E2: = TextExtractor[:E1:]
Plan: Scrape any relevant links found within the extracted text.
:E3: = LinkScraper[:E2:]
Plan: Use InfoAnalyzer to find out who designed the Eiffel Tower.
:E4: = InfoAnalyzer[Who designed the Eiffel Tower? Given context: :E3:]
Plan: Use InfoAnalyzer again to learn about the history of the Eiffel Tower.
:E5: = InfoAnalyzer[What is the history of the Eiffel Tower? Given context: :E3:]
Final Answer: :E4: and :E5:

System: A chat.


Instruction:
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?

Response:
Plan: Initiate a web search to determine the current Prime Minister of Canada.
:evidence0: = DuckDuckGo[Current Prime Minister of Canada]
Plan: Employ a language model to analyze the search results and identify the name of the Prime Minister.
:evidence1: = AskMe[Who is the current Prime Minister of Canada, given :evidence0:?]
Plan: Perform another web search to uncover the key policies of the identified Canadian Prime Minister.
:evidence2: = DuckDuckGo[Key policies of :evidence1:]
Plan: Extract pertinent URLs from the DuckDuckGo search results for a more targeted search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Utilize the TextScraper tool to gather information from the relevant URLs.
:evidence4: = TextScraper[:evidence3:]
Plan: Lastly, apply the language model to recognize and summarize the key policies of the Canadian Prime Minister from the gathered data.
:evidence5: = AskMe[What are the key policies of :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
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?

Response:
Plan: Begin by performing a web search to ascertain who invented the light bulb.
:evidence0: = YahooSearch[Light bulb inventor]
Plan: Use the info model to analyze the search results and pinpoint the inventor.
:evidence1: = InfoModel[Who invented the light bulb, given :evidence0:?]
Plan: Execute another web search to discover other inventions by the identified inventor.
:evidence2: = YahooSearch[Other inventions by :evidence1:]
Plan: Extract the relevant URLs from the Yahoo search results for a more concentrated search.
:evidence3: = URLExtractor[:evidence2:]
Plan: Deploy the site reader tool to extract details from the relevant URLs.
:evidence4: = SiteReader[:evidence3:]
Plan: Finally, employ the info model to identify and summarize the other inventions by the inventor from the extracted details.
:evidence5: = InfoModel[What other inventions were made by :evidence1:, given :evidence4:?]
Final Answer: :evidence5:

System: A chat.


Instruction:
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?

Response:
Plan: Conduct a web search to identify who won the Nobel Prize in Literature in 2019.
#E1 = BingSearch[Nobel Prize in Literature 2019 winner]
Plan: Extract the website contents from the search results.
#E2 = WebScraper[#E1]
Plan: Summarize the extracted information.
#E3 = InfoSummarizer[#E2]
Plan: Verify the winner of the Nobel Prize in Literature in 2019 from the summarized information.
#E4 = FactChecker[Who won the Nobel Prize in Literature in 2019? Given context: #E3]
Final Answer: #E4

System: A chat.


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

Here are the tools available to be called:
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?

Response:
Plan: Start by conducting a web search to find out about the Great Fire of London.
:evidence0: = Bing[Great Fire of London]
Plan: Use a link extractor to gather relevant sources from the search results.
:evidence1: = LinkGrabber[:evidence0:]
Plan: Scrape the contents of these links for detailed information.
:evidence2: = WebScraper[:evidence1:]
Plan: Finally, use the language model to interpret the scraped data and summarize the impact of the Great Fire of London.
:evidence3: = SAM[What was the impact of the Great Fire of London, given :evidence2:?]
Answer: :evidence3:

System: A chat.


Instruction:
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?

Response:
Plan: Start by initiating a web search to figure out who directed 'The Godfather'.
:evidence0: = ExciteSearch['The Godfather' director]
Plan: Exploit QAMachine to analyze the search results and isolate the director.
:evidence1: = QAMachine[Who directed 'The Godfather', in consideration of :evidence0:?]
Plan: Instigate another web search to uncover other films directed by the identified director.
:evidence2: = ExciteSearch[Other films directed by :evidence1:]
Plan: Assemble the applicable links from the ExciteSearch search results for a thorough search.
:evidence3: = LinkSelector[:evidence2:]
Plan: Deploy WebRetriever to procure information from the assembled links.
:evidence4: = WebRetriever[:evidence3:]
Plan: At last, resort to QAMachine to discern and condense the other films directed by the director from the procured information.
:evidence5: = QAMachine[What other films were directed by :evidence1:, considering :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
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?

Response:
Plan: Begin by searching Wikipedia for information about Leonardo da Vinci.
#E1 = WikiSearch[Leonardo da Vinci]
Plan: Collect URLs from the Wikipedia page for further research.
#E2 = URLCollector[#E1]
Plan: Read the content of the collected URLs for more detailed information.
#E3 = PageReader[#E2]
Plan: Find out who Leonardo da Vinci was from the read content.
#E4 = InfoFinder[Who was Leonardo da Vinci? Given context: #E3]
Plan: Identify some of Leonardo da Vinci's most famous works from the read content.
#E5 = InfoFinder[What are some of Leonardo da Vinci's most famous works? Given context: #E3]
Final answer: Leonardo da Vinci was described in #E4 and some of his most famous works are listed in #E5.

System: A chat.


Instruction:
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?

Response:
Plan: Search Wikipedia for information on Albert Einstein's contribution to quantum theory.
#Evidence1 = WikiSearch[Albert Einstein Quantum Theory]
Plan: Utilize QAEngine to extract specific details about Einstein's contributions from the obtained Wikipedia data.
#Evidence2 = QAEngine[What was Albert Einstein's contribution to quantum theory? Given context: #Evidence1]
Plan: Use FactChecker to validate the contributions made by Albert Einstein to quantum theory.
#Evidence3 = FactChecker[#Evidence2]
Plan: If the fact-checking confirms the contributions, utilize WikiSearch again to find how these contributions have been verified over time.
#Evidence4 = WikiSearch[Verification of Albert Einstein's contribution to quantum theory]
Plan: Lastly, employ QAEngine to extract details about how Einstein's contributions to quantum theory have been verified from the gathered Wikipedia data.
#Evidence5 = QAEngine[How have Albert Einstein's contributions to quantum theory been verified? Given context: #Evidence4]
Final Answer: #Evidence5

System: A chat.


Instruction:
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]

Response:
Plan: First, use the BuildingFacts tool to get factual information about the Sydney Opera House. If this does not provide the answer, use the ArchitectDB tool with "Sydney Opera House" as the input.

#E1 = BuildingFacts["Sydney Opera House"]

Plan: Based on the result of #E1, if it provides the architect's name, that will be the final answer. If not, proceed to use the ArchitectDB tool.

#E2 = ArchitectDB["Sydney Opera House"]

Final answer: #E2

System: A chat.


Instruction:
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?

Response:
Plan: Initiate a web search to gather information about the Rosetta Stone.
:evidence0: = DuckDuckGo[Rosetta Stone]
Plan: Utilize ELIZA to interpret the search results and determine the significance of the Rosetta Stone.
:evidence1: = ELIZA[What is the significance of the Rosetta Stone? Given :evidence0:]
Plan: Execute another web search to discover the current location of the Rosetta Stone.
:evidence2: = DuckDuckGo[Rosetta Stone current location]
Plan: Extract pertinent links from the search results for detailed exploration.
:evidence3: = URLExtractor[:evidence2:]
Plan: Deploy PageLoader to retrieve data from the selected links.
:evidence4: = PageLoader[:evidence3:]
Plan: Lastly, apply ELIZA to pinpoint and summarise the current location of the Rosetta Stone from the retrieved data.
:evidence5: = ELIZA[Where is the Rosetta Stone currently located? Given :evidence4:]
Final Answer: :evidence5:

System: A chat.


Instruction:
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.

Response:
Plan:

Step 1: Use the BioTerms tool to define "photosynthesis" and "chloroplasts". This will provide a basic understanding of these terms.
- Input to BioTerms: ["photosynthesis", "chloroplasts"]
- Expected output: Definitions of photosynthesis and chloroplasts.

Step 2: Use ScienceDirect to search for scientific articles that explain how photosynthesis works and the role of chloroplasts in this process.
- Input to ScienceDirect: ["how does photosynthesis work", "role of chloroplasts in photosynthesis"]
- Expected output: Relevant scientific articles on photosynthesis and the role of chloroplasts.

Step 3: Use TextSummarizer to summarize the information from the scientific articles obtained in Step 2. This will make the information more digestible for the user.
- Input to TextSummarizer: [Scientific articles from Step 2]
- Expected output: Summaries of the scientific articles.

Step 4: Use DiagramGenerator to create a diagram illustrating the process of photosynthesis and highlighting the role of chloroplasts. This visual aid will help the user understand the process better.
- Input to DiagramGenerator: ["photosynthesis process", "role of chloroplasts in photosynthesis"]
- Expected output: A diagram showing the process of photosynthesis and the role of chloroplasts.

Step 5: Use QA to answer any additional questions the user might have about photosynthesis or chloroplasts, using the summarized texts and diagrams as context.
- Input to QA: User's follow-up questions, [summarized texts and diagrams from Steps 3 and 4]
- Expected output: Answers to the user's questions.

Final Output: Provide the user with definitions of photosynthesis and chloroplasts, summaries of relevant scientific articles, a diagram illustrating the process of photosynthesis and the role of chloroplasts, and answers to any further questions they may have.

System: A chat.


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebScraper[input]: Load one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
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?

Response:
Plan: Start by conducting a web search to find out the most populated city in Australia.
:evidence0: = Bing[Most populated city in Australia]
Plan: Use the TextAnalyzer to interpret the search results and identify the city.
:evidence1: = TextAnalyzer[What is the most populated city in Australia, given :evidence0:?]
Plan: Conduct another web search to find the main economic activity of the identified city.
:evidence2: = Bing[Main economic activity in :evidence1:]
Plan: Extract the relevant links from the Bing search results for a deeper investigation.
:evidence3: = LinkExtractor[:evidence2:]
Plan: Utilize the WebScraper tool to extract detailed information from the selected links.
:evidence4: = WebScraper[:evidence3:]
Plan: Finally, utilize the TextAnalyzer to summarize the main economic activity of the city from the extracted information.
:evidence5: = TextAnalyzer[What is the main economic activity in :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
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?

Response:
Plan: Start by conducting a web search to find out who invented the telephone.
#E0 = Bing[Who invented the telephone]
Plan: Use a language model to interpret the search results and identify the inventor of the telephone.
#E1 = AskJeeves[Who invented the telephone, given #E0?]
Plan: Conduct another web search to find the key scientific contributions made by the identified inventor.
#E2 = Bing[Key scientific contributions by #E1]
Plan: Extract the relevant links from the Bing search results for a more focused search.
#E3 = LinkExtractor[#E2]
Plan: Use a website reader tool to extract information from the relevant links.
#E4 = WebsiteReader[#E3]
Plan: Finally, use the language model to identify and summarize the key scientific contributions made by the inventor from the extracted information.
#E5 = AskJeeves[What are the key scientific contributions made by #E1, given #E4?]
Answer: #E5

System: A chat.


Instruction:
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?

Response:
Plan: Start by conducting a web search to find out who the current president of Microsoft is.
:evidence0: = WebSearch[Current president of Microsoft]
Plan: Use InfoExtractor to interpret the search results and identify the name of the president.
:evidence1: = InfoExtractor[Who is the current president of Microsoft, given :evidence0:?]
Plan: Conduct another web search to find the notable achievements of the identified president of Microsoft.
:evidence2: = WebSearch[Notable achievements of :evidence1:]
Plan: Extract the relevant links from the search results for a more detailed search.
:evidence3: = LinkPicker[:evidence2:]
Plan: Use TextScraper to extract information from the relevant links.
:evidence4: = TextScraper[:evidence3:]
Plan: Finally, use InfoExtractor to summarize the notable achievements of the president from the extracted information.
:evidence5: = InfoExtractor[What are the notable achievements of :evidence1:, given :evidence4:?]
Answer: :evidence5:

System: A chat.


Instruction:
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?

Response:
Plan: Begin by conducting a web search to find out who won the Nobel Prize in Literature in 2019.
:evidence0: = WebSearch[Nobel Prize in Literature 2019 winner]
Plan: Grab the most relevant link from the search results.
:evidence1: = LinkGrabber[:evidence0:]
Plan: Read the contents of the website from the selected link.
:evidence2: = SiteReader[:evidence1:]
Plan: Utilize the AI Assistant to interpret the site contents and identify the winner and their work.
:evidence3: = AIAssistant[Who won the Nobel Prize in Literature in 2019 and what was their work about? Given context: :evidence2:]
Answer: :evidence3:

System: A chat.


Instruction:
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?

Response:
Plan: Search Wikipedia for information about Nikola Tesla.
#E1 = WikiSearch[Nikola Tesla]
Plan: Identify Tesla's mentor using the QA engine.
#E2 = QAEngine[Who was Nikola Tesla's mentor? Given context: #E1]
Plan: Search Wikipedia for more information about Tesla's mentor.
#E3 = WikiSearch[#E2]
Plan: Determine the mentor's major contributions to science using the QA engine.
#E4 = QAEngine[What were the major contributions to science by #E2? Given context: #E3]
Final Answer: #E4

System: A chat.


Instruction:
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?

Response:
Plan: Ignite a Dogpile search to decipher who sculpted 'David'.
:Hint0: = DogpileSearch[sculptor of 'David']
Plan: Deploy ZetaSolver to sift through the search quotients and recognize the sculptor.
:Hint1: = ZetaSolver[Who sculpted 'David'? Given context: :Hint0:]
Plan: Commence another Dogpile search to trace other masterpieces crafted by the recognized artist.
:Hint2: = DogpileSearch[:Hint1: other masterpieces]
Plan: Separate the URLs from the search quotients for meticulous examination.
:Hint3: = LinkDetector[:Hint2:]
Plan: Secure the content of the chief URL from the hoard.
:Hint4: = WebpageMiner[:Hint3[0]]
Plan: Finally, activate ZetaSolver to browse the webpage text and spotlight the other revered masterpieces of the artist.
:Hint5: = ZetaSolver[What other masterpieces is :Hint1: venerated for? Given context: :Hint4:]
Final Answer: :Hint5:

System: A chat.


Instruction:
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]

Response:
Plan: Retrieve the historical weather data for London in July over the past decade.
#E1 = WeatherHistory["London, July, 2010-2020"]

Plan: Calculate the average temperature from the retrieved data.
#E2 = QA["What is the average of the temperatures provided in #E1?"]

Plan: Get the global average temperature for July over the same period.
#E3 = GlobalAverageTemperature["July, 2010-2020"]

Plan: Compare the average temperature in London to the global average.
#E4 = CompareNumbers[#E2, #E3]

Final Answer: #E4

System: A chat.