--- title: "Prompt Variables and Templating: Dynamic Content Injection with Jinja2 and f-strings" description: "Master prompt templating techniques using Jinja2 and Python f-strings. Learn variable injection patterns, conditional blocks, loop constructs, custom filters, and safety practices for dynamic prompts." canonical: https://callsphere.ai/blog/prompt-variables-templating-dynamic-content-injection-jinja2-fstrings category: "Learn Agentic AI" tags: ["Prompt Templating", "Jinja2", "Python", "Dynamic Prompts", "Prompt Engineering"] author: "CallSphere Team" published: 2026-03-17T00:00:00.000Z updated: 2026-05-06T01:02:44.133Z --- # Prompt Variables and Templating: Dynamic Content Injection with Jinja2 and f-strings > Master prompt templating techniques using Jinja2 and Python f-strings. Learn variable injection patterns, conditional blocks, loop constructs, custom filters, and safety practices for dynamic prompts. ## Why Static Prompts Fall Short Hardcoded prompts work for demos. Production agents need prompts that adapt — inserting the user's name, adjusting tone based on context, including relevant data, and conditionally enabling features. This is prompt templating: defining a prompt structure once and injecting dynamic values at runtime. The two dominant approaches in Python are f-strings for simple cases and Jinja2 for complex logic. Understanding when to use each prevents both over-engineering and under-engineering your prompt layer. ## f-string Templating: Simple and Direct For prompts with straightforward variable substitution, Python f-strings are the fastest path. ```mermaid flowchart TD SPEC(["Task spec"]) SYSTEM["System prompt role plus rules"] SHOTS["Few shot examples 3 to 5"] VARS["Variable injection Jinja or f-string"] COT["Chain of thought or scratchpad"] CONSTR["Output constraint JSON schema"] LLM["LLM call"] EVAL["Offline eval LLM as judge plus regex"] GATE{"Score over threshold?"} COMMIT(["Promote to prod version pinned"]) REVISE(["Revise prompt"]) SPEC --> SYSTEM --> SHOTS --> VARS --> COT --> CONSTR --> LLM --> EVAL --> GATE GATE -->|Yes| COMMIT GATE -->|No| REVISE --> SYSTEM style LLM fill:#4f46e5,stroke:#4338ca,color:#fff style EVAL fill:#f59e0b,stroke:#d97706,color:#1f2937 style COMMIT fill:#059669,stroke:#047857,color:#fff ``` ```python def build_support_prompt( user_name: str, account_tier: str, issue_summary: str ) -> str: """Build a support agent prompt with user context.""" return f"""You are a customer support agent for Acme Corp. The customer's name is {user_name}. Their account tier is {account_tier}. Issue summary: {issue_summary} Respond helpfully and professionally. If the customer has a Premium or Enterprise tier, prioritize their request and offer direct escalation options.""" ``` This is readable and type-safe — your IDE catches missing variables. However, f-strings hit limits quickly. You cannot loop over lists of items, conditionally include sections, or reuse template fragments. ## Jinja2 Templating: Full Power Jinja2 gives you conditionals, loops, filters, template inheritance, and macros. It is the standard for complex prompt templating. ```python from jinja2 import Environment, FileSystemLoader, select_autoescape class PromptTemplateEngine: """Render prompts using Jinja2 templates.""" def __init__(self, templates_dir: str = "prompt_templates"): self.env = Environment( loader=FileSystemLoader(templates_dir), autoescape=select_autoescape(default=False), trim_blocks=True, lstrip_blocks=True, ) def render( self, template_name: str, **variables ) -> str: """Render a named template with variables.""" template = self.env.get_template(template_name) return template.render(**variables) ``` Store templates as separate files. ```python # prompt_templates/support_agent.md.j2 # --- # Template: support_agent # Variables: user_name, account_tier, conversation_history, # available_tools, escalation_allowed # --- You are a customer support agent for Acme Corp. Customer: {{ user_name }} ({{ account_tier }} tier) {% if conversation_history %} ## Previous Conversation {% for msg in conversation_history %} {{ msg.role | upper }}: {{ msg.content }} {% endfor %} {% endif %} ## Available Actions {% for tool in available_tools %} - {{ tool.name }}: {{ tool.description }} {% endfor %} {% if account_tier in ["premium", "enterprise"] %} This is a high-priority customer. You may offer: - Direct phone callback within 1 hour - Escalation to a senior specialist {% endif %} {% if not escalation_allowed %} Note: Do NOT offer escalation options in this session. {% endif %} ``` ```python # Usage engine = PromptTemplateEngine() prompt = engine.render( "support_agent.md.j2", user_name="Alice Chen", account_tier="premium", conversation_history=[ {"role": "user", "content": "My invoice is wrong"}, {"role": "assistant", "content": "Let me look into that."}, ], available_tools=[ {"name": "lookup_invoice", "description": "Fetch invoice details"}, {"name": "create_ticket", "description": "Open a support ticket"}, ], escalation_allowed=True, ) ``` ## Custom Filters for Prompt-Specific Needs Jinja2 filters transform values inline. Add custom filters for common prompt operations. ```python def setup_prompt_filters(env: Environment): """Add prompt-specific Jinja2 filters.""" def truncate_tokens(text: str, max_tokens: int = 500) -> str: """Rough truncation by word count as a token proxy.""" words = text.split() if len(words) str: """Format a list for prompt readability.""" if style == "numbered": return "\n".join( f"{i+1}. {item}" for i, item in enumerate(items) ) return "\n".join(f"- {item}" for item in items) def mask_pii(text: str) -> str: """Mask email addresses and phone numbers.""" import re text = re.sub( r'[\w.+-]+@[\w-]+\.[\w.]+', '[EMAIL]', text ) text = re.sub( r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[PHONE]', text ) return text env.filters["truncate_tokens"] = truncate_tokens env.filters["format_list"] = format_list env.filters["mask_pii"] = mask_pii ``` Use them in templates: `{{ user_message | mask_pii | truncate_tokens(200) }}`. ## Safety Practices Dynamic prompts introduce injection risks. User-provided values could contain instructions that hijack the agent's behavior. ```python class SafePromptRenderer: """Render prompts with input sanitization.""" def __init__(self, engine: PromptTemplateEngine): self.engine = engine def sanitize_input(self, value: str) -> str: """Remove patterns that could be prompt injections.""" dangerous_patterns = [ "ignore previous instructions", "ignore all instructions", "disregard the above", "new instructions:", "system:", "ADMIN OVERRIDE", ] sanitized = value for pattern in dangerous_patterns: sanitized = sanitized.replace( pattern, "[FILTERED]" ) return sanitized def render_safe( self, template_name: str, **variables ) -> str: """Render with all string variables sanitized.""" safe_vars = {} for key, value in variables.items(): if isinstance(value, str): safe_vars[key] = self.sanitize_input(value) else: safe_vars[key] = value return self.engine.render(template_name, **safe_vars) ``` Always sanitize user-provided inputs before injecting them into prompts. Treat prompt templates like SQL queries — never insert raw user input without validation. ## FAQ ### When should I use f-strings versus Jinja2? Use f-strings when your prompt has fewer than five variables and no conditional logic. Switch to Jinja2 when you need conditionals, loops, template inheritance, or when non-engineers need to edit the templates. The readability of Jinja2 templates makes them better for team collaboration. ### How do I handle missing template variables? Configure Jinja2 with `undefined=StrictUndefined` to raise errors on missing variables rather than silently inserting empty strings. This catches bugs during development. In production, you can use `default` filters: `{{ user_name | default("Customer") }}`. ### Can prompt injection be fully prevented with sanitization? No. Blocklist-based sanitization catches known patterns but misses creative bypasses. Layer multiple defenses: sanitize inputs, use structured system-vs-user message separation, validate outputs, and monitor for anomalous agent behavior. Sanitization is one layer in a defense-in-depth strategy. --- #PromptTemplating #Jinja2 #Python #DynamicPrompts #PromptEngineering #AgenticAI #LearnAI #AIEngineering --- Source: https://callsphere.ai/blog/prompt-variables-templating-dynamic-content-injection-jinja2-fstrings