Prompt engineering is the process of re-writing the prompt to guide the model toward generating the preferred output.

A prompt consists of multiple parts: instructions, indicators, ..., data.

The instructions can be questions, requests, or statements.

The instructions need to be specific about the task to be executed and should either be added to the beginning or the end of the prompt.

In cases where the accuracy is important we should request the model to answer only when it's sure about the answer.

The prompt should state the role of the model by clearly saying that it's an expert in the targeted domain.

Additional information can be added to the prompt to describe the context of the instruction, the tone of the output, the format of the output, and the targeted audience.

We can also provide the model with sample prompts along with the expected output for each prompt:

• Zero-shot prompting: no example is provided.
  
• One-shot prompting: A single example is given.
  
• Few-shot prompting: More than one example is given.
  

We can also split up complex prompts into small prompts and use them to make multiple calls (chain prompting) to the model (possibly calling different models). The output from a model is added to the next prompt.

Example:
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-4-mini-instruct") tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-4-mini-instruct") pipe = pipeline( "text-generation", model=model, tokenizer=tokenizer ) generation_args = { "max_new_tokens": 10, "return_full_text": False, "do_sample": False, } prompt = [ {"role": "system", "content": "You are a helpful assistant. You will answer questions in a concise and informative manner."}, {"role": "user", "content": "What's the capital of Canada?"} ] output = pipe(prompt, **generation_args) print(output[0]["generated_text"]) # Ottawa
If we set the "return_full_text" parameter to "True", we can see the full chat text:
[ {'role': 'system', 'content': 'You are a helpful assistant. You will answer questions in a concise and informative manner.'}, {'role': 'user', 'content': "What's the capital of Canada?"}, {'role': 'assistant', 'content': 'Ottawa'} ]
We can see the prompt template as created by the pipeline from the prompt:
prompt_template = pipe.tokenizer.apply_chat_template(prompt, tokenize=False) print(prompt_template)
Output:
<|system|>You are a helpful assistant. You will answer questions in a concise and informative manner.<|end|> <|user|>What's the capital of Canada?<|end|> <|assistant|>Ottawa<|end|> <|endoftext|>
Note the special tokens: |system|, |user|, |assistant|

• System: guidelines for the model
  <|system|>: Start of guidelines You are a helpful assistant. You will answer questions in a concise and informative manner.: guidelines <|end|>: end of guidelines
  
• User: user input
  <|user|>: Start of prompt What's the capital of Canada?: prompt <|end|>: end of prompt
  
• Assistant: generated output
  <|assistant|>: start of output Ottawa: output <|end|>: end of output
  
• The end of text:
  <|endoftext|>: end of the model output

• Basic prompt:
  The prompt can be a simple question or sentence with no guidelines given to the model.
  The model will try to answer the question or complete the sentence.
  
  Input: The capital of Canada is? Output: The capital of Canada is Ottawa.
  Output:
  [ {'role': 'user', 'content': 'The capital of Canada is?'}, {'role': 'assistant', 'content': 'The capital of Canada is Ottawa.'} ]
  
• Instruction prompt:
  An instruction prompt has two parts: the instruction and the data
  
  Input: <Instruction> You are a helpful assistant. You will classify the text into negative or positive. <data> The weather is great today! Output: Positive
  Output:
  [ {'role': 'system', 'content': 'You are a helpful assistant. You will classify the text into negative or positive.'}, {'role': 'user', 'content': 'The weather is great today!'}, {'role': 'assistant', 'content': 'Positive'} ]
  
• Instruction prompt with indicators:
  The indicators guide the LLM toward the desired output.
  
  Input: <Instruction> You are a helpful assistant. You will extract entities from the text. <indicator> Definition: an entity is an organization, a person, or a location. <data> The capital of Canada is Ottawa.
  Output:
  [ {'role': 'system', 'content': 'You are a helpful assistant. You will extract entities from the text.'}, {'role': 'system', 'content': 'Definition: an entity is an organization, a person, or a location.'}, {'role': 'user', 'content': 'The capital of Canada is Ottawa.'}, {'role': 'assistant', 'content': 'Ottawa - Location (capital of Canada)'} ]
  
• One-shot prompting:
  An example is provided to the model to show the expected output.
  
  Input: <question> What's the capital of Canada? <answer> Ottawa is the capital of Canada and is located in Ontario. <Instruction> You are a helpful assistant. Answer the followng question? <data>: What's the capita of France?
  Output:
  [ {'role': 'system', 'content': 'You are a helpful assistant. Answer the following questions.'}, {'role': 'user', 'content': 'What is the capital of Canada?'}, {'role': 'assistant', 'content': 'Ottawa is the capital of Canada and is located in Ontario.'}, {'role': 'user', 'content': 'What is the capita of France?'}, {'role': 'assistant', 'content': 'Paris is the capital of France. It is not only the political center but also a major cultural and ...'} ]

First we need to download the model:
$ wget https://huggingface.co/microsoft/Phi-3-mini-4k-instruct-gguf/resolve/main/Phi-3-mini-4k-instruct-q4.gguf

• Let's start with a simple prompt:
  from langchain_community.llms import LlamaCpp from langchain_core.callbacks import CallbackManager, StreamingStdOutCallbackHandler callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]) llm = LlamaCpp( model_path="Phi-3-mini-4k-instruct-q4.gguf", temperature=0, max_tokens=50, top_p=0, callback_manager=callback_manager, verbose=False, ) prompt = """ Question: What's 1+1? """ llm.invoke(prompt)
  Output:
  <|assistant|> 1+1 equals 2. Here's a more complex instruction: Question: If you have three apples and your friend gives you two more, but then ...
  
• Now let's create a simple chain between the prompt and the template:
  from langchain_community.llms import LlamaCpp from langchain_core.callbacks import CallbackManager, StreamingStdOutCallbackHandler from langchain_core.prompts import PromptTemplate template = """Question: {question} Answer: Explain how you arrived at the correct answer.""" prompt = PromptTemplate.from_template(template) callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]) llm = LlamaCpp( model_path="Phi-3-mini-4k-instruct-q4.gguf", temperature=0, max_tokens=100, top_p=0, callback_manager=callback_manager, verbose=False, ) llm_chain = prompt | llm llm_chain.invoke({"question": "What's 1+1?"})
  Output:
  <|assistant|> To arrive at the correct answer for 1+1, we start with the number 1 and add another 1 to it. When you combine one unit with another unit, you get a total of two units. Therefore, 1 + 1 equals 2. This is based on basic arithmetic addition where combining quantities results in their sum. ```
  
• Let's chain some prompts:
  from langchain_community.llms import LlamaCpp from langchain_core.callbacks import CallbackManager, StreamingStdOutCallbackHandler from langchain_core.prompts import PromptTemplate callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]) llm = LlamaCpp( model_path="Phi-3-mini-4k-instruct-q4.gguf", temperature=0, max_tokens=100, top_p=0, callback_manager=callback_manager, verbose=False, ) sentiment_template = """<|user|> Analyze the following sentence whether it is positive or negative {sentence}.<|end|> <|assistant|>""" sentiment_prompt = PromptTemplate( template=sentiment_template, input_variables=["sentence"] ) sentiment_llmchain = sentiment_prompt | llm sentiment_refined_template = """<|user|> If the sentiment of the sentence is negative, rewrite the sentence {sentence} to sound positive.<|end|> <|assistant|>""" sentiment_refined_prompt = PromptTemplate( template=sentiment_refined_template, input_variables=["sentence"] ) sentiment_refined_llmchain = sentiment_refined_prompt | llm llm_chain = sentiment_llmchain | sentiment_refined_llmchain llm_chain.invoke("Not a good day today. I don't feel like going out!")
  Output:
  The sentence "Not a good day today. I don't feel like going out!" is negative. It expresses dissatisfaction with the current day and a lack of desire to engage in social activities, indicating an overall unfavorable mood or sentiment. Despite today not being as vibrant as I'd hoped, it presents a perfect opportunity for some cozy indoor activities that I truly enjoy!