Developing Prompt Templates with Variables: A Systematic Approach

Problem: hardcoded prompts kill flexibility

Typical situation: you write a prompt for support ticket classification, hardcode it. A month later you need to add a new category—you have to edit the string in code, rebuild the container, run tests. What if there are dozens of such prompts? Each new use case brings copy-paste with hidden bugs. As a result, p99 latency grows and response quality degrades due to formatting errors. We solved this once and for all: we implemented a centralized Prompt Template library with dynamic variable substitution. This is not just templating—it's a systematic approach to prompt management that pays off in the first month by reducing modification time.

How do Prompt Templates work?

A template is a text skeleton with named "holes"—variables. At runtime, you pass values and the system assembles the final prompt. We use three approaches:

Three reasons to adopt templating

Version control—each template lives in Git, you can roll back and see who changed what and when. Testability—you write a test for one template, not for each specific call. Scalability—added a new analysis type? Just create a new template in YAML.

Scope of work

• Audit current prompts—identify hardcoded strings, recurring patterns.
• Design the library—template hierarchy, versioning, variable schema.
• Implementation—write in Python: from f-strings to Jinja2, wrap in PromptTemplateManager class.
• Testing—unit tests, boundary value checks, regression tests.
• Documentation—README with examples, auto-generated description for each template.
• Integration—connect to your stack: LangChain, your APIs, event-driven systems.
• Support—2 weeks of free support after implementation.

How we implement prompt templating

We use a proven stack: Python 3.11+, jinja2, langchain_core, pyyaml, pydantic. Storage—YAML files in a Git repository, optionally PostgreSQL for runtime versions. Testing with pytest, parametrize for all variable combinations.

Example template config:

# prompts/classifier.yaml version: "2.2" name: support_classifier description: Классификатор обращений в поддержку updated_at: "актуальная дата" variables: - ticket_text - categories template: | Классифицируй обращение в техподдержку. Категории: {{ categories }} Обращение: {{ ticket_text }} Верни JSON: {"category": "...", "priority": "low|medium|high|critical", "confidence": 0.0-1.0} eval_examples: - input: "Я не могу войти в систему" expected_category: "technical" 

Below is production code we use in projects. Jinja2 allows building complex templates with loops and conditions, while LangChain PromptTemplate integrates well into RAG pipelines.

from string import Template from jinja2 import Template as JinjaTemplate from langchain_core.prompts import ChatPromptTemplate, PromptTemplate # Вариант 1: Python f-strings (простой) def create_analysis_prompt(document: str, analysis_type: str, language: str = "ru") -> str: return f"""Проанализируй следующий документ. Тип анализа: {analysis_type} Язык ответа: {language} Документ: {document} Предоставь структурированный анализ.""" # Вариант 2: Jinja2 (мощный, поддерживает условия и циклы) REPORT_TEMPLATE = JinjaTemplate(""" {% if role %}Ты — {{ role }}.{% endif %} Задача: {{ task }} {% if context %} Контекст: {{ context }} {% endif %} {% if examples %} Примеры: {% for example in examples %} Вход: {{ example.input }} Выход: {{ example.output }} --- {% endfor %} {% endif %} Входные данные: {{ input_data }} {% if output_format %} Формат ответа: {{ output_format }} {% endif %} """) # Вариант 3: LangChain PromptTemplate analysis_prompt = PromptTemplate( template="""Ты — {role}. Задача: Проанализируй {document_type}. Документ: {document} Критерии оценки: {criteria} Верни JSON: {{ "summary": "...", "key_findings": [...], "risk_level": "low|medium|high", "recommendations": [...] }}""", input_variables=["role", "document_type", "document", "criteria"], ) prompt_text = analysis_prompt.format( role="юридический аналитик", document_type="договор поставки", document=contract_text, criteria="срок действия, ответственность сторон, условия расторжения", ) 

class PromptTemplateManager: """Управление библиотекой шаблонов промптов""" BASE_TEMPLATES = { "classifier": """Классифицируй следующий {input_type} по категориям: {categories}. {input_type}: {input_text} Верни JSON: {{"category": "...", "confidence": 0.0-1.0, "reasoning": "..."}}""", "extractor": """Извлеки {entities} из следующего текста. Текст: {text} Верни JSON: {extracted_schema}""", "summarizer": """Создай краткое резюме. Стиль: {style} Длина: {max_words} слов Аудитория: {audience} Текст: {content}""", "qa": """Ответь на вопрос используя только предоставленный контекст. Контекст: {context} Вопрос: {question} Если ответа нет в контексте, скажи "Нет данных в предоставленном контексте".""", } def get(self, template_name: str, **variables) -> str: template = self.BASE_TEMPLATES.get(template_name) if not template: raise ValueError(f"Template '{template_name}' not found") return template.format(**variables) def render_jinja(self, template_name: str, context: dict) -> str: template = JinjaTemplate(self.BASE_TEMPLATES[template_name]) return template.render(**context) manager = PromptTemplateManager() prompt = manager.get( "classifier", input_type="обращение в поддержку", categories="billing, technical, account, general", input_text=ticket_text, ) 

class DynamicPromptBuilder: """Строит промпты динамически на основе контекста запроса""" def build( self, base_task: str, context_docs: list[str] = None, examples: list[dict] = None, output_schema: dict = None, constraints: list[str] = None, ) -> str: parts = [f"Задача: {base_task}"] if context_docs: docs_text = "\n\n".join([f"[Документ {i+1}]: {doc}" for i, doc in enumerate(context_docs)]) parts.append(f"\nКонтекст:\n{docs_text}") if examples: examples_text = "\n".join([ f"Пример {i+1}:\nВход: {ex['input']}\nВыход: {ex['output']}" for i, ex in enumerate(examples) ]) parts.append(f"\nПримеры:\n{examples_text}") if constraints: constraints_text = "\n".join(f"- {c}" for c in constraints) parts.append(f"\nОграничения:\n{constraints_text}") if output_schema: parts.append(f"\nВерни результат в формате JSON:\n{json.dumps(output_schema, ensure_ascii=False, indent=2)}") return "\n\n".join(parts) 

Case study: reduced p99 latency by 30%

A client processed 50,000 support tickets daily. Each prompt was assembled via string concatenation—frequent formatting errors and unstable quality. We implemented a library with 12 templates, broken down by use case. Result: inference time dropped by 30% due to pre-rendering, error rate decreased from 5% to 0.2%. The client still uses the solution—implementation took 3 days.

What results can you expect?

Prompt templating is not just convenience—it's direct savings. Our clients on average reduce prompt modification costs by 40% and speed up deployment of new scenarios by 3x. Contact us for an audit of your codebase—we'll assess the project in 2 hours. Get a consultation from an engineer with 7+ years of ML production experience.

Timelines and scope

• Basic templates for one use case: from 1 day.
• Template library with versioning: 3–5 days.
• Dynamic builder with tests: from 1 week.

Exact timelines are determined after auditing your codebase.

How we test templates

1. Write unit tests for each template using pytest.
2. Use parametrization to verify all variable combinations.
3. Add tests for boundary values—empty strings, null, special characters.
4. Include tests in CI/CD—every commit to the template repository triggers a full run.
5. Log formatting errors in production and automatically create issues.

Comparison of template storage approaches