# How the n8n-mcp Example Generator Creates Real-World Configurations from Templates

> Discover how the n8n-mcp example generator transforms node schemas into real-world n8n configurations using templates and intelligent metadata for seamless workflow creation.

- Repository: [Romuald Członkowski/n8n-mcp](https://github.com/czlonkowski/n8n-mcp)
- Tags: internals
- Published: 2026-03-24

---

**The n8n-mcp ExampleGenerator service transforms abstract node schemas into ready-to-run n8n configurations by combining a curated template library with intelligent, metadata-driven generation.**

The czlonkowski/n8n-mcp repository provides a Model Context Protocol (MCP) server that bridges AI assistants with n8n workflow automation. At its core, the **n8n-mcp example generator** converts technical node definitions into practical, executable configurations that users can deploy immediately without manual drafting.

## Understanding the ExampleGenerator Architecture

Located in [`src/services/example-generator.ts`](https://github.com/czlonkowski/n8n-mcp/blob/main/src/services/example-generator.ts), the ExampleGenerator service operates through a dual-mode system. It first consults a static library of hand-crafted templates, then falls back to dynamic generation when curated examples are unavailable. This architecture ensures comprehensive coverage across both popular n8n nodes and obscure custom integrations.

The service integrates with [`src/parsers/property-extractor.ts`](https://github.com/czlonkowski/n8n-mcp/blob/main/src/parsers/property-extractor.ts) to obtain node metadata and exposes its functionality through [`src/mcp/tools.ts`](https://github.com/czlonkowski/n8n-mcp/blob/main/src/mcp/tools.ts), enabling AI assistants to deliver production-ready configurations on demand.

## Curated Templates vs. Dynamic Generation

### The NODE_EXAMPLES Library

The static `NODE_EXAMPLES` map (lines 19-78) stores production-ready configurations for common n8n nodes like `httpRequest`, `webhook`, and `code`. Each entry organizes examples into three tiers: `minimal`, `common`, and `advanced`.

When you request an HTTP Request node example, the generator returns pre-built configurations such as POST requests to `https://api.example.com/users` with proper JSON body structures and authentication headers already configured.

```typescript
import { ExampleGenerator } from 'n8n-mcp';

// Returns the full set (minimal / common / advanced) for the HTTP Request node
const httpExamples = ExampleGenerator.getExamples('nodes-base.httpRequest');

console.log(httpExamples.common);
// → {
//   method: 'POST',
//   url: 'https://api.example.com/users',
//   sendBody: true,
//   contentType: 'json',
//   jsonBody: '{\n  "name": "John Doe",\n  "email": "john@example.com"\n}'
// }

```

### Automatic Fallback with generateBasicExamples

For node types absent from the curated library, the generator invokes `generateBasicExamples()` (lines 96-112). This method inspects the node's *essentials*—required and common properties extracted by the property parser—and constructs minimal working configurations.

The system derives sensible defaults from property metadata, ensuring that even undocumented or brand-new node types receive functional starter configurations.

```typescript
// Suppose we have a brand‑new node type "nodes-custom.fooBar"
const essentials = {
  required: [{ name: 'url', type: 'string' }],
  common: [{ name: 'timeout', type: 'number' }]
};

const generated = ExampleGenerator.getExamples('nodes-custom.fooBar', essentials);

console.log(generated.minimal);
// → { url: 'https://api.example.com', timeout: 30000 }

```

## The Default Value Engine

### Type-Aware Value Resolution

The `getDefaultValue()` method (lines 118-150) determines appropriate placeholder values based on property types and metadata. It handles booleans, numbers, arrays, and objects with type-specific logic that mirrors real-world usage patterns.

### String Pattern Recognition

For string properties, the generator delegates to `getStringDefault()` (lines 154-190), which recognizes semantic patterns in property names. It automatically supplies `https://api.example.com` for URL fields, `user@example.com` for email parameters, and realistic file paths for directory inputs.

## Public API Methods

### Retrieving Examples by Node Type

The `getExamples(nodeType, essentials?)` method serves as the primary entry point. When called with a curated node type like `nodes-base.httpRequest`, it returns the complete example set. For unknown nodes, it accepts an `essentials` parameter containing required and common properties to trigger on-the-fly generation.

### Task-Based Example Selection

The `getTaskExample(nodeType, task)` method (lines 78-105) maps high-level descriptors to specific complexity tiers. It translates human-readable tasks like "simple", "complex", or "full" into the appropriate `minimal`, `common`, or `advanced` configuration levels.

```typescript
const codeExample = ExampleGenerator.getTaskExample(
  'nodes-base.code',
  'complex'   // maps to the "advanced" tier
);

console.log(codeExample?.language); // → 'javaScript'
console.log(codeExample?.jsCode?.slice(0, 60)); // first 60 chars of the advanced script

```

## Integration with MCP Tools

The generator exposes its functionality through MCP tools defined in [`src/mcp/tools.ts`](https://github.com/czlonkowski/n8n-mcp/blob/main/src/mcp/tools.ts). When an AI assistant calls the tool with parameters like `getNodeExample('nodes-base.slack', 'full')`, the system returns the advanced Slack configuration ready for immediate workflow integration.

```typescript
// Inside src/mcp/tools.ts (simplified)
export async function getNodeExample(nodeType: string, task = 'basic') {
  const example = ExampleGenerator.getTaskExample(nodeType, task);
  return { nodeType, example };
}

```

The property metadata required for dynamic generation originates from [`src/parsers/property-extractor.ts`](https://github.com/czlonkowski/n8n-mcp/blob/main/src/parsers/property-extractor.ts), which analyzes n8n node schemas to identify required fields and common parameters.

## Summary

- The ExampleGenerator combines curated templates in `NODE_EXAMPLES` with dynamic generation via `generateBasicExamples()`
- `getDefaultValue()` and `getStringDefault()` provide intelligent defaults based on property types and naming patterns
- The `getExamples()` and `getTaskExample()` APIs offer both direct node lookup and task-based complexity selection
- Integration with [`src/mcp/tools.ts`](https://github.com/czlonkowski/n8n-mcp/blob/main/src/mcp/tools.ts) enables AI assistants to deliver production-ready n8n configurations without manual drafting

## Frequently Asked Questions

### How does the n8n-mcp example generator handle unsupported node types?

When a node type lacks a curated entry in `NODE_EXAMPLES`, the generator falls back to `generateBasicExamples()` in [`src/services/example-generator.ts`](https://github.com/czlonkowski/n8n-mcp/blob/main/src/services/example-generator.ts). This method analyzes the node's essential properties and constructs a minimal configuration using `getDefaultValue()` to populate sensible defaults based on property metadata.

### What is the difference between minimal, common, and advanced example tiers?

The three tiers represent progressive complexity levels stored in the static `NODE_EXAMPLES` map (lines 19-78). Minimal configurations contain only required parameters, common examples add standard optional fields, and advanced tiers include complex features like error handling, pagination, and authentication flows.

### How does the generator determine default values for string properties?

The `getStringDefault()` method (lines 154-190) analyzes property names for semantic patterns. It recognizes URLs, email addresses, file paths, and API endpoints, then returns realistic placeholders like `https://api.example.com` or `user@example.com` that match the expected data format.

### Can AI assistants request specific complexity levels for node examples?

Yes, through the `getTaskExample()` method which accepts task descriptors like "simple", "complex", or "full". This method maps human-readable complexity indicators to the appropriate tier in the example set, allowing AI systems to request configurations matching the user's technical expertise level.