Prompt & Model Versioning

prompts/
  alert-triage/
    v1.0.0.yaml
    v1.1.0.yaml
    v2.0.0.yaml
    latest.yaml
  runbook-lookup/
    v1.0.0.yaml
    latest.yaml
  incident-summary/
    v1.0.0.yaml
    latest.yaml

name: alert-triage
version: 2.1.0
model: gpt-4
temperature: 0.0
max_tokens: 500

system_prompt: |
  You are an alert triage assistant for a cloud infrastructure team.

  Classify alerts as P1-P4 based on:
  - User impact
  - Blast radius
  - Data loss risk
  - Service criticality

  Output format: JSON with severity, confidence, reasoning

tags:
  - alert-triage
  - production
  - v2.1.0

changelog: |
  v2.1.0: Added blast radius consideration
  v2.0.0: Changed from text to JSON output format
  v1.0.0: Initial version

class PromptDeployer:
    def __init__(self, prompt_registry):
        self.registry = prompt_registry

    def deploy(self, prompt_name, new_version, rollout_pct=10):
        """Deploy a new prompt version to a percentage of traffic."""
        current = self.registry.get(prompt_name, "latest")
        canary = self.registry.get(prompt_name, new_version)

        # Route traffic based on percentage
        def get_prompt(name):
            import random
            if random.randint(1, 100) <= rollout_pct:
                log_canary_usage(name, new_version)
                return canary
            return current

        return get_prompt

    def promote(self, prompt_name, version):
        """Promote a canary version to 100%."""
        self.registry.set(prompt_name, "latest", version)
        log_promotion(prompt_name, version)

class PromptManager:
    def __init__(self, registry):
        self.registry = registry

    def get_prompt(self, task_name, version="latest"):
        """Get a specific prompt version."""
        prompt_config = self.registry.get(task_name, version)
        return {
            "model": prompt_config["model"],
            "temperature": prompt_config["temperature"],
            "system_prompt": prompt_config["system_prompt"],
            "version": prompt_config["version"],
        }

    def log_request(self, task_name, version, request_id):
        """Log which prompt version was used for every request."""
        self.db.log({
            "task": task_name,
            "version": version,
            "request_id": request_id,
            "timestamp": datetime.utcnow()
        })

import yaml
from pathlib import Path

class PromptRegistry:
    def __init__(self, base_dir="prompts"):
        self.base_dir = Path(base_dir)

    def get(self, task_name, version="latest"):
        """Load a prompt version."""
        if version == "latest":
            path = self.base_dir / task_name / "latest.yaml"
            version = yaml.safe_load(path.read_text())["version"]
        path = self.base_dir / task_name / f"v{version}.yaml"
        return yaml.safe_load(path.read_text())

    def list_versions(self, task_name):
        """List all versions of a prompt."""
        versions_dir = self.base_dir / task_name
        return sorted([f.stem for f in versions_dir.glob("v*.yaml")])

    def diff(self, task_name, v1, v2):
        """Show differences between two versions."""
        p1 = self.get(task_name, v1)
        p2 = self.get(task_name, v2)
        return {k: (p1.get(k), p2.get(k)) for k in set(p1) | set(p2) if p1.get(k) != p2.get(k)}