# What Templating System Generates Structured AI Responses in Lemon AI?

> Discover the custom templating system powering structured AI responses in Lemon AI. Explore the lightweight solution in the srcutils template.js file. Understand its unique placeholder syntax.

- Repository: [hexdocom/lemonai](https://github.com/hexdocom/lemonai)
- Tags: deep-dive
- Published: 2026-03-03

---

**Lemon AI implements a lightweight, custom templating layer in [`src/utils/template.js`](https://github.com/hexdocom/lemonai/blob/main/src/utils/template.js) that uses curly-brace placeholder syntax rather than external engines like Jinja, Handlebars, or Mustache.**

The Lemon AI templating system provides a fast, zero-dependency solution for generating dynamic prompts and structured AI payloads. By leveraging simple string replacement with `{variable}` syntax, the system enables rapid template rendering across knowledge feedback, coding assistance, and agent planning modules.

## How the Custom Templating System Works

The core implementation resides in [`src/utils/template.js`](https://github.com/hexdocom/lemonai/blob/main/src/utils/template.js) and operates through three primary mechanisms: variable extraction, string replacement, and file-based template loading.

### Variable Extraction with `extractTemplateVariables`

The system identifies dynamic placeholders using a regular expression that scans for curly-brace-wrapped keys. The `extractTemplateVariables` function parses template strings to determine which data keys must be supplied at runtime.

```javascript
// src/utils/template.js (simplified)
const extractTemplateVariables = (template) => {
  const regex = /\{([^}]+)\}/g;
  const vars = new Set();
  let match;
  while ((match = regex.exec(template))) vars.add(match[1]);
  return [...vars];
};

```

### Template Rendering with `resolveTemplate`

The `resolveTemplate` function executes the actual substitution, replacing each `{placeholder}` with corresponding values from a data object. If a key is missing, the original placeholder text is preserved.

```javascript
const resolveTemplate = async (template, data = {}) => {
  return template.replace(/\{([^}]+)\}/g, (_, key) =>
    key in data ? data[key] : `{${key}}`
  );
};

```

### File-Based Template Storage

Templates are stored as plain text files under `src/template/` and loaded via the `loadTemplate` function. This separation of concerns allows non-developers to modify prompt structures without touching application logic.

## Implementation Examples Across Lemon AI

The templating system is utilized throughout the codebase to construct context-aware AI prompts for different functional domains.

### Knowledge Feedback Generation

In [`src/knowledge/feedback.js`](https://github.com/hexdocom/lemonai/blob/main/src/knowledge/feedback.js), the system loads [`knowledge.txt`](https://github.com/hexdocom/lemonai/blob/main/knowledge.txt) templates to generate contextual feedback prompts. The template receives dynamic values such as user queries and domain context to produce targeted AI responses.

```javascript
const { resolveTemplate, loadTemplate } = require("@src/utils/template");

const tmpl = await loadTemplate("knowledge.txt");
const filled = await resolveTemplate(tmpl, {
  user_query: "How does photosynthesis work?",
  context: "Botanical basics",
});

```

### Coding Assistance Prompts

The [`src/editor/coding.js`](https://github.com/hexdocom/lemonai/blob/main/src/editor/coding.js) module leverages the templating system to construct coding assistance prompts. It reads local template files and injects dynamic code context including full source code, selected snippets, and specific requirements.

```javascript
const { resolveTemplate } = require("@src/utils/template");
const fs = require("fs");
const path = require("path");

const templatePath = path.join(__dirname, "template.txt");
const template = fs.readFileSync(templatePath, "utf-8");

const opts = { full_code, selection, requirement };
const prompt = await resolveTemplate(template, opts);

```

### Agent Planning Prompts

In [`src/agent/prompt/plan.js`](https://github.com/hexdocom/lemonai/blob/main/src/agent/prompt/plan.js), the templating system generates planning prompts for the AI agent. This enables dynamic construction of multi-step reasoning prompts based on current task context and available tools.

## Summary

- **Lemon AI uses a custom templating system** located in [`src/utils/template.js`](https://github.com/hexdocom/lemonai/blob/main/src/utils/template.js) rather than external libraries like Jinja or Handlebars.
- **Curly-brace syntax** (`{variable}`) defines placeholders that are replaced at runtime via regex-based string substitution.
- **Three core functions** power the system: `extractTemplateVariables` for parsing, `resolveTemplate` for rendering, and `loadTemplate` for file operations.
- **File-based templates** stored in `src/template/` enable separation of prompt content from application logic.
- **Zero-dependency implementation** ensures fast performance and reduced supply chain risk across knowledge, coding, and agent modules.

## Frequently Asked Questions

### Does Lemon AI use Jinja2 or Handlebars for templating?

No, Lemon AI does not use Jinja2, Handlebars, Mustache, or any external templating engine. According to the source code in [`src/utils/template.js`](https://github.com/hexdocom/lemonai/blob/main/src/utils/template.js), Lemon AI implements a lightweight, custom templating layer that uses simple regex-based string replacement for curly-brace placeholders.

### How does variable substitution work in Lemon AI templates?

Variable substitution occurs through the `resolveTemplate` function, which uses the regular expression `/\{([^}]+)\}/g` to find all `{variable}` patterns in the template string. It then replaces each match with the corresponding value from the provided data object. If a variable is not found in the data object, the original placeholder text is preserved.

### Where are template files stored in the Lemon AI repository?

Template files are stored as plain text files under the `src/template/` directory. The `loadTemplate` function in [`src/utils/template.js`](https://github.com/hexdocom/lemonai/blob/main/src/utils/template.js) handles reading these files from disk, after which the loaded string is processed by `resolveTemplate` to substitute dynamic values before being sent to the AI model.

### Can I use conditionals or loops in Lemon AI templates?

No, the custom templating system in Lemon AI does not support advanced features like conditionals, loops, or filters. It performs only simple variable substitution using curly-brace syntax. For complex logic, the codebase handles transformations in JavaScript before passing the final data object to `resolveTemplate`.