Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Versionsstyring og kataloghåndtering af prompts

Lektion 14 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Versionsstyring og kataloghåndtering af prompts
  2. Hvorfor versionere prompts
  3. Katalogstruktur
  4. Brug af kataloget i din applikation
  5. Versionsstyring med Git
  6. Bedste praksis
  7. Test af kataloget med et rollback
  8. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres kun med en ræsonneringsindsats på none, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificere reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.

Versionsstyring og kataloghåndtering af prompts

I produktion udvikler dine prompts sig lige så meget som din kode. Uden versionsstyring mister du overblikket over ændringer, kan ikke rulle tilbage og har ingen idé om, hvilken version der kører i produktion. Denne lektion viser dig, hvordan du håndterer prompts som softwareartefakter.

Hvorfor versionere prompts

En ændring i et prompt kan radikalt ændre din applikations adfærd. I modsætning til kode er disse ændringer ofte subtile og svære at opdage uden automatiserede tests: en omformuleret sætning, et flyttet ord, og modellen begynder at fejlklassificere ét ud af ti edge cases. Ingen standard unit-test vil fange dette gab, men supporten vil flagge det tre uger senere som en vag klage over fejlroutede billetter.

Versionsstyring adresserer fire forskellige behov. For det første sporbarhed: at vide hvem der ændrede hvad og hvornår, gør en steril teamdiskussion til et simpelt historiktjek. For det andet rollback: når en regression opstår, er det umiddelbare mål ikke at forstå hvorfor, men at genoprette kendt adfærd. For det tredje ydelsessammenligning: dette kræver, at ældre versioner forbliver eksekverbare præcis som de var, med deres originale model og indstillinger. Endelig revision: for systemer underlagt GDPR (General Data Protection Regulation) eller andre compliance-rammer skal du kunne demonstrere, hvilke instrukser der var gældende på en given dato – et skærmbillede er ikke nok.

Katalogstruktur

Klassen PromptCatalog imødekommer disse behov med minimal infrastruktur: én mappe per prompt, én JSON-fil per version, nummereret sekventielt. Hver fil samler system-prompt-teksten sammen med den tilhørende model og temperatur – et prompt finjusteret til 0,1 og det samme prompt ved 0,7 er ikke det samme, og at låse dem sammen forhindrer, at man gendanner teksten mens man glemmer sine indstillinger.

Feltet status sporer livscyklussen. En version starter som draft, hvilket tillader forberedelse og test uden at påvirke live-trafik. At kalde activate skifter den til active og nedgraderer automatisk den tidligere version til deprecated, hvilket sikrer, at kun én version betjener trafikken ad gangen. Denne metode gør rollback trivielt: at genaktivere en tidligere version er et enkelt kald, ikke en deployment. Din applikation kalder get_active i produktion, mens list_versions understøtter reviews og revisioner.

import json
from datetime import datetime
from pathlib import Path

class PromptCatalog:
    """Prompt-kataloghåndterer med versionsstyring."""

    def __init__(self, catalog_dir: str = "prompts/"):
        self.catalog_dir = Path(catalog_dir)
        self.catalog_dir.mkdir(parents=True, exist_ok=True)

    def save_prompt(self, name: str, system_prompt: str,
                    model: str, temperature: float,
                    metadata: dict = None) -> str:
        """Gemmer en ny version af et prompt."""
        prompt_dir = self.catalog_dir / name
        prompt_dir.mkdir(exist_ok=True)

        # Bestem versionsnummer
        versions = sorted(prompt_dir.glob("v*.json"))
        version = len(versions) + 1
        version_str = f"v{version:03d}"

        # Gem
        prompt_data = {
            "name": name,
            "version": version_str,
            "created_at": datetime.now().isoformat(),
            "model": model,
            "temperature": temperature,
            "system_prompt": system_prompt,
            "metadata": metadata or {},
            "status": "draft"  # draft | active | deprecated
        }

        filepath = prompt_dir / f"{version_str}.json"
        filepath.write_text(json.dumps(prompt_data, indent=2,
                                        ensure_ascii=False))

        return version_str

    def get_prompt(self, name: str,
                   version: str = "latest") -> dict:
        """Henter et prompt efter navn og version."""
        prompt_dir = self.catalog_dir / name

        if version == "latest":
            versions = sorted(prompt_dir.glob("v*.json"))
            if not versions:
                raise FileNotFoundError(f"Prompt '{name}' ikke fundet")
            filepath = versions[-1]
        else:
            filepath = prompt_dir / f"{version}.json"

        return json.loads(filepath.read_text())

    def get_active(self, name: str) -> dict:
        """Henter den aktive version af et prompt."""
        prompt_dir = self.catalog_dir / name
        for filepath in sorted(prompt_dir.glob("v*.json"),
                               reverse=True):
            data = json.loads(filepath.read_text())
            if data["status"] == "active":
                return data
        raise FileNotFoundError(
            f"Ingen aktiv version for '{name}'"
        )

    def activate(self, name: str, version: str):
        """Aktiverer en version og deaktiverer andre."""
        prompt_dir = self.catalog_dir / name

        for filepath in prompt_dir.glob("v*.json"):
            data = json.loads(filepath.read_text())
            if data["version"] == version:
                data["status"] = "active"
            elif data["status"] == "active":
                data["status"] = "deprecated"
            filepath.write_text(json.dumps(data, indent=2,
                                            ensure_ascii=False))

    def list_versions(self, name: str) -> list[dict]:
        """Lister alle versioner af et prompt."""
        prompt_dir = self.catalog_dir / name
        versions = []
        for filepath in sorted(prompt_dir.glob("v*.json")):
            data = json.loads(filepath.read_text())
            versions.append({
                "version": data["version"],
                "status": data["status"],
                "created_at": data["created_at"],
                "model": data["model"]
            })
        return versions

Brug af kataloget i din applikation

På kalder-siden er reglen simpel: din kode indeholder ingen prompt-tekst; den anmoder om den aktive version fra kataloget. Dette holder prompts modificerbare uden at røre ved applikationskoden, og forhindrer tredive-linjes strenge i at blive begravet midt i en funktion. Metadata gemt under lagring – forfatter, beskrivelse, ændringslog – har ingen effekt på eksekveringen, men gør historikken læsbar seks måneder senere, når ingen kan huske, hvorfor ordlyden blev ændret.

Den kritiske detalje ligger i slutningen af classifier_ticket: det returnerede svar inkluderer prompt_version. Log dette felt med hvert resultat, og hændelsesanalyse bliver mulig – du vil vide, at tirsdag eftermiddags fejlklassificerede billetter alle kom fra v004, uden at skulle krydsreferere deployment-tidsstempler.

from openai import OpenAI

client = OpenAI()
catalog = PromptCatalog("prompts/")

# Gem et prompt
catalog.save_prompt(
    name="ticket-classifier",
    system_prompt="""Du er en classifier af support-billetter.
Kategorisér hver billet som: bug, feature, question, billing.
Svar i JSON med category, priority (1-5), summary.""",
    model="gpt-5.6-terra",
    temperature=0.1,
    metadata={
        "author": "marie.dupont",
        "description": "Automatisk klassificering af Zendesk-billetter",
        "changelog": "Oprindelig version"
    }
)

# I produktion: brug den aktive version
def classifier_ticket(ticket_text: str) -> dict:
    """Klassificerer en billet ved hjælp af det aktive prompt."""
    prompt_config = catalog.get_active("ticket-classifier")

    response = client.responses.create(
        model=prompt_config["model"],
        reasoning={"effort": "none"},  # temperature kræver effort none
        instructions=prompt_config["system_prompt"],
        input=ticket_text,
        temperature=prompt_config["temperature"]
    )

    return {
        "result": json.loads(response.output_text),
        "prompt_version": prompt_config["version"]
    }

Versionsstyring med Git

For teams skal du gemme dine prompts i et dedikeret Git-repository. Træet nedenfor følger en simpel konvention: én mappe per prompt, indeholdende dets definition, testcases og ændringslog. At holde tests sammen med det prompt, de verificerer, er ikke kosmetisk – en pull-request modificerer begge dele sammen, og revieweren bedømmer ændringen på baggrund af beviser snarere end erklæret hensigt.

prompts/
  ticket-classifier/
    prompt.yaml
    tests/
      test_cases.json
    CHANGELOG.md
  invoice-extractor/
    prompt.yaml
    tests/
      test_cases.json
    CHANGELOG.md

YAML erstatter JSON her af en specifik årsag: prompts er flerslinjede tekster, og syntaksen | viser dem præcis som sendt, uden escaping eller vildfarne \n-tegn. En Git-diff på denne fil læses som en prosa-diff – revieweren ser, at en sætning blev tilføjet. Output-skemaet rejser i samme fil, så den komplette konfiguration for et kald passer i ét enkelt artefakt.

# prompts/ticket-classifier/prompt.yaml
name: ticket-classifier
model: gpt-5.6-terra
temperature: 0.1
max_output_tokens: 500
system_prompt: |
  Du er en classifier af support-billetter.
  Kategorisér hver billet som: bug, feature, question, billing.
  Svar i JSON med category, priority (1-5), summary.
schema:
  type: object
  properties:
    category:
      type: string
      enum: [bug, feature, question, billing]
    priority:
      type: integer
    summary:
      type: string
  required: [category, priority, summary]
  additionalProperties: false

Bedste praksis

Det, der adskiller et levende katalog fra en arkivmappe, kommer ned til nogle få husordensregler. Hold ét prompt per fil: at blande flere prompts i ét enkelt dokument gør diffs ulæselige og rollbacks umulige at målrette. Håndhæv en ændringslog, der dokumenterer ikke hvad der ændrede sig – det viser diff’en – men hvorfor: „tilføjede instruktion om flersprogede billetter efter feedback fra support” er ti linjers teknisk beskrivelse værd.

Associer systematisk en testsuite med hvert prompt; ellers vil brugerne være de første til at fortælle dig, når en modification bryder etableret adfærd. Rout ændringer af prompts gennem samme code review-proces som selve koden: et prompt, der går i produktion uden review, producerer de samme overraskelser som urevieweret kode. Verificér, at rollback tager mindre end et minut, og test det på en stille dag snarere end under en hændelse. Markér endelig deployede versioner med tags for entydigt at koble observeret adfærd til en specifik repository-tilstand.

Test af kataloget med et rollback

Opsæt et PromptCatalog for tre rigtige prompts fra din applikation, og optegn derefter to eller tre versioner af hver ved at udvikle instrukserne i små skridt – en tone-instruktion, en tilføjet kategori. Versionsstyring beviser sin værdi på disse finkornede ændringer, fordi det er dem, du ikke vil kunne huske at have lavet. Opsæt aktivering og deaktivering, og knyt en testsuite til hvert prompt.

Afslut med den mest instruktive øvelse: aktivér bevidst en degraderet version, observer regressionen via tests, og udfør rollbacket mens du tager tid. Hvis operationen overstiger ét minut, så ret proceduren før du tilføjer ét eneste prompt til kataloget – et langsomt rollback er ikke et rollback, det er en langvarig hændelse.

Vigtige pointer

  • Prompts er softwareartefakter, der kræver versionsstyring
  • Hver version er en JSON- eller YAML-fil med metadata
  • Status (draft, active, deprecated) muliggør gradvis deployment
  • Gem prompts i Git med tests og en ændringslog
  • Rollback skal være øjeblikkeligt ved regression