agenta-1-prompt-versioning-and-management

name	agenta-1-prompt-versioning-and-management
description	Sub-skill of agenta: 1. Prompt Versioning and Management.
version	1.0.0
category	ai-prompting
type	reference
scripts_exempt	true

1. Prompt Versioning and Management

1. Prompt Versioning and Management

Creating Versioned Prompts:

"""
Create and manage versioned prompts with Agenta.
"""
import agenta as ag
from agenta import Agenta
from typing import Optional, Dict, Any

# Initialize Agenta
ag.init()

@ag.entrypoint
def generate_summary(
    text: str,
    max_length: int = 100,
    style: str = "professional"
) -> str:
    """
    Generate a summary with versioned prompt.

    Args:
        text: Text to summarize
        max_length: Maximum summary length
        style: Writing style (professional, casual, technical)

    Returns:
        Generated summary
    """
    # Define prompt template (this becomes versioned)
    prompt = f"""Summarize the following text in a {style} tone.
Keep the summary under {max_length} words.

Text: {text}

Summary:"""

    # Call LLM (Agenta tracks this)
    response = ag.llm.complete(
        prompt=prompt,
        model="gpt-4",
        temperature=0.3,
        max_tokens=max_length * 2
    )

    return response.text


# Example usage
text = """
The company reported strong Q3 results with revenue up 25% year-over-year.
Operating margins improved to 18% from 15% in the prior year.
The CEO highlighted expansion into new markets and product launches.
"""

summary = generate_summary(text, max_length=50, style="professional")
print(summary)

Managing Prompt Versions:

"""
Manage multiple prompt versions programmatically.
"""
import agenta as ag
from agenta import Agenta
from dataclasses import dataclass
from typing import List, Dict, Optional
from datetime import datetime

@dataclass
class PromptVersion:
    """Represents a prompt version."""
    version_id: str
    name: str
    template: str
    parameters: Dict[str, Any]
    created_at: datetime
    is_active: bool = False


class PromptManager:
    """
    Manage prompt versions with Agenta.
    """

    def __init__(self, app_name: str):
        self.app_name = app_name
        self.client = Agenta()

    def create_version(
        self,
        name: str,
        template: str,
        parameters: Dict[str, Any] = None
    ) -> PromptVersion:
        """
        Create a new prompt version.

        Args:
            name: Version name
            template: Prompt template
            parameters: Default parameters

        Returns:
            Created PromptVersion
        """
        
        variant = .client.create_variant(
            app_name=.app_name,
            variant_name=name,
            config={
                : template,
                : parameters  {}
            }
        )

         PromptVersion(
            version_id=variant.,
            name=name,
            template=template,
            parameters=parameters  {},
            created_at=datetime.now(),
            is_active=
        )

     () -> [PromptVersion]:
        
        variants = .client.list_variants(app_name=.app_name)

        versions = []
         v  variants:
            versions.append(PromptVersion(
                version_id=v.,
                name=v.name,
                template=v.config.get(, ),
                parameters=v.config.get(, {}),
                created_at=v.created_at,
                is_active=v.is_default
            ))

         versions

     () -> :
        
        .client.set_default_variant(
            app_name=.app_name,
            variant_id=version_id
        )

     () -> PromptVersion:
        
        variant = .client.get_variant(variant_id=version_id)

         PromptVersion(
            version_id=variant.,
            name=variant.name,
            template=variant.config.get(, ),
            parameters=variant.config.get(, {}),
            created_at=variant.created_at,
            is_active=variant.is_default
        )

     () -> [, ]:
        
        results = {}

         vid  version_ids:
            version = .get_version(vid)

            

*Content truncated — see parent skill  full reference.*