Instruction:
A chat. Develop a strategy to solve the problem at hand using the provided tools. For each step, indicate which external tool along with its input would be used to gather evidence. Store this evidence into a variable #E[index] that can be referred to later.

Available tools:
FactFinder[input]: Tool that enables the user to retrieve factual information about people, places, companies, historical events, etc. It uses a database of facts instead of searching the entire internet. The input should be a specific fact-related query.
AskMe[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.

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

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

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


Instruction:
A chat. Formulate a systematic approach to answer the query utilizing the available tools. Every stage of your plan should produce an evidence variable.

Available Tools:
WikiLookup[input]: Retrieves information about the input topic from Wikipedia.
DataCrawler[input]: Crawls the internet to gather data related to the input.
QAModel[input]: AI-powered Question-Answering model that provides answers based on the input context.

Required Output Format:
Plan: [Action to perform]
:Evidence[index]: = [Tool to employ with its input]
...
Final Response: :Evidence[n]:

Question: When was the Eiffel Tower built and who was its architect?


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

Here are the tools you can call:
WebSearch[input]: This tool allows users to search for information on the internet using a general web search engine. It finds a list of sites that may contain the answer to the user's query but does not directly provide the answer.
PageReader[input]: This function loads one or more websites from the input string containing newline-delimited links and produces plain text output containing the content of those pages.
LinkFinder[input]: Extracts links from plain text and provides a plain text, newline-delimited response of links.
QAExpert[input]: A question-answering language model useful for answering questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., "What is the capital of France, 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., QAExpert[What is the capital of France, given #E1?]

Remember to include only one evidence output per plan step.

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

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


Instruction:
A chat. Generate a sequential plan to respond optimally to the user's request, leveraging the range of tools available. Each plan will correspond to an evidence value, which is the output of one of the accessible functions given an input string that could be the user's question, one or more past evidence values, or a blend of both.

Here are the tools available to be called:
EncyclopediaSearch[input]: Allows the user to search for information from an online encyclopedia. It's particularly helpful for acquiring knowledge about individuals, locations, businesses, historical occurrences, and other kinds of factual data.
TextSimplifier[input]: Simplifies a chunk of text and outputs the main ideas.
URLAggregator[input]: Aggregates URLs from a piece of text and provides them as a line-separated list.
QueryEngine[input]: A language model skilled at answering inquiries based on an input paragraph of text. The input has to be a text question that cites a |fact[n]| variable, such as 'What is the climate of Antarctica, given |fact1|?'

Each function merely requires a plain string as input, without quotation marks or '+' symbols to merge a string with a fact variable, like QueryEngine[What is the currency of Japan, given |fact3|?].

Be sure to offer only one evidence output for each planning stage.

The output should conform to this format:
Plan: [First action derived from the input question]
|fact0 = [Function to call with input parameter]
Plan: [Following action, based on the consequence of |fact0]
|fact1 = [Next function to call and input parameter, perhaps citing previous evidence, such as 'Given context |fact0']
...
Final Answer: [|fact[n], comprising the final answer.]

Question: What were the significant contributions of Nikola Tesla to the field of electrical engineering and how did they influence modern technology?


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

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

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

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


Instruction:
A chat. Develop a step-by-step plan to address the user's query using the tools at your disposal. Each plan will have a corresponding evidence value, generated by one of the functions.

Here are the tools available to be called:
GoogleSearch[input]: Searches for information on Google and returns a list of sites that might contain the answer.
SiteReader[input]: Reads the content of a site and outputs the text.
QAModel[input]: Answers questions based on general knowledge or given context.
LinkGatherer[input]: Gathers links from a block of text and outputs them in a list.

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

Question: How does photosynthesis work and what are its main stages?


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

Here are the tools available to be called:
YahooSearch[input]: Tool that allows the user to search for information from Yahoo Search.  This tool is particularly useful in gaining knowledge about people, places, companies, historical events, and other types of factual information.  The input to this function should be a search string that would help find the appropriate page.  The output may be quite verbose and noisy, but often contains the correct piece of information related to the input query.
TextParser[input]: Parse 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.
HyperlinkCollector[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
SmartAnswer[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: Who is the founder of Microsoft and what were his major contributions to the company?


Instruction:
A chat. Devise a systematic plan to respond to the user instruction using the provided tools. Each plan will correlate with an evidence value, which will be the output of one of the available functions given an input string that can be the user question, past evidence values, or both.

Here are the tools available to be used:
AskJeeves[input]: A tool that allows the user to search for information on Ask Jeeves. This tool is beneficial in finding a list of sites that may contain the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline-separated links, where input is one or more links, and produces plain text output containing the content of the links.
LinkMiner[input]: Mines links from plain text and produces a plain text, newline separated response of links.
MLQA[input]: Machine Learning-based Question Answering model, specifically useful in answering questions based on an input passage of text. The input must be a text question that refers to a :fact[n]: variable, e.g., What is the distance between Earth and Mars, given :fact1:?

Each function input should just be a plain string, without quotes or "+" to combine a string with an evidence variable, e.g., MLQA[What is the GDP of India, given :fact2:?]

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

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

Question: What are the primary causes of global warming and what steps can individuals take to mitigate its effects?


Instruction:
A chat. Construct a sequential plan to answer the following user question using the tools provided. Each step in your plan should produce an evidence output that informs the next step.

Tools Available:
InfoSeeker[input]: Searches the internet broadly for information related to the input string.
TextAnalyzer[input]: Analyzes a body of text and answers questions based on the content.
LinkGatherer[input]: Gathers all URLs linked within a piece of text.

Output Format:
Plan: [Initial action based on user question]
:E1: = [Tool to use with specific input]
Plan: [Subsequent action informed by prior evidence]
:E2: = [Next tool to use with specific input, potentially referencing earlier evidence]
...
Final Answer: :En:

Question: When was the Eiffel Tower built and who was its architect?


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.
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.
URLCollector[input]: Extract URLs from plain text and produces a plain text, newline delimited response of URLs.
SAM[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]
#E1 = [function to call with input parameter]
Plan: [next action to take, based on result of #E1]
#E2 = [next function to call and input parameter, which may include reference to previous evidence]
...
Final answer: #E[n]

Question: What is the capital city of Australia and what is its population?


Instruction:
A chat. Develop a sequential plan to answer the user's query using the provided tools. Store each tool's output in a variable named #Evidence[index] for future reference.

Available Tools:
1. GoogleSearch[input]: Performs a Google search with the input string.
2. TextSummarizer[input]: Summarizes large blocks of text into concise paragraphs.
3. QAEngine[input]: Answers queries based on common sense, world knowledge, and given context.
4. ImageFinder[input]: Finds images related to the input string.

Output Format:
Plan: [First action description]
#Evidence1 = [Function call]
Plan: [Second action description based on #Evidence1]
#Evidence2 = [Next function call, possibly referring to #Evidence1]
...
Final Answer: [#Evidence[n] containing the final response]

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


Instruction:
A chat. Formulate a detailed execution plan to resolve the user query utilizing the listed tools. Every step should be associated with an evidence marker that holds the result of the respective function invoked.

Tools at Disposal:
YahooSearch[input]: Search engine tool suitable for gathering broad details about the input query.
SiteReader[input]: Fetches specific website(s) from the input link(s) and returns the plain text content of the site(s).
HyperlinkCollector[input]: Accumulates all hyperlinks embedded within the supplied plain text.
BERT_QA[input]: A state-of-the-art language model adept at responding to queries based on an input context. The input should pose a question citing an :evidence[n]: variable.

Format of Output:
Plan: [Step derived from the input question]
:evidence0: = [Function accompanied by its input]
Plan: [Subsequent step influenced by the result of :evidence0:]
:evidence1: = [Following function and its input, potentially referring to earlier evidence]
...
Final Solution: :evidence[n]:

Question: Who invented the World Wide Web and what was the main purpose behind its creation?


Instruction:
A chat. Develop a systematic plan to respond to the user query utilizing the provided tools. Each plan will correspond to an evidence value which is the outcome of one of the functions when fed an input string that could be the user question, earlier evidence values or both.

Available tools:
BingSearch[input]: Allows the user to look up information via Bing. It finds potential sites that might hold the answer to the user's query.
SiteLoader[input]: Loads websites from the input string having newline separated links. Input is one or more links and it outputs plain text content of those links.
URLCollector[input]: Collects URLs from plain text and provides a plain text, newline separated list of URLs.
InfoProcessor[input]: A language model adept at answering queries based on an input text chunk. The input needs to be a textual question referencing an #E[n] variable.

Input to each function should simply be a plain string, without any quotation marks or "+" to join a string with an evidence variable.

Output should follow this format:
Plan: [initial action based on input question]
#E0 = [function to call with input parameter]
Plan: [subsequent action, based on result of #E0]
#E1 = [next function to call and input parameter, possibly referring to prior evidence]
...
Final Answer: #E[n]

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


Instruction:
A chat. Please create a plan to generate an ideal response to the user instruction, making use of the available tools. Each plan will correspond to an 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:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is helpful in finding a list of sites that may contain the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
UrlCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
QuerySolver[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, e.g. What is the capital of France, given :evidence1:?

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

Question: Who invented the telephone and when was it patented?


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

Available Tools:
WikiLookup[input]: A tool that searches Wikipedia for information related to the input query.
WebCrawler[input]: A tool that crawls the web for information related to the input query.
QAModel[input]: A tool that answers questions based on common sense, world knowledge, or given context. It can reference previous evidence variables in its input.

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 with input parameter referencing previous evidence if needed]
...
Final Answer: #E[n]

Question: What is the history of the Eiffel Tower and how was it constructed?


Instruction:
A chat. Question: Who was Albert Einstein and what were his major contributions to physics?

Here are the tools available to be called:
BiographyTool[input]: Tool that provides biographical information about individuals.
ScienceArchive[input]: Tool that provides information about scientific discoveries and contributions.
QA[input]: Tool that can answer questions based on common sense and general world knowledge, as well as answering questions given input context that may contain the answer.
TimelineCreator[input]: Tool that creates timelines showing key events in a person's life or a sequence of events.
ImageSearch[input]: Tool that searches for images related to a specified topic.

Plan: First action to take based on input question
#E1 = BiographyTool["Albert Einstein"]
Plan: Next action to take, based on result of #E1
#E2 = ScienceArchive["Albert Einstein"]
Plan: Create a timeline of Einstein's life and achievements
#E3 = TimelineCreator[#E1 + " " + #E2]
Plan: Search for relevant images
#E4 = ImageSearch["Albert Einstein"]
Final Answer: #E1 + ", " + #E2 + ", " + #E3 + ", " + #E4


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

Tools Available:
GoogleSearch[input]: Allows the user to search for information via Google. Finds a list of sites that might contain the answer to the user's question.
WebScraper[input]: Loads one or more websites from the input string (containing newline delimited links) and produces plain text output containing the content of the links.
LinksExtractor[input]: Extracts links from plain text and produces a plain text, newline-delimited response of links.
QAModel[input]: Language model that answers questions based on an input passage of text.

The output should follow this format:
Plan: [First action based on input question]
:Evidence0: = [Function to call with input parameter]
Plan: [Next action based on result of :Evidence0:]
:Evidence1: = [Next function to call and input parameter, possibly referring to previous evidence, e.g., "Given context :Evidence0:"]
...
Answer: [:Evidence[n]: containing the final answer.]

Question: Who invented the Internet and what was their motivation?


Instruction:
A chat. Develop a detailed execution plan for solving the following problem. You have access to a number of external tools which you can use to retrieve data. Store this data into variables #E[index] that can be referenced later.

Available Tools:
Bing[input]: A tool that uses Bing's search engine to gather information related to the input query.
DataMiner[input]: A tool that extracts structured data from unstructured text obtained from a webpage.
QA_Solver[input]: A tool that answers questions using general world knowledge and specific context provided as input.

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

Question: Who invented the light bulb and what was their motivation behind it?


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

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

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

Question: What are some significant contributions made by Nikola Tesla?


Instruction:
A chat. Generate a step-by-step plan to answer the question: "Who won the Wimbledon Men's Singles title in 2019?"

Here are the tools available:
SportsDB[input]: A tool that provides sports-related information.
QA[input]: A tool that answers questions using common sense and general world knowledge or given an input context.
NewsArchive[input]: This tool searches archived news articles.
TextAnalyzer[input]: Analyzes a piece of text and extracts key details.
LLM[input]: Question answering language model.

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


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information using a web search engine. This tool is useful in finding an appropriate list of sites that may include the answer to the user's question.
TextParser[input]: Extracts key information from plain text and produces a plain text response containing this information.
SiteScraper[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.
AnswerBot[input]: Question answering bot, particularly useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable.

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

Question: What is the history behind the construction of the Eiffel Tower?


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

Here are the tools you have at your disposal:
DuckDuckGo[input]: A tool that allows users to search for information on the internet via DuckDuckGo. This function doesn't directly provide answers but offers a list of sites that might contain the required information.
WebReader[input]: Load one or more websites from the input string containing newline delimited links. The 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.
InfoProcessor[input]: Question answering language model, useful in providing answers based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., What color is the cat, given :evidence1:?

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

Remember to include only one evidence output per plan step.

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

Question: Who was the first person to climb Mount Everest and what were their key achievements?


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

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

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

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

Question: What is the average lifespan of a Galapagos tortoise and where do they primarily live?


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

Here are the tools available to use:
Bing[input]: A tool that allows the user to search for information via Bing's search engine. This tool is useful in finding a list of sites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from websites given an input string containing newline delimited links.
LinkParser[input]: Parses plain text and produces a plain text, newline-delimited response of links.
AIQA[input]: An artificial intelligence question answering model that answers questions based on an input passage of text. The input must be a text question that references a :data[n]: variable.

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

Remember to include only one evidence output per plan step.

The output format should be:
Plan: [first action based on input question]
:data0: = [function to call with input parameter]
Plan: [next action based on result of :data0:]
:data1: = [next function to call and input parameter, referencing previous evidence if necessary]
...
Answer: [:data[n]: containing the final answer.]

Question: What is the population of the largest city in Canada and what languages are commonly spoken there?


Instruction:
A chat. Provide a detailed plan to solve the following problem using the available tools. Each plan should correspond to an evidence value, which will be the output of one of the available functions given an input string. This string could be the user's question, one or more previous evidence values, or a combination of both.

Here are the tools at your disposal:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding a suitable list of sites that may or may not contain the answer to the user's question. The function does not directly answer the question; instead, it locates a list of sites that might have the answer.
PageLoader[input]: Loads one or more websites from the input string containing newline-delimited links. The input is one or more links, and the output is plain text containing the content of the links.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and generates a plain text, newline-delimited response of links.
KnowledgeModel[input]: A question-answering language model, particularly effective in answering questions based on an input passage of text. The input must be a text question that refers to an :evidence[n]: variable, e.g., What color is the dog, given :evidence1:?

Each function requires a simple string as input, without quotation marks or "+" to concatenate a string with an evidence variable, e.g., KnowledgeModel[What is the population of New York City, given :evidence3:?]

Ensure that there is only one evidence output per plan step.

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

Question: Who designed the Eiffel Tower and what other notable structures did they design?


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

Here are the tools you have at your disposal:

1. DuckDuckGo[input]: This tool allows users to search for information using the DuckDuckGo search engine. It is useful in finding relevant websites that may contain answers to the user's question. The function does not directly provide an answer; it generates a list of sites that might have the answer.
2. TextParser[input]: Extracts and organizes important information from plain text. The input must be a plain text string.
3. LinkExtractor[input]: Pulls out links from plain text and provides a plain text response containing newline-separated links.
4. KnowledgeBaseQA[input]: A question-answering tool particularly adept at answering questions based on an input passage of text. The input must be a text question referencing an :evidence[n]: variable.

The input to each function should be a simple string without quotes or "+" signs to concatenate a string with an evidence variable (for example, KnowledgeBaseQA[What is the capital of France, given :evidence3:?]).

Each step of your plan should include only one evidence output.

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

Question: What are some major achievements of Elon Musk?


Instruction:
A chat. Create a plan to answer the following question using the available tools. Each step in your plan should be followed by an evidence value that is generated from one of the available functions.

Here are the tools you can use:
SearchEngine[input]: A tool that allows users to search for information on the internet. The input should be a string related to the query.
InfoExtractor[input]: This tool extracts specific pieces of information from a given text. The input must be a text and a query about the text.
TextSummarizer[input]: Summarizes large texts into smaller, more manageable chunks. The input should be a lengthy piece of text.
QA[input]: Tool that answers questions based on common sense and general world knowledge or from a given context.

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

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


Instruction:
A chat. Generate a comprehensive plan to respond to the user's request using the designated tools. Be sure to attach an evidence tag to every stage of your plan.

Available Tools:
CurrencyConverter[input]: Converts between different currencies.
WeatherAPI[input]: Provides weather forecasts for specified locations.
FlightTracker[input]: Gives real-time updates on flight statuses.
HotelFinder[input]: Finds hotels based on user-specified criteria.
GeniusAI[input]: Answers questions based on general knowledge or given context.

Output Format:
Plan: Initial step according to the input question
:Evidence0: = Function to perform with appropriate input
Plan: Following step influenced by the result of :Evidence0:
:Evidence1: = Upcoming function to execute with its input, potentially referencing earlier evidence such as "Based on :Evidence0:"
...
Answer: [:EvidenceN: containing the ultimate solution.]

Question: I'm planning a trip from London to Tokyo next week. Can you tell me the current exchange rate, the weather forecast in Tokyo, my flight status, and suggest a good hotel? Also, what is the time difference between London and Tokyo?


Instruction:
A chat. Create a plan to answer the following question using these available tools. Each tool should be followed by one evidence variable.

Tools:
Bing[input]: This function allows you to search for information on Bing. It can find a list of sites that may contain the answer.
TextReader[input]: This tool reads and extracts text from an input string containing newline delimited links, where input is one or more links, and produces plain text output containing the content of the links.
LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
AIML[input]: A language model that answers questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g. What color is the cat, given :evidence1:?

The output should follow this format:
Plan: [first action]
:evidence0: = [function with input parameter]
Plan: [next action]
:evidence1: = [next function with input parameter, which may include reference to previous evidence]
...
Answer: [:evidence[n]: containing the final answer.]

Question: Who is the current president of Microsoft and what are some of their major achievements?


Instruction:
A chat. Create a plan to respond to the following user instruction using the provided tools. For each step in your plan, provide an associated evidence value, which will be the output of a function given an input string that could be the user's query, prior evidence values, or a combination of both.

Available tools:
DuckDuckGo[input]: A tool that lets users perform searches on DuckDuckGo. Useful for identifying potential sources of answers to the user's question.
WebCrawler[input]: Takes one or more URLs from the input string (separated by newlines) and outputs the plaintext contents of those pages.
URLPicker[input]: Extracts URLs from plaintext and provides a plaintext, newline-separated list of URLs.
InfoBot[input]: A question-answering language model. Its input should be a textual question that references an :evidence[n]: variable.

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

Question: Who was Nikola Tesla and what were his most significant inventions?


Instruction:
A chat. Develop a systematic plan to solve the following problem using the listed tools. Each step in your plan should be accompanied by an evidence value representing the output of a function.

Tools Available:
NetSearch[input]: Searches the internet for information related to the input.
URLExtractor[input]: Extracts URLs from a block of text.
PageReader[input]: Reads webpage content from the provided URLs.
QuerySolver[input]: Answers questions based on a given context. The input should reference a #Evidence[n] variable.

Output Format:
Plan: [Initial action based on the input question]
#Evidence1 = [Function to call with input parameter]
Plan: [Following action based on the result of #Evidence1]
#Evidence2 = [Next function to call with input parameter, possibly referencing previous evidence]
...
Final Solution: #Evidence[n]

Question: When did the Renaissance period begin and end, and what were its major contributions to art?


Instruction:
A chat. Create a sequential plan to solve the user's question using the tools listed below. Each step in your plan should produce 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:
DuckDuckGo[input]: Allows users to perform searches using the DuckDuckGo search engine. Useful for locating websites that might contain the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string (which contains newline separated links), producing a plain text output containing the website(s)' content.
URLExtractor[input]: Extracts URLs from plain text and returns a plain text, newline-separated list of URLs.
InfoBot[input]: A question-answering language model that provides answers based on an input text passage. The input must be a textual question that references an :info[n]: variable.

Function inputs should be plain strings, without quotes or "+" symbols to concatenate a string with an info variable, e.g., InfoBot[What is the population of New York City, given :info1:?]

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

Output format:
Plan: [First action based on input question]
:info0: = [Function call with input parameter]
Plan: [Next action based on result of :info0:]
:info1: = [Next function call and input parameter, potentially referencing previous evidence, e.g., "Given context :info0"]
...
Final Answer: [:info[n]: Containing the final answer.]

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


Instruction:
A chat. Formulate a comprehensive plan to answer the user's inquiry utilizing the provided tools. Each stage of your plan should produce an evidence value, representing the outcome of one of the available functions when supplied with an appropriate input string. This string could be the original user question, one or more earlier evidence values, or a mix of both.

Available Tools:
WikiSearch[input]: Searches Wikipedia for information related to the input query.
QA_Solver[input]: Answers questions using either general world knowledge or a given context that may contain the answer.
NewsSearch[input]: Finds recent news articles related to the input query.
ArticleSummarizer[input]: Summarizes long articles into shorter texts.

Output Format:
Plan: [Initial action based on the user's question]
#E1 = [Called function with necessary input]
Plan: [Next action based on the result of #E1]
#E2 = [Following function to call with necessary input, potentially referring to previous evidence such as "Given context #E1"]
...
Final Answer: #E[n]

Question: What is quantum computing and how has it been used recently?


Instruction:
A chat. Construct a plan to solve: "What are the ingredients of a Margherita pizza and where did it originate?"

Tools available:
RecipeFinder[input]: Tool that provides recipes and ingredient lists for various dishes.
FoodOrigin[input]: Tool that provides information about the origin of different foods.
QA[input]: Tool that answers questions using general world knowledge.

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


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

Here are the tools available to be called:
DuckDuckGo[input]: Tool that allows the user to search for information using the DuckDuckGo search engine.
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.
URLFinder[input]: Extract links from plain text and produces a plain text, newline delimited response of links.
BERT[input]: Question answering language model, particularly useful in answering questions based on an input passage of text.

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

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

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


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

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


Instruction:
A chat. Develop a plan to solve the problem presented in the following question using the tools outlined below. For each step in your plan, assign an associated evidence value (#E[index]) that represents the output of a specific function given its input parameters.

Tools Available:
BingSearch[input]: Tool that enables users to perform a Bing search. It does not provide direct answers but generates a list of potentially relevant websites.
URLLoader[input]: Loads the content of one or more websites from an input string containing newline separated URLs.
HyperlinkExtractor[input]: Extracts hyperlinks from a block of plain text and returns them in a newline-separated format.
KnowledgeInterpreter[input]: Language model designed to answer questions based on a given piece of text. The input should be a question referencing a #E[index] variable.

Output Format:
Plan: [Initial action based on the question]
#E1 = [Function to execute with input parameters]
Plan: [Subsequent action based on #E1]
#E2 = [Next function to execute with input parameters, possibly referring to prior evidence like "Considering #E1"]
...
Final Answer: #E[n]

Question: Who invented the telephone and what were some significant events in their life?


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

Here are the tools you can use:
Bing[input]: This tool allows users to search for information on Bing. It is useful in finding relevant websites that may contain answers to the user's questions.
TextExtractor[input]: Extracts text from a website given its URL. The input must be a single link and the output is plain text containing the content of the webpage.
LinkFinder[input]: Finds links within plain text and produces a list of URLs.
AIAnswerer[input]: A language model designed to answer questions based on provided context. The input must be a question that references an :evidence[n]: variable.

Each function only accepts plain strings as inputs. To concatenate a string with an evidence variable, simply write them together without quotes or "+" symbols, e.g., AIAnswerer[What is the capital of France, given :evidence3:?]

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

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


Instruction:
A chat. Develop a step-by-step execution plan to respond to the user's query, utilizing the set of available tools. Each plan will correspond to an evidence value, which is the output of one of the available functions given an input string that could be the user's question, previous evidence values, or both.

Here are the tools available to be called:
BingSearch[input]: Tool that allows the user to search for information using Bing. It helps in finding sites that might contain the answer to the user's question.
SiteReader[input]: Load a website from the input string (a single link) and produce plain text output containing the content of the link.
URLCollector[input]: Extract URLs from plain text and produce a newline-delimited response of URLs.
AIAnswerer[input]: An AI model that answers questions based on an input passage of text. The input must be a text question that references a :evidence[n]: variable, e.g., What is the population of New York City, given :evidence1:?

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

Question: Who is the current Prime Minister of Canada and what are some significant policies they implemented?


Instruction:
A chat. Create a comprehensive plan to answer the following user inquiry, utilizing the listed tools. Each step in your plan should produce a piece of evidence, which represents the output of a particular function after receiving its input. This input could be the initial user question, any previously generated evidence, or a combination thereof.

Here are the tools at your disposal:
YahooSearch[input]: Allows users to perform searches via Yahoo. It generates a list of potential sites that might hold the answer, but does not provide the answer directly.
WebReader[input]: Accepts one or more URLs (divided by newlines) as input and yields the plaintext contents of those pages.
HyperlinkGatherer[input]: Gathers hyperlinks from plaintext and delivers them as newline-separated plaintext.
InfoProcessor[input]: An AI language model that can answer questions if supplied with a textual context. The input has to be a question referring to an :evidence[n]: variable, like "How old is Queen Elizabeth II, given :evidence1:?"

Each function's input should be a straightforward string, devoid of quotation marks or '+' symbols used to merge strings with evidence variables. For example, InfoProcessor[What is the population of Tokyo, given :evidence3:?].

Make sure every plan step includes just one piece of evidence.

Your output should follow this structure:
Plan: [First action derived from input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Next action, influenced by the result of :evidence0:]
:evidence1: = [Following function to call with input parameter, possibly referring to earlier evidence like "In light of :evidence0"]
...
Final Response: [:evidence[n]: which holds the final answer.]

Question: How did the Great Fire of London start and what were its consequences?


Instruction:
A chat. Develop a plan to solve the query: "Who invented the telephone and when was it patented?" Here are the available tools:

1. Encyclopedia[input]: Searches for factual information from an online encyclopedia.
2. TimeMachine[input]: Provides historical data related to a specific event or person.
3. AnswerBot[input]: Answers questions given a certain context.

Each step should have a corresponding evidence value. The final output should be presented as follows:
Step 1: [action]
#Evidence1 = [tool with input]
Step 2: [action]
#Evidence2 = [tool with input]
...
Final Result: #EvidenceN


Instruction:
A chat. Develop a plan to solve the following problem using the tools at your disposal. For each step in your plan, specify an evidence value that corresponds to the output of a particular function, taking into account the user's query, prior evidence values, or both.

These are the tools you can use:
DuckDuckGo[input]: A tool that lets users search for information via DuckDuckGo. It helps locate potential sources that might contain the user's desired information.
SiteReader[input]: Reads websites specified by newline-separated links in the input string. Outputs plain text comprising the contents of these sites.
URLGrabber[input]: Pulls URLs from plain text, producing a newline-separated list of links.
RoboQA[input]: A robot-powered Q&A model adept at generating answers from an input text passage. Input should be a text-based question that references an :evidence[n]: variable.

Each function requires a basic string as input, devoid of quotation marks or "+" signs used to concatenate strings with evidence variables (for example, RoboQA[Who won the 1998 World Cup, given :evidence3:?]).

Output should follow this format:
Plan: [initial action based on the input question]
:evidence0: = [call to function with input parameter]
Plan: [subsequent action based on the outcome of :evidence0:]
:evidence1: = [next call to function and input parameter, potentially referencing earlier evidence such as "Given context :evidence0"]
...
Answer: [:evidence[n]: that contains the ultimate answer.]

Question: Who was Ada Lovelace and what were her contributions to computing?


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

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

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

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


Instruction:
A chat. Devise a systematic approach to answer this question using these tools:
EncyclopediaLookup[input]: Looks up encyclopedia entries related to the input.
BookScanner[input]: Scans books for relevant sections.
SummaryGenerator[input]: Generates summaries of large bodies of text.
AccuracyTester[input]: Tests the accuracy of statements.
ContextualReplier[input]: Replies to inquiries based on contextual understanding.

Question: What are the origins and cultural significance of the Japanese tea ceremony?


Instruction:
A chat. Develop a comprehensive plan to solve the following user instruction using the tools provided. Each plan must correspond to an evidence value, which will be the output of one of the functions using an input string that could be the user's question, one or more previous evidence values, or both.

Here are the tools available to be called:
Bing[input]: A tool that enables users to conduct an internet search using Bing. This tool provides a list of sites that might contain the answer to the user's question.
SiteReader[input]: Loads one or more websites from the input string containing newline delimited links. Input is one or more links, and outputs plain text containing the site's content.
HyperlinkExtractor[input]: Extracts hyperlinks from plain text and produces a plain text, newline delimited response of links.
NLPModel[input]: Natural language processing 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., Who won the world series in 2020, given :evidence1:?

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

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


Instruction:
A chat. Generate a detailed plan to solve the following query, making use of the provided tools. Store the output of each tool into an evidence variable (#E[index]).

Available Tools:
1. Encyclopedia[input]: Searches for comprehensive and detailed information about a topic from online encyclopedias.
2. QA_System[input]: Answers questions based on general knowledge or given context.
3. CurrencyConverter[input]: Converts one currency to another at the current exchange rate.

Output Format:
Plan: [first action]
#E1 = [tool call with input]
Plan: [second action]
#E2 = [next tool call with input referencing previous evidence if needed]
...
Final Answer: #E[n]

Question: How much would 1000 Euros be worth in the country where the author of "War and Peace" was born?


Instruction:
A chat. Design a plan to answer the question: "Who wrote the novel 'Pride and Prejudice'?"

Here are the tools available:
BookLookup[input]: Tool that provides information about books and their authors.
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.
AuthorInfo[input]: Provides information about authors and their works.
LitAnalysis[input]: Analyses literary texts and extracts key details.
LLM[input]: Question answering language model.

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


Instruction:
A chat. Develop a detailed plan to solve the problem at hand. Each plan should utilize one of the available tools and store the output in a variable #E[index].

Available Tools:
Wiki[input]: Searches Wikipedia for information related to the input query.
Translate[input]: Translates the input text into English.
KnowledgeBase[input]: Can answer questions directly from common sense and general world knowledge, as well as answering questions given input context that may contain the answer.

The output should follow this format:
Plan: [First Action]
#E1 = [Function with Input Parameter]
Plan: [Next Action Based on Result of #E1]
#E2 = [Next Function Call and Input Parameter]
...
Final Answer: #E[n]

Question: What is the significance of the Sistine Chapel ceiling and who painted it?


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

Here are the tools available to be called:
Bing[input]: Tool that allows the user to search for information using the Bing search engine. This tool is useful in finding an appropriate list of sites that may or may not include the answer to the user's question.
WebReader[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.
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, e.g. What color is the cat, given :evidence1:?

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

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


Instruction:
A chat. Develop a step-by-step execution plan to respond to the user's request using the tools provided. Each step corresponds to an evidence value, which represents the output of a function given specific inputs.

Tools Available:
DuckDuckGo[input]: A tool that enables users to conduct a web search using DuckDuckGo. It finds a list of websites that might contain the answer to the user's question.
HTMLParser[input]: Loads one or more websites from the input string (containing newline-separated links), producing a plain-text output of the website contents.
URLExtractor[input]: Extracts URLs from plain text, providing a plain-text, newline-separated list of URLs.
TransformerQA[input]: A QA language model effective at answering questions based on an input text passage. The input should be a textual question referencing a #E[index] variable.

Output Format:
Plan: [Initial action based on the input question]
#E1 = [Function to call with input parameter]
Plan: [Subsequent action based on the outcome of #E1]
#E2 = [Next function to call with input parameter, potentially referring to prior evidence]
...
Final Answer: #E[n]

Question: Who designed the Sydney Opera House and what was their architectural style?


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

Here are the tools available to be called:
WebSearch[input]: Tool that allows the user to search for information on the internet. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts text from a website and produces plain text output containing the content of the site.
LinkFinder[input]: Extracts links from plain text and produces a plain text response of links.
KnowledgeBase[input]: A tool that answers questions based on common knowledge and facts. The input must be a text question that references a :data[n]: variable, e.g., What color is the sky, given :data1:?

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

Each plan should only include one evidence output.

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

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


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

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

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

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

Question: What is the significance of Fibonacci sequence in nature?


Instruction:
A chat. Develop a comprehensive plan to address the user's inquiry utilizing the following tools. Each step in your plan should correspond to an evidence value, which will be the output of one of the available functions given an input string that can be the user's question, earlier evidence values, or both.

Here are the tools available to use:
NetSearch[input]: Tool that enables the user to perform an internet search. This tool is beneficial in locating suitable websites that may hold the answer to the user's question.
ContentExtractor[input]: Extracts plain text from a webpage link provided as input and outputs plain text containing the contents of the page.
HyperlinkFinder[input]: Extracts hyperlinks from plain text and generates a plain text response of links.
QueryBot[input]: A question-answering bot that provides answers based on an input text passage. The input must be a text question that refers to a #E[n] variable, e.g., How tall is the Eiffel Tower, given #E1?

Each function's input should simply be a plain string, without quotation marks or "+" to concatenate a string with an evidence variable, e.g., QueryBot[Who wrote War and Peace, given #E3?]

Ensure that there is only one evidence output per plan step.

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

Question: Who were the key players involved in the Apollo 11 mission and what were their roles?


Instruction:
A chat. Develop a plan to solve the following query using the mentioned tools. Every tool must be utilized at least once and every plan step should produce an evidence value.

Tools Available:
DuckDuckGo[input]: This tool lets you search for information via the DuckDuckGo search engine. It helps in locating a range of websites that might hold the answer to the user's query.
PlainTextParser[input]: This tool examines a text chunk and pinpoints crucial details like names, locations, dates, etc.
URLGatherer[input]: Gathers all URLs from a specified text.
WebpageDataExtractor[input]: Pulls out specific data from a website using a URL.
QnA[input]: A tool capable of answering questions based on general knowledge or context supplied by preceding evidence.

Output Format:
Plan: [First action to take based on input question]
#Evidence1 = [Function to call with input parameter]
Plan: [Subsequent action to take, depending on the outcome of #Evidence1]
#Evidence2 = [Next function to call and input parameter, possibly referencing prior evidence, e.g., "Considering context #Evidence1"]
...
Final Answer: #Evidence[n]

Question: What year did NASA launch the Mars Rover Perseverance and what were its primary objectives?


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that allows the user to search for information using the DuckDuckGo search engine. This tool is useful in finding relevant websites that may contain the answer to the user's question.
TextExtractor[input]: Extracts plain text from a website link provided as input and produces a plain text output containing the content of the site.
LinkLister[input]: Extracts links from plain text and provides a list of links as output.
NLPModel[input]: Natural Language Processing model capable of answering questions based on an input passage of text. The input must be a text question referencing a #E[n] variable, e.g., What color is the cat, given #E1?

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

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


Instruction:
A chat. Construct a systematic plan to generate an optimal response to the user's query, leveraging the range of tools at your disposal. Each phase of your plan should correspond to an evidence value, which will be the output of one of the accessible functions when supplied with an input string that could be the user's question, preceding evidence values, or both.

The following tools are available for use:
1. Ecosia[input]: This tool enables the user to carry out an internet search using the Ecosia search engine. It creates a list of possible websites that might hold the answer to the user's question.
2. PageLoader[input]: This function retrieves one or more websites from the input string, which comprises newline-separated links, and delivers plain text output containing the content of the pages.
3. URLCollector[input]: This tool mines links from plain text and produces a plain text, newline-separated list of links.
4. KnowledgeEngine[input]: A question-answering language model, particularly skilled at delivering answers based on an input text passage. The input has to be a text question that refers to an :evidence[n]: variable.

The output should comply with the following format:
Plan: [First action to undertake based on the input question]
:evidence0: = [Function to invoke with input parameter]
Plan: [Next action to undertake, based on the outcome of :evidence0:]
:evidence1: = [Next function to invoke and input parameter, which may refer to previous evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

Question: What is the origin story of Batman and how has the character evolved over time?


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

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

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

Remember to include only one evidence output per plan step.

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

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


Instruction:
A chat. Create a step-by-step plan to address the following inquiry using the available resources. Each stage should have a corresponding piece of evidence, which is the output generated by executing the chosen function with the proper inputs.

Available Tools:
YahooSearch[input]: Allows users to conduct information searches through Yahoo. Useful for locating potential sources of answers.
PageLoader[input]: Takes a URL as input and retrieves the full text content of the page.
URLPicker[input]: Extracts all URLs from a given text and presents them as a simple list.
InfoAssistant[input]: Answers questions using either common sense, general world knowledge, or specific information provided in a context. To refer to previously obtained evidence, use #Evidence[index].

Output Format:
Plan: [First step based on the initial question]
#Evidence1 = [Function to be performed with suitable inputs]
Plan: [Next step based on the result of #Evidence1]
#Evidence2 = [Subsequent function to perform with required inputs, potentially referring back to previous evidence]
...
Final Response: #Evidence[n]

Question: What is quantum entanglement and how does it work?


Instruction:
A chat. Please create a step-by-step plan to generate an answer 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.
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 current population of Tokyo and what are some famous landmarks there?


Instruction:
A chat. Develop a plan to answer the following query using the tools provided. Each part of your plan should generate an evidence value, which will be the outcome of one of the available functions given an input string that could be the user's question, earlier evidence values, or both.

Tools available:
FactFinder[input]: This tool lets you search for factual information online. It doesn't provide direct answers but generates a list of potentially helpful sites.
InfoExtractor[input]: This tool extracts links from plain text and provides a plain text, newline-delimited response of links.
DataDigger[input]: This tool loads one or more websites from the input string (containing newline-delimited links) and outputs plain text containing the site contents.
QuerySolver[input]: This is a question-answering language model that excels at providing answers based on an input text passage. The input should be a text question referencing an #E[index] variable.

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

Question: Who designed the Sydney Opera House and what other notable buildings did they design?


Instruction:
A chat. Develop a sequential plan to solve the problem below, making use of the tools provided. Each step in your plan should produce an evidence value, which is the output of one of the available functions when fed an input string that could be the user's question, previous evidence values, or a combination of both.

These are the tools you can use:

1. WebSearch[input]: This tool lets users search for information via a renowned search engine. It helps locate a range of sites that may hold the answer to the user's question. The function does not offer direct answers but locates potential sources of these answers.
2. SiteReader[input]: This tool reads one or more websites indicated by the input string containing newline separated links. The input consists of one or more URLs, and the output is plain text containing the contents of these sites.
3. URLCollector[input]: This tool extracts URLs from plain text and generates a plain text, newline-separated list of URLs.
4. QueryMaster[input]: This is a language model designed to answer questions based on a supplied passage of text. The input has to be a textual question that references a :evidence[n]: variable, such as "What is the dog's breed, given :evidence1:?"

Each function requires a simple string as input, without quotation marks or "+" to join a string with an evidence variable, like QueryMaster[What is the population of Brazil, given :evidence2:?]

Ensure that each plan step includes just one evidence output.

The output should follow this format:
Plan: [initial action derived from input question]
:evidence0: = [function to call with input parameter]
Plan: [subsequent action derived from the outcome of :evidence0:]
:evidence1: = [next function to call and input parameter, possibly referring to prior evidence, e.g., "Given context :evidence0"]
...
Answer: [:evidence[n]: containing the final answer.]

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


Instruction:
A chat. 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.
ScraperTool[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.
LinkExtractorTool[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 are some major accomplishments of Albert Einstein?


Instruction:
A chat. Question: Who composed the music for the movie 'Inception' and what other movies has he/she worked on?

Here are the tools available to be called:
IMDb[input]: Tool that provides information about movies, TV shows, and celebrities.
ComposerFinder[input]: Finds the composer of a specified movie or show.
FilmographyExtractor[input]: Extracts the filmography of a specified person.

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


Instruction:
A chat. Generate a step-by-step execution plan to solve the problem presented in the user instruction, using the tools provided. Each plan should be followed by exactly one evidence (#E[index]) value.

Available tools:
DuckDuckGo[input]: Tool that enables users to search for information via DuckDuckGo search engine. It finds a list of sites that might have the answer to the user's question.
SiteLoader[input]: Loads one or more websites from the input string containing newline-delimited links. Input is one or more links, and it produces plain text output containing the link contents.
LinkCollector[input]: Extracts links from plain text and provides a plain text, newline-delimited response of links.
QuerySolver[input]: A question-answering language model. Particularly useful in answering questions based on an input passage of text. The input must be a text question that references a #E[n] variable.

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

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


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

Available Tools:
SearchEngine[input]: This tool allows you to search for information on the internet. The input is a string query and the output is a list of websites that may contain relevant information.
TextExtractor[input]: Extracts text from a website given its URL. The input is a string containing the URL, and the output is plain text content of the webpage.
QA[input]: Can answer questions based on common sense, general world knowledge or given context. The input should be a question string which may reference previous evidence variables as context.
DataAnalyzer[input]: Analyzes data and extracts key points. Particularly useful when dealing with large amounts of text or data. Input must be a text string referencing an evidence variable.

The output format should be:
Plan: [first action]
#E1 = [function call with input parameter]
Plan: [next action based on #E1]
#E2 = [next function call with input parameter, possibly referencing #E1]
...
Final Answer: #E[n]

Question: What are some of the main tourist attractions in Paris?


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

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

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

Question: What is the history of the Eiffel Tower and who was its architect?


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

Here are the tools available to be called:
DuckDuckGo[input]: A tool that enables the user to search for information using the DuckDuckGo search engine. It helps in finding suitable sites that might contain the answer to the user's question.
PageLoader[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 content of the pages.
LinkPicker[input]: Picks links from plain text and gives a plain text, newline-separated response of links.
NLPModel[input]: Natural Language Processing Model, particularly useful in answering questions based on an input text passage. The input should be a text question that refers to a :evidence[n]: variable, e.g., What is the weather like, given :evidence1:?

Each function's input should simply be a plain string, without quotes or "+" to join a string with an evidence variable, e.g., NLPModel[What is the population of New York City, given :evidence3:?]

Only include one evidence output per plan step.

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

Question: Who was awarded the Nobel Prize in Literature in 2021 and what is their most famous work?


Instruction:
A chat. Please generate a plan to answer the following question using these tools: WikiSearch[input], QASystem[input], GoogleMaps[input], WebScraper[input], LinkCollector[input] and TextAnalyzer[input]. Each tool must be used at least once, and one of them should be a question answering system similar to "QA". The output format should include an execution plan followed by exactly one evidence variable.

Here are the descriptions for each tool:

WikiSearch[input]: This tool allows you to search for information from Wikipedia. It is particularly useful in gaining knowledge about people, places, companies, historical events, etc.

QASystem[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.

GoogleMaps[input]: Tool that provides geographical data based on the input string. Useful for finding locations or getting geographical details about a place.

WebScraper[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.

LinkCollector[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.

TextAnalyzer[input]: Analyzes a piece of text and extracts key pieces of information such as names, dates, locations, etc.

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

Question: What is the history of the Eiffel Tower and how far is it from the Louvre Museum?


Instruction:
A chat. Create a step-by-step plan to address the user query, making use of the available tools. Each plan should have a corresponding evidence value.

Here are the tools available to be called:
DuckDuckGo[input]: Allows the user to search for information using DuckDuckGo. Useful in finding potential sources of answers.
WebReader[input]: Loads one or more websites from the input string containing newline delimited links, producing plain text output containing the content of the links.
LinkHarvester[input]: Extracts links from plain text and produces a plain text, newline delimited response of links.
JLM[input]: A question-answering language model, particularly useful in answering questions based on an input passage of text.

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

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


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

Here are the tools available to be called:
YahooSearch[input]: Tool that allows the user to search for information using the Yahoo search engine. This tool is useful in finding a suitable list of sites that may or may not include the answer to the user's question.
SiteReader[input]: Reads one or more websites from the input string containing newline separated links, where input is one or more links, and produces plain text output containing the content of the links.
HyperlinkSelector[input]: Selects links from plain text and produces a plain text, newline separated response of links.
QAModel[input]: Question answering language model, especially useful in answering questions based on an input passage of text. The input must be a text question that references an :evidence[n]: variable, e.g., How tall is the Eiffel Tower, given :evidence1:?

The input to each function should just be a plain string, without quotes or "+" to concatenate a string with an evidence variable, e.g., QAModel[Who invented the telephone, given :evidence2:?]

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

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

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


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

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

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

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


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

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

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

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

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