Comprehensive Guide on Prompt Engineering in LLMs

This series of tutorials are dedicated to exploring Large Language Models (LLMs) and their real-life applications across various use cases. If you’ve missed any previous posts, you can catch up on them here (links attached):

1. Gentle Introduction to Large Language Models
2. Semantic Search and RAG with Large Language Models
3. Open-Sourced and Closed-Sourced Large Language Models
4. Comprehensive Guide on Prompt Enginerring
5. Enhancing LLM Performance with Vector Search and Vector Databases

Do not forget to subscribe in order to receive the practical use-cases in the world of NLP.

What is Prompt Engineering (PE) and why do we need it?

As we discussed in a previous post about open-source LLMs, using open-sourced LLM models straight out of the box doesn’t always yield the best results for your specific tasks. One effective strategy for optimizing the performance of LLMs is known as prompt engineering.

Prompt engineering involves crafting precise and contextually rich prompts (input instructions) to guide the model towards generating more accurate and relevant outputs. By fine-tuning the input queries, you can significantly improve the quality of the responses.

Remember, prompt engineering is a cheaper and faster way to increase the LLMs performance, rather than spending tons of hours on fine-tuning the LLM. But always remember that it is not a magic wand that will do all the work for you, it is just one of the cheapest strategies from which you can start optimizing the model’s performance.

Few words about Alignment in LLMs

Alignment in language models refers to the model’s ability to understand and respond to input prompts (input instructions).

In language modeling, a model is trained to predict the next sequence of tokens based on the context of the preceding tokens. This method doesn’t ensure that the model will follow instructions, which limits the effectiveness of LLMs.

Prompt engineering becomes particularly challenging if the language model hasn’t been properly aligned with the prompts (input instructions) and this can lead to irrelevant output.

What alignment strategies are there:

1. Constitutional AI-driven Reinforcement Learning from AI Feedback (RLAIF)
2. Reinforcement Learning from Human Feedback (RLHF)

By incorporating alignment strategies like RLAIF and RLHF, models can better handle complex tasks such as question-answering or language translation.

Prompt Engineering and Prompt Engineering Strategies

Prompt engineering strategy refers to the methods and techniques used to design and structure input prompts for language models to obtain the most accurate and relevant responses.

The effectiveness of an LLM often hinges on how well the prompts are crafted, as the prompts guide the model in generating appropriate and meaningful output.

The prompting or prompt engineering is like a game of trial and error, you will never know beforehand what kind of prompt, structure and the content of your prompt will work brilliantly. If you like experimenting you will definitely like prompt engineering.

There is a list of comprehensive approaches that will return to you desirable results depending on your tasks:

The list of prompt strategies with description and examples

Let’s break down each of the strategies and see how each of the approaches works in practice.

1. Direct Instructions

Direct Instructions is the most straightforward and intuitive approach for prompt creation. This method involves explicitly stating the task you want the LLM to perform. The key to success with this approach lies in the clarity and precision of your prompt.

You simply provide a clear, simple and direct request, specifying exactly what you need the model to do. This approach is highly effective for simple tasks that can be resolved in a straightforward manner, such as:

• Grammar Correction: Correct the grammar of this sentence: “She go to the store yestardey.”
• Translation: Translate the following text from English to Polish: “Where is the nearest hospital?”
• Recipe Generation: “Provide a recipe for making brownies.”

The effectiveness of Direct Instructions hinges on the alignment of the language model. Instruction-aligned models are trained to understand and execute direct commands accurately.

Tips and tricks with Direct Instructions:

• A direct instruction: sounds dumb, but yes just ask what do you want to get back: “Translate from English to Polish…”. This is a form of direct instruction part of the prompt.
• Define the designated input after direct instruction: “Translate from English to Polish “How to get to the city centre?”
• Add a designated delimiter between direct instruction and input, e.g.: “Translate from English to Polish : “How to get to the city centre?”.

The example of Direct Instruction via Llama3 LLM in translation task (via LM Studio)

The same instruction can be inputted in the code sample. Just for the simplicity, most of the approaches will be shown through the LM Studio Chat UI or OpenAI’s API.

2. Few-Shot Prompting

Direct Instruction strategy works well for simple tasks. However, for more complex tasks that require a deeper understanding and context, we should employ a strategy like Few-Shot Prompting.

Few-Shot Prompting involves providing the language model with a few examples of the task you want it to perform. These examples help the model understand the context, nuances, and desired outcome, thereby improving its ability to generate accurate and relevant responses.

By including a few examples, you give the model a clearer idea of the task requirements. The model leverages these examples to infer patterns, context, and specific details that are crucial for completing the task effectively.

This approach is especially useful for tasks that require a specific tone, style, or domain-specific knowledge. And it is widely used in practice or in production together with other strategies.

Tips and tricks with Few-Shot Prompting:

• Clear Input Instruction (e.g. “Classify the following reviews as positive or negative…”).
• Relevance: Ensure that the examples you provide are highly relevant to the task at hand.
• Diversity: Use examples that cover a range of possible scenarios to give the model a broad understanding of the task (e.g. you should not provide totally identical examples).
• Clarity: Make sure each example is clear and unambiguous to avoid confusing the model.

The example of Few-Shot Prompting via Llama3 in classification task

Limitations with Few-Shot Prompting that you must know before considering using this in your task:

• Example Dependence: The quality of the model’s output heavily depends on the quality and relevance of the provided examples.
• Scalability: Providing multiple examples can become cumbersome for very large datasets or extremely complex tasks.
• Inference Cost: Few-Shot Learning can increase the computational cost of inference due to the additional context that needs to be processed.

In practice this is one of the popular approaches. If you want to test the Few-Shot prompting approach via your models or via simple Completion functionality of OpenAI’s API, you should define the prompt structure in the following way:

import openai
import os

# Create .env file in root directory and place here 
# Your OpenAI's API Key named as OPENAI_API_KEY
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
client = OpenAI(api_key = OPENAI_API_KEY)

# Define the few-shot learning prompt
# The prompt definition always starts and ends with triple quotes
few_shot_prompt = """
Classify the following reviews as positive or negative:
- 'The product quality is amazing!' (Positive)
- 'I am very disappointed with the service.' (Negative)
- 'Exceeded my expectations in every way!' (Positive)
- 'Not worth the money.' (Negative)

Now classify this review: 'Fantastic customer support and great value for money.'
"""

response = client.completions.create(
  model="gpt-4o",
  prompt=few_shot_prompt,
  max_tokens=60,
  temperature=0.2,
)

print(response.choices[0].text.strip())

In real projects such prompt can consist of few hundreds rows of explanations in order to solve specific task. The example above is just a simple one that you can use and test straight away.

3. Zero-Shot Prompting:

Zero-Shot Prompting is a powerful technique where the model is asked to perform a task without being given any specific examples beforehand. This approach leverages the extensive training that the model has undergone to understand and complete tasks based solely on the instructions provided in the prompt.

It’s particularly useful for tasks where examples are not readily available or when you want to test the model’s generalization capabilities.

In Zero-Shot Prompting, you simply provide a clear and concise prompt that describes the task you want the model to perform. The model uses its pre-trained knowledge to generate a response based on the instructions given.

Zero-Shot Learning works because modern language models, like GPT-4, have been trained on vast amounts of diverse data. This training allows them to understand and respond to a wide range of tasks, even those they haven’t explicitly been trained on. The model relies on its ability to generalize from the patterns and information it has learned during training.

Tips and tricks with Zero-Shot Prompting:

• Clarity: Ensure your instructions are as clear and specific as possible.
• Simplicity: Avoid overly complex prompts that might confuse the model.
• Context: Provide enough context to help the model understand the task, but keep it concise.

Zero-Shot Prompting often goes with hand in hand with such tasks as summarization and classification, but also can be easily extrapolated to other tasks as well.

Limitations in Zero-Shot Prompting:

• Accuracy: May not be as accurate as few-shot or fine-tuned approaches, especially for very specific or complex tasks.
• Dependence on Clarity: The quality of the output heavily depends on the clarity and specificity of the prompt.
• Context Understanding: Without examples, the model might misunderstand the context or nuances of the task.

import openai
import os

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
client = OpenAI(api_key = OPENAI_API_KEY)

# Define the zero-shot learning prompt for summarization
zero_shot_prompt = """
Summarize the following article in one sentence: 
'Artificial intelligence is transforming various industries by automating tasks and providing insights through data analysis. This technology is becoming increasingly important in sectors such as healthcare, finance, and transportation.'
"""

response = client.completions.create(
  model="gpt-4o",
  prompt=zero_shot_prompt,
  max_tokens=60,
  temperature=0.7,
)

print(response.choices[0].text.strip())

4. Chain-of-Thought Prompting:

Chain-of-Thought Prompting is an advanced technique that guides the language model through a series of logical steps to complete a task.

By breaking down complex tasks into smaller, manageable parts, this approach helps the model understand the process and generate accurate, detailed responses.

This technique is particularly useful for tasks requiring reasoning, multi-step processes, or detailed explanations.

Chain-of-Thought Prompting leverages the model’s ability to understand and follow sequences of instructions. By breaking down the task, the model can process each part individually, leading to more accurate and thorough responses.

Tips and tricks with Chain-of-Thought Prompting:

• Step-by-Step Instructions: Clearly outline each step of the task in the prompt.
• Logical Flow: Ensure that the steps follow a logical sequence.
• Clarity and Detail: Provide detailed instructions for each step to avoid ambiguity.

import openai
import os

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
client = OpenAI(api_key = OPENAI_API_KEY)

# Define the complex chain-of-thought prompting 
# for solving a multi-step math and physics problem
chain_of_thought_prompt = """
Solve the following problem step-by-step: Given a right triangle where one leg is twice the length of the other leg and the hypotenuse is 10 units:
1. Find the lengths of the legs and the area of the triangle.
2. Use the area to solve for x in the equation Area = 2x + 10.
3. Calculate the time it takes for an object to fall from the height of the longer leg under gravity (assuming no air resistance and g = 9.8 m/s^2).

Step 1: Define the variables.
Let the shorter leg be denoted as 'a'. Therefore, the longer leg will be '2a'.

Step 2: Use the Pythagorean theorem to set up the equation.
The Pythagorean theorem states that in a right triangle, the square of the hypotenuse (c) is equal to the sum of the squares of the other two sides (a and b). 
Thus, we have: a^2 + (2a)^2 = 10^2

Step 3: Simplify and solve for 'a'.
a^2 + 4a^2 = 100
5a^2 = 100
a^2 = 20
a = sqrt(20)
a = 2sqrt(5)

Step 4: Find the length of the longer leg.
The longer leg is 2a, so: 2a = 2 * 2sqrt(5) = 4sqrt(5)

Step 5: Calculate the area of the triangle.
The area of a triangle is given by (1/2) * base * height. Here, the base and height are the legs of the triangle.
Area = (1/2) * a * 2a
Area = (1/2) * 2sqrt(5) * 4sqrt(5)
Area = (1/2) * 8 * 5
Area = 20

Step 6: Use the area to solve for 'x' in the equation Area = 2x + 10.
We have: 20 = 2x + 10
Solve for 'x': 
20 - 10 = 2x
10 = 2x
x = 5

Step 7: Calculate the time for an object to fall from the height of the longer leg under gravity.
The height of the longer leg is 4sqrt(5) units.
Convert to meters (if necessary) and use the equation of motion: h = (1/2)gt^2, solve for t.
4sqrt(5) = (1/2) * 9.8 * t^2
t^2 = 8sqrt(5) / 9.8
t = sqrt(8sqrt(5) / 9.8)

Step 8: Summarize the findings.
The lengths of the legs are 2sqrt(5) units and 4sqrt(5) units. The area of the triangle is 20 square units. The value of x is 5. The time for an object to fall from the height of the longer leg is t = sqrt(8sqrt(5) / 9.8) seconds.
"""

response = client.completions.create(
  model="gpt-4o",
  prompt=chain_of_thought_prompt,
  max_tokens=500,
  temperature=0.7,
)

print(response.choices[0].text.strip())

Limitations of this approach:

• Complexity: Creating detailed, step-by-step prompts can be time-consuming.
• Over-Specification: Too much detail in the prompts can lead to rigidity and reduce the model’s ability to generate creative or flexible responses.

This technique is especially useful for tasks requiring multi-step processes or detailed explanations, but might be too complex for unexperienced users with lack of the domain knowledge (imagine that you are automating some process or task in medical sphere or finance markets).

5. Role-Playing:

Role-Playing is another prompt engineering technique where the language model is assigned a specific role (e.g. experienced software engineer, social media marketer, speech writer and etc.) to generate responses that align with a particular style and experience.

Role-Playing works because it leverages the model’s extensive training on diverse text sources. By providing a clear context and role, you help the model narrow its focus and generate responses that are more aligned with the desired role.

Tips and tricks with Role-Playing Prompting:

• Clear Role Definition: Clearly define the role you want the model to adopt (e.g. programmer, marketer and etc).
• Consistent Prompts: Maintain consistency in the prompts to reinforce the desired role.
• Contextual Details: Provide relevant contextual details to help the model understand the scenario better.

Limitations and bottlenecks of the Role-Play Prompting:

• Potential for Misinterpretation: If the role or context is not clearly defined, the model might generate inappropriate or off-topic responses.
• Consistency: Maintaining a consistent role over long interactions can be challenging due to different reasons, especially due to the limitations in the LLM’s context length.
• Bias and Stereotyping: Care must be taken to avoid reinforcing stereotypes or biases through certain roles.

import openai
import os

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
client = OpenAI(api_key = OPENAI_API_KEY)

# Define the role-playing prompt for a customer service representative
role_playing_prompt = """
You are a friendly customer service representative. 
Respond to the following customer inquiry: 
"I need help with my order. It hasn't arrived yet."
"""


response = client.completions.create(
  model="gpt-4o",
  prompt=role_playing_prompt,
  max_tokens=100,
  temperature=0.7,
)

print(response.choices[0].text.strip())

6. Multi-Turn Prompting:

Multi-Turn Prompting is an interactive approach that involves a back-and-forth dialogue between the user and the language model. This method is particularly useful for complex tasks that require clarification, follow-up questions, or a step-by-step approach to problem-solving.

In Multi-Turn Prompting, the conversation between the user and the model consists of multiple exchanges. Each exchange builds on the previous ones, allowing the model to refine its understanding and provide more relevant responses. This iterative process helps in tackling complex problems, where the initial prompt might not be sufficient to capture all the nuances of the task (imagine the SQL code generation by provided context and asking for the follow-up questions).

Tips and tricks with Multi-Turn Prompting:

• Maintain Context: Ensure each turn builds on the previous one to maintain context.
• Be Specific: Ask specific follow-up questions to gather detailed information.
• Iterative Refinement: Use the iterative process to refine the model’s understanding and responses.

Benefits:

• Enhanced Accuracy: Allows for clarifications and follow-up questions, leading to more accurate responses.
• Dynamic Interaction: Mimics natural conversation, making it more engaging and effective.
• Context Retention: Maintains context across multiple exchanges, improving the relevance of responses.

Limitations:

• Complexity: Requires careful management of context and follow-up questions.
• Time-Consuming: Can be more time-consuming compared to single-turn interactions.
• Dependency on Model’s Context Window: The model’s ability to maintain context is limited by its context window size.

The code sample will be more structured and more complex because it is a complex case that works perfectly:

import openai
import os

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
client = OpenAI(api_key = OPENAI_API_KEY)

class SalesConversation:
    def __init__(self):
        self.conversation_history = ""
        self.client = OpenAI(api_key = OPENAI_API_KEY)

    def update_conversation(self, user_input, model_response):
        self.conversation_history += f"User: {user_input}\nModel: {model_response}\n"

    def get_response(self, prompt, max_tokens=150, temperature=0.7):
        response = self.client.completions.create(
            model="gpt-4o",
            prompt=prompt,
            max_tokens=max_tokens,
            temperature=temperature,
        )
        return response.choices[0].text.strip()

    def generate_prompt(self, user_input):
        return f"{self.conversation_history}User: {user_input}\nModel:"

    def run_conversation(self):
        # Initial prompt
        initial_prompt = """
You are a friendly and knowledgeable B2B sales representative. Respond to the following potential client inquiry:
User: I'm interested in learning more about your software solutions for data analytics.
"""
        response_1 = self.get_response(initial_prompt)
        self.update_conversation("I'm interested in learning more about your software solutions for data analytics.", response_1)
        print("Model:", response_1)

        # User follow-up 1
        user_followup_1 = "Can you provide an overview of the features and pricing?"
        followup_prompt_1 = self.generate_prompt(user_followup_1)
        response_2 = self.get_response(followup_prompt_1)
        self.update_conversation(user_followup_1, response_2)
        print("Model:", response_2)

        # User follow-up 2
        user_followup_2 = "Our main focus is on scalability and integration with existing systems. How does your solution handle that?"
        followup_prompt_2 = self.generate_prompt(user_followup_2)
        response_3 = self.get_response(followup_prompt_2)
        self.update_conversation(user_followup_2, response_3)
        print("Model:", response_3)

        # User follow-up 3
        user_followup_3 = "Can we schedule a demo to see the product in action?"
        followup_prompt_3 = self.generate_prompt(user_followup_3)
        response_4 = self.get_response(followup_prompt_3)
        self.update_conversation(user_followup_3, response_4)
        print("Model:", response_4)

        # User follow-up 4
        user_followup_4 = "Great, can you also provide some case studies or references?"
        followup_prompt_4 = self.generate_prompt(user_followup_4)
        response_5 = self.get_response(followup_prompt_4)
        self.update_conversation(user_followup_4, response_5)
        print("Model:", response_5)

        # Continue the conversation as needed...or you 
        # can use the chat completion class from open ai
        # it shown for simplicity and clear explantions of the approach

if __name__ == "__main__":
    sales_conversation = SalesConversation()
    sales_conversation.run_conversation()

As you see from the prompt this method combines several strategies as role-playing, direct instructions and few-shot prompting. It is particularly useful for technical support, research assistance, code completion or software architecture and personalized recommendations.

7. Structured Output:

Structured Output is a prompt engineering technique where you guide the language model to produce responses in a specific format, such as lists, tables, or JSON. This method is particularly useful for tasks that require organized data or need to be easily parsed and integrated into other systems.

Structured Output works because it leverages the model’s ability to recognize patterns and follow detailed instructions. By providing a clear template or format, you help the model focus on organizing the information in a specific way. This approach ensures consistency and reduces the need for post-processing, making the output more useful for practical applications.

Tips and tricks for Stuctured Output:

• Clear Template: Provide a detailed template or example in the prompt.
• Specific Instructions: Be explicit about the format you want.
• Consistency: Ensure that the instructions are consistent across similar prompts.

Example of structured output prompt via Llama3

While Structured Output is powerful, it has some limitations:

• Complex Prompts: Creating detailed templates can be time-consuming.
• Model Limitations: The model’s ability to follow complex structures may vary.
• Over-Specification: Overly rigid templates can limit the model’s flexibility and creativity.

Code implementation:

import openai
import os

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
client = OpenAI(api_key = OPENAI_API_KEY)

def get_response(prompt, max_tokens=150, temperature=0.7):
    response = client.completions.create(
        model="gpt-4o",
        prompt=prompt,
        max_tokens=max_tokens,
        temperature=temperature,
    )
    return response.choices[0].text.strip()

# Define the structured output prompt for generating JSON
structured_prompt_json = """
Provide a summary of the following article in JSON format. 
The JSON should include the title, author, date, and main points of the article.
Article: 'Artificial intelligence is transforming various industries by automating tasks and providing insights through data analysis. This technology is becoming increasingly important in sectors such as healthcare, finance, and transportation.'
JSON Output: { "title": "AI in Various Industries", "author": "Unknown", "date": "N/A", "main_points": ["AI automates tasks", "AI provides data insights", "AI is important in healthcare", "AI is important in finance", "AI is important in transportation"] }
"""

response_json = get_response(structured_prompt_json)
print("Model JSON Output:", response_json)

# Define the structured output prompt for creating a table
structured_prompt_table = """
List the top 5 programming languages in 2024 along with their primary use cases in a table format.
| Programming Language | Primary Use Case |
|----------------------|------------------|
| Python               | Data Science     |
| JavaScript           | Web Development  |
| Java                 | Enterprise Apps  |
| C++                  | System Programming|
| Rust                 | Safe Systems     |
"""

response_table = get_response(structured_prompt_table)
print("Model Table Output:", response_table)

8. Comparative Prompting:

Comparative Prompting is a technique used to guide the language model to compare and contrast multiple items, ideas, or concepts. This approach is particularly useful for tasks that require a detailed examination of similarities and differences, such as comparing product features.

Limitations:

• Complex Prompts: Requires well-crafted prompts to guide the comparison effectively.
• Model Limitations: The model’s understanding of nuanced differences may vary.
• Potential Bias: The model’s training data may introduce biases in the comparisons.

9. Contextual Prompting:

Contextual Prompting is a technique used to provide the language model with detailed context before asking it to generate a response. By embedding relevant context within the prompt, you can enhance the model’s ability to generate accurate and contextually appropriate responses.

In Contextual Prompting, you include all relevant background information and context within the prompt before asking the model to generate a response. This helps the model understand the broader scenario and produce answers that are consistent with the provided context.

The context can include previous conversation history, detailed descriptions, or any other pertinent information. This approach is very useful and helpful in RAG applications.

Tips and trick with Contextual Prompting:

• Comprehensive Context: Include all relevant information and background details in the prompt.
• Clear Segmentation: Use clear segments or markers to separate different parts of the context.
• Maintain Coherence: Ensure that the context provided is coherent and logically structured.

Limitations:

• Complex Prompts: Requires well-crafted prompts with detailed context.
• Model Limitations: The model’s context window size may limit the amount of information it can consider.
• Time-Consuming: Creating detailed context for prompts can be time-consuming.

Here is a simple example of how the Contextual Prompting might look like:

import openai
import os

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
client = OpenAI(api_key = OPENAI_API_KEY)

def get_response(prompt, max_tokens=150, temperature=0.7):
    response = client.completions.create(
        model="gpt-4o",
        prompt=prompt,
        max_tokens=max_tokens,
        temperature=temperature,
    )
    return response.choices[0].text.strip()

# Define the contextual prompting for customer support interaction
contextual_prompt_support = """
You are a customer support agent. Here is the conversation history:
- User: I'm having trouble with my order.
- Support: I'm sorry to hear that. Can you provide your order number?
- User: My order number is 12345.
- Support: Thank you. I see that your order is delayed due to a shipping issue. We are working to resolve it.
Now continue the conversation and provide further assistance.
"""

response_support = get_response(contextual_prompt_support)
print("Model Support Output:", response_support)

By providing comprehensive context and background information, you can enhance the model’s ability to maintain coherence and produce relevant answers. This technique is particularly useful for tasks that require understanding complex scenarios or maintaining a coherent narrative over multiple interactions.

10. Interactive Prompting:

Interactive Prompting is a technique that involves a dynamic back-and-forth dialogue between the user and the language model. This method is particularly useful for tasks that require iterative refinement, clarification, or multi-step problem solving.

In Interactive Prompting, the user and the language model engage in a continuous conversation, with each interaction building on the previous one. The user can provide feedback, ask follow-up questions, and refine the initial prompt based on the model’s responses. This iterative process helps in gathering detailed information, clarifying misunderstandings, and arriving at accurate solutions.

Tips and trick with Interactive Prompting:

• Iterative Refinement: Use the model’s responses to refine and clarify the query.
• Maintain Context: Ensure that the conversation history is included in each prompt to maintain context.
• Specific Feedback: Provide specific feedback or follow-up questions to guide the model’s responses.

Limitations:

• Complex Prompts: Requires careful management of conversation history and context.
• Model Limitations: The model’s context window size may limit the amount of information it can consider.
• Time-Consuming: Iterative interactions can be time-consuming compared to single-turn queries.

Usually this approach can combine of all above-mentioned approaches in one in order to solve the problem as effective as it possible.

The simple example on educational mentor:

Educational Tutoring:

• User: “Can you explain the concept of photosynthesis?”
• Model: “Photosynthesis is the process by which green plants and some other organisms use sunlight to synthesize foods with the help of chlorophyll. Do you want to know about the specific steps involved?”
• User: “Yes, please explain the steps.”
• Model: “The steps of photosynthesis are: 1. Light absorption by chlorophyll, 2. Conversion of light energy to chemical energy, 3. Splitting of water molecules, 4. Formation of glucose and oxygen. Do you need a detailed explanation of each step?”

Mastering prompt engineering — the art of crafting and refining prompts to enhance the performance of language models — can be both a fun and iterative process, albeit sometimes challenging.

By focusing on designing and optimizing prompts, you can significantly improve how language models understand and respond to inputs. Remember, the art of prompt engineering is ever-evolving, just like language itself. Keep experimenting, iterating, and refining your prompts to unlock the full potential of your language models.

Also please share this knowledge with more people and join to the community in order to gather more insights and valuable information, specifically on how to apply gained knowledge in various use-cases.