# n8n Node Configuration

Expert guidance for operation-aware node configuration with property dependencies.

## Overview

**Skill Name**: n8n Node Configuration
**Priority**: Medium
**Purpose**: Teach operation-aware configuration with progressive discovery and dependency awareness

## The Problem This Solves

Node configuration patterns:

- get_node is the primary discovery tool (18s avg from search → standard detail)
- 91.7% success rate with standard detail configuration
- 56 seconds average between configuration edits

**Key insight**: Most configurations only need standard detail, not full schema!

## What This Skill Teaches

### Core Concepts

1. **Operation-Aware Configuration**
   - Resource + operation determine required fields
   - Different operations = different requirements
   - Always check requirements when changing operation

2. **Property Dependencies**
   - Fields appear/disappear based on other field values
   - displayOptions control visibility
   - Conditional required fields
   - Understanding dependency chains

3. **Progressive Discovery**
   - Start with get_node standard detail (91.7% success)
   - Escalate to get_node({mode: "search_properties"}) if needed
   - Use get_node({detail: "full"}) only when necessary
   - Right tool for right job

4. **Configuration Workflow**
   - Identify → Discover → Configure → Validate → Iterate
   - Average 2-3 validation cycles
   - Read errors for dependency hints
   - 56 seconds between edits average

5. **Common Patterns**
   - Resource/operation nodes (Slack, Sheets)
   - HTTP-based nodes (HTTP Request, Webhook)
   - Database nodes (Postgres, MySQL)
   - Conditional logic nodes (IF, Switch)

## File Structure

```
n8n-node-configuration/
├── SKILL.md (692 lines)
│   Main configuration guide
│   - Configuration philosophy (progressive disclosure)
│   - Core concepts (operation-aware, dependencies)
│   - Configuration workflow (8-step process)
│   - get_node vs get_node({detail: "full"})
│   - Property dependencies deep dive
│   - Common node patterns (4 categories)
│   - Operation-specific examples
│   - Conditional requirements
│   - Anti-patterns and best practices
│
├── DEPENDENCIES.md (671 lines)
│   Property dependencies reference
│   - displayOptions mechanism
│   - show vs hide rules
│   - Multiple conditions (AND logic)
│   - Multiple values (OR logic)
│   - 4 common dependency patterns
│   - Using get_node({mode: "search_properties"})
│   - Complex dependency examples
│   - Nested dependencies
│   - Auto-sanitization interaction
│   - Troubleshooting guide
│   - Advanced patterns
│
├── OPERATION_PATTERNS.md (783 lines)
│   Common configurations by node type
│   - HTTP Request (GET/POST/PUT/DELETE)
│   - Webhook (basic/auth/response)
│   - Slack (post/update/create)
│   - Gmail (send/get)
│   - Postgres (query/insert/update)
│   - Set (values/mapping)
│   - Code (per-item/all-items)
│   - IF (string/number/boolean)
│   - Switch (rules/fallback)
│   - OpenAI (chat completion)
│   - Schedule (daily/interval/cron)
│   - Gotchas and tips for each
│
└── README.md (this file)
    Skill metadata and statistics
```

**Total**: ~2,146 lines across 4 files + 4 evaluations

## Usage Statistics

Configuration metrics:

| Metric | Value | Insight |
|---|---|---|
| get_node | Primary tool | Most popular discovery pattern |
| Success rate (standard) | 91.7% | Standard detail sufficient for most |
| Avg time search→get_node | 18 seconds | Fast discovery workflow |
| Avg time between edits | 56 seconds | Iterative configuration |

## Tool Usage Pattern

**Most common discovery pattern**:
```
search_nodes → get_node (18s average)
```

**Configuration cycle**:
```
get_node → configure → validate → iterate (56s avg per edit)
```

## Key Insights

### 1. Progressive Disclosure Works

**91.7% success rate** with get_node (standard detail) proves most configurations don't need full schema.

**Strategy**:
1. Start with standard detail
2. Escalate to search_properties mode if stuck
3. Use full schema only when necessary

### 2. Operations Determine Requirements

**Same node, different operation = different requirements**

Example: Slack message
- `operation="post"` → needs channel + text
- `operation="update"` → needs messageId + text (different!)

### 3. Dependencies Control Visibility

**Fields appear/disappear based on other values**

Example: HTTP Request
- `method="GET"` → body hidden
- `method="POST"` + `sendBody=true` → body required

### 4. Configuration is Iterative

**Average 56 seconds between edits** shows configuration is iterative, not one-shot.

**Normal workflow**:
1. Configure minimal
2. Validate → error
3. Add missing field
4. Validate → error
5. Adjust value
6. Validate → valid ✅

### 5. Common Gotchas Exist

**Top 5 gotchas** from patterns:
1. Webhook data under `$json.body` (not `$json`)
2. POST needs `sendBody: true`
3. Slack channel format (`#name`)
4. SQL parameterized queries (injection prevention)
5. Timezone must be explicit (schedule nodes)

## Usage Examples

### Example 1: Basic Configuration Flow

```javascript
// Step 1: Get standard info
const info = get_node({
  nodeType: "nodes-base.slack"
});

// Step 2: Configure for operation
{
  "resource": "message",
  "operation": "post",
  "channel": "#general",
  "text": "Hello!"
}

// Step 3: Validate
validate_node({...});
// ✅ Valid!
```

### Example 2: Handling Dependencies

```javascript
// Step 1: Configure HTTP POST
{
  "method": "POST",
  "url": "https://api.example.com/create"
}

// Step 2: Validate → Error: "sendBody required"
// Step 3: Check dependencies
get_node({mode: "search_properties"})({
  nodeType: "nodes-base.httpRequest"
});
// Shows: body visible when sendBody=true

// Step 4: Fix
{
  "method": "POST",
  "url": "https://api.example.com/create",
  "sendBody": true,
  "body": {
    "contentType": "json",
    "content": {...}
  }
}
// ✅ Valid!
```

### Example 3: Operation Change

```javascript
// Initial config (post operation)
{
  "resource": "message",
  "operation": "post",
  "channel": "#general",
  "text": "Hello"
}

// Change operation
{
  "resource": "message",
  "operation": "update",  // Changed!
  // Need to check new requirements
}

// Get standard info for update operation
get_node({nodeType: "nodes-base.slack"});
// Shows: messageId required, channel optional

// Correct config
{
  "resource": "message",
  "operation": "update",
  "messageId": "1234567890.123456",
  "text": "Updated"
}
```

## When This Skill Activates

**Trigger phrases**:
- "how to configure"
- "what fields are required"
- "property dependencies"
- "get_node vs get_node({detail: "full"})"
- "operation-specific"
- "field not visible"

**Common scenarios**:
- Configuring new nodes
- Understanding required fields
- Field appears/disappears unexpectedly
- Choosing between discovery tools
- Switching operations
- Learning common patterns

## Integration with Other Skills

### Works With:
- **n8n MCP Tools Expert** - How to call discovery tools correctly
- **n8n Validation Expert** - Interpret missing_required errors
- **n8n Expression Syntax** - Configure expression fields
- **n8n Workflow Patterns** - Apply patterns with proper node config

### Complementary:
- Use MCP Tools Expert to learn tool selection
- Use Validation Expert to fix configuration errors
- Use Expression Syntax for dynamic field values
- Use Workflow Patterns to understand node relationships

## Testing

**Evaluations**: 4 test scenarios

1. **eval-001-property-dependencies.json**
   - Tests understanding of displayOptions
   - Guides to get_node({mode: "search_properties"})
   - Explains conditional requirements

2. **eval-002-operation-specific-config.json**
   - Tests operation-aware configuration
   - Identifies resource + operation pattern
   - References OPERATION_PATTERNS.md

3. **eval-003-conditional-fields.json**
   - Tests unary vs binary operators
   - Explains singleValue dependency
   - Mentions auto-sanitization

4. **eval-004-standard-vs-full.json**
   - Tests tool selection knowledge
   - Explains progressive disclosure
   - Provides success rate statistics

## Success Metrics

**Before this skill**:
- Using get_node({detail: "full"}) for everything (slow, overwhelming)
- Not understanding property dependencies
- Confused when fields appear/disappear
- Not aware of operation-specific requirements
- Trial and error configuration

**After this skill**:
- Start with get_node standard detail (91.7% success)
- Understand displayOptions mechanism
- Predict field visibility based on dependencies
- Check requirements when changing operations
- Systematic configuration approach
- Know common patterns by node type

## Coverage

**Node types covered**: Top 20 most-used nodes

| Category | Nodes | Coverage |
|---|---|---|
| HTTP/API | HTTP Request, Webhook | Complete |
| Communication | Slack, Gmail | Common operations |
| Database | Postgres, MySQL | CRUD operations |
| Transform | Set, Code | All modes |
| Conditional | IF, Switch | All operator types |
| AI | OpenAI | Chat completion |
| Schedule | Schedule Trigger | All modes |

## Related Documentation

- **n8n-mcp MCP Server**: Provides discovery tools
- **n8n Node API**: get_node, get_node({mode: "search_properties"}), get_node({detail: "full"})
- **n8n Schema**: displayOptions mechanism, property definitions

## Version History

- **v1.0** (2025-10-20): Initial implementation
  - SKILL.md with configuration workflow
  - DEPENDENCIES.md with displayOptions deep dive
  - OPERATION_PATTERNS.md with 20+ node patterns
  - 4 evaluation scenarios

## Author

Conceived by Romuald Członkowski - [www.aiadvisors.pl/en](https://www.aiadvisors.pl/en)

Part of the n8n-skills meta-skill collection.
