Prompt Engineering for OpenAI Chat Completions
Tags: llm, openai, promptengineering
Published: 2024-02-19 11:47:57

A prompt, essentially a piece of text, is what we offer to the model to steer its response. The quality and clarity of the prompt directly influence the accuracy and relevance of the generated responses. With well-crafted prompts, developers can shape the model's understanding, context, and expected output, leading to more precise and useful responses while saving time and effort in the interaction process.

### **Setting Up**

To get started with prompting, you'll need to set up the OpenAI Python library. Install the library using pip:

```bash
pip install openai
```

Once the library is installed, the next step is to import the OpenAI library and set your API key:

```python
from openai import OpenAI

client = OpenAI(api_key="your-api")
```

### **Quickstart**

Let's dive right in with a simple example. Suppose we want a joke about cats. Our prompt could be:

```python
prompt = "Tell me a joke about cats"
```

Using the OpenAI library, we can obtain a response from the model based on this prompt:

```python
response = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {
      "role": "user",
      "content": prompt
    }
  ],
)
```

```python
response.choices[0].message.content
```

Output:

```
"Why don't cats play poker in the wild? Too many cheetahs!"
```

That's it! We've successfully obtained a joke about cats using a simple prompt.

Let's enhance our prompt dynamically by incorporating a placeholder for the topic:

```python
topic = "dog"

prompt = "Tell me a joke about {topic}"
```

```python
print(prompt.format(topic=topic))
```

What is happening here is that we are using the `format` method to replace the placeholder `{topic}` with the value of the `topic` variable. This results in the following prompt:

Output:

```bash
 "Tell me a joke about dog"
```

A helper function can be created to simplify the process of obtaining chat completions:

```python
def get_chat_response(prompt):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
    )
    return response.choices[0].message.content
```

Now, we can obtain a response based on this dynamic prompt:

```python
get_chat_response(prompt.format(topic=topic))
```

Output:

```bash
"Why did the dog sit in the shade? Because he didn't want to be a hot dog!"
```

Hilarious!

### **Fine-tuning Model Parameters**

OpenAI allows control over model parameters such as temperature and top-p, influencing the randomness and creativity of the generated responses. Lower temperature values result in more accurate responses, while higher values foster creativity.

Let's modify our function to include a temperature parameter:

```python

def get_chat_response(prompt, temperature=0):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
        temperature=temperature,
    )
    return response.choices[0].message.content
```

Increasing the temperature may produce different responses:

```python
get_chat_response(prompt.format(topic=topic), temperature=1)
```

Output:

```bash
"Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!"
```

There are many other parameters that can be used to fine-tune the model's behavior, such as `max_tokens`, `top_p`, and `presence_penalty` etc.

Use `max_tokens` to control the length of the response. For example, setting `max_tokens=20` will limit the response to 20 tokens. This is useful for controlling the prevent the model from generating overly long responses, and save resources.

### **Elements of a Good Prompt**

A good prompt is clear, concise, and specific, providing enough context for the model to understand the user's intent and generate a relevant response. Here are key elements to consider:

1. **Instruction**: Clearly state the task or instruction you want the model to perform.
2. **Context**: Provide external information or additional context to steer the model towards better responses.
3. **Input Data**: Offer the input or question for which you seek a response.
4. **Output Indicator**: Specify the type or format of the desired output.

### **Crafting Complex Prompts**

This examples are very basic. For generating more complex and specific responses, we can use more advanced prompts and context to guide the model's understanding.

Let's say I want to generate a weekly plan based on specific goals.

```python
prompt = """Efficiently plan the week to achieve all goals while maximizing productivity and allowing time for relaxation.\

Goals of the week:\

1. Complete development sprint for project X.\
2. Lead team meeting to discuss project updates and assign tasks.\
3. Research and prototype innovative features for product Y.\
4. Attend networking event to expand professional network.\
5. Review industry trends and advancements for potential business opportunities.\
"""
```

let's see what the model comes up with for this prompt:

```python
get_chat_response(prompt, temperature=1)

```

Output:

```bash
To efficiently plan the week and achieve all goals while maximizing productivity and allowing time for relaxation, consider the following schedule:

Monday:
- Start the day by reviewing project X and outlining tasks for the development sprint.
- Lead team meeting in the afternoon to discuss project updates and assign tasks accordingly.
- Dedicate time in the evening to research and prototype innovative features for product Y.

Tuesday:
- Focus on completing tasks for project X development sprint.
- Attend the networking event in the evening to expand professional network.

Wednesday:
- Review industry trends and advancements in the morning for potential business opportunities.
- Continue working on project X development sprint in the afternoon.
- Allocate time in the evening for relaxation and self-care.

Thursday:
- Finalize development sprint for project X and prepare for presentation or review.
- Work on prototyping innovative features for product Y in the afternoon.

Friday:
- Present completed development sprint for project X to the team.
- Follow up with any additional tasks or updates from the team meeting.
- Reflect on the week's accomplishments and plan for the following week.

Throughout the week, ensure to prioritize tasks, allocate time for breaks and relaxation, and maintain open communication with the team. By organizing tasks and allocating time effectively, you can achieve all goals while also maintaining a healthy work-life balance.
```

That's nice! The model has generated a detailed plan for the week based on the provided goals. But the generated output does have a chatgpt conversational style to it.

The Prompt does provide a clear instruction, context and input data. But in order to get a more structured output, we can provide an output indicator to the prompt.

### **Few Shot Prompting**

Few-shot learning is a technique that allows models to learn from a small number of examples or instructions. This can be particularly useful when you want to guide the model's understanding with specific examples or context.

Let's modify the prompt to include an output indicator:

```python
prompt = """Efficiently plan the week to achieve all goals while maximizing productivity and allowing time for relaxation.

Goals of the week:
1. Generate an end-to-end plan for automating task creation in Notion using LLMs.
2. Conduct necessary research before diving into automation.
3. Consolidate the plan and generate sprints and tasks to complete the automation.
4. Learn Prompt Engineering for developers using OpenAI.
5. Complete development sprint for project X.
6. Lead team meeting to discuss project updates and assign tasks.
7. Research and prototype innovative features for product Y.
8. Attend networking event to expand professional network.
9. Review industry trends and advancements for potential business opportunities.

Output Format:

9:00 AM - 10:30 AM: Task 1
10:30 AM - 11:00 AM: Break
11:00 AM - 12:30 PM: Task 2
12:30 PM - 1:30 PM: Lunch
1:30 PM - 3:00 PM: Task 3
3:00 PM - 3:30 PM: Break
3:30 PM - 5:00 PM: Task 4

Example Outputs:
Monday, 12/02/2024

- 9:00 AM - 10:30 AM: Brainstorming session for innovative Notion automation ideas
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Research session on latest AI advancements for task automation
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Prototyping session for Notion automation features
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Review and refine Notion automation plan
"""
```

Now, let's see what the model comes up this time:

```bash
**Tuesday, 12/03/2024**

- 9:00 AM - 10:30 AM: Learn Prompt Engineering for developers using OpenAI
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Continue learning Prompt Engineering for developers
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Apply Prompt Engineering knowledge to project work
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Attend team meeting to discuss project updates and assign tasks

**Wednesday, 12/04/2024**

- 9:00 AM - 10:30 AM: Research and prototype innovative features for product Y
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Continue research and prototyping for product Y
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Networking event to expand professional network
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Review industry trends and advancements for potential business opportunities

**Thursday, 12/05/2024**

- 9:00 AM - 10:30 AM: Generate an end-to-end plan for automating task creation in Notion using LLMs
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Conduct necessary research before diving into automation
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Consolidate the plan and generate sprints and tasks to complete the automation
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Continue working on automation plan and tasks

**Friday, 12/06/2024**

- 9:00 AM - 10:30 AM: Complete development sprint for project X
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Continue development sprint for project X
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Finish up any pending tasks for project X
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Wrap up any remaining tasks and prepare for next week's goals
```

Now that's some detailed planning! The model has generated a weekly schedule based on the specific goals provided in the prompt. This demonstrates how prompts can be used to guide the model's understanding and generate specific, relevant outputs.

We successfully used few-shot learning to guide the model's understanding and generate specific outputs based on the provided examples.

### **Conclusion and What's Next**

There are other advanced techniques such chain-of-thought (CoT), and Tree of Thoughts (ToT) etc, which can enhance the capabilities of these models for a wide range of applications, from simple conversations to complex problem-solving tasks.

I encourage you to read the source material at [PromptingGuide.ai](https://www.promptingguide.ai/techniques) To delve deeper into prompting techniques.

### **Stay Connected**

Join me on LinkedIn, where I share insights and updates on AI, Automation, Productivity, and more.

[Connect with me on LinkedIn](https://www.linkedin.com/in/sreejin-sreenivasan/)

Additionally, if you're interested in learning more about how I'm leveraging AI for simple automations and productivity hacks, subscribe to my newsletter "Growth Journal". Be the first to receive exclusive content and stay up-to-date with the latest trends in AI and automation.

[Subscribe to my newsletter](https://sreejin.substack.com/?utm_source=navbar&utm_medium=web&r=8ikhn)

Until next time, happy prompting!