Creating the Prompt Manager

Welcome to the next lesson of the course, where we will focus on creating the Prompt Manager, a crucial component of the DeepResearcher tool. The Prompt Manager is responsible for loading and rendering templates, which are essential for generating dynamic prompts in AI interactions. This lesson will guide you through the process of implementing a Prompt Manager, which will enhance your ability to manage and utilize prompts effectively within the DeepResearcher project.

Let's start by recalling how to load a template file. The load_template function is responsible for accessing and reading template files from a specified directory.

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)

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

• os.path.dirname(__file__): This retrieves the directory where the current script is located.
• os.path.join(): This function constructs the full path to the template file by combining the base directory, the data folder, and the template filename.
• open(file_path, 'r', encoding='utf-8'): Opens the file in read mode with UTF-8 encoding, ensuring that the file's content is read correctly.

This function returns the content of the template file as a string, which we will use in the next steps.

Next, we will explore how to render templates by replacing placeholders with actual values. The render_template function handles this task.

import re
import logging

def render_template(template_str, variables):
    missing_keys = []

    def replacer(match):
        full_expr = match.group(0)
        parts = match.group(1).split('|', 1)
        var_name = parts[0]
        default_value = parts[1] if len(parts) == 2 else None

        if var_name in variables:
            return str(variables[var_name])
        elif default_value is not None:
            return default_value
        else:
            missing_keys.append(var_name)
            return full_expr

    pattern = re.compile(r"\{\{([\w|]+?)\}\}")
    result = pattern.sub(replacer, template_str)

    if missing_keys:
        for key in missing_keys:
            logging.warning(f"Missing value for variable: '{key}' and no default provided.")

    return result

• Regular Expressions: The re.compile(r"\{\{([\w|]+?)\}\}") pattern matches placeholders in the form {{VAR}} or {{VAR|default}}.
• Replacer Function: This function checks if a variable is present in the variables dictionary. If not, it uses the default value or logs a warning if neither is available.
• Logging: Warnings are logged for any missing variables without defaults, helping you identify issues in template rendering.

Now, let's see how to integrate the loading and rendering processes using the render_prompt_from_file function.

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

• load_template(file_path): Loads the template content from the specified file.
• render_template(template, variables): Renders the template by replacing placeholders with actual values from the variables dictionary.

This function combines the loading and rendering steps, producing the final prompt string ready for use.

Let's apply what we've learned to a practical example using character creator templates. Consider the following template file:

prompts/data/character_creator_user.txt

Create a character profile based on the following:

Name: {{name | default("Unnamed Hero")}}
Age: {{age | default("Unknown")}}
Species: {{species | default("Human")}}
Occupation: {{occupation | default("Adventurer")}}
World Setting: {{setting | default("a mystical fantasy realm")}}

Genre: {{genre | default("Fantasy")}}
Tone: {{tone | default("Epic")}}

Include the following:
- A short background story (3-4 sentences)
- Key personality traits
- Strengths and flaws
- Any special abilities or equipment

To render a character profile, you would use the render_prompt_from_file function with appropriate variables:

variables = {
    'name': 'Aria',
    'age': '25',
    'species': 'Elf',
    'occupation': 'Ranger',
    'setting': 'Enchanted Forest',
    'genre': 'Fantasy',
    'tone': 'Epic'
}

character_profile = render_prompt_from_file('character_creator_user', variables)
print(character_profile)

This code will output a character profile with the specified attributes, demonstrating the power of the Prompt Manager in creating dynamic content.

In this lesson, you learned how to create a Prompt Manager by loading and rendering templates with variables. This component is essential for generating dynamic prompts in the DeepResearcher tool. You explored the functions involved in this process and applied them to a practical example using character creator templates.

Congratulations on reaching the end of this lesson! You are now equipped with the skills to implement and utilize a Prompt Manager in your own projects. As you move on to the practice exercises, remember to apply what you've learned and continue exploring the possibilities of AI-powered applications. Well done!