Prompt Structure and Variables

Welcome to the lesson on "Prompt Structure and Variables." In this lesson, we will explore how prompts are structured and how variables are used to create dynamic and flexible AI interactions. Prompts are essential in guiding AI behavior, allowing us to tailor responses to specific needs. By the end of this lesson, you will understand how to load and render templates using variables, a crucial skill in building the DeepResearcher tool.

Before we dive into templates, let's briefly recall file handling in Python. This knowledge is essential as we will be loading template files in this lesson. Remember, the open() function is used to open a file, and the read() method is used to read its contents. Here's a quick reminder:

file_path = 'example.txt'
with open(file_path, 'r') as file:
    content = file.read()
print(content)

This code snippet opens a file named example.txt, reads its contents, and prints them. The with statement ensures the file is closed automatically after reading.

Our templates will represent prompts that can be enriched with variables, in the form of text files with placeholders. These placeholders will be enclosed in curly braces, like {{input}}. Let's look at an example template:

Rewrite the following sentence in a different way that retains its original meaning:

Original: {{input}}

Return a list of up to 3 paraphrased versions as plain text strings.

In this template, {{input}} is a placeholder that will be replaced with a specific sentence when the template is rendered. This structure allows us to create flexible prompts that can adapt to different inputs.

To use a template, we first need to load it from a file. Let's break down the load_template function:

We start by defining the load_template function, which takes a template_name as an argument.

import os

def load_template(template_name):
    base_dir = os.path.dirname(__file__)
    filename = f"{template_name}.txt"
    file_path = os.path.join(base_dir, 'data', filename)

Here, base_dir is the directory where the current script is located. We construct the full file path by joining base_dir, the data directory, and the template filename.

Next, we open the file and read its contents.

    with open(file_path, 'r', encoding='utf-8') as f:
        return f.read()

The with statement ensures the file is closed after reading. The read() method returns the entire content of the file as a string.

Once we have loaded a template, we can render it by replacing placeholders with actual values. Let's explore the render_template function:

The render_template function takes a template_str and an input_value.

import re

def render_template(template_str, input_value):
    pattern = re.compile(r"\{\{input\}\}")
    return pattern.sub(str(input_value), template_str)

We use the re module to compile a pattern that matches {{input}}. The sub() method replaces all occurrences of this pattern with the input_value.

Finally, let's see how loading and rendering are combined in the render_prompt_from_file function:

This function will take a file_path and an input_value.

def render_prompt_from_file(file_path, input_value):
    template = load_template(file_path)
    return render_template(template, input_value)

We first load the template using load_template(), then render it with render_template(), replacing placeholders with the provided input_value.

In this lesson, you learned how to structure prompts using templates and variables. We covered loading templates from files, rendering them with actual values, and combining these steps to create dynamic prompts. As you move on to the practice exercises, you'll apply these skills to create and render your own templates. Experiment with different inputs to see how they affect the output. Keep up the great work, and enjoy the hands-on practice!