@caoscompanybr/merlin 3.5.0

package/.merlin-core/skills/domain/n8n-automation/references/mcp-tools-expert.md

@@ -0,0 +1,2111 @@
+<!-- Adapted from czlonkowski/n8n-skills (MIT). Source files: SKILL.md, SEARCH_GUIDE.md, VALIDATION_GUIDE.md, WORKFLOW_GUIDE.md -->
+
+# n8n MCP Tools Expert
+
+Master guide for using n8n-mcp MCP server tools to build workflows.
+
+---
+
+## Tool Categories
+
+n8n-mcp provides tools organized into categories:
+
+1. **Node Discovery** -- [Search Guide](#node-discovery-tools-guide)
+2. **Configuration Validation** -- [Validation Guide](#configuration-validation-tools-guide)
+3. **Workflow Management** -- [Workflow Guide](#workflow-management-tools-guide)
+4. **Template Library** - Search and deploy 2,700+ real workflows
+5. **Documentation & Guides** - Tool docs, AI agent guide, Code node guides
+
+---
+
+## Quick Reference
+
+### Most Used Tools (by success rate)
+
+| Tool                          | Use When                                          | Speed     |
+| ----------------------------- | ------------------------------------------------- | --------- |
+| `search_nodes`                | Finding nodes by keyword                          | <20ms     |
+| `get_node`                    | Understanding node operations (detail="standard") | <10ms     |
+| `validate_node`               | Checking configurations (mode="full")             | <100ms    |
+| `n8n_create_workflow`         | Creating workflows                                | 100-500ms |
+| `n8n_update_partial_workflow` | Editing workflows (MOST USED!)                    | 50-200ms  |
+| `validate_workflow`           | Checking complete workflow                        | 100-500ms |
+| `n8n_deploy_template`         | Deploy template to n8n instance                   | 200-500ms |
+
+---
+
+## Tool Selection Guide
+
+### Finding the Right Node
+
+**Workflow**:
+
+```
+1. search_nodes({query: "keyword"})
+2. get_node({nodeType: "nodes-base.name"})
+3. [Optional] get_node({nodeType: "nodes-base.name", mode: "docs"})
+```
+
+**Example**:
+
+```javascript
+// Step 1: Search
+search_nodes({ query: "slack" });
+// Returns: nodes-base.slack
+
+// Step 2: Get details
+get_node({ nodeType: "nodes-base.slack" });
+// Returns: operations, properties, examples (standard detail)
+
+// Step 3: Get readable documentation
+get_node({ nodeType: "nodes-base.slack", mode: "docs" });
+// Returns: markdown documentation
+```
+
+**Common pattern**: search -> get_node (18s average)
+
+### Validating Configuration
+
+> See also: [validation-expert.md](validation-expert.md) for detailed error handling patterns.
+
+**Workflow**:
+
+```
+1. validate_node({nodeType, config: {}, mode: "minimal"}) - Check required fields
+2. validate_node({nodeType, config, profile: "runtime"}) - Full validation
+3. [Repeat] Fix errors, validate again
+```
+
+**Common pattern**: validate -> fix -> validate (23s thinking, 58s fixing per cycle)
+
+### Managing Workflows
+
+> See also: [workflow-patterns.md](workflow-patterns.md) for architectural pattern selection.
+
+**Workflow**:
+
+```
+1. n8n_create_workflow({name, nodes, connections})
+2. n8n_validate_workflow({id})
+3. n8n_update_partial_workflow({id, operations: [...]})
+4. n8n_validate_workflow({id}) again
+5. n8n_update_partial_workflow({id, operations: [{type: "activateWorkflow"}]})
+```
+
+**Common pattern**: iterative updates (56s average between edits)
+
+---
+
+## Critical: nodeType Formats
+
+**Two different formats** for different tools!
+
+### Format 1: Search/Validate Tools
+
+```javascript
+// Use SHORT prefix
+"nodes-base.slack";
+"nodes-base.httpRequest";
+"nodes-base.webhook";
+"nodes-langchain.agent";
+```
+
+**Tools that use this**:
+
+- search_nodes (returns this format)
+- get_node
+- validate_node
+- validate_workflow
+
+### Format 2: Workflow Tools
+
+```javascript
+// Use FULL prefix
+"n8n-nodes-base.slack";
+"n8n-nodes-base.httpRequest";
+"n8n-nodes-base.webhook";
+"@n8n/n8n-nodes-langchain.agent";
+```
+
+**Tools that use this**:
+
+- n8n_create_workflow
+- n8n_update_partial_workflow
+
+### Conversion
+
+```javascript
+// search_nodes returns BOTH formats
+{
+  "nodeType": "nodes-base.slack",          // For search/validate tools
+  "workflowNodeType": "n8n-nodes-base.slack"  // For workflow tools
+}
+```
+
+---
+
+## Common Mistakes
+
+### Mistake 1: Wrong nodeType Format
+
+**Problem**: "Node not found" error
+
+```javascript
+// WRONG
+get_node({ nodeType: "slack" }); // Missing prefix
+get_node({ nodeType: "n8n-nodes-base.slack" }); // Wrong prefix
+
+// CORRECT
+get_node({ nodeType: "nodes-base.slack" });
+```
+
+### Mistake 2: Using detail="full" by Default
+
+**Problem**: Huge payload, slower response, token waste
+
+```javascript
+// WRONG - Returns 3-8K tokens, use sparingly
+get_node({ nodeType: "nodes-base.slack", detail: "full" });
+
+// CORRECT - Returns 1-2K tokens, covers 95% of use cases
+get_node({ nodeType: "nodes-base.slack" }); // detail="standard" is default
+get_node({ nodeType: "nodes-base.slack", detail: "standard" });
+```
+
+**When to use detail="full"**:
+
+- Debugging complex configuration issues
+- Need complete property schema with all nested options
+- Exploring advanced features
+
+**Better alternatives**:
+
+1. `get_node({detail: "standard"})` - for operations list (default)
+2. `get_node({mode: "docs"})` - for readable documentation
+3. `get_node({mode: "search_properties", propertyQuery: "auth"})` - for specific property
+
+### Mistake 3: Not Using Validation Profiles
+
+> See also: [validation-expert.md](validation-expert.md) for profile selection guidance.
+
+**Problem**: Too many false positives OR missing real errors
+
+**Profiles**:
+
+- `minimal` - Only required fields (fast, permissive)
+- `runtime` - Values + types (recommended for pre-deployment)
+- `ai-friendly` - Reduce false positives (for AI configuration)
+- `strict` - Maximum validation (for production)
+
+```javascript
+// WRONG - Uses default profile
+validate_node({ nodeType, config });
+
+// CORRECT - Explicit profile
+validate_node({ nodeType, config, profile: "runtime" });
+```
+
+### Mistake 4: Ignoring Auto-Sanitization
+
+**What happens**: ALL nodes sanitized on ANY workflow update
+
+**Auto-fixes**:
+
+- Binary operators (equals, contains) -> removes singleValue
+- Unary operators (isEmpty, isNotEmpty) -> adds singleValue: true
+- IF/Switch nodes -> adds missing metadata
+
+**Cannot fix**:
+
+- Broken connections
+- Branch count mismatches
+- Paradoxical corrupt states
+
+```javascript
+// After ANY update, auto-sanitization runs on ALL nodes
+n8n_update_partial_workflow({id, operations: [...]})
+// -> Automatically fixes operator structures
+```
+
+### Mistake 5: Not Using Smart Parameters
+
+**Problem**: Complex sourceIndex calculations for multi-output nodes
+
+**Old way** (manual):
+
+```javascript
+// IF node connection
+{
+  type: "addConnection",
+  source: "IF",
+  target: "Handler",
+  sourceIndex: 0  // Which output? Hard to remember!
+}
+```
+
+**New way** (smart parameters):
+
+```javascript
+// IF node - semantic branch names
+{
+  type: "addConnection",
+  source: "IF",
+  target: "True Handler",
+  branch: "true"  // Clear and readable!
+}
+
+{
+  type: "addConnection",
+  source: "IF",
+  target: "False Handler",
+  branch: "false"
+}
+
+// Switch node - semantic case numbers
+{
+  type: "addConnection",
+  source: "Switch",
+  target: "Handler A",
+  case: 0
+}
+```
+
+### Mistake 6: Not Using intent Parameter
+
+**Problem**: Less helpful tool responses
+
+```javascript
+// WRONG - No context for response
+n8n_update_partial_workflow({
+  id: "abc",
+  operations: [{type: "addNode", node: {...}}]
+})
+
+// CORRECT - Better AI responses
+n8n_update_partial_workflow({
+  id: "abc",
+  intent: "Add error handling for API failures",
+  operations: [{type: "addNode", node: {...}}]
+})
+```
+
+---
+
+## Tool Usage Patterns
+
+### Pattern 1: Node Discovery (Most Common)
+
+**Common workflow**: 18s average between steps
+
+```javascript
+// Step 1: Search (fast!)
+const results = await search_nodes({
+  query: "slack",
+  mode: "OR", // Default: any word matches
+  limit: 20,
+});
+// -> Returns: nodes-base.slack, nodes-base.slackTrigger
+
+// Step 2: Get details (~18s later, user reviewing results)
+const details = await get_node({
+  nodeType: "nodes-base.slack",
+  includeExamples: true, // Get real template configs
+});
+// -> Returns: operations, properties, metadata
+```
+
+### Pattern 2: Validation Loop
+
+**Typical cycle**: 23s thinking, 58s fixing
+
+```javascript
+// Step 1: Validate
+const result = await validate_node({
+  nodeType: "nodes-base.slack",
+  config: {
+    resource: "channel",
+    operation: "create"
+  },
+  profile: "runtime"
+});
+
+// Step 2: Check errors (~23s thinking)
+if (!result.valid) {
+  console.log(result.errors);  // "Missing required field: name"
+}
+
+// Step 3: Fix config (~58s fixing)
+config.name = "general";
+
+// Step 4: Validate again
+await validate_node({...});  // Repeat until clean
+```
+
+### Pattern 3: Workflow Editing
+
+**Most used update tool**: 99.0% success rate, 56s average between edits
+
+```javascript
+// Iterative workflow building (NOT one-shot!)
+// Edit 1
+await n8n_update_partial_workflow({
+  id: "workflow-id",
+  intent: "Add webhook trigger",
+  operations: [{type: "addNode", node: {...}}]
+});
+
+// ~56s later...
+
+// Edit 2
+await n8n_update_partial_workflow({
+  id: "workflow-id",
+  intent: "Connect webhook to processor",
+  operations: [{type: "addConnection", source: "...", target: "..."}]
+});
+
+// ~56s later...
+
+// Edit 3 (validation)
+await n8n_validate_workflow({id: "workflow-id"});
+
+// Ready? Activate!
+await n8n_update_partial_workflow({
+  id: "workflow-id",
+  intent: "Activate workflow for production",
+  operations: [{type: "activateWorkflow"}]
+});
+```
+
+---
+
+## Template Usage
+
+### Search Templates
+
+```javascript
+// Search by keyword (default mode)
+search_templates({
+  query: "webhook slack",
+  limit: 20,
+});
+
+// Search by node types
+search_templates({
+  searchMode: "by_nodes",
+  nodeTypes: ["n8n-nodes-base.httpRequest", "n8n-nodes-base.slack"],
+});
+
+// Search by task type
+search_templates({
+  searchMode: "by_task",
+  task: "webhook_processing",
+});
+
+// Search by metadata (complexity, setup time)
+search_templates({
+  searchMode: "by_metadata",
+  complexity: "simple",
+  maxSetupMinutes: 15,
+});
+```
+
+### Get Template Details
+
+```javascript
+get_template({
+  templateId: 2947,
+  mode: "structure", // nodes+connections only
+});
+
+get_template({
+  templateId: 2947,
+  mode: "full", // complete workflow JSON
+});
+```
+
+### Deploy Template Directly
+
+```javascript
+// Deploy template to your n8n instance
+n8n_deploy_template({
+  templateId: 2947,
+  name: "My Weather to Slack", // Custom name (optional)
+  autoFix: true, // Auto-fix common issues (default)
+  autoUpgradeVersions: true, // Upgrade node versions (default)
+});
+// Returns: workflow ID, required credentials, fixes applied
+```
+
+---
+
+## Self-Help Tools
+
+### Get Tool Documentation
+
+```javascript
+// Overview of all tools
+tools_documentation();
+
+// Specific tool details
+tools_documentation({
+  topic: "search_nodes",
+  depth: "full",
+});
+
+// Code node guides
+tools_documentation({ topic: "javascript_code_node_guide", depth: "full" });
+tools_documentation({ topic: "python_code_node_guide", depth: "full" });
+```
+
+### AI Agent Guide
+
+```javascript
+// Comprehensive AI workflow guide
+ai_agents_guide();
+// Returns: Architecture, connections, tools, validation, best practices
+```
+
+### Health Check
+
+```javascript
+// Quick health check
+n8n_health_check();
+
+// Detailed diagnostics
+n8n_health_check({ mode: "diagnostic" });
+// -> Returns: status, env vars, tool status, API connectivity
+```
+
+---
+
+## Tool Availability
+
+**Always Available** (no n8n API needed):
+
+- search_nodes, get_node
+- validate_node, validate_workflow
+- search_templates, get_template
+- tools_documentation, ai_agents_guide
+
+**Requires n8n API** (N8N_API_URL + N8N_API_KEY):
+
+- n8n_create_workflow
+- n8n_update_partial_workflow
+- n8n_validate_workflow (by ID)
+- n8n_list_workflows, n8n_get_workflow
+- n8n_test_workflow
+- n8n_executions
+- n8n_deploy_template
+- n8n_workflow_versions
+- n8n_autofix_workflow
+
+If API tools unavailable, use templates and validation-only workflows.
+
+---
+
+## Unified Tool Reference
+
+### get_node (Unified Node Information)
+
+**Detail Levels** (mode="info", default):
+
+- `minimal` (~200 tokens) - Basic metadata only
+- `standard` (~1-2K tokens) - Essential properties + operations (RECOMMENDED)
+- `full` (~3-8K tokens) - Complete schema (use sparingly)
+
+**Operation Modes**:
+
+- `info` (default) - Node schema with detail level
+- `docs` - Readable markdown documentation
+- `search_properties` - Find specific properties (use with propertyQuery)
+- `versions` - List all versions with breaking changes
+- `compare` - Compare two versions
+- `breaking` - Show only breaking changes
+- `migrations` - Show auto-migratable changes
+
+```javascript
+// Standard (recommended)
+get_node({ nodeType: "nodes-base.httpRequest" });
+
+// Get documentation
+get_node({ nodeType: "nodes-base.webhook", mode: "docs" });
+
+// Search for properties
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "auth",
+});
+
+// Check versions
+get_node({ nodeType: "nodes-base.executeWorkflow", mode: "versions" });
+```
+
+### validate_node (Unified Validation)
+
+**Modes**:
+
+- `full` (default) - Comprehensive validation with errors/warnings/suggestions
+- `minimal` - Quick required fields check only
+
+**Profiles** (for mode="full"):
+
+- `minimal` - Very lenient
+- `runtime` - Standard (default, recommended)
+- `ai-friendly` - Balanced for AI workflows
+- `strict` - Most thorough (production)
+
+```javascript
+// Full validation with runtime profile
+validate_node({nodeType: "nodes-base.slack", config: {...}, profile: "runtime"})
+
+// Quick required fields check
+validate_node({nodeType: "nodes-base.webhook", config: {}, mode: "minimal"})
+```
+
+---
+
+## Performance Characteristics
+
+| Tool                        | Response Time | Payload Size |
+| --------------------------- | ------------- | ------------ |
+| search_nodes                | <20ms         | Small        |
+| get_node (standard)         | <10ms         | ~1-2KB       |
+| get_node (full)             | <100ms        | 3-8KB        |
+| validate_node (minimal)     | <50ms         | Small        |
+| validate_node (full)        | <100ms        | Medium       |
+| validate_workflow           | 100-500ms     | Medium       |
+| n8n_create_workflow         | 100-500ms     | Medium       |
+| n8n_update_partial_workflow | 50-200ms      | Small        |
+| n8n_deploy_template         | 200-500ms     | Medium       |
+
+---
+
+## Best Practices
+
+### Do
+
+- Use `get_node({detail: "standard"})` for most use cases
+- Specify validation profile explicitly (`profile: "runtime"`)
+- Use smart parameters (`branch`, `case`) for clarity
+- Include `intent` parameter in workflow updates
+- Follow search -> get_node -> validate workflow
+- Iterate workflows (avg 56s between edits)
+- Validate after every significant change
+- Use `includeExamples: true` for real configs
+- Use `n8n_deploy_template` for quick starts
+
+### Don't
+
+- Use `detail: "full"` unless necessary (wastes tokens)
+- Forget nodeType prefix (`nodes-base.*`)
+- Skip validation profiles
+- Try to build workflows in one shot (iterate!)
+- Ignore auto-sanitization behavior
+- Use full prefix (`n8n-nodes-base.*`) with search/validate tools
+- Forget to activate workflows after building
+
+---
+
+## Summary
+
+**Most Important**:
+
+1. Use **get_node** with `detail: "standard"` (default) - covers 95% of use cases
+2. nodeType formats differ: `nodes-base.*` (search/validate) vs `n8n-nodes-base.*` (workflows)
+3. Specify **validation profiles** (`runtime` recommended)
+4. Use **smart parameters** (`branch="true"`, `case=0`)
+5. Include **intent parameter** in workflow updates
+6. **Auto-sanitization** runs on ALL nodes during updates
+7. Workflows can be **activated via API** (`activateWorkflow` operation)
+8. Workflows are built **iteratively** (56s avg between edits)
+
+**Common Workflow**:
+
+1. search_nodes -> find node
+2. get_node -> understand config
+3. validate_node -> check config
+4. n8n_create_workflow -> build
+5. n8n_validate_workflow -> verify
+6. n8n_update_partial_workflow -> iterate
+7. activateWorkflow -> go live!
+
+**Related Skills**:
+
+- [validation-expert.md](validation-expert.md) - Interpret validation errors
+- [node-configuration.md](node-configuration.md) - Operation-specific node setup
+- [workflow-patterns.md](workflow-patterns.md) - Architectural patterns from templates
+- n8n Expression Syntax - Write expressions in workflow fields
+- n8n Code JavaScript - Write JavaScript in Code nodes
+- n8n Code Python - Write Python in Code nodes
+
+---
+
+# Node Discovery Tools Guide
+
+Complete guide for finding and understanding n8n nodes.
+
+---
+
+## search_nodes (START HERE!)
+
+**Speed**: <20ms
+
+**Use when**: You know what you're looking for (keyword, service, use case)
+
+**Syntax**:
+
+```javascript
+search_nodes({
+  query: "slack", // Required: search keywords
+  mode: "OR", // Optional: OR (default), AND, FUZZY
+  limit: 20, // Optional: max results (default 20)
+  source: "all", // Optional: all, core, community, verified
+  includeExamples: false, // Optional: include template configs
+});
+```
+
+**Returns**:
+
+```javascript
+{
+  "query": "slack",
+  "results": [
+    {
+      "nodeType": "nodes-base.slack",                    // For search/validate tools
+      "workflowNodeType": "n8n-nodes-base.slack",       // For workflow tools
+      "displayName": "Slack",
+      "description": "Consume Slack API",
+      "category": "output",
+      "relevance": "high"
+    }
+  ]
+}
+```
+
+**Tips**:
+
+- Common searches: webhook, http, database, email, slack, google, ai
+- `OR` mode (default): matches any word
+- `AND` mode: requires all words
+- `FUZZY` mode: typo-tolerant (finds "slak" -> Slack)
+- Use `source: "core"` for only built-in nodes
+- Use `includeExamples: true` for real-world configs
+
+---
+
+## get_node (UNIFIED NODE INFORMATION)
+
+The `get_node` tool provides all node information with different detail levels and modes.
+
+> See also: [node-configuration.md](node-configuration.md) for operation-specific configuration requirements.
+
+### Detail Levels (mode="info")
+
+| Detail     | Tokens | Use When                     |
+| ---------- | ------ | ---------------------------- |
+| `minimal`  | ~200   | Quick metadata check         |
+| `standard` | ~1-2K  | **Most use cases (DEFAULT)** |
+| `full`     | ~3-8K  | Complex debugging only       |
+
+### Standard Detail (RECOMMENDED)
+
+**Speed**: <10ms | **Size**: ~1-2K tokens
+
+**Use when**: You've found the node and need configuration details
+
+```javascript
+get_node({
+  nodeType: "nodes-base.slack", // Required: SHORT prefix format
+  includeExamples: true, // Optional: get real template configs
+});
+// detail="standard" is the default
+```
+
+**Returns**:
+
+- Available operations and resources
+- Essential properties (10-20 most common)
+- Metadata (isAITool, isTrigger, hasCredentials)
+- Real examples from templates (if includeExamples: true)
+
+### Minimal Detail
+
+**Speed**: <5ms | **Size**: ~200 tokens
+
+**Use when**: Just need basic metadata
+
+```javascript
+get_node({
+  nodeType: "nodes-base.slack",
+  detail: "minimal",
+});
+```
+
+**Returns**: nodeType, displayName, description, category
+
+### Full Detail (USE SPARINGLY)
+
+**Speed**: <100ms | **Size**: ~3-8K tokens
+
+**Use when**: Debugging complex configuration, need complete schema
+
+```javascript
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  detail: "full",
+});
+```
+
+**Warning**: Large payload! Use `standard` for most cases.
+
+---
+
+## get_node Modes
+
+### mode="docs" (READABLE DOCUMENTATION)
+
+**Use when**: Need human-readable documentation with examples
+
+```javascript
+get_node({
+  nodeType: "nodes-base.slack",
+  mode: "docs",
+});
+```
+
+**Returns**: Formatted markdown with:
+
+- Usage examples
+- Authentication guide
+- Common patterns
+- Best practices
+
+**Better than raw schema for learning!**
+
+### mode="search_properties" (FIND SPECIFIC FIELDS)
+
+**Use when**: Looking for specific property in a node
+
+```javascript
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "auth", // Required for this mode
+  maxPropertyResults: 20, // Optional: default 20
+});
+```
+
+**Returns**: Property paths and descriptions matching query
+
+**Common searches**: auth, header, body, json, url, method, credential
+
+### mode="versions" (VERSION HISTORY)
+
+**Use when**: Need to check node version history
+
+```javascript
+get_node({
+  nodeType: "nodes-base.executeWorkflow",
+  mode: "versions",
+});
+```
+
+**Returns**: Version history with breaking changes flags
+
+### mode="compare" (COMPARE VERSIONS)
+
+**Use when**: Need to see differences between versions
+
+```javascript
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "compare",
+  fromVersion: "3.0",
+  toVersion: "4.1", // Optional: defaults to latest
+});
+```
+
+**Returns**: Property-level changes between versions
+
+### mode="breaking" (BREAKING CHANGES ONLY)
+
+**Use when**: Checking for breaking changes before upgrades
+
+```javascript
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "breaking",
+  fromVersion: "3.0",
+});
+```
+
+**Returns**: Only breaking changes (not all changes)
+
+### mode="migrations" (AUTO-MIGRATABLE)
+
+**Use when**: Checking what can be auto-migrated
+
+```javascript
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "migrations",
+  fromVersion: "3.0",
+});
+```
+
+**Returns**: Changes that can be automatically migrated
+
+---
+
+## Additional Parameters
+
+### includeTypeInfo
+
+Add type structure metadata (validation rules, JS types)
+
+```javascript
+get_node({
+  nodeType: "nodes-base.if",
+  includeTypeInfo: true, // Adds ~80-120 tokens per property
+});
+```
+
+Use for complex nodes like filter, resourceMapper
+
+### includeExamples
+
+Include real-world configuration examples from templates
+
+```javascript
+get_node({
+  nodeType: "nodes-base.slack",
+  includeExamples: true, // Adds ~200-400 tokens per example
+});
+```
+
+Only works with `mode: "info"` and `detail: "standard"`
+
+---
+
+## Common Workflow: Finding & Configuring
+
+```
+Step 1: Search
+search_nodes({query: "slack"})
+-> Returns: nodes-base.slack
+
+Step 2: Get Operations (18s avg thinking time)
+get_node({
+  nodeType: "nodes-base.slack",
+  includeExamples: true
+})
+-> Returns: operations list + example configs
+
+Step 3: Validate Config
+validate_node({
+  nodeType: "nodes-base.slack",
+  config: {resource: "channel", operation: "create"},
+  profile: "runtime"
+})
+-> Returns: validation result
+
+Step 4: Use in Workflow
+(Configuration ready!)
+```
+
+**Most common pattern**: search -> get_node (18s average)
+
+---
+
+## Quick Comparison
+
+| Tool/Mode                      | When to Use              | Speed  | Size   |
+| ------------------------------ | ------------------------ | ------ | ------ |
+| `search_nodes`                 | Find by keyword          | <20ms  | Small  |
+| `get_node (standard)`          | **Get config (DEFAULT)** | <10ms  | 1-2K   |
+| `get_node (minimal)`           | Quick metadata           | <5ms   | 200    |
+| `get_node (full)`              | Complex debugging        | <100ms | 3-8K   |
+| `get_node (docs)`              | Learn usage              | Fast   | Medium |
+| `get_node (search_properties)` | Find specific field      | Fast   | Small  |
+| `get_node (versions)`          | Check versions           | Fast   | Small  |
+
+**Best Practice**: search -> get_node(standard) -> validate
+
+---
+
+## nodeType Format (CRITICAL!)
+
+**Search/Validate Tools** (SHORT prefix):
+
+```javascript
+"nodes-base.slack";
+"nodes-base.httpRequest";
+"nodes-langchain.agent";
+```
+
+**Workflow Tools** (FULL prefix):
+
+```javascript
+"n8n-nodes-base.slack";
+"n8n-nodes-base.httpRequest";
+"@n8n/n8n-nodes-langchain.agent";
+```
+
+**Conversion**: search_nodes returns BOTH formats:
+
+```javascript
+{
+  "nodeType": "nodes-base.slack",          // Use with get_node, validate_node
+  "workflowNodeType": "n8n-nodes-base.slack"  // Use with n8n_create_workflow
+}
+```
+
+---
+
+## Examples
+
+### Find and Configure HTTP Request
+
+```javascript
+// Step 1: Search
+search_nodes({ query: "http request" });
+
+// Step 2: Get standard info
+get_node({ nodeType: "nodes-base.httpRequest" });
+
+// Step 3: Find auth options
+get_node({
+  nodeType: "nodes-base.httpRequest",
+  mode: "search_properties",
+  propertyQuery: "authentication",
+});
+
+// Step 4: Validate config
+validate_node({
+  nodeType: "nodes-base.httpRequest",
+  config: { method: "POST", url: "https://api.example.com" },
+  profile: "runtime",
+});
+```
+
+### Explore AI Nodes
+
+```javascript
+// Find all AI-related nodes
+search_nodes({ query: "ai agent", source: "all" });
+
+// Get AI Agent documentation
+get_node({ nodeType: "nodes-langchain.agent", mode: "docs" });
+
+// Get configuration details with examples
+get_node({
+  nodeType: "nodes-langchain.agent",
+  includeExamples: true,
+});
+```
+
+### Check Version Compatibility
+
+```javascript
+// See all versions
+get_node({ nodeType: "nodes-base.executeWorkflow", mode: "versions" });
+
+// Check breaking changes from v1 to v2
+get_node({
+  nodeType: "nodes-base.executeWorkflow",
+  mode: "breaking",
+  fromVersion: "1.0",
+});
+```
+
+---
+
+# Configuration Validation Tools Guide
+
+Complete guide for validating node configurations and workflows.
+
+> See also: [validation-expert.md](validation-expert.md) for interpreting validation errors and advanced error handling strategies.
+
+---
+
+## Validation Philosophy
+
+**Validate early, validate often**
+
+Validation is typically iterative with validate -> fix cycles
+
+---
+
+## validate_node (UNIFIED VALIDATION)
+
+The `validate_node` tool provides all validation capabilities with different modes.
+
+### Quick Check (mode="minimal")
+
+**Speed**: <50ms
+
+**Use when**: Checking what fields are required
+
+```javascript
+validate_node({
+  nodeType: "nodes-base.slack",
+  config: {}, // Empty to see all required fields
+  mode: "minimal",
+});
+```
+
+**Returns**:
+
+```javascript
+{
+  "valid": true,           // Usually true (most nodes have no strict requirements)
+  "missingRequiredFields": []
+}
+```
+
+**When to use**: Planning configuration, seeing basic requirements
+
+### Full Validation (mode="full", DEFAULT)
+
+**Speed**: <100ms
+
+**Use when**: Validating actual configuration before deployment
+
+```javascript
+validate_node({
+  nodeType: "nodes-base.slack",
+  config: {
+    resource: "channel",
+    operation: "create",
+    channel: "general",
+  },
+  profile: "runtime", // Recommended!
+});
+// mode="full" is the default
+```
+
+---
+
+## Validation Profiles
+
+Choose based on your stage:
+
+**minimal** - Only required fields
+
+- Fastest
+- Most permissive
+- Use: Quick checks during editing
+
+**runtime** - Values + types (**RECOMMENDED**)
+
+- Balanced validation
+- Catches real errors
+- Use: Pre-deployment validation
+
+**ai-friendly** - Reduce false positives
+
+- For AI-generated configs
+- Tolerates minor issues
+- Use: When AI configures nodes
+
+**strict** - Maximum validation
+
+- Strictest rules
+- May have false positives
+- Use: Production deployment
+
+---
+
+## Validation Response
+
+```javascript
+{
+  "nodeType": "nodes-base.slack",
+  "workflowNodeType": "n8n-nodes-base.slack",
+  "displayName": "Slack",
+  "valid": false,
+  "errors": [
+    {
+      "type": "missing_required",
+      "property": "name",
+      "message": "Channel name is required",
+      "fix": "Provide a channel name (lowercase, no spaces, 1-80 characters)"
+    }
+  ],
+  "warnings": [
+    {
+      "type": "best_practice",
+      "property": "errorHandling",
+      "message": "Slack API can have rate limits",
+      "suggestion": "Add onError: 'continueRegularOutput' with retryOnFail"
+    }
+  ],
+  "suggestions": [],
+  "summary": {
+    "hasErrors": true,
+    "errorCount": 1,
+    "warningCount": 1,
+    "suggestionCount": 0
+  }
+}
+```
+
+### Error Types
+
+- `missing_required` - Must fix
+- `invalid_value` - Must fix
+- `type_mismatch` - Must fix
+- `best_practice` - Should fix (warning)
+- `suggestion` - Optional improvement
+
+---
+
+## validate_workflow (STRUCTURE VALIDATION)
+
+**Speed**: 100-500ms
+
+**Use when**: Checking complete workflow before execution
+
+**Syntax**:
+
+```javascript
+validate_workflow({
+  workflow: {
+    nodes: [...],        // Array of nodes
+    connections: {...}   // Connections object
+  },
+  options: {
+    validateNodes: true,       // Default: true
+    validateConnections: true, // Default: true
+    validateExpressions: true, // Default: true
+    profile: "runtime"         // For node validation
+  }
+})
+```
+
+**Validates**:
+
+- Node configurations
+- Connection validity (no broken references)
+- Expression syntax ({{ }} patterns)
+- Workflow structure (triggers, flow)
+- AI connections (8 types)
+
+**Returns**: Comprehensive validation report with errors, warnings, suggestions
+
+### Validate by Workflow ID
+
+```javascript
+// Validate workflow already in n8n
+n8n_validate_workflow({
+  id: "workflow-id",
+  options: {
+    validateNodes: true,
+    validateConnections: true,
+    validateExpressions: true,
+    profile: "runtime",
+  },
+});
+```
+
+---
+
+## Validation Loop Pattern
+
+**Typical cycle**: 23s thinking, 58s fixing
+
+```
+1. Configure node
+   |
+2. validate_node (23s thinking about errors)
+   |
+3. Fix errors
+   |
+4. validate_node again (58s fixing)
+   |
+5. Repeat until valid
+```
+
+**Example**:
+
+```javascript
+// Iteration 1
+let config = {
+  resource: "channel",
+  operation: "create",
+};
+
+const result1 = validate_node({
+  nodeType: "nodes-base.slack",
+  config,
+  profile: "runtime",
+});
+// -> Error: Missing "name"
+
+// Iteration 2 (~58s later)
+config.name = "general";
+
+const result2 = validate_node({
+  nodeType: "nodes-base.slack",
+  config,
+  profile: "runtime",
+});
+// -> Valid!
+```
+
+---
+
+## Auto-Sanitization System
+
+**When it runs**: On ANY workflow update (create or update_partial)
+
+**What it fixes** (automatically on ALL nodes):
+
+1. Binary operators (equals, contains, greaterThan) -> removes `singleValue`
+2. Unary operators (isEmpty, isNotEmpty, true, false) -> adds `singleValue: true`
+3. Invalid operator structures -> corrects to proper format
+4. IF v2.2+ nodes -> adds complete `conditions.options` metadata
+5. Switch v3.2+ nodes -> adds complete `conditions.options` for all rules
+
+**What it CANNOT fix**:
+
+- Broken connections (references to non-existent nodes)
+- Branch count mismatches (3 Switch rules but only 2 outputs)
+- Paradoxical corrupt states (API returns corrupt, rejects updates)
+
+**Example**:
+
+```javascript
+// Before auto-sanitization
+{
+  "type": "boolean",
+  "operation": "equals",
+  "singleValue": true  // Binary operators shouldn't have this
+}
+
+// After auto-sanitization (automatic!)
+{
+  "type": "boolean",
+  "operation": "equals"
+  // singleValue removed automatically
+}
+```
+
+**Recovery tools**:
+
+- `cleanStaleConnections` operation - removes broken connections
+- `n8n_autofix_workflow({id})` - preview/apply fixes
+
+---
+
+## n8n_autofix_workflow (AUTO-FIX TOOL)
+
+**Use when**: Validation errors need automatic fixes
+
+```javascript
+// Preview fixes (default - doesn't apply)
+n8n_autofix_workflow({
+  id: "workflow-id",
+  applyFixes: false, // Preview mode
+  confidenceThreshold: "medium", // high, medium, low
+});
+
+// Apply fixes
+n8n_autofix_workflow({
+  id: "workflow-id",
+  applyFixes: true,
+});
+```
+
+**Fix Types**:
+
+- `expression-format` - Fix expression syntax
+- `typeversion-correction` - Correct typeVersion
+- `error-output-config` - Fix error output settings
+- `webhook-missing-path` - Add missing webhook paths
+- `typeversion-upgrade` - Upgrade to latest version
+- `version-migration` - Apply version migrations
+
+---
+
+## Binary vs Unary Operators
+
+**Binary operators** (compare two values):
+
+- equals, notEquals, contains, notContains
+- greaterThan, lessThan, startsWith, endsWith
+- **Must NOT have** `singleValue: true`
+
+**Unary operators** (check single value):
+
+- isEmpty, isNotEmpty, true, false
+- **Must have** `singleValue: true`
+
+**Auto-sanitization fixes these automatically!**
+
+---
+
+## Handling Validation Errors
+
+> See also: [validation-expert.md](validation-expert.md) for comprehensive error interpretation and resolution strategies.
+
+### Process
+
+```
+1. Read error message carefully
+2. Check if it's a known false positive
+3. Fix real errors
+4. Validate again
+5. Iterate until clean
+```
+
+### Common Errors
+
+**"Required field missing"**
+-> Add the field with appropriate value
+
+**"Invalid value"**
+-> Check allowed values in get_node output
+
+**"Type mismatch"**
+-> Convert to correct type (string/number/boolean)
+
+**"Cannot have singleValue"**
+-> Auto-sanitization will fix on next update
+
+**"Missing operator metadata"**
+-> Auto-sanitization will fix on next update
+
+### False Positives
+
+Some validation warnings may be acceptable:
+
+- Optional best practices
+- Node-specific edge cases
+- Profile-dependent issues
+
+Use **ai-friendly** profile to reduce false positives.
+
+---
+
+## Validation Best Practices
+
+### Do
+
+- Use **runtime** profile for pre-deployment
+- Validate after every configuration change
+- Fix errors immediately (avg 58s)
+- Iterate validation loop
+- Trust auto-sanitization for operator issues
+- Use `mode: "minimal"` for quick checks
+- Use `n8n_autofix_workflow` for bulk fixes
+- Activate workflows via API when ready (`activateWorkflow` operation)
+
+### Don't
+
+- Skip validation before deployment
+- Ignore error messages
+- Use strict profile during development (too many warnings)
+- Assume validation passed (check result)
+- Try to manually fix auto-sanitization issues
+
+---
+
+## Example: Complete Validation Workflow
+
+```javascript
+// Step 1: Get node requirements (quick check)
+validate_node({
+  nodeType: "nodes-base.slack",
+  config: {},
+  mode: "minimal"
+});
+// -> Know what's required
+
+// Step 2: Configure node
+const config = {
+  resource: "message",
+  operation: "post",
+  channel: "#general",
+  text: "Hello!"
+};
+
+// Step 3: Validate configuration (full validation)
+const result = validate_node({
+  nodeType: "nodes-base.slack",
+  config,
+  profile: "runtime"
+});
+
+// Step 4: Check result
+if (result.valid) {
+  console.log("Configuration valid!");
+} else {
+  console.log("Errors:", result.errors);
+  // Fix and validate again
+}
+
+// Step 5: Validate in workflow context
+validate_workflow({
+  workflow: {
+    nodes: [{...config as node...}],
+    connections: {...}
+  }
+});
+
+// Step 6: Apply auto-fixes if needed
+n8n_autofix_workflow({
+  id: "workflow-id",
+  applyFixes: true
+});
+```
+
+---
+
+## Validation Tool Selection
+
+- **validate_node({mode: "minimal"})**: Quick required fields check
+- **validate_node({profile: "runtime"})**: Full config validation (**use this!**)
+- **validate_workflow**: Complete workflow check
+- **n8n_validate_workflow({id})**: Validate existing workflow
+- **n8n_autofix_workflow({id})**: Auto-fix common issues
+
+---
+
+# Workflow Management Tools Guide
+
+Complete guide for creating, updating, and managing n8n workflows.
+
+> See also: [workflow-patterns.md](workflow-patterns.md) for architectural patterns and when to use each.
+
+---
+
+## Tool Availability
+
+**Requires n8n API**: All tools in this guide need `N8N_API_URL` and `N8N_API_KEY` configured.
+
+If unavailable, use template examples and validation-only workflows.
+
+---
+
+## n8n_create_workflow
+
+**Speed**: 100-500ms
+
+**Use when**: Creating new workflows from scratch
+
+**Syntax**:
+
+```javascript
+n8n_create_workflow({
+  name: "Webhook to Slack",  // Required
+  nodes: [...],              // Required: array of nodes
+  connections: {...},        // Required: connections object
+  settings: {...}            // Optional: workflow settings
+})
+```
+
+**Returns**: Created workflow with ID
+
+**Example**:
+
+```javascript
+n8n_create_workflow({
+  name: "Webhook to Slack",
+  nodes: [
+    {
+      id: "webhook-1",
+      name: "Webhook",
+      type: "n8n-nodes-base.webhook", // Full prefix!
+      typeVersion: 2,
+      position: [250, 300],
+      parameters: {
+        path: "slack-notify",
+        httpMethod: "POST",
+      },
+    },
+    {
+      id: "slack-1",
+      name: "Slack",
+      type: "n8n-nodes-base.slack",
+      typeVersion: 2,
+      position: [450, 300],
+      parameters: {
+        resource: "message",
+        operation: "post",
+        channel: "#general",
+        text: "={{$json.body.message}}",
+      },
+    },
+  ],
+  connections: {
+    Webhook: {
+      main: [[{ node: "Slack", type: "main", index: 0 }]],
+    },
+  },
+});
+```
+
+**Notes**:
+
+- Workflows created **inactive** (activate with `activateWorkflow` operation)
+- Auto-sanitization runs on creation
+- Validate before creating for best results
+
+---
+
+## n8n_update_partial_workflow (MOST USED!)
+
+**Speed**: 50-200ms | **Uses**: 38,287 (most used tool!)
+
+**Use when**: Making incremental changes to workflows
+
+**Common pattern**: 56s average between edits (iterative building!)
+
+### 17 Operation Types
+
+**Node Operations** (6 types):
+
+1. `addNode` - Add new node
+2. `removeNode` - Remove node by ID or name
+3. `updateNode` - Update node properties (use dot notation)
+4. `moveNode` - Change position
+5. `enableNode` - Enable disabled node
+6. `disableNode` - Disable active node
+
+**Connection Operations** (5 types): 7. `addConnection` - Connect nodes (supports smart params) 8. `removeConnection` - Remove connection (supports ignoreErrors) 9. `rewireConnection` - Change connection target 10. `cleanStaleConnections` - Auto-remove broken connections 11. `replaceConnections` - Replace entire connections object
+
+**Metadata Operations** (4 types): 12. `updateSettings` - Workflow settings 13. `updateName` - Rename workflow 14. `addTag` - Add tag 15. `removeTag` - Remove tag
+
+**Activation Operations** (2 types): 16. `activateWorkflow` - Activate workflow for automatic execution 17. `deactivateWorkflow` - Deactivate workflow
+
+### Intent Parameter (IMPORTANT!)
+
+Always include `intent` for better responses:
+
+```javascript
+n8n_update_partial_workflow({
+  id: "workflow-id",
+  intent: "Add error handling for API failures",  // Describe what you're doing
+  operations: [...]
+})
+```
+
+### Smart Parameters
+
+> See also: [node-configuration.md](node-configuration.md) for IF/Switch node setup details.
+
+**IF nodes** - Use semantic branch names:
+
+```javascript
+{
+  type: "addConnection",
+  source: "IF",
+  target: "True Handler",
+  branch: "true"  // Instead of sourceIndex: 0
+}
+
+{
+  type: "addConnection",
+  source: "IF",
+  target: "False Handler",
+  branch: "false"  // Instead of sourceIndex: 1
+}
+```
+
+**Switch nodes** - Use semantic case numbers:
+
+```javascript
+{
+  type: "addConnection",
+  source: "Switch",
+  target: "Handler A",
+  case: 0
+}
+
+{
+  type: "addConnection",
+  source: "Switch",
+  target: "Handler B",
+  case: 1
+}
+```
+
+### AI Connection Types (8 types)
+
+**Full support** for AI workflows:
+
+```javascript
+// Language Model
+{
+  type: "addConnection",
+  source: "OpenAI Chat Model",
+  target: "AI Agent",
+  sourceOutput: "ai_languageModel"
+}
+
+// Tool
+{
+  type: "addConnection",
+  source: "HTTP Request Tool",
+  target: "AI Agent",
+  sourceOutput: "ai_tool"
+}
+
+// Memory
+{
+  type: "addConnection",
+  source: "Window Buffer Memory",
+  target: "AI Agent",
+  sourceOutput: "ai_memory"
+}
+
+// All 8 types:
+// - ai_languageModel
+// - ai_tool
+// - ai_memory
+// - ai_outputParser
+// - ai_embedding
+// - ai_vectorStore
+// - ai_document
+// - ai_textSplitter
+```
+
+### Property Removal with undefined
+
+Remove properties by setting them to `undefined`:
+
+```javascript
+// Remove a property
+{
+  type: "updateNode",
+  nodeName: "HTTP Request",
+  updates: { onError: undefined }
+}
+
+// Migrate from deprecated property
+{
+  type: "updateNode",
+  nodeName: "HTTP Request",
+  updates: {
+    continueOnFail: undefined,  // Remove old
+    onError: "continueErrorOutput"  // Add new
+  }
+}
+```
+
+### Activation Operations
+
+```javascript
+// Activate workflow
+n8n_update_partial_workflow({
+  id: "workflow-id",
+  intent: "Activate workflow for production",
+  operations: [{ type: "activateWorkflow" }],
+});
+
+// Deactivate workflow
+n8n_update_partial_workflow({
+  id: "workflow-id",
+  intent: "Deactivate workflow for maintenance",
+  operations: [{ type: "deactivateWorkflow" }],
+});
+```
+
+### Example Usage
+
+```javascript
+n8n_update_partial_workflow({
+  id: "workflow-id",
+  intent: "Add transform node after IF condition",
+  operations: [
+    // Add node
+    {
+      type: "addNode",
+      node: {
+        name: "Transform",
+        type: "n8n-nodes-base.set",
+        position: [400, 300],
+        parameters: {},
+      },
+    },
+    // Connect it (smart parameter)
+    {
+      type: "addConnection",
+      source: "IF",
+      target: "Transform",
+      branch: "true", // Clear and semantic!
+    },
+  ],
+});
+```
+
+### Cleanup & Recovery
+
+**cleanStaleConnections** - Remove broken connections:
+
+```javascript
+{
+  type: "cleanStaleConnections";
+}
+```
+
+**rewireConnection** - Change target atomically:
+
+```javascript
+{
+  type: "rewireConnection",
+  source: "Webhook",
+  from: "Old Handler",
+  to: "New Handler"
+}
+```
+
+**Best-effort mode** - Apply what works:
+
+```javascript
+n8n_update_partial_workflow({
+  id: "workflow-id",
+  operations: [...],
+  continueOnError: true  // Don't fail if some operations fail
+})
+```
+
+**Validate before applying**:
+
+```javascript
+n8n_update_partial_workflow({
+  id: "workflow-id",
+  operations: [...],
+  validateOnly: true  // Preview without applying
+})
+```
+
+---
+
+## n8n_deploy_template (QUICK START!)
+
+**Speed**: 200-500ms
+
+**Use when**: Deploying a template directly to n8n instance
+
+```javascript
+n8n_deploy_template({
+  templateId: 2947, // Required: from n8n.io
+  name: "My Weather to Slack", // Optional: custom name
+  autoFix: true, // Default: auto-fix common issues
+  autoUpgradeVersions: true, // Default: upgrade node versions
+  stripCredentials: true, // Default: remove credential refs
+});
+```
+
+**Returns**:
+
+- Workflow ID
+- Required credentials
+- Fixes applied
+
+**Example**:
+
+```javascript
+// Deploy a webhook to Slack template
+const result = n8n_deploy_template({
+  templateId: 2947,
+  name: "Production Slack Notifier",
+});
+
+// Result includes:
+// - id: "new-workflow-id"
+// - requiredCredentials: ["slack"]
+// - fixesApplied: ["typeVersion upgraded", "expression format fixed"]
+```
+
+---
+
+## n8n_workflow_versions (VERSION CONTROL)
+
+**Use when**: Managing workflow history, rollback, cleanup
+
+### List Versions
+
+```javascript
+n8n_workflow_versions({
+  mode: "list",
+  workflowId: "workflow-id",
+  limit: 10,
+});
+```
+
+### Get Specific Version
+
+```javascript
+n8n_workflow_versions({
+  mode: "get",
+  versionId: 123,
+});
+```
+
+### Rollback to Previous Version
+
+```javascript
+n8n_workflow_versions({
+  mode: "rollback",
+  workflowId: "workflow-id",
+  versionId: 123, // Optional: specific version
+  validateBefore: true, // Default: validate before rollback
+});
+```
+
+### Delete Versions
+
+```javascript
+// Delete specific version
+n8n_workflow_versions({
+  mode: "delete",
+  workflowId: "workflow-id",
+  versionId: 123,
+});
+
+// Delete all versions for workflow
+n8n_workflow_versions({
+  mode: "delete",
+  workflowId: "workflow-id",
+  deleteAll: true,
+});
+```
+
+### Prune Old Versions
+
+```javascript
+n8n_workflow_versions({
+  mode: "prune",
+  workflowId: "workflow-id",
+  maxVersions: 10, // Keep 10 most recent
+});
+```
+
+---
+
+## n8n_test_workflow (TRIGGER EXECUTION)
+
+**Use when**: Testing workflow execution
+
+**Auto-detects** trigger type (webhook, form, chat)
+
+```javascript
+// Test webhook workflow
+n8n_test_workflow({
+  workflowId: "workflow-id",
+  triggerType: "webhook", // Optional: auto-detected
+  httpMethod: "POST",
+  data: { message: "Hello!" },
+  waitForResponse: true,
+  timeout: 120000,
+});
+
+// Test chat workflow
+n8n_test_workflow({
+  workflowId: "workflow-id",
+  triggerType: "chat",
+  message: "Hello, AI agent!",
+  sessionId: "session-123", // For conversation continuity
+});
+```
+
+---
+
+## n8n_validate_workflow (by ID)
+
+**Use when**: Validating workflow stored in n8n
+
+```javascript
+n8n_validate_workflow({
+  id: "workflow-id",
+  options: {
+    validateNodes: true,
+    validateConnections: true,
+    validateExpressions: true,
+    profile: "runtime",
+  },
+});
+```
+
+---
+
+## n8n_get_workflow
+
+**Use when**: Retrieving workflow details
+
+**Modes**:
+
+- `full` (default) - Complete workflow JSON
+- `details` - Full + execution stats
+- `structure` - Nodes + connections only
+- `minimal` - ID, name, active, tags
+
+```javascript
+// Full workflow
+n8n_get_workflow({ id: "workflow-id" });
+
+// Just structure
+n8n_get_workflow({ id: "workflow-id", mode: "structure" });
+
+// Minimal metadata
+n8n_get_workflow({ id: "workflow-id", mode: "minimal" });
+```
+
+---
+
+## n8n_executions (EXECUTION MANAGEMENT)
+
+**Use when**: Managing workflow executions
+
+### Get Execution Details
+
+```javascript
+n8n_executions({
+  action: "get",
+  id: "execution-id",
+  mode: "summary", // preview, summary, filtered, full, error
+});
+
+// Error mode for debugging
+n8n_executions({
+  action: "get",
+  id: "execution-id",
+  mode: "error",
+  includeStackTrace: true,
+});
+```
+
+### List Executions
+
+```javascript
+n8n_executions({
+  action: "list",
+  workflowId: "workflow-id",
+  status: "error", // success, error, waiting
+  limit: 100,
+});
+```
+
+### Delete Execution
+
+```javascript
+n8n_executions({
+  action: "delete",
+  id: "execution-id",
+});
+```
+
+---
+
+## Workflow Lifecycle
+
+**Standard pattern**:
+
+```
+1. CREATE
+   n8n_create_workflow({...})
+   -> Returns workflow ID
+
+2. VALIDATE
+   n8n_validate_workflow({id})
+   -> Check for errors
+
+3. EDIT (iterative! 56s avg between edits)
+   n8n_update_partial_workflow({id, intent: "...", operations: [...]})
+   -> Make changes
+
+4. VALIDATE AGAIN
+   n8n_validate_workflow({id})
+   -> Verify changes
+
+5. ACTIVATE
+   n8n_update_partial_workflow({
+     id,
+     intent: "Activate workflow",
+     operations: [{type: "activateWorkflow"}]
+   })
+   -> Workflow now runs on triggers!
+
+6. MONITOR
+   n8n_executions({action: "list", workflowId: id})
+   n8n_executions({action: "get", id: execution_id})
+```
+
+---
+
+## Common Patterns from Telemetry
+
+### Pattern 1: Edit -> Validate (7,841 occurrences)
+
+```javascript
+n8n_update_partial_workflow({...})
+// | 23s (thinking about what to validate)
+n8n_validate_workflow({id})
+```
+
+### Pattern 2: Validate -> Fix (7,266 occurrences)
+
+```javascript
+n8n_validate_workflow({id})
+// | 58s (fixing errors)
+n8n_update_partial_workflow({...})
+```
+
+### Pattern 3: Iterative Building (31,464 occurrences)
+
+```javascript
+update -> update -> update -> ... (56s avg between edits)
+```
+
+**This shows**: Workflows are built **iteratively**, not in one shot!
+
+---
+
+## Workflow Management Best Practices
+
+### Do
+
+- Build workflows **iteratively** (avg 56s between edits)
+- Include **intent** parameter for better responses
+- Use **smart parameters** (branch, case) for clarity
+- Validate **after** significant changes
+- Use **atomic mode** (default) for critical updates
+- Specify **sourceOutput** for AI connections
+- Clean stale connections after node renames/deletions
+- Use `n8n_deploy_template` for quick starts
+- Activate workflows via API when ready
+
+### Don't
+
+- Try to build workflows in one shot
+- Skip the intent parameter
+- Use sourceIndex when branch/case available
+- Skip validation before activation
+- Forget to test workflows after creation
+- Ignore auto-sanitization behavior
+
+---
+
+## Workflow Management Summary
+
+**Most Important**:
+
+1. **n8n_update_partial_workflow** is most-used tool (38,287 uses)
+2. Include **intent** parameter for better responses
+3. Workflows built **iteratively** (56s avg between edits)
+4. Use **smart parameters** (branch="true", case=0) for clarity
+5. **AI connections** supported (8 types with sourceOutput)
+6. **Workflow activation** supported via API (`activateWorkflow` operation)
+7. **Auto-sanitization** runs on all operations
+8. Use **n8n_deploy_template** for quick starts
+
+**Additional Tools**:
+
+- `n8n_deploy_template` - Deploy templates directly
+- `n8n_workflow_versions` - Version control & rollback
+- `n8n_test_workflow` - Trigger execution
+- `n8n_executions` - Manage executions