@caoscompanybr/merlin 3.5.0

package/.merlin-core/skills/domain/n8n-automation/references/node-configuration.md

@@ -0,0 +1,2523 @@
+<!-- Adapted from czlonkowski/n8n-skills (MIT). Source files: SKILL.md, DEPENDENCIES.md, OPERATION_PATTERNS.md -->
+
+# n8n Node Configuration
+
+Expert guidance for operation-aware node configuration with property dependencies.
+
+---
+
+## Configuration Philosophy
+
+**Progressive disclosure**: Start minimal, add complexity as needed
+
+Configuration best practices:
+
+- `get_node` with `detail: "standard"` is the most used discovery pattern
+- 56 seconds average between configuration edits
+- Covers 95% of use cases with 1-2K tokens response
+
+**Key insight**: Most configurations need only standard detail, not full schema!
+
+---
+
+## Core Concepts
+
+### 1. Operation-Aware Configuration
+
+**Not all fields are always required** - it depends on operation!
+
+**Example**: Slack node
+
+```javascript
+// For operation='post'
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "#general",  // Required for post
+  "text": "Hello!"        // Required for post
+}
+
+// For operation='update'
+{
+  "resource": "message",
+  "operation": "update",
+  "messageId": "123",     // Required for update (different!)
+  "text": "Updated!"      // Required for update
+  // channel NOT required for update
+}
+```
+
+**Key**: Resource + operation determine which fields are required!
+
+### 2. Property Dependencies
+
+**Fields appear/disappear based on other field values**
+
+**Example**: HTTP Request node
+
+```javascript
+// When method='GET'
+{
+  "method": "GET",
+  "url": "https://api.example.com"
+  // sendBody not shown (GET doesn't have body)
+}
+
+// When method='POST'
+{
+  "method": "POST",
+  "url": "https://api.example.com",
+  "sendBody": true,       // Now visible!
+  "body": {               // Required when sendBody=true
+    "contentType": "json",
+    "content": {...}
+  }
+}
+```
+
+**Mechanism**: displayOptions control field visibility
+
+### 3. Progressive Discovery
+
+**Use the right detail level**:
+
+1. **get_node({detail: "standard"})** - DEFAULT
+   - Quick overview (~1-2K tokens)
+   - Required fields + common options
+   - **Use first** - covers 95% of needs
+
+2. **get_node({mode: "search_properties", propertyQuery: "..."})** (for finding specific fields)
+   - Find properties by name
+   - Use when looking for auth, body, headers, etc.
+
+3. **get_node({detail: "full"})** (complete schema)
+   - All properties (~3-8K tokens)
+   - Use only when standard detail is insufficient
+
+> **Cross-reference**: For detailed `get_node` tool usage, see [mcp-tools-expert.md](../mcp-tools-expert.md).
+
+---
+
+## Configuration Workflow
+
+### Standard Process
+
+```
+1. Identify node type and operation
+   |
+2. Use get_node (standard detail is default)
+   |
+3. Configure required fields
+   |
+4. Validate configuration
+   |
+5. If field unclear -> get_node({mode: "search_properties"})
+   |
+6. Add optional fields as needed
+   |
+7. Validate again
+   |
+8. Deploy
+```
+
+> **Cross-reference**: For validation details, see [validation-expert.md](../validation-expert.md). For where nodes fit in workflow patterns, see [workflow-patterns.md](../workflow-patterns.md).
+
+### Example: Configuring HTTP Request
+
+**Step 1**: Identify what you need
+
+```javascript
+// Goal: POST JSON to API
+```
+
+**Step 2**: Get node info
+
+```javascript
+const info = get_node({
+  nodeType: "nodes-base.httpRequest",
+});
+
+// Returns: method, url, sendBody, body, authentication required/optional
+```
+
+**Step 3**: Minimal config
+
+```javascript
+{
+  "method": "POST",
+  "url": "https://api.example.com/create",
+  "authentication": "none"
+}
+```
+
+**Step 4**: Validate
+
+```javascript
+validate_node({
+  nodeType: "nodes-base.httpRequest",
+  config,
+  profile: "runtime",
+});
+// -> Error: "sendBody required for POST"
+```
+
+**Step 5**: Add required field
+
+```javascript
+{
+  "method": "POST",
+  "url": "https://api.example.com/create",
+  "authentication": "none",
+  "sendBody": true
+}
+```
+
+**Step 6**: Validate again
+
+```javascript
+validate_node({...});
+// -> Error: "body required when sendBody=true"
+```
+
+**Step 7**: Complete configuration
+
+```javascript
+{
+  "method": "POST",
+  "url": "https://api.example.com/create",
+  "authentication": "none",
+  "sendBody": true,
+  "body": {
+    "contentType": "json",
+    "content": {
+      "name": "={{$json.name}}",
+      "email": "={{$json.email}}"
+    }
+  }
+}
+```
+
+**Step 8**: Final validation
+
+```javascript
+validate_node({...});
+// -> Valid!
+```
+
+---
+
+## get_node Detail Levels
+
+### Standard Detail (DEFAULT - Use This!)
+
+```javascript
+get_node({
+  nodeType: "nodes-base.slack",
+});
+// detail="standard" is the default
+```
+
+**Returns** (~1-2K tokens):
+
+- Required fields
+- Common options
+- Operation list
+- Metadata
+
+**Use**: 95% of configuration needs
+
+### Full Detail (Use Sparingly)
+
+```javascript
+get_node({
+  nodeType: "nodes-base.slack",
+  detail: "full",
+});
+```
+
+**Returns** (~3-8K tokens):
+
+- Complete schema
+- All properties
+- All nested options
+
+**Warning**: Large response, use only when standard insufficient
+
+### Search Properties Mode
+
+```javascript
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "auth",
+});
+```
+
+**Use**: Find authentication, headers, body fields, etc.
+
+> **Cross-reference**: For complete `get_node` modes and parameters, see [mcp-tools-expert.md](../mcp-tools-expert.md).
+
+### Decision Tree
+
+```
++-----------------------------------+
+| Starting new node config?         |
++-----------------------------------+
+| YES -> get_node (standard)        |
++-----------------------------------+
+         |
++-----------------------------------+
+| Standard has what you need?       |
++-----------------------------------+
+| YES -> Configure with it          |
+| NO  -> Continue                   |
++-----------------------------------+
+         |
++-----------------------------------+
+| Looking for specific field?       |
++-----------------------------------+
+| YES -> search_properties mode     |
+| NO  -> Continue                   |
++-----------------------------------+
+         |
++-----------------------------------+
+| Still need more details?          |
++-----------------------------------+
+| YES -> get_node({detail: "full"}) |
++-----------------------------------+
+```
+
+---
+
+## Operation Patterns
+
+Common node configuration patterns organized by node type and operation.
+
+### Overview
+
+**Purpose**: Quick reference for common node configurations
+
+**Coverage**: Top 20 most-used nodes from 525 available
+
+**Pattern format**:
+
+- Minimal valid configuration
+- Common options
+- Real-world examples
+- Gotchas and tips
+
+---
+
+### HTTP & API Nodes
+
+#### HTTP Request (nodes-base.httpRequest)
+
+Most versatile node for HTTP operations
+
+##### GET Request
+
+**Minimal**:
+
+```javascript
+{
+  "method": "GET",
+  "url": "https://api.example.com/users",
+  "authentication": "none"
+}
+```
+
+**With query parameters**:
+
+```javascript
+{
+  "method": "GET",
+  "url": "https://api.example.com/users",
+  "authentication": "none",
+  "sendQuery": true,
+  "queryParameters": {
+    "parameters": [
+      {
+        "name": "limit",
+        "value": "100"
+      },
+      {
+        "name": "offset",
+        "value": "={{$json.offset}}"
+      }
+    ]
+  }
+}
+```
+
+**With authentication**:
+
+```javascript
+{
+  "method": "GET",
+  "url": "https://api.example.com/users",
+  "authentication": "predefinedCredentialType",
+  "nodeCredentialType": "httpHeaderAuth"
+}
+```
+
+##### POST with JSON
+
+**Minimal**:
+
+```javascript
+{
+  "method": "POST",
+  "url": "https://api.example.com/users",
+  "authentication": "none",
+  "sendBody": true,
+  "body": {
+    "contentType": "json",
+    "content": {
+      "name": "John Doe",
+      "email": "john@example.com"
+    }
+  }
+}
+```
+
+**With expressions**:
+
+```javascript
+{
+  "method": "POST",
+  "url": "https://api.example.com/users",
+  "authentication": "none",
+  "sendBody": true,
+  "body": {
+    "contentType": "json",
+    "content": {
+      "name": "={{$json.name}}",
+      "email": "={{$json.email}}",
+      "metadata": {
+        "source": "n8n",
+        "timestamp": "={{$now.toISO()}}"
+      }
+    }
+  }
+}
+```
+
+**Gotcha**: Remember `sendBody: true` for POST/PUT/PATCH!
+
+##### PUT/PATCH Request
+
+**Pattern**: Same as POST, but method changes
+
+```javascript
+{
+  "method": "PUT",  // or "PATCH"
+  "url": "https://api.example.com/users/123",
+  "authentication": "none",
+  "sendBody": true,
+  "body": {
+    "contentType": "json",
+    "content": {
+      "name": "Updated Name"
+    }
+  }
+}
+```
+
+##### DELETE Request
+
+**Minimal** (no body):
+
+```javascript
+{
+  "method": "DELETE",
+  "url": "https://api.example.com/users/123",
+  "authentication": "none"
+}
+```
+
+**With body** (some APIs allow):
+
+```javascript
+{
+  "method": "DELETE",
+  "url": "https://api.example.com/users",
+  "authentication": "none",
+  "sendBody": true,
+  "body": {
+    "contentType": "json",
+    "content": {
+      "ids": ["123", "456"]
+    }
+  }
+}
+```
+
+---
+
+#### Webhook (nodes-base.webhook)
+
+Most common trigger - 813 searches!
+
+##### Basic Webhook
+
+**Minimal**:
+
+```javascript
+{
+  "path": "my-webhook",
+  "httpMethod": "POST",
+  "responseMode": "onReceived"
+}
+```
+
+**Gotcha**: Webhook data is under `$json.body`, not `$json`!
+
+```javascript
+// Wrong
+{
+  "text": "={{$json.email}}"
+}
+
+// Correct
+{
+  "text": "={{$json.body.email}}"
+}
+```
+
+##### Webhook with Authentication
+
+**Header auth**:
+
+```javascript
+{
+  "path": "secure-webhook",
+  "httpMethod": "POST",
+  "responseMode": "onReceived",
+  "authentication": "headerAuth",
+  "options": {
+    "responseCode": 200,
+    "responseData": "{\n  \"success\": true\n}"
+  }
+}
+```
+
+##### Webhook Returning Data
+
+**Custom response**:
+
+```javascript
+{
+  "path": "my-webhook",
+  "httpMethod": "POST",
+  "responseMode": "lastNode",  // Return data from last node
+  "options": {
+    "responseCode": 201,
+    "responseHeaders": {
+      "entries": [
+        {
+          "name": "Content-Type",
+          "value": "application/json"
+        }
+      ]
+    }
+  }
+}
+```
+
+---
+
+### Communication Nodes
+
+#### Slack (nodes-base.slack)
+
+Popular choice for AI agent workflows
+
+##### Post Message
+
+**Minimal**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "#general",
+  "text": "Hello from n8n!"
+}
+```
+
+**With dynamic content**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "={{$json.channel}}",
+  "text": "New user: {{$json.name}} ({{$json.email}})"
+}
+```
+
+**With attachments**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "#alerts",
+  "text": "Error Alert",
+  "attachments": [
+    {
+      "color": "#ff0000",
+      "fields": [
+        {
+          "title": "Error Type",
+          "value": "={{$json.errorType}}"
+        },
+        {
+          "title": "Timestamp",
+          "value": "={{$now.toLocaleString()}}"
+        }
+      ]
+    }
+  ]
+}
+```
+
+**Gotcha**: Channel must start with `#` for public channels or be a channel ID!
+
+##### Update Message
+
+**Minimal**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "update",
+  "messageId": "1234567890.123456",  // From previous message post
+  "text": "Updated message content"
+}
+```
+
+**Note**: `messageId` required, `channel` optional (can be inferred)
+
+##### Create Channel
+
+**Minimal**:
+
+```javascript
+{
+  "resource": "channel",
+  "operation": "create",
+  "name": "new-project-channel",  // Lowercase, no spaces
+  "isPrivate": false
+}
+```
+
+**Gotcha**: Channel name must be lowercase, no spaces, 1-80 chars!
+
+---
+
+#### Gmail (nodes-base.gmail)
+
+Popular for email automation
+
+##### Send Email
+
+**Minimal**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "send",
+  "to": "user@example.com",
+  "subject": "Hello from n8n",
+  "message": "This is the email body"
+}
+```
+
+**With dynamic content**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "send",
+  "to": "={{$json.email}}",
+  "subject": "Order Confirmation #{{$json.orderId}}",
+  "message": "Dear {{$json.name}},\n\nYour order has been confirmed.\n\nThank you!",
+  "options": {
+    "ccList": "admin@example.com",
+    "replyTo": "support@example.com"
+  }
+}
+```
+
+##### Get Email
+
+**Minimal**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "getAll",
+  "returnAll": false,
+  "limit": 10
+}
+```
+
+**With filters**:
+
+```javascript
+{
+  "resource": "message",
+  "operation": "getAll",
+  "returnAll": false,
+  "limit": 50,
+  "filters": {
+    "q": "is:unread from:important@example.com",
+    "labelIds": ["INBOX"]
+  }
+}
+```
+
+---
+
+### Database Nodes
+
+#### Postgres (nodes-base.postgres)
+
+Database operations - 456 templates
+
+##### Execute Query
+
+**Minimal** (SELECT):
+
+```javascript
+{
+  "operation": "executeQuery",
+  "query": "SELECT * FROM users WHERE active = true LIMIT 100"
+}
+```
+
+**With parameters** (SQL injection prevention):
+
+```javascript
+{
+  "operation": "executeQuery",
+  "query": "SELECT * FROM users WHERE email = $1 AND active = $2",
+  "additionalFields": {
+    "mode": "list",
+    "queryParameters": "user@example.com,true"
+  }
+}
+```
+
+**Gotcha**: ALWAYS use parameterized queries for user input!
+
+```javascript
+// BAD - SQL injection risk!
+{
+  "query": "SELECT * FROM users WHERE email = '{{$json.email}}'"
+}
+
+// GOOD - Parameterized
+{
+  "query": "SELECT * FROM users WHERE email = $1",
+  "additionalFields": {
+    "mode": "list",
+    "queryParameters": "={{$json.email}}"
+  }
+}
+```
+
+##### Insert
+
+**Minimal**:
+
+```javascript
+{
+  "operation": "insert",
+  "table": "users",
+  "columns": "name,email,created_at",
+  "additionalFields": {
+    "mode": "list",
+    "queryParameters": "John Doe,john@example.com,NOW()"
+  }
+}
+```
+
+**With expressions**:
+
+```javascript
+{
+  "operation": "insert",
+  "table": "users",
+  "columns": "name,email,metadata",
+  "additionalFields": {
+    "mode": "list",
+    "queryParameters": "={{$json.name}},={{$json.email}},{{JSON.stringify($json)}}"
+  }
+}
+```
+
+##### Update
+
+**Minimal**:
+
+```javascript
+{
+  "operation": "update",
+  "table": "users",
+  "updateKey": "id",
+  "columns": "name,email",
+  "additionalFields": {
+    "mode": "list",
+    "queryParameters": "={{$json.id}},Updated Name,newemail@example.com"
+  }
+}
+```
+
+---
+
+### Data Transformation Nodes
+
+#### Set (nodes-base.set)
+
+Most used transformation - 68% of workflows!
+
+##### Set Fixed Values
+
+**Minimal**:
+
+```javascript
+{
+  "mode": "manual",
+  "duplicateItem": false,
+  "assignments": {
+    "assignments": [
+      {
+        "name": "status",
+        "value": "active",
+        "type": "string"
+      },
+      {
+        "name": "count",
+        "value": 100,
+        "type": "number"
+      }
+    ]
+  }
+}
+```
+
+##### Set from Input Data
+
+**Mapping data**:
+
+```javascript
+{
+  "mode": "manual",
+  "duplicateItem": false,
+  "assignments": {
+    "assignments": [
+      {
+        "name": "fullName",
+        "value": "={{$json.firstName}} {{$json.lastName}}",
+        "type": "string"
+      },
+      {
+        "name": "email",
+        "value": "={{$json.email.toLowerCase()}}",
+        "type": "string"
+      },
+      {
+        "name": "timestamp",
+        "value": "={{$now.toISO()}}",
+        "type": "string"
+      }
+    ]
+  }
+}
+```
+
+**Gotcha**: Use correct `type` for each field!
+
+```javascript
+// Wrong type
+{
+  "name": "age",
+  "value": "25",      // String
+  "type": "string"    // Will be string "25"
+}
+
+// Correct type
+{
+  "name": "age",
+  "value": 25,        // Number
+  "type": "number"    // Will be number 25
+}
+```
+
+---
+
+#### Code (nodes-base.code)
+
+JavaScript execution - 42% of workflows
+
+##### Simple Transformation
+
+**Minimal**:
+
+```javascript
+{
+  "mode": "runOnceForAllItems",
+  "jsCode": "return $input.all().map(item => ({\n  json: {\n    name: item.json.name.toUpperCase(),\n    email: item.json.email\n  }\n}));"
+}
+```
+
+**Per-item processing**:
+
+```javascript
+{
+  "mode": "runOnceForEachItem",
+  "jsCode": "// Process each item\nconst data = $input.item.json;\n\nreturn {\n  json: {\n    fullName: `${data.firstName} ${data.lastName}`,\n    email: data.email.toLowerCase(),\n    timestamp: new Date().toISOString()\n  }\n};"
+}
+```
+
+**Gotcha**: In Code nodes, use `$input.item.json` or `$input.all()`, NOT `{{...}}`!
+
+```javascript
+// Wrong - expressions don't work in Code nodes
+{
+  "jsCode": "const name = '={{$json.name}}';"
+}
+
+// Correct - direct access
+{
+  "jsCode": "const name = $input.item.json.name;"
+}
+```
+
+---
+
+### Conditional Nodes
+
+#### IF (nodes-base.if)
+
+Conditional logic - 38% of workflows
+
+##### String Comparison
+
+**Equals** (binary):
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "value1": "={{$json.status}}",
+        "operation": "equals",
+        "value2": "active"
+      }
+    ]
+  }
+}
+```
+
+**Contains** (binary):
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "value1": "={{$json.email}}",
+        "operation": "contains",
+        "value2": "@example.com"
+      }
+    ]
+  }
+}
+```
+
+**isEmpty** (unary):
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "value1": "={{$json.email}}",
+        "operation": "isEmpty"
+        // No value2 - unary operator
+        // singleValue: true added by auto-sanitization
+      }
+    ]
+  }
+}
+```
+
+**Gotcha**: Unary operators (isEmpty, isNotEmpty) don't need value2!
+
+##### Number Comparison
+
+**Greater than**:
+
+```javascript
+{
+  "conditions": {
+    "number": [
+      {
+        "value1": "={{$json.age}}",
+        "operation": "larger",
+        "value2": 18
+      }
+    ]
+  }
+}
+```
+
+##### Boolean Comparison
+
+**Is true**:
+
+```javascript
+{
+  "conditions": {
+    "boolean": [
+      {
+        "value1": "={{$json.isActive}}",
+        "operation": "true"
+        // Unary - no value2
+      }
+    ]
+  }
+}
+```
+
+##### Multiple Conditions (AND)
+
+**All must match**:
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "value1": "={{$json.status}}",
+        "operation": "equals",
+        "value2": "active"
+      }
+    ],
+    "number": [
+      {
+        "value1": "={{$json.age}}",
+        "operation": "larger",
+        "value2": 18
+      }
+    ]
+  },
+  "combineOperation": "all"  // AND logic
+}
+```
+
+##### Multiple Conditions (OR)
+
+**Any can match**:
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "value1": "={{$json.status}}",
+        "operation": "equals",
+        "value2": "active"
+      },
+      {
+        "value1": "={{$json.status}}",
+        "operation": "equals",
+        "value2": "pending"
+      }
+    ]
+  },
+  "combineOperation": "any"  // OR logic
+}
+```
+
+---
+
+#### Switch (nodes-base.switch)
+
+Multi-way routing - 18% of workflows
+
+##### Basic Switch
+
+**Minimal**:
+
+```javascript
+{
+  "mode": "rules",
+  "rules": {
+    "rules": [
+      {
+        "conditions": {
+          "string": [
+            {
+              "value1": "={{$json.status}}",
+              "operation": "equals",
+              "value2": "active"
+            }
+          ]
+        }
+      },
+      {
+        "conditions": {
+          "string": [
+            {
+              "value1": "={{$json.status}}",
+              "operation": "equals",
+              "value2": "pending"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "fallbackOutput": "extra"  // Catch-all for non-matching
+}
+```
+
+**Gotcha**: Number of rules must match number of outputs!
+
+---
+
+### AI Nodes
+
+#### OpenAI (nodes-langchain.openAi)
+
+AI operations - 234 templates
+
+##### Chat Completion
+
+**Minimal**:
+
+```javascript
+{
+  "resource": "chat",
+  "operation": "complete",
+  "messages": {
+    "values": [
+      {
+        "role": "user",
+        "content": "={{$json.prompt}}"
+      }
+    ]
+  }
+}
+```
+
+**With system prompt**:
+
+```javascript
+{
+  "resource": "chat",
+  "operation": "complete",
+  "messages": {
+    "values": [
+      {
+        "role": "system",
+        "content": "You are a helpful assistant specialized in customer support."
+      },
+      {
+        "role": "user",
+        "content": "={{$json.userMessage}}"
+      }
+    ]
+  },
+  "options": {
+    "temperature": 0.7,
+    "maxTokens": 500
+  }
+}
+```
+
+---
+
+### Schedule Nodes
+
+#### Schedule Trigger (nodes-base.scheduleTrigger)
+
+Time-based workflows - 28% have schedule triggers
+
+##### Daily at Specific Time
+
+**Minimal**:
+
+```javascript
+{
+  "rule": {
+    "interval": [
+      {
+        "field": "hours",
+        "hoursInterval": 24
+      }
+    ],
+    "hour": 9,
+    "minute": 0,
+    "timezone": "America/New_York"
+  }
+}
+```
+
+**Gotcha**: Always set timezone explicitly!
+
+```javascript
+// Bad - uses server timezone
+{
+  "rule": {
+    "interval": [...]
+  }
+}
+
+// Good - explicit timezone
+{
+  "rule": {
+    "interval": [...],
+    "timezone": "America/New_York"
+  }
+}
+```
+
+##### Every N Minutes
+
+**Minimal**:
+
+```javascript
+{
+  "rule": {
+    "interval": [
+      {
+        "field": "minutes",
+        "minutesInterval": 15
+      }
+    ]
+  }
+}
+```
+
+##### Cron Expression
+
+**Advanced scheduling**:
+
+```javascript
+{
+  "mode": "cron",
+  "cronExpression": "0 */2 * * *",  // Every 2 hours
+  "timezone": "America/New_York"
+}
+```
+
+---
+
+### Operation Patterns Summary
+
+**Key Patterns by Category**:
+
+| Category      | Most Common        | Key Gotcha                |
+| ------------- | ------------------ | ------------------------- |
+| HTTP/API      | GET, POST JSON     | Remember sendBody: true   |
+| Webhooks      | POST receiver      | Data under $json.body     |
+| Communication | Slack post         | Channel format (#name)    |
+| Database      | SELECT with params | Use parameterized queries |
+| Transform     | Set assignments    | Correct type per field    |
+| Conditional   | IF string equals   | Unary vs binary operators |
+| AI            | OpenAI chat        | System + user messages    |
+| Schedule      | Daily at time      | Set timezone explicitly   |
+
+**Configuration Approach**:
+
+1. Use patterns as starting point
+2. Adapt to your use case
+3. Validate configuration
+4. Iterate based on errors
+5. Deploy when valid
+
+> **Cross-reference**: For where these node patterns fit within larger workflow compositions, see [workflow-patterns.md](../workflow-patterns.md).
+
+---
+
+## Property Dependencies Deep Dive
+
+### What Are Property Dependencies?
+
+**Definition**: Rules that control when fields are visible or required based on other field values.
+
+**Mechanism**: `displayOptions` in node schema
+
+**Purpose**:
+
+- Show relevant fields only
+- Hide irrelevant fields
+- Simplify configuration UX
+- Prevent invalid configurations
+
+---
+
+### displayOptions Structure
+
+#### Basic Format
+
+```javascript
+{
+  "name": "fieldName",
+  "type": "string",
+  "displayOptions": {
+    "show": {
+      "otherField": ["value1", "value2"]
+    }
+  }
+}
+```
+
+**Translation**: Show `fieldName` when `otherField` equals "value1" OR "value2"
+
+#### Show vs Hide
+
+##### show (Most Common)
+
+**Show field when condition matches**:
+
+```javascript
+{
+  "name": "body",
+  "displayOptions": {
+    "show": {
+      "sendBody": [true]
+    }
+  }
+}
+```
+
+**Meaning**: Show `body` when `sendBody = true`
+
+##### hide (Less Common)
+
+**Hide field when condition matches**:
+
+```javascript
+{
+  "name": "advanced",
+  "displayOptions": {
+    "hide": {
+      "simpleMode": [true]
+    }
+  }
+}
+```
+
+**Meaning**: Hide `advanced` when `simpleMode = true`
+
+#### Multiple Conditions (AND Logic)
+
+```javascript
+{
+  "name": "body",
+  "displayOptions": {
+    "show": {
+      "sendBody": [true],
+      "method": ["POST", "PUT", "PATCH"]
+    }
+  }
+}
+```
+
+**Meaning**: Show `body` when:
+
+- `sendBody = true` AND
+- `method IN (POST, PUT, PATCH)`
+
+**All conditions must match** (AND logic)
+
+#### Multiple Values (OR Logic)
+
+```javascript
+{
+  "name": "someField",
+  "displayOptions": {
+    "show": {
+      "method": ["POST", "PUT", "PATCH"]
+    }
+  }
+}
+```
+
+**Meaning**: Show `someField` when:
+
+- `method = POST` OR
+- `method = PUT` OR
+- `method = PATCH`
+
+**Any value matches** (OR logic)
+
+---
+
+### Common Dependency Patterns
+
+#### Pattern 1: Boolean Toggle
+
+**Use case**: Optional feature flag
+
+**Example**: HTTP Request sendBody
+
+```javascript
+// Field: sendBody (boolean)
+{
+  "name": "sendBody",
+  "type": "boolean",
+  "default": false
+}
+
+// Field: body (depends on sendBody)
+{
+  "name": "body",
+  "displayOptions": {
+    "show": {
+      "sendBody": [true]
+    }
+  }
+}
+```
+
+**Flow**:
+
+1. User sees sendBody checkbox
+2. When checked -> body field appears
+3. When unchecked -> body field hides
+
+#### Pattern 2: Resource/Operation Cascade
+
+**Use case**: Different operations show different fields
+
+**Example**: Slack message operations
+
+```javascript
+// Operation: post
+{
+  "name": "channel",
+  "displayOptions": {
+    "show": {
+      "resource": ["message"],
+      "operation": ["post"]
+    }
+  }
+}
+
+// Operation: update
+{
+  "name": "messageId",
+  "displayOptions": {
+    "show": {
+      "resource": ["message"],
+      "operation": ["update"]
+    }
+  }
+}
+```
+
+**Flow**:
+
+1. User selects resource="message"
+2. User selects operation="post" -> sees channel
+3. User changes to operation="update" -> channel hides, messageId shows
+
+#### Pattern 3: Type-Specific Configuration
+
+**Use case**: Different types need different fields
+
+**Example**: IF node conditions
+
+```javascript
+// String operations
+{
+  "name": "value2",
+  "displayOptions": {
+    "show": {
+      "conditions.string.0.operation": ["equals", "notEquals", "contains"]
+    }
+  }
+}
+
+// Unary operations (isEmpty) don't show value2
+{
+  "displayOptions": {
+    "hide": {
+      "conditions.string.0.operation": ["isEmpty", "isNotEmpty"]
+    }
+  }
+}
+```
+
+#### Pattern 4: Method-Specific Fields
+
+**Use case**: HTTP methods have different options
+
+**Example**: HTTP Request
+
+```javascript
+// Query parameters (all methods can have)
+{
+  "name": "queryParameters",
+  "displayOptions": {
+    "show": {
+      "sendQuery": [true]
+    }
+  }
+}
+
+// Body (only certain methods)
+{
+  "name": "body",
+  "displayOptions": {
+    "show": {
+      "sendBody": [true],
+      "method": ["POST", "PUT", "PATCH", "DELETE"]
+    }
+  }
+}
+```
+
+---
+
+### Finding Property Dependencies
+
+#### Using get_node with search_properties Mode
+
+```javascript
+// Find properties related to "body"
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "body",
+});
+```
+
+#### Using get_node with Full Detail
+
+```javascript
+// Get complete schema with displayOptions
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  detail: "full",
+});
+```
+
+> **Cross-reference**: For full `get_node` usage including all modes and parameters, see [mcp-tools-expert.md](../mcp-tools-expert.md).
+
+#### When to Use
+
+**Use when**:
+
+- Validation fails with "missing field" but you don't see that field
+- A field appears/disappears unexpectedly
+- You need to understand what controls field visibility
+- Building dynamic configuration tools
+
+**Don't use when**:
+
+- Simple configuration (use `get_node` with standard detail)
+- Just starting configuration
+- Field requirements are obvious
+
+---
+
+### Complex Dependency Examples
+
+#### Example 1: HTTP Request Complete Flow
+
+**Scenario**: Configuring POST with JSON body
+
+**Step 1**: Set method
+
+```javascript
+{
+  "method": "POST"
+  // -> sendBody becomes visible
+}
+```
+
+**Step 2**: Enable body
+
+```javascript
+{
+  "method": "POST",
+  "sendBody": true
+  // -> body field becomes visible AND required
+}
+```
+
+**Step 3**: Configure body
+
+```javascript
+{
+  "method": "POST",
+  "sendBody": true,
+  "body": {
+    "contentType": "json"
+    // -> content field becomes visible AND required
+  }
+}
+```
+
+**Step 4**: Add content
+
+```javascript
+{
+  "method": "POST",
+  "sendBody": true,
+  "body": {
+    "contentType": "json",
+    "content": {
+      "name": "John",
+      "email": "john@example.com"
+    }
+  }
+}
+// Valid!
+```
+
+**Dependency chain**:
+
+```
+method=POST
+  -> sendBody visible
+    -> sendBody=true
+      -> body visible + required
+        -> body.contentType=json
+          -> body.content visible + required
+```
+
+#### Example 2: IF Node Operator Dependencies
+
+**Scenario**: String comparison with different operators
+
+**Binary operator** (equals):
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "operation": "equals"
+        // -> value1 required
+        // -> value2 required
+        // -> singleValue should NOT be set
+      }
+    ]
+  }
+}
+```
+
+**Unary operator** (isEmpty):
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "operation": "isEmpty"
+        // -> value1 required
+        // -> value2 should NOT be set
+        // -> singleValue should be true (auto-added)
+      }
+    ]
+  }
+}
+```
+
+**Dependency table**:
+
+| Operator   | value1   | value2   | singleValue |
+| ---------- | -------- | -------- | ----------- |
+| equals     | Required | Required | false       |
+| notEquals  | Required | Required | false       |
+| contains   | Required | Required | false       |
+| isEmpty    | Required | Hidden   | true        |
+| isNotEmpty | Required | Hidden   | true        |
+
+#### Example 3: Slack Operation Matrix
+
+**Scenario**: Different Slack operations show different fields
+
+```javascript
+// post message
+{
+  "resource": "message",
+  "operation": "post"
+  // Shows: channel (required), text (required), attachments, blocks
+}
+
+// update message
+{
+  "resource": "message",
+  "operation": "update"
+  // Shows: messageId (required), text (required), channel (optional)
+}
+
+// delete message
+{
+  "resource": "message",
+  "operation": "delete"
+  // Shows: messageId (required), channel (required)
+  // Hides: text, attachments, blocks
+}
+
+// get message
+{
+  "resource": "message",
+  "operation": "get"
+  // Shows: messageId (required), channel (required)
+  // Hides: text, attachments, blocks
+}
+```
+
+**Field visibility matrix**:
+
+| Field       | post     | update   | delete   | get      |
+| ----------- | -------- | -------- | -------- | -------- |
+| channel     | Required | Optional | Required | Required |
+| text        | Required | Required | Hidden   | Hidden   |
+| messageId   | Hidden   | Required | Required | Required |
+| attachments | Optional | Optional | Hidden   | Hidden   |
+| blocks      | Optional | Optional | Hidden   | Hidden   |
+
+---
+
+### Nested Dependencies
+
+#### What Are They?
+
+**Definition**: Dependencies within object properties
+
+**Example**: HTTP Request body.contentType controls body.content structure
+
+```javascript
+{
+  "body": {
+    "contentType": "json",
+    // -> content expects JSON object
+    "content": {
+      "key": "value"
+    }
+  }
+}
+
+{
+  "body": {
+    "contentType": "form-data",
+    // -> content expects form fields array
+    "content": [
+      {
+        "name": "field1",
+        "value": "value1"
+      }
+    ]
+  }
+}
+```
+
+#### How to Handle
+
+**Strategy**: Configure parent first, then children
+
+```javascript
+// Step 1: Parent
+{
+  "body": {
+    "contentType": "json"  // Set parent first
+  }
+}
+
+// Step 2: Children (structure determined by parent)
+{
+  "body": {
+    "contentType": "json",
+    "content": {           // JSON object format
+      "key": "value"
+    }
+  }
+}
+```
+
+---
+
+### Auto-Sanitization and Dependencies
+
+#### What Auto-Sanitization Fixes
+
+**Operator structure issues** (IF/Switch nodes):
+
+**Example**: singleValue property
+
+```javascript
+// You configure (missing singleValue)
+{
+  "type": "boolean",
+  "operation": "isEmpty"
+  // Missing singleValue
+}
+
+// Auto-sanitization adds it
+{
+  "type": "boolean",
+  "operation": "isEmpty",
+  "singleValue": true  // Added automatically
+}
+```
+
+#### What It Doesn't Fix
+
+**Missing required fields**:
+
+```javascript
+// You configure (missing channel)
+{
+  "resource": "message",
+  "operation": "post",
+  "text": "Hello"
+  // Missing required field: channel
+}
+
+// Auto-sanitization does NOT add
+// You must add it yourself
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "#general",  // You must add
+  "text": "Hello"
+}
+```
+
+---
+
+### Troubleshooting Dependencies
+
+#### Problem 1: "Field X is required but not visible"
+
+**Error**:
+
+```json
+{
+  "type": "missing_required",
+  "property": "body",
+  "message": "body is required"
+}
+```
+
+**But you don't see body field in configuration!**
+
+**Solution**:
+
+```javascript
+// Check field dependencies using search_properties
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "body"
+});
+
+// Find that body shows when sendBody=true
+// Add sendBody
+{
+  "method": "POST",
+  "sendBody": true,  // Now body appears!
+  "body": {...}
+}
+```
+
+#### Problem 2: "Field disappears when I change operation"
+
+**Scenario**:
+
+```javascript
+// Working configuration
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "#general",
+  "text": "Hello"
+}
+
+// Change operation
+{
+  "resource": "message",
+  "operation": "update",  // Changed
+  "channel": "#general",  // Still here
+  "text": "Updated"       // Still here
+  // Missing: messageId (required for update!)
+}
+```
+
+**Validation error**: "messageId is required"
+
+**Why**: Different operation = different required fields
+
+**Solution**:
+
+```javascript
+// Check requirements for new operation
+get_node({
+  nodeType: "nodes-base.slack"
+});
+
+// Configure for update operation
+{
+  "resource": "message",
+  "operation": "update",
+  "messageId": "1234567890",  // Required for update
+  "text": "Updated",
+  "channel": "#general"       // Optional for update
+}
+```
+
+#### Problem 3: "Validation passes but field doesn't save"
+
+**Scenario**: Field hidden by dependencies after validation
+
+**Example**:
+
+```javascript
+// Configure
+{
+  "method": "GET",
+  "sendBody": true,  // GET doesn't support body
+  "body": {...}      // This will be stripped
+}
+
+// After save
+{
+  "method": "GET"
+  // body removed because method=GET hides it
+}
+```
+
+**Solution**: Respect dependencies from the start
+
+```javascript
+// Correct approach - check property dependencies
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "body"
+});
+
+// See that body only shows for POST/PUT/PATCH/DELETE
+// Use correct method
+{
+  "method": "POST",
+  "sendBody": true,
+  "body": {...}
+}
+```
+
+> **Cross-reference**: For interpreting validation errors and profiles, see [validation-expert.md](../validation-expert.md).
+
+---
+
+### Advanced Patterns
+
+#### Pattern 1: Conditional Required with Fallback
+
+**Example**: Channel can be string OR expression
+
+```javascript
+// Option 1: String
+{
+  "channel": "#general"
+}
+
+// Option 2: Expression
+{
+  "channel": "={{$json.channelName}}"
+}
+
+// Validation accepts both
+```
+
+#### Pattern 2: Mutually Exclusive Fields
+
+**Example**: Use either ID or name, not both
+
+```javascript
+// Use messageId
+{
+  "messageId": "1234567890"
+  // name not needed
+}
+
+// OR use messageName
+{
+  "messageName": "thread-name"
+  // messageId not needed
+}
+
+// Dependencies ensure only one is required
+```
+
+#### Pattern 3: Progressive Complexity
+
+**Example**: Simple mode vs advanced mode
+
+```javascript
+// Simple mode
+{
+  "mode": "simple",
+  "text": "{{$json.message}}"
+  // Advanced fields hidden
+}
+
+// Advanced mode
+{
+  "mode": "advanced",
+  "attachments": [...],
+  "blocks": [...],
+  "metadata": {...}
+  // Simple field hidden, advanced fields shown
+}
+```
+
+---
+
+## AI Connection Types
+
+### Resource/Operation Nodes
+
+Nodes like Slack, Gmail, and Google Sheets follow the resource/operation pattern where the `resource` selects the entity type and `operation` selects the action. Each combination produces a unique set of required and optional fields.
+
+### HTTP-Based Nodes
+
+HTTP Request and Webhook nodes are method-driven. The HTTP method determines which body, query, and header options are available. Authentication type further controls credential fields.
+
+### Database Nodes
+
+Postgres, MySQL, and MongoDB nodes are operation-driven. The operation (executeQuery, insert, update, delete) determines which fields (query, table, columns, values, where) are required.
+
+### Conditional Logic Nodes
+
+IF and Switch nodes use condition-type-driven configuration. The condition type (string, number, boolean) and operator (binary vs unary) determine which value fields appear.
+
+### AI/LangChain Nodes
+
+OpenAI and other LangChain nodes follow the resource/operation pattern but with AI-specific fields like messages, temperature, and maxTokens. System and user message roles control the prompt structure.
+
+---
+
+## Common Node Patterns
+
+### Pattern 1: Resource/Operation Nodes
+
+**Examples**: Slack, Google Sheets, Airtable
+
+**Structure**:
+
+```javascript
+{
+  "resource": "<entity>",      // What type of thing
+  "operation": "<action>",     // What to do with it
+  // ... operation-specific fields
+}
+```
+
+**How to configure**:
+
+1. Choose resource
+2. Choose operation
+3. Use get_node to see operation-specific requirements
+4. Configure required fields
+
+### Pattern 2: HTTP-Based Nodes
+
+**Examples**: HTTP Request, Webhook
+
+**Structure**:
+
+```javascript
+{
+  "method": "<HTTP_METHOD>",
+  "url": "<endpoint>",
+  "authentication": "<type>",
+  // ... method-specific fields
+}
+```
+
+**Dependencies**:
+
+- POST/PUT/PATCH -> sendBody available
+- sendBody=true -> body required
+- authentication != "none" -> credentials required
+
+### Pattern 3: Database Nodes
+
+**Examples**: Postgres, MySQL, MongoDB
+
+**Structure**:
+
+```javascript
+{
+  "operation": "<query|insert|update|delete>",
+  // ... operation-specific fields
+}
+```
+
+**Dependencies**:
+
+- operation="executeQuery" -> query required
+- operation="insert" -> table + values required
+- operation="update" -> table + values + where required
+
+### Pattern 4: Conditional Logic Nodes
+
+**Examples**: IF, Switch, Merge
+
+**Structure**:
+
+```javascript
+{
+  "conditions": {
+    "<type>": [
+      {
+        "operation": "<operator>",
+        "value1": "...",
+        "value2": "..."  // Only for binary operators
+      }
+    ]
+  }
+}
+```
+
+**Dependencies**:
+
+- Binary operators (equals, contains, etc.) -> value1 + value2
+- Unary operators (isEmpty, isNotEmpty) -> value1 only + singleValue: true
+
+---
+
+## Operation-Specific Configuration
+
+### Slack Node Examples
+
+#### Post Message
+
+```javascript
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "#general",      // Required
+  "text": "Hello!",           // Required
+  "attachments": [],          // Optional
+  "blocks": []                // Optional
+}
+```
+
+#### Update Message
+
+```javascript
+{
+  "resource": "message",
+  "operation": "update",
+  "messageId": "1234567890",  // Required (different from post!)
+  "text": "Updated!",         // Required
+  "channel": "#general"       // Optional (can be inferred)
+}
+```
+
+#### Create Channel
+
+```javascript
+{
+  "resource": "channel",
+  "operation": "create",
+  "name": "new-channel",      // Required
+  "isPrivate": false          // Optional
+  // Note: text NOT required for this operation
+}
+```
+
+### HTTP Request Node Examples
+
+#### GET Request
+
+```javascript
+{
+  "method": "GET",
+  "url": "https://api.example.com/users",
+  "authentication": "predefinedCredentialType",
+  "nodeCredentialType": "httpHeaderAuth",
+  "sendQuery": true,                    // Optional
+  "queryParameters": {                  // Shows when sendQuery=true
+    "parameters": [
+      {
+        "name": "limit",
+        "value": "100"
+      }
+    ]
+  }
+}
+```
+
+#### POST with JSON
+
+```javascript
+{
+  "method": "POST",
+  "url": "https://api.example.com/users",
+  "authentication": "none",
+  "sendBody": true,                     // Required for POST
+  "body": {                             // Required when sendBody=true
+    "contentType": "json",
+    "content": {
+      "name": "John Doe",
+      "email": "john@example.com"
+    }
+  }
+}
+```
+
+### IF Node Examples
+
+#### String Comparison (Binary)
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "value1": "={{$json.status}}",
+        "operation": "equals",
+        "value2": "active"              // Binary: needs value2
+      }
+    ]
+  }
+}
+```
+
+#### Empty Check (Unary)
+
+```javascript
+{
+  "conditions": {
+    "string": [
+      {
+        "value1": "={{$json.email}}",
+        "operation": "isEmpty",
+        // No value2 - unary operator
+        "singleValue": true             // Auto-added by sanitization
+      }
+    ]
+  }
+}
+```
+
+---
+
+## Handling Conditional Requirements
+
+### Example: HTTP Request Body
+
+**Scenario**: body field required, but only sometimes
+
+**Rule**:
+
+```
+body is required when:
+  - sendBody = true AND
+  - method IN (POST, PUT, PATCH, DELETE)
+```
+
+**How to discover**:
+
+```javascript
+// Option 1: Read validation error
+validate_node({...});
+// Error: "body required when sendBody=true"
+
+// Option 2: Search for the property
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "body"
+});
+// Shows: body property with displayOptions rules
+
+// Option 3: Try minimal config and iterate
+// Start without body, validation will tell you if needed
+```
+
+### Example: IF Node singleValue
+
+**Scenario**: singleValue property appears for unary operators
+
+**Rule**:
+
+```
+singleValue should be true when:
+  - operation IN (isEmpty, isNotEmpty, true, false)
+```
+
+**Good news**: Auto-sanitization fixes this!
+
+**Manual check**:
+
+```javascript
+get_node({
+  nodeType: "nodes-base.if",
+  detail: "full",
+});
+// Shows complete schema with operator-specific rules
+```
+
+---
+
+## Configuration Anti-Patterns
+
+### Don't: Over-configure Upfront
+
+**Bad**:
+
+```javascript
+// Adding every possible field
+{
+  "method": "GET",
+  "url": "...",
+  "sendQuery": false,
+  "sendHeaders": false,
+  "sendBody": false,
+  "timeout": 10000,
+  "ignoreResponseCode": false,
+  // ... 20 more optional fields
+}
+```
+
+**Good**:
+
+```javascript
+// Start minimal
+{
+  "method": "GET",
+  "url": "...",
+  "authentication": "none"
+}
+// Add fields only when needed
+```
+
+### Don't: Skip Validation
+
+**Bad**:
+
+```javascript
+// Configure and deploy without validating
+const config = {...};
+n8n_update_partial_workflow({...});  // YOLO
+```
+
+**Good**:
+
+```javascript
+// Validate before deploying
+const config = {...};
+const result = validate_node({...});
+if (result.valid) {
+  n8n_update_partial_workflow({...});
+}
+```
+
+> **Cross-reference**: For validation profiles and error interpretation, see [validation-expert.md](../validation-expert.md).
+
+### Don't: Ignore Operation Context
+
+**Bad**:
+
+```javascript
+// Same config for all Slack operations
+{
+  "resource": "message",
+  "operation": "post",
+  "channel": "#general",
+  "text": "..."
+}
+
+// Then switching operation without updating config
+{
+  "resource": "message",
+  "operation": "update",  // Changed
+  "channel": "#general",  // Wrong field for update!
+  "text": "..."
+}
+```
+
+**Good**:
+
+```javascript
+// Check requirements when changing operation
+get_node({
+  nodeType: "nodes-base.slack",
+});
+// See what update operation needs (messageId, not channel)
+```
+
+---
+
+## Best Practices
+
+### Do
+
+1. **Start with get_node (standard detail)**
+   - ~1-2K tokens response
+   - Covers 95% of configuration needs
+   - Default detail level
+
+2. **Validate iteratively**
+   - Configure -> Validate -> Fix -> Repeat
+   - Average 2-3 iterations is normal
+   - Read validation errors carefully
+
+3. **Use search_properties mode when stuck**
+   - If field seems missing, search for it
+   - Understand what controls field visibility
+   - `get_node({mode: "search_properties", propertyQuery: "..."})`
+
+4. **Respect operation context**
+   - Different operations = different requirements
+   - Always check get_node when changing operation
+   - Don't assume configs are transferable
+
+5. **Trust auto-sanitization**
+   - Operator structure fixed automatically
+   - Don't manually add/remove singleValue
+   - IF/Switch metadata added on save
+
+6. **Check dependencies when stuck**
+
+   ```javascript
+   get_node({
+     nodeType: "...",
+     mode: "search_properties",
+     propertyQuery: "...",
+   });
+   ```
+
+7. **Configure parent properties first**
+
+   ```javascript
+   // First: method, resource, operation
+   // Then: dependent fields
+   ```
+
+8. **Validate after changing operation**
+
+   ```javascript
+   // Operation changed -> requirements changed
+   validate_node({nodeType: "...", config: {...}, profile: "runtime"});
+   ```
+
+9. **Read validation errors for dependency hints**
+   ```
+   Error: "body required when sendBody=true"
+   -> Hint: Set sendBody=true to enable body
+   ```
+
+### Don't
+
+1. **Jump to detail="full" immediately**
+   - Try standard detail first
+   - Only escalate if needed
+   - Full schema is 3-8K tokens
+
+2. **Configure blindly**
+   - Always validate before deploying
+   - Understand why fields are required
+   - Use search_properties for conditional fields
+
+3. **Copy configs without understanding**
+   - Different operations need different fields
+   - Validate after copying
+   - Adjust for new context
+
+4. **Manually fix auto-sanitization issues**
+   - Let auto-sanitization handle operator structure
+   - Focus on business logic
+   - Save and let system fix structure
+
+5. **Ignore dependency errors**
+
+   ```javascript
+   // Error: "body not visible" -> Check displayOptions
+   ```
+
+6. **Hardcode all possible fields**
+
+   ```javascript
+   // Bad: Adding fields that will be hidden
+   ```
+
+7. **Assume operations are identical**
+   ```javascript
+   // Each operation has unique requirements
+   ```
+
+---
+
+## Property Dependencies Summary
+
+**Key Concepts**:
+
+- `displayOptions` control field visibility
+- `show` = field appears when conditions match
+- `hide` = field disappears when conditions match
+- Multiple conditions = AND logic
+- Multiple values = OR logic
+
+**Common Patterns**:
+
+1. Boolean toggle (sendBody -> body)
+2. Resource/operation cascade (different operations -> different fields)
+3. Type-specific config (string vs boolean conditions)
+4. Method-specific fields (GET vs POST)
+
+**Troubleshooting**:
+
+- Field required but not visible -> Check dependencies
+- Field disappears after change -> Operation changed requirements
+- Field doesn't save -> Hidden by dependencies
+
+**Tools**:
+
+- `get_node({mode: "search_properties"})` - Find property dependencies
+- `get_node({detail: "full"})` - See complete schema with displayOptions
+- `get_node` - See operation requirements (standard detail)
+- Validation errors - Hints about dependencies
+
+---
+
+## Summary
+
+**Configuration Strategy**:
+
+1. Start with `get_node` (standard detail is default)
+2. Configure required fields for operation
+3. Validate configuration
+4. Search properties if stuck
+5. Iterate until valid (avg 2-3 cycles)
+6. Deploy with confidence
+
+**Key Principles**:
+
+- **Operation-aware**: Different operations = different requirements
+- **Progressive disclosure**: Start minimal, add as needed
+- **Dependency-aware**: Understand field visibility rules
+- **Validation-driven**: Let validation guide configuration
+
+**Related Skills**:
+
+- **[mcp-tools-expert.md](../mcp-tools-expert.md)** - How to use discovery tools correctly (get_node modes and parameters)
+- **[validation-expert.md](../validation-expert.md)** - Interpret validation errors and profiles
+- **[workflow-patterns.md](../workflow-patterns.md)** - Apply patterns with proper configuration within workflow compositions
+- **n8n Expression Syntax** - Configure expression fields