Promptsjablonen voor handlebars gebruiken

8 minuten

Semantische kernel ondersteunt het gebruik van de syntaxis van de handlebars-sjabloon voor prompts. Handlebars zijn een eenvoudige sjabloontaal die voornamelijk wordt gebruikt voor het genereren van HTML, maar het kan ook andere tekstindelingen maken. Handlebars-sjablonen bestaan uit reguliere tekst die is gekruist met Handlebars-expressies.

Als u een handlebars-sjabloon wilt gebruiken met Semantische kernel, begint u met het installeren van het pakket:

dotnet add package Microsoft.SemanticKernel.PromptTemplates.Handlebars --version 1.30.0

pip install --upgrade semantic-kernel

Importeer vervolgens het pakket in uw code:

using Microsoft.SemanticKernel.PromptTemplates.Handlebars;

Alle toegevoegde instructies op het hoogste niveau omvatten het volgende:

using Microsoft.SemanticKernel; // Core Semantic Kernel SDK
using Microsoft.SemanticKernel.Connectors.AI.OpenAI; // Azure OpenAI connector
using Microsoft.SemanticKernel.PromptTemplates; // For prompt template configuration
using Microsoft.SemanticKernel.PromptTemplates.Handlebars; // For Handlebars template support
using System; // For Console and basic types
using System.Collections.Generic; // For Dictionary and KernelArguments
using System.IO; // For file operations (e.g., loading YAML)
using System.Threading.Tasks; // For async/await support

from semantic_kernel.prompt_template.handlebars_prompt_template import HandlebarsPromptTemplate

Alle toegevoegde instructies op het hoogste niveau omvatten het volgende:

from semantic_kernel.prompt_template import PromptTemplateConfig      # for prompt_config
from semantic_kernel.prompt_template.handlebars_prompt_template import HandlebarsPromptTemplate  # for function
import json      # for loading appsettings.json
import yaml      # for loading HandlebarsPrompt.yaml
import asyncio   # for running async main
from semantic_kernel import Kernel      #  Needed (for kernel)
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion  # for chat_service

In het volgende voorbeeld ziet u een sjabloon voor chatprompts die gebruikmaakt van de syntaxis van handlebars. De sjabloon bevat handlebars-expressies, aangeduid door {{ en }}. Wanneer de sjabloon wordt uitgevoerd, worden deze expressies vervangen door waarden uit een invoerobject.

const string HandlebarsTemplate = """
    <message role="system">You are an AI assistant designed to help with image recognition tasks.</message>
    <message role="user">
        <text>{{request}}</text>
        <image>{{imageData}}</image>
    </message>
    """;

handlebars_template = """
<message role="system">You are an AI assistant designed to help with image recognition tasks.</message>
<message role="user">
    <text>{{request}}</text>
    <image>{{imageData}}</image>
</message>
"""

In dit voorbeeld zijn er twee invoerobjecten:

request - Bevat de aanvraag die de assistent moet voltooien.
imageData - Bevat de base64-afbeeldingsgegevens.

Als u de promptsjabloon wilt gebruiken, moet u een PromptTemplateConfig object maken dat de sjabloon en de bijbehorende indeling bevat. Daarna maakt u een KernelFunction object op basis van de sjabloonconfiguratie en geeft u de factory van de handlebars-sjabloon op. Hier is een voorbeeld:

// Create the prompt template configuration
var templateFactory = new HandlebarsPromptTemplateFactory();
var promptTemplateConfig = new PromptTemplateConfig()
{
    Template = HandlebarsTemplate,
    TemplateFormat = "handlebars",
    Name = "Vision_Chat_Prompt",
};

// Create a function from the Handlebars template configuration
var function = kernel.CreateFunctionFromPrompt(promptTemplateConfig, templateFactory);

# Load Azure OpenAI config from a JSON file
with open('appsettings.json', 'r') as f:
    config = json.load(f)

model_id = config["modelId"]
endpoint = config["endpoint"]
api_key = config["apiKey"]

# Set up Semantic Kernel and Azure OpenAI service
kernel = Kernel()
chat_service = AzureChatCompletion(
    deployment_name=model_id,
    endpoint=endpoint,
    api_key=api_key
)
kernel.add_service(chat_service, "chat_completion")

# Create the prompt template config and function
prompt_config = PromptTemplateConfig(
    template=handlebars_template,
    template_format="handlebars",
    name="Vision_Chat_Prompt"
)
function = HandlebarsPromptTemplate(prompt_template_config=prompt_config)

U kunt nu het KernelArguments object maken met de invoergegevens en uw functie aanroepen.

var arguments = new KernelArguments(new Dictionary<string, object?>
{
    {"request","Describe this image:"},
    {"imageData", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAAXNSR0IArs4c6QAAACVJREFUKFNj/KTO/J+BCMA4iBUyQX1A0I10VAizCj1oMdyISyEAFoQbHwTcuS8AAAAASUVORK5CYII="}
});

var response = await kernel.InvokeAsync(function, arguments);

arguments = {
    "request": "Describe this image:",
    "imageData": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAAXNSR0IArs4c6QAAACVJREFUKFNj/KTO/J+BCMA4iBUyQX1A0I10VAizCj1oMdyISyEAFoQbHwTcuS8AAAAASUVORK5CYII="
}

async def main():
    result = await kernel.invoke_prompt(
        prompt=prompt_config.template,
        request=arguments["request"],
        imageData=arguments["imageData"],
        service_id="chat_completion",
        template_format="handlebars"
    )
    print("Kernel result:", result)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

Het antwoord op deze prompt is vergelijkbaar met de volgende uitvoer:

The image is a solid block of bright red color. There are no additional features, shapes, or textures present.

Handlebars-sjablonen gebruiken in YAML-prompts

U kunt promptfuncties maken op basis van YAML-bestanden, zodat u uw promptsjablonen kunt opslaan naast de bijbehorende metagegevens en instellingen voor het uitvoeren van prompts. Deze bestanden kunnen worden beheerd in versiebeheer, wat handig is voor het bijhouden van wijzigingen in complexe prompts.

De volgende code is een voorbeeld van de YAML-weergave van de chatprompt die in de vorige sectie wordt gebruikt:

name: Vision_Chat_Prompt
template: |
    <message role="system">
        You are an AI assistant designed to help with image recognition tasks.
    </message>
    <message role="user">
        <text>{{request}}</text>
        <image>{{imageData}}</image>
    </message>
template_format: handlebars
description: Vision chat prompt template.
input_variables:
  - name: request
    description: Request details.
    is_required: true
  - name: imageData
    description: Base64 image data.
    is_required: true

Als u deze prompt wilt gebruiken, laadt u deze als een ingesloten resource, converteert u deze naar een functie en roept u deze vervolgens aan.

// Load prompt from resource
var handlebarsPromptYaml = EmbeddedResource.Read("HandlebarsPrompt.yaml");

// Create the prompt function from the YAML resource
var templateFactory = new HandlebarsPromptTemplateFactory();
var function = kernel.CreateFunctionFromPromptYaml(handlebarsPromptYaml, templateFactory);

// Input data for the prompt rendering and execution
var arguments = new KernelArguments(new Dictionary<string, object?>
{
    {"request","Describe this image:"},
    {"imageData", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAAXNSR0IArs4c6QAAACVJREFUKFNj/KTO/J+BCMA4iBUyQX1A0I10VAizCj1oMdyISyEAFoQbHwTcuS8AAAAASUVORK5CYII="}
});

// Invoke the prompt function
var response = await kernel.InvokeAsync(function, arguments);

import yaml

# Load YAML prompt from file
with open("HandlebarsPrompt.yaml", "r") as f:
    yaml_prompt = yaml.safe_load(f)

prompt_config = PromptTemplateConfig(
    template=yaml_prompt["template"],
    template_format="handlebars",
    name=yaml_prompt.get("name", "Vision_Chat_Prompt")
)

function = HandlebarsPromptTemplate(prompt_template_config=prompt_config)

arguments = {
    "request": "Describe this image:",
    "imageData": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAAXNSR0IArs4c6QAAACVJREFUKFNj/KTO/J+BCMA4iBUyQX1A0I10VAizCj1oMdyISyEAFoQbHwTcuS8AAAAASUVORK5CYII="
}

async def main():
    result = await kernel.invoke_prompt(
        prompt=prompt_config.template,
        request=arguments["request"],
        imageData=arguments["imageData"],
        service_id="chat_completion",
        template_format="handlebars"
    )
    print("Kernel result:", result)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

Het gebruik van handlebars-sjablonen met Semantic Kernel is een eenvoudige en effectieve manier om dynamische prompts voor uw toepassingen te maken. De syntaxis van de handlebars is eenvoudig te gebruiken en stelt u in staat variabelen op te nemen, prompts in YAML te beheren voor een betere organisatie en AI-gestuurde functies naadloos te integreren. Deze aanpak maakt uw prompts flexibeler, herbruikbaar en eenvoudiger te onderhouden.

Meer informatie over handlebars promptsjablonen vindt u in de handleiding voor handlebars.

Feedback

Is deze pagina nuttig?