How to design effective AI prompts with Microsoft Prompt Engine

How to design effective AI prompts with Microsoft Prompt Engine

 

Introduction 

 

Explain what large language models (LLMs) are and what are some examples (GPT-3, Codex, etc.) 

 
Large language models (LLMs) are computer programs that can analyze and create text. They are trained using massive amounts of text data, which helps them become better at tasks like generating text, answering questions, summarizing documents, translating languages, and more. Language models are the foundation for many natural language processing (NLP) applications, such as speech-to-text, sentiment analysis, chatbots, and search engines. 

LLMs use deep learning models, which are multi-layered neural networks that can process, analyze, and make predictions with complex data. LLMs learn from the patterns and relationships in the text data they are fed, and they store this knowledge in their network weights. This allows them to generate coherent and relevant text based on a given input or context. 
Some examples of LLMs are: 

• GPT-3: A 175 billion parameter model developed by OpenAI that can generate text for various domains and tasks. It is one of the most advanced LLMs available to date. 

 

• Codex: A 12 billion parameter model also developed by OpenAI that can generate computer code in various programming languages. It is based on GPT-3 but fine-tuned on a large corpus of code. 

 

• LaMDA: A 137 billion parameter model developed by Google Research that can generate natural and engaging dialogues on any topic. It is trained on a diverse set of conversational data sources. 

 
Megatron-Turing NLG: A 530 billion parameter model developed by Microsoft/Nvidia that can generate natural language for various tasks such as summarization, question answering, and text completion. It is one of the largest LLMs ever trained. 

LLMs have shown impressive capabilities and potential for various NLP applications. However, they also pose some challenges and risks such as ethical issues, bias issues, environmental issues, security issues etc. Therefore, it is important to use them responsibly and with caution. 
 

Explain what are prompts and why they are important for LLMs 

 
Prompts are a way of communicating with large language models (LLMs) by providing them with some input text that guides them to perform a specific task. Prompts can be natural language sentences, questions, keywords, symbols, or even imaginary words that are designed to elicit a desired output from the LLM. 

Prompts are important for LLMs because they help them leverage their general knowledge and skills for various domains and tasks without requiring extensive fine-tuning or retraining. Prompts can also help users explore the capabilities and limitations of LLMs, as well as discover novel and creative applications. 

There are different types of prompts for LLMs, such as: 

• Zero-shot prompts: These are prompts that do not include any examples of the task. For example, a zero-shot prompt for translation may be: "Translate from English to Spanish: I like this book." 
• Few-shot prompts: These are prompts that include a few examples of the task before the input.  

For example, a few-shot prompt for translation may be:  
Translate from English to Spanish: 

Hello -> Hola 
 
Goodbye -> Adiós 
 
I like this book -> Me gusta este libro. 
 
Extensible prompts: These are prompts that use an extensible vocabulary of imaginary words that are defined by the user.  

For example, an extensible prompt for sentiment analysis may be:  
Sentiment analysis: 

Positive -> 🌞 
Negative -> 🌧️ 
Neutral -> 🌥️ 

This movie was boring and predictable. Sentiment =? 

Prompts can be challenging to design and optimize for LLMs, as they may depend on various factors such as the model size, the task complexity, the domain specificity, and the prompt format. Therefore, it is important to experiment with different prompts and evaluate their performance and robustness. 
 
Introduce Microsoft Prompt Engine as a library for helping developers create prompts for LLMs 
 
Introducing Microsoft Prompt Engine: A Library for Helping Developers Create Prompts for LLMs 
Large Language Models (LLMs) like GPT-3 and Codex have shown amazing capabilities of generating natural language and code, but they also pose some challenges for developers who want to use them for specific tasks. One of these challenges is prompt engineering, which is the art of crafting input texts that guides the LLMs to produce the desired output texts. 

Prompt engineering can be tricky and time-consuming, as it requires a lot of trial and error, domain knowledge, and intuition. Moreover, different LLMs may require different prompts for the same task, depending on their architecture, training data, and parameters. 

To help developers overcome these challenges, Microsoft has released Prompt Engine, an open-source library that provides a set of tools and utilities for creating and maintaining prompts for LLMs. Prompt Engine allows developers to: 

• Define prompt templates using a simple syntax that supports variables, conditions, formatting options, and more. 
• Generate multiple variations of prompts from a single template by sampling values from predefined or custom dictionaries. 
• Evaluate the quality and diversity of prompts using various metrics such as perplexity, accuracy, coverage, etc. 
• Optimize prompts using gradient-based or evolutionary methods to maximize their performance on a given task or dataset. 
• Store and manage prompts using a JSON-based format that can be easily imported or exported. 

Prompt Engine is designed to be flexible and compatible with any LLM that supports text generation via an API. It also integrates with popular frameworks such as Hugging Face Transformers and OpenAI Codex to provide easy access to state-of-the-art models. 
With Prompt Engine, developers can save time and effort in creating effective prompts for LLMs. They can also experiment with different prompt strategies and techniques to discover new possibilities and applications of LLMs. 
 
 

Body 

 

Explain how Prompt Engine works and what are its features 

 
It provides a set of classes and methods for defining prompt patterns, templates, constraints, etc. 
 
AI prompts are a way of communicating with large language models (LLMs) like GPT-3 and Codex, which can generate natural language and code based on a given input. However, LLMs are not perfect and may produce outputs that are irrelevant, inaccurate or inappropriate. To avoid these issues, developers need to craft inputs that guide the LLMs to produce certain kinds of outputs. This process is called prompt engineering. 

Microsoft Prompt Engine is an open-source library that helps developers create effective prompts for LLMs. It provides a set of classes and methods for defining prompt patterns, templates, constraints and other components that can be used to construct inputs for LLMs. It also allows developers to test their prompts on different models and datasets and evaluate their performance using various metrics. 
Some of the features of Microsoft Prompt Engine are: 

Pattern: A pattern is a general structure of an input that specifies what kind of output is expected from the LLM. For example, a pattern for question answering could be “Q: {question} A: {answer}”. A pattern can have multiple slots that can be filled with different values. 
 
Template: A template is a specific instance of a pattern that fills the slots with concrete values. For example, a template for question answering could be “Q: What is the capital of France? A: Paris”. A template can also have additional elements such as prefixes or suffixes that provide more context or instructions to the LLM. 
 
Constraint: A constraint is a condition that limits the possible values of a slot or an output. For example, a constraint for question answering could be “The answer must be a city name”. A constraint can be expressed as a regular expression, a list of values or a function. 
 

• Prompt: A prompt is the final input that is sent to the LLM. It consists of one or more templates concatenated together with optional separators. For example, a prompt for question answering could be “Q: What is the capital of France? A: Paris\nQ: What is the capital of Italy? A:”. The prompt should end with an incomplete template to indicate what output is expected from the LLM. 
• Using Microsoft Prompt Engine, developers can easily create and modify these components using Python code or JSON files. They can also use built-in methods to generate random templates from patterns and constraints, or load templates from external sources such as files or databases. 
• Microsoft Prompt Engine also supports testing and evaluation of prompts on different models and datasets. Developers can use methods such as run_prompt or run_batch to send prompts to various LLMs via APIs such as OpenAI’s GPT-3 Playground or Hugging Face’s Inference API. They can also use methods such as evaluate_prompt or evaluate_batch to measure how well their prompts perform on different tasks such as classification, summarization or generation using metrics such as accuracy, F1-score or BLEU score. 

By using Microsoft Prompt Engine, developers can leverage the power of LLMs while ensuring their outputs are relevant, accurate and appropriate for their applications. 
 
It allows users to test their prompts interactively or programmatically 
 
One of the challenges of prompt engineering is to find the optimal input that elicits the desired output from a large language model (LLM). To do this, users need to test their prompts on different models and datasets and observe how they perform various tasks. Microsoft Prompt Engine provides two ways of testing prompts: interactively or programmatically. 

Interactive testing allows users to send prompts to LLMs via APIs such as OpenAI’s GPT-3 Playground or Hugging Face’s Inference API and see the outputs in real time. Users can use methods such as run_prompt or run_batch to send one or more prompts to a specified model and dataset, and optionally specify parameters such as temperature, top-p or frequency penalty. Users can also use methods such as print_prompt or print_batch to display the prompts and outputs in a formatted way. 

Programmatic testing allows users to evaluate their prompts on different models and datasets using various metrics. Users can use methods such as evaluate_prompt or evaluate_batch to measure how well their prompts perform on tasks such as classification, summarization or generation using metrics such as accuracy, F1-score or BLEU score. Users can also use methods such as compare_prompts or compare_batches to compare the performance of different prompts on the same task using statistical tests. 

By using Microsoft Prompt Engine’s interactive or programmatic testing features, users can easily experiment with different prompt components and parameters and find the best input for their applications. 
 
It supports various LLMs such as GPT-3 and Codex via OpenAI API 
 
Large language models (LLMs) such as GPT-3 and Codex are powerful tools that can generate natural language and code based on a given input. However, to use these models effectively, developers need to create prompts that guide them to produce relevant, accurate and appropriate outputs. Microsoft Prompt Engine is an open-source library that helps developers create and test prompts for LLMs. 

One of the features of Microsoft Prompt Engine is that it supports various LLMs such as GPT-3 and Codex via OpenAI API. OpenAI API is a service that provides access to different versions of GPT-3 and Codex models through a simple interface. Developers can use methods such as run_prompt or run_batch to send prompts to any model available on OpenAI API, and receive outputs in JSON format. Developers can also specify parameters such as temperature, top-p or frequency penalty to control the randomness and diversity of the outputs. 

By using Microsoft Prompt Engine with OpenAI API, developers can leverage the power of LLMs such as GPT-3 and Codex for various applications such as question answering, summarization, classification or dialog. They can also experiment with different prompt components and parameters and evaluate their performance using various metrics. 
 
Give some examples of using Prompt Engine to create prompts for different tasks and domains 
 

Question answering 

 
Microsoft Prompt Engine is a library for helping developers create prompts for Large Language Models (LLMs) like GPT-3 and Codex1. Prompt engineering is a technique for enabling specific behavior out of LLMs by crafting inputs that coax the model to produce certain kinds of outputs. 
One of the common use cases for LLMs is question answering, where the model can answer natural language questions based on some given context. For example, given a passage about Microsoft’s history, the model can answer questions like “When was Microsoft founded?” or “Who is the current CEO of Microsoft?”. 

However, answering the question with LLMs is not trivial. Depending on how the input is formatted, the model may give incorrect or irrelevant answers, or fail to answer at all. Moreover, different domains may require different types of questions and answers, such as factual vs. opinion-based, single-word vs. multiple-sentence, etc. 

This is where Microsoft Prompt Engine comes in handy. It provides a simple tool that helps you construct an appropriate pattern for building prompts. It also helps you manage the limitations of LLMs by adding constraints and filters to ensure that the output is accurate and on-topic. 

To use Microsoft Prompt Engine, you need to install it from GitHub4 and import it into your Python code. Then you can use its classes and methods to create prompts for various domains and tasks. 
For example, suppose you want to create a prompt for question answering in the domain of sports. You can use the following code: 

from prompt_engine import * 
 
# Create a domain object 
sports = Domain("Sports") 
 
# Add some context 
sports.add_context("The 2020 Summer Olympics were held in Tokyo from July 23 to August 8.") 
 
# Create a task object 
qa = Task("Question Answering") 
 
# Add some questions 
qa.add_question("How many medals did Japan win?") 
qa.add_question("Which country won the most gold medals?") 
qa.add_question("What sport was added to the Olympics for the first time?") 
 
# Create a prompt object 
prompt = Prompt(sports, qa) 
 
# Generate an input string 
input_string = prompt.generate_input() 
 
# Print it out 
print(input_string) 
 
The output would look something like this: 
Domain: Sports 
 
Context: The 2020 Summer Olympics were held in Tokyo from July 23 to August 8. 
 
Task: Question Answering 
 
Questions: 
- How many medals did Japan win? 
- Which country won the most gold medals? 
- What sport was added to the Olympics for the first time? 
 
Answers: 
 
You can then feed this input string to an LLM of your choice (such as GPT-3 or Codex) and get something like this: 
Domain: Sports 
 
Context: The 2020 Summer Olympics were held in Tokyo from July 23 to August 8. 
 
Task: Question Answering 
 
Questions: 
- How many medals did Japan win? 
- Which country won the most gold medals? 
- What sport was added to the Olympics for the first time? 
 
Answers: 
- Japan won 58 medals (27 gold, 14 silver, 17 bronze). 
- The United States won the most gold medals with 39. 
- Karate was added to the Olympics for the first time. 
 
Of course, this is just one example of how you can use Microsoft Prompt Engine to create prompts for question answering. You can customize your prompts by adding more context, questions, constraints and filters according to your needs. 
 

Summarization 

 
Summarization is the task of producing a concise and accurate summary of a longer text or document. It is one of the many applications of Large Language Models (LLMs) like GPT-3 and Codex, which can generate natural language and code based on given inputs. 
However, LLMs are not perfect and may produce outputs that are irrelevant, inaccurate, or biased. To avoid these issues, we need to craft effective inputs that guide the LLMs to produce the desired outputs. This process is called prompt engineering. 

Prompt engineering involves designing a pattern of text that includes instructions, examples, keywords, and other elements that help the LLM understand the task and generate appropriate responses. For example, a simple prompt for summarization could look like this: 

<code> 
Summarize this article in three sentences: 
 
Article: Lorem ipsum dolor sit amet... 
 

Summary: 

 
Some possible summaries are: 
 
- A placeholder text that illustrates how to summarize an article using LLMs. 
- An example of an article summary using prompt engineering with LLMs. 
- Lorem ipsum is a common text used for demonstration purposes in summarization tasks. 
</code> 

To create effective prompts for different tasks and domains of summarization, we can use Microsoft Prompt Engine, a Python utility library that helps developers create and maintain prompts for LLMs. 
Microsoft Prompt Engine provides several features that make prompt engineering easier and more efficient: 

• It allows us to define templates for different types of prompts, such as question answering, classification, translation, etc., and customize them with parameters such as length limit, number of examples, keywords, etc. 
  
  
• It enables us to test our prompts with different LLMs (such as GPT-3 or Codex) using OpenAI’s API or local models (such as Hugging Face Transformers) and compare their outputs and metrics (such as accuracy, diversity, etc.). 
   
• It helps us to refine our prompts by applying various techniques such as rewriting rules (to improve clarity or style), filtering rules (to remove unwanted outputs), ranking rules (to select the best output), etc. 
   
• It helps us to manage our prompts by organizing them into projects and folders, saving them as JSON files or Python scripts, loading them from local or remote sources (such as GitHub), etc. 

 
Using Microsoft Prompt Engine can help us create more effective prompts for summarization tasks across different domains. 

For example, 

• We can create a template for news article summarization that includes instructions such as “Write a headline that summarizes the main point of the article”, “Write one sentence that explains why this news is important”, “Write one sentence that provides some background information or context”, etc., and test it with different articles from various sources (such as CNN or BBC). 
  
  
• We can create a template for scientific paper summarization that includes instructions such as “Write one sentence that states the research question or problem”, “Write one sentence that summarizes the main findings or results”, “Write one sentence that discusses the implications or limitations of the study”, etc., and test it with different papers from various fields (such as biology or computer science). 
  
  
• We can create a template for product review summarization that includes instructions such as “Write one sentence that expresses your overall opinion about the product”, “Write one sentence that mentions its pros and cons”, “Write one sentence that recommends it to others or not”, etc., and test it with different reviews from various platforms (such as Amazon or Yelp). 

 
By using Microsoft Prompt Engine for summarization tasks, we can leverage the power of LLMs while avoiding their pitfalls and produce high-quality summaries that are relevant, accurate and informative. 
 

Classification 

Classification is the task of assigning a label or category to a given text or document based on its content or features. It is one of the many applications of Large Language Models (LLMs) like GPT-3 and Codex, which can generate natural language and code based on given inputs. 

However, LLMs are not perfect and may produce outputs that are irrelevant, inaccurate, or biased. To avoid these issues, we need to craft effective inputs that guide the LLMs to produce the desired outputs. This process is called prompt engineering. 

Prompt engineering involves designing a pattern of text that includes instructions, examples, keywords, and other elements that help the LLM understand the task and generate appropriate responses. For example, a simple prompt for classification could look like this: 

<code> 
Classify this tweet into one of these categories: Positive, Negative, Neutral. 
 
Tweet: I love this product! It works great and looks amazing! 
 
Category: 
 
Some possible categories are: 
 
- Positive 
- Negative 
- Neutral 
 
The correct category for this tweet is Positive. 
</code> 
 
To create effective prompts for different tasks and domains of classification, we can use Microsoft Prompt Engine, a Python utility library that helps developers create and maintain prompts for LLMs. 
Microsoft Prompt Engine provides several features that make prompt engineering easier and more efficient: 

• It allows us to define templates for different types of prompts such as question answering, summarization, translation, etc., and customize them with parameters such as length limit, number of examples, keywords, etc. 
  
  
• It enables us to test our prompts with different LLMs (such as GPT-3 or Codex) using OpenAI’s API or local models (such as Hugging Face Transformers) and compare their outputs and metrics (such as accuracy, diversity, etc.). 
   
• It helps us to refine our prompts by applying various techniques such as rewriting rules (to improve clarity or style), filtering rules (to remove unwanted outputs), ranking rules (to select the best output), etc. 
   
• It helps us to manage our prompts by organizing them into projects and folders, saving them as JSON files or Python scripts, loading them from local or remote sources (such as GitHub), etc. 
  
  

Using Microsoft Prompt Engine can help us create more effective prompts for classification tasks across different domains. For example, 
 

• We can create a template for sentiment analysis that includes instructions such as “Classify this text into one of these categories: Positive, Negative, Neutral”, 
  
  
• “Use emoticons to indicate your confidence level: 😊 for high confidence, 😐 for medium confidence, 😕 for low confidence”, “Explain your reasoning briefly”, etc., and test it with different texts from various sources (such as tweets, reviews, comments, etc.). 
   
• We can create a template for topic modeling that includes instructions such as “Assign one or more topics to this document from this list: Politics, Sports, Entertainment, Business”, “Use hashtags (#) to separate multiple topics”, “Rank the topics by relevance from most relevant to least relevant”, etc., and test it with different documents from various fields (such as news articles, blogs, reports, etc.). 
  
  
• We can create a template for spam detection that includes instructions such as “Determine if this email is spam or not”, “Use YES or NO to indicate your answer”, “Provide some evidence from the email content that supports your answer”, etc., and test it with different emails from various sources (such as newsletters, promotions, scams, etc.). 

 
By using Microsoft Prompt Engine for classification tasks, we can leverage the power of LLMs while avoiding their pitfalls, and produce high-quality labels that are relevant, accurate, and informative. 
 
 

Code generation 

 
Code generation is the task of producing executable code or pseudocode based on a given specification or description. It is one of the most impressive applications of Large Language Models (LLMs) like GPT-3 and Codex, which can generate natural language and code based on given inputs. 

However, LLMs are not flawless and may produce outputs that are syntactically incorrect, semantically inconsistent, or functionally incomplete. To avoid these issues, we need to craft effective inputs that guide the LLMs to produce the desired outputs. This process is called prompt engineering. 

Prompt engineering involves designing a pattern of text that includes instructions, examples, keywords, and other elements that help the LLM understand the task and generate appropriate responses. For example, a simple prompt for code generation could look like this: 

<code> 
Write a Python function that takes a list of numbers as input and returns the sum of all even numbers in the list. 
 
def sum_even_numbers(numbers): 
  # Your code here 
 
Some possible solutions are: 
 
def sum_even_numbers(numbers): 
  # Initialize sum variable 
  sum = 0 
  # Loop through each number in the list 
  for num in numbers: 
    # Check if number is even 
    if num % 2 == 0: 
      # Add number to sum 
      sum += num 
  # Return sum 
  return sum 
 
def sum_even_numbers(numbers): 
  # Use list comprehension to filter even numbers 
  even_numbers = [num for num in numbers if num % 2 == 0] 
  # Use built-in function to calculate sum 
  return sum(even_numbers) 
</code> 
 
To create effective prompts for different tasks and domains of code generation, we can use Microsoft Prompt Engine, a Python utility library that helps developers create and maintain prompts for LLMs. 
Microsoft Prompt Engine provides several features that make prompt engineering easier and more efficient: 

• It allows us to define templates for different types of prompts, such as code completion, code synthesis, code translation, etc., and customize them with parameters such as language, framework, style, difficulty, etc. 
   
• It enables us to test our prompts with different LLMs (such as GPT-3 or Codex) using OpenAI’s API or local models (such as Hugging Face Transformers) and compare their outputs and metrics (such as correctness, efficiency, readability, etc.). 
   
• It helps us to refine our prompts by applying various techniques such as rewriting rules (to improve syntax or semantics), filtering rules (to remove invalid or redundant outputs), ranking rules (to select the best output), etc. 
  
  
• It helps us to manage our prompts by organizing them into projects and folders, saving them as JSON files or Python scripts, loading them from local or remote sources (such as GitHub), etc. 

 
Using Microsoft Prompt Engine can help us create more effective prompts for code generation tasks across different domains. For example, 

• We can create a template for code completion that includes instructions such as “Complete this line of code”, “Use proper indentation”, “Use meaningful variable names”, etc., and test it with different lines of code from various languages (such as Python, Java, C#, etc.). 
  
  
• We can create a template for code synthesis that includes instructions such as “Write a function that performs this task”, “Use comments to explain your logic”, “Include error handling”, etc., and test it with different tasks from various fields (such as web development, data science, machine learning, etc.). 
   
• We can create a template for code translation that includes instructions such as “Translate this code from X language to Y language”, “Preserve the functionality and style of the original code”, “Use idiomatic expressions of Y language”, etc., and test it with different codes from various languages (such as JavaScript, Ruby, PHP, etc.). 

 
By using Microsoft Prompt Engine for code generation tasks, we can leverage the power of LLMs while avoiding their pitfalls, and produce high-quality codes that are correct, consistent, and complete. 
 

Dialog 

 

• Dialog is the task of producing natural language responses based on a given context or goal. It is one of the most challenging and diverse applications of Large Language Models (LLMs) like GPT-3 and Codex, which can generate natural language and code based on given inputs. 
  
  
• However, LLMs are not perfect and may produce outputs that are irrelevant, inconsistent, or inappropriate. To avoid these issues, we need to craft effective inputs that guide the LLMs to produce the desired outputs. This process is called prompt engineering. 
  
  
• Prompt engineering involves designing a pattern of text that includes instructions, examples, keywords, and other elements that help the LLM understand the task and generate appropriate responses. For example, a simple prompt for dialog could look like this: 

<code> 
You are a chatbot that helps users book movie tickets online. You can ask questions to get user preferences and provide suggestions based on availability and ratings. You should be polite, informative, and engaging. 
 
User: Hi 
Chatbot: Hello, welcome to MovieBot! I'm here to help you book movie tickets online. What movie would you like to watch? 
</code> 
 
To create effective prompts for different tasks and domains of dialog, we can use Microsoft Prompt Engine, a Python utility library that helps developers create and maintain prompts for LLMs. 
Microsoft Prompt Engine provides several features that make prompt engineering easier and more efficient: 

• It allows us to define templates for different types of dialogs, such as chit-chat, question answering, task-oriented, etc., and customize them with parameters such as domain, persona, style, tone, etc. 
  
  
• It enables us to test our prompts with different LLMs (such as GPT-3 or Codex) using OpenAI’s API or local models (such as Hugging Face Transformers) and compare their outputs and metrics (such as relevance, coherence, fluency, etc.). 
   
• It supports us to refine our prompts by applying various techniques such as rewriting rules (to improve grammar or semantics), filtering rules (to remove off-topic or offensive outputs), ranking rules (to select the best output), etc. 
   
• It helps us to manage our prompts by organizing them into projects and folders, saving them as JSON files or Python scripts, loading them from local or remote sources (such as GitHub), etc. 

 
Using Microsoft Prompt Engine can help us create more effective prompts for dialog tasks across different domains. For example, 

• We can create a template for chit-chat dialog that includes instructions such as “Have a casual conversation with the user”, “Use humor and emotion”, “Show interest in the user’s topics”, etc., and test it with different users from various backgrounds (such as age, gender, location, etc.). 
  
  
• We can create a template for question answering dialog that includes instructions such as “Answer the user’s questions accurately”, “Provide sources if possible”, “Ask follow-up questions if appropriate”, etc., and test it with different questions from various fields (such as history, science, sports, etc.). 
   
• We can create a template for task-oriented dialog that includes instructions such as “Help the user complete a specific goal”, “Use confirmations and clarifications”, “Provide feedback and suggestions”, etc., and test it with different goals from various domains (such as travel, shopping, banking, etc.). 

 
By using Microsoft Prompt Engine for dialog tasks, we can leverage the power of LLMs while avoiding their pitfalls, and produce high-quality dialogs that are relevant, consistent, and appropriate. 
 
 
 

Discuss some best practices and tips for designing effective prompts with Prompt Engine 

 

Use clear and specific instructions 

 
One of the best practices for designing effective prompts with Microsoft Prompt Engine is to use clear and specific instructions for what you want the LLM to do. Instructions are part of the input that guides the LLM’s behavior and output. They should be concise, precise, and unambiguous. 
For example, if you want to generate a summary of a news article, you can use an instruction like this: 
<code>Write a summary of this news article in three sentences:</code> 
Some tips for writing clear and specific instructions are: 

• Use imperative verbs that indicate an action or a task, such as write, generate, answer, classify, etc. 
  
  
• Specify any constraints or requirements for the output, such as length, format, tone, style, etc. 
   
• Avoid vague or general terms that may confuse or mislead the LLM, such as interesting, good quality, relevant, etc. 
   
• Use examples or templates to illustrate your expectations or provide guidance for the LLM. 
   
• Using clear and specific instructions can help you create prompts that elicit accurate and consistent responses from LLMs. 

 

Use relevant examples and counterexamples 

 
Another best practice for designing effective prompts with Microsoft Prompt Engine is to use relevant examples and counterexamples for what you want the LLM to do. Examples and counterexamples are part of the input that provide context and feedback for the LLM’s behavior and output. They should be related to your task, domain, and goal. 

For example, if you want to generate a tweet for a product launch, you can use an example like this: 

<code> 
Example: We're thrilled to announce our new product: Prompt Engine! A tool that helps you create amazing prompts for LLMs. Check it out at https://prompt.engine.com 
</code> 
 
And a counterexample like this: 
<code> 
Counterexample: Prompt Engine is here! It's awesome! You should buy it now! https://prompt.engine.com 
</code> 
 
Some tips for using relevant examples and counterexamples are: 

• Use examples that demonstrate good quality, style, tone, format, etc. for your desired output. 
  
  
• Use counterexamples that demonstrate common errors, pitfalls, biases, etc. that you want to avoid or correct in your output. 
   
• Use enough examples and counterexamples to cover different scenarios, cases, variations, etc. that may occur in your task or domain. 
   
• Update your examples and counterexamples as you interact with the LLM and observe its performance. 

Using relevant examples and counterexamples can help you create prompts that elicit accurate and consistent responses from LLMs. 
 

Use constraints to limit the output length or format 

 
Another best practice for designing effective prompts with Microsoft Prompt Engine is to use constraints to limit the output length or format for what you want the LLM to do. Constraints are part of the input that specify boundaries or rules for the LLM’s behavior and output. They should be relevant to your task, domain, and goal. 

For example, if you want to generate a tweet for a product launch, you can use a constraint like this:

 
<code>Constraint: The tweet should be no more than 280 characters long.</code> 
 

Some tips for using constraints are: 

• Use constraints that are clear, specific, and measurable for your desired output. 
  
  
• Use constraints that are appropriate and realistic for your task or domain. 
   
• Use constraints that are compatible and consistent with your instructions, examples, and counterexamples. 
   
• Use constraints that are flexible enough to allow some creativity or variation in your output. 
   
• Using constraints can help you create prompts that elicit accurate and consistent responses from LLMs. 

 

Use feedback loops to refine the prompts based on the outputs 

 
Another best practice for designing effective prompts with Microsoft Prompt Engine is to use feedback loops to refine the prompts based on the outputs for what you want the LLM to do. Feedback loops are part of the process that involve testing, evaluating, and improving your prompts based on how well they perform with your LLM. They should be iterative, data-driven, and goal-oriented. 

For example, if you want to generate a tweet for a product launch, you can use a feedback loop like this: 

• Test your prompt with different inputs and observe how your LLM responds. 
  
  
• Evaluate your output based on criteria such as accuracy, relevance, quality, style, tone, format, etc. 
   
• Improve your prompt by adding or modifying instructions, examples, counterexamples, constraints, etc. based on your evaluation. 

 

Some tips for using feedback loops are: 

• Use feedback loops that are frequent, timely, and consistent for your desired output. 
  
  
• Use feedback loops that are objective and measurable for your task or domain. 
   
• Use feedback loops that are collaborative and inclusive of different perspectives and stakeholders. 
   
• Use feedback loops that are adaptive and responsive to changing needs and expectations. 
   
• Using feedback loops can help you create prompts that elicit accurate and consistent responses from LLMs. 

 
 

Conclusion 

 
AI prompts are input patterns that instruct Large Language Models (LLMs) like GPT-3 and Codex to perform various tasks such as generating text, code, images, etc. Designing effective AI prompts can be challenging and time-consuming, especially for complex or novel tasks. 

That’s why Microsoft has developed Prompt Engine, a simple tool that helps you construct appropriate prompts for LLMs. Prompt Engine is a Python utility library that allows you to create and maintain prompts using instructions, examples, counterexamples, constraints, etc. It also provides feedback loops to test and refine your prompts based on your LLM’s outputs. 

Some benefits of using Prompt Engine for prompt engineering are: 

• It simplifies and standardizes the process of creating prompts for different tasks and domains. 
• It improves the quality and consistency of your LLM’s outputs by providing clear and relevant guidance. 
• It reduces the risk of errors or biases in your LLM’s outputs by providing counterexamples and constraints. 
• It enables you to iterate and improve your prompts based on data-driven feedback. 
• If you want to learn more about Prompt Engine or try it out yourself, here are some links or resources for further reading or learning: 
• The GitHub repository for Prompt Engine contains installation instructions, documentation, examples, tutorials, etc. 

The article "Design effective AI prompts with Microsoft Prompt Engine" provides an overview of how Prompt Engine works and how to use it for different tasks such as summarization, classification, question answering, etc. 

The video "Microsoft Designer: AI Prompt Design Principles" explains some techniques and principles for designing user-friendly and engaging AI prompts. 

Prompt Engine is an innovative tool that can help you harness the power of LLMs for various applications. By using Prompt Engine, you can create effective AI prompts that elicit accurate and consistent responses from LLMs.