Prompt Templates — How a Missing {variable} Cost Us $12k in Token Waste

from jinja2 import Environment, FileSystemLoader
import tiktoken
import time

# Create a cached environment (reuse this across requests)
env = Environment(loader=FileSystemLoader('templates/'), autoescape=True)

# Template with explicit output format instructions
template_str = """
You are a fraud analyst. Given the following transaction context:
{{ context }}

Respond with valid JSON only:
{
    "fraud_score": <float between 0 and 1>,
    "reason": "<string>"
}
"""

# Compile the template once (this is the expensive part)
compiled_template = env.from_string(template_str)

# Measure render time
start = time.time()
context = "Transaction: $5000 from account 12345 to account 67890"
rendered = compiled_template.render(context=context)
print(f"Render time: {(time.time() - start)*1000:.2f}ms")

# Tokenize the rendered prompt
enc = tiktoken.encoding_for_model('gpt-4')
token_count = len(enc.encode(rendered))
print(f"Token count: {token_count}")

# Validate output schema (pre-send check)
import json
try:
    # Simulate LLM response (in production, this is the API call)
    response = '{"fraud_score": 0.85, "reason": "Suspicious transaction"}'
    parsed = json.loads(response)
    assert 0 <= parsed['fraud_score'] <= 1
    print("Output schema valid")
except (json.JSONDecodeError, AssertionError) as e:
    print(f"Output schema invalid: {e}")

from pydantic import BaseModel, Field, ValidationError
from jinja2 import Environment, FileSystemLoader
import json
from typing import Optional

# Pydantic model for input variables
class PromptVariables(BaseModel):
    context: str = Field(..., min_length=1, max_length=2000)
    user_name: Optional[str] = None

# Template with explicit output schema instructions
TEMPLATE_STR = """
You are a customer support agent. Context: {{ context }}
{% if user_name %}User: {{ user_name }}{% endif %}

Respond with valid JSON only:
{
    "response_text": "<string>",
    "action": "<escalate|resolve|ask_more_info>"
}
"""

# Pydantic model for output validation
class LLMOutput(BaseModel):
    response_text: str = Field(..., max_length=500)
    action: str = Field(..., pattern=r'^(escalate|resolve|ask_more_info)$')

class PromptTemplateEngine:
    def __init__(self):
        self.env = Environment(loader=FileSystemLoader('templates/'), autoescape=True)
        self.compiled = self.env.from_string(TEMPLATE_STR)

    def render(self, variables: dict) -> str:
        # Validate input variables
        try:
            validated = PromptVariables(**variables)
        except ValidationError as e:
            raise ValueError(f"Invalid prompt variables: {e}")

        # Render the template
        return self.compiled.render(**validated.dict())

    def validate_output(self, response: str) -> LLMOutput:
        try:
            parsed = json.loads(response)
            return LLMOutput(**parsed)
        except (json.JSONDecodeError, ValidationError) as e:
            raise ValueError(f"Invalid LLM output: {e}")

# Usage in production
engine = PromptTemplateEngine()
try:
    prompt = engine.render({"context": "User reported login issue", "user_name": "Alice"})
    # Send to LLM...
    llm_response = '{"response_text": "Let me help you with that.", "action": "resolve"}'
    validated_output = engine.validate_output(llm_response)
    print(f"Valid output: {validated_output}")
except ValueError as e:
    print(f"Error: {e}")
    # Fallback: use a simpler template
    fallback_prompt = "User reported an issue. Please respond with 'escalate' or 'resolve'."

# When NOT to use a template: static prompts
# Bad: using a template for a static prompt
from jinja2 import Environment
env = Environment()
static_template = env.from_string("You are a helpful assistant.")
# This adds unnecessary overhead

# Good: use a raw string
STATIC_PROMPT = "You are a helpful assistant."

# When NOT to use a template: user input contains template syntax
# Bad: injecting user input directly into a template
user_input = "{{ malicious_code }}"
template = env.from_string(f"User said: {user_input}")
# This could execute template syntax

# Good: escape user input or use raw blocks
from jinja2 import escape
template = env.from_string("User said: {{ user_input | e }}")
rendered = template.render(user_input=user_input)
# The | e filter escapes template syntax

# When NOT to use a template: dynamic prompts built by code
# Bad: using a template for a JSON structure
import json
data = {"key": "value"}
template = env.from_string("{{ data | tojson }}")
# Good: build the JSON directly
prompt = f"Respond with: {json.dumps(data)}"

import hashlib
import json
from jinja2 import Environment, FileSystemLoader
from pydantic import BaseModel
import tiktoken

class TemplateRegistry:
    def __init__(self):
        self.env = Environment(loader=FileSystemLoader('templates/'), autoescape=True)
        self.templates = {}  # version -> compiled template

    def register(self, version: str, template_str: str):
        # Hash the template for deduplication
        template_hash = hashlib.sha256(template_str.encode()).hexdigest()
        compiled = self.env.from_string(template_str)
        self.templates[version] = (compiled, template_hash)

    def render(self, version: str, variables: dict) -> str:
        if version not in self.templates:
            raise ValueError(f"Unknown template version: {version}")
        compiled, _ = self.templates[version]
        return compiled.render(**variables)

# Monitor token usage per template variant
enc = tiktoken.encoding_for_model('gpt-4')

def pre_send_hook(rendered_prompt: str, max_tokens: int = 2000):
    token_count = len(enc.encode(rendered_prompt))
    if token_count > max_tokens:
        raise ValueError(f"Prompt too long: {token_count} tokens (max {max_tokens})")
    if token_count < 10:
        raise ValueError(f"Prompt too short: {token_count} tokens")
    return token_count

# Usage
registry = TemplateRegistry()
registry.register("v1", "You are a fraud analyst. Context: {{ context }}")
registry.register("v2", "You are a fraud analyst. Context: {{ context }}. Respond with JSON.")

# Render with versioning
prompt = registry.render("v2", {"context": "Transaction data"})
token_count = pre_send_hook(prompt)
print(f"Rendered prompt with {token_count} tokens")

# Mistake 1: Missing variable validation
# Bad: no validation
from jinja2 import Environment
env = Environment()
template = env.from_string("Context: {{ context }}")
rendered = template.render()  # context is missing, renders as empty string
# Good: validate with Pydantic
from pydantic import BaseModel, Field
class Variables(BaseModel):
    context: str = Field(..., min_length=1)

# Mistake 2: No output schema enforcement
# Bad: no output instructions
template = env.from_string("Analyze this: {{ text }}")
# Good: include output schema
template = env.from_string("Analyze this: {{ text }}. Respond with JSON: {\"result\": \"...\"}")

# Mistake 3: Using | safe on user input
# Bad: bypasses escaping
template = env.from_string("User said: {{ user_input | safe }}")
# Good: use autoescaping (default) or | e filter
template = env.from_string("User said: {{ user_input | e }}")

# Mistake 4: Not caching the compiled template
# Bad: recompiling every request
import time
start = time.time()
for _ in range(100):
    t = env.from_string("Context: {{ context }}")
    t.render(context="test")
print(f"Without caching: {(time.time() - start)*1000:.2f}ms")
# Good: cache the compiled template
compiled = env.from_string("Context: {{ context }}")
start = time.time()
for _ in range(100):
    compiled.render(context="test")
print(f"With caching: {(time.time() - start)*1000:.2f}ms")

import time
from jinja2 import Environment
from langchain.prompts import PromptTemplate

# Jinja2 (direct)
env = Environment()
jinja2_template = env.from_string("Context: {{ context }}")

# LangChain PromptTemplate
langchain_template = PromptTemplate(
    input_variables=["context"],
    template="Context: {context}"
)

# Measure latency
start = time.time()
for _ in range(1000):
    jinja2_template.render(context="test")
jinja2_time = (time.time() - start) * 1000

start = time.time()
for _ in range(1000):
    langchain_template.format(context="test")
langchain_time = (time.time() - start) * 1000

print(f"Jinja2: {jinja2_time:.2f}ms for 1000 renders")
print(f"LangChain: {langchain_time:.2f}ms for 1000 renders")
print(f"LangChain is {langchain_time/jinja2_time:.1f}x slower")
# Output: LangChain is ~2.5x slower due to overhead

import logging
import json
from pydantic import BaseModel, ValidationError
from jinja2 import Environment
import tiktoken

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class PromptMonitor:
    def __init__(self):
        self.env = Environment()
        self.enc = tiktoken.encoding_for_model('gpt-4')

    def render_and_log(self, template_str: str, variables: dict, version: str):
        compiled = self.env.from_string(template_str)
        rendered = compiled.render(**variables)
        token_count = len(self.enc.encode(rendered))

        # Log the filled prompt and metadata
        logger.info({
            "event": "prompt_rendered",
            "version": version,
            "variables": list(variables.keys()),
            "token_count": token_count,
            "rendered_preview": rendered[:100],  # Log first 100 chars
        })

        # Check for anomalies
        if token_count > 2000:
            logger.warning(f"Prompt too long: {token_count} tokens")
        if token_count < 10:
            logger.warning(f"Prompt too short: {token_count} tokens")

        return rendered

# Usage
monitor = PromptMonitor()
template = "Context: {{ context }}"
rendered = monitor.render_and_log(template, {"context": "Transaction data"}, "v1")

// io.thecodeforge
from langchain.callbacks import get_openai_callback

def profile_template_tokens(template, variables):
    """Fail CI if template exceeds token budget."""
    MAX_TOKENS = 512
    prompt = template.format(**variables)
    
    with get_openai_callback() as cb:
        # Simulate a single call to count tokens
        llm = ChatOpenAI(model="gpt-4", max_tokens=1)
        llm.invoke(prompt)
    
    total_tokens = cb.total_tokens
    if total_tokens > MAX_TOKENS:
        raise ValueError(
            f"Template costs {total_tokens} tokens — budget is {MAX_TOKENS}. "
            f"Trim or justify."
        )
    print(f"Green: {total_tokens} tokens used.")

// io.thecodeforge
from pydantic import BaseModel, Field
from typing import List

class TicketOutput(BaseModel):
    summary: str = Field(..., max_length=100)
    priority: int = Field(ge=1, le=5)
    assignee: str | None = None
    tags: List[str] = Field(default_factory=list)

# Template stays minimal — schema does the heavy lifting
TEMPLATE = """Extract ticket fields from: {user_input}
Return a valid object matching the schema."""

# In the chain, use output_parser=JsonOutputParser(pydantic_object=TicketOutput)
# Model cannot return junk without blowing up."