[Trigger] → [HTTP Request] → [Transform Data] → [Send Email]
     ↓                              ↓
[Webhook]                    [Google Sheets]

// Example: Reading data from Google Sheets
// Node: Google Sheets → Read Rows
 
// Output will be an array of objects:
[
  {
    "Name": "John Smith",
    "Email": "john@example.com",
    "Status": "Active"
  },
  {
    "Name": "Jane Doe",
    "Email": "jane@example.com",
    "Status": "Pending"
  }
]

// Workflow: AI Agent with tool usage
// 1. Trigger: Webhook (receives user message)
// 2. AI Agent node: 
//    - Model: OpenAI GPT-4o
//    - System Prompt: "You are a customer service assistant"
//    - Tools: HTTP Request, Google Sheets, Slack
// 3. Output: Send response to Slack
 
// Example JSON for AI Agent node:
{
  "model": "gpt-4o",
  "systemMessage": "You are a helpful customer service assistant. Use the available tools to answer customer questions.",
  "tools": ["httpRequest", "googleSheets", "slack"],
  "maxIterations": 5,
  "temperature": 0.7
}

[Document Loader] → [Text Splitter] → [Vector Store] 
                                          ↓
[Query] → [Retriever] → [AI Chain] → [Response]

// Code Node: Transform data with JavaScript
const items = $input.all();
 
const results = items.map(item => ({
  json: {
    ...item.json,
    fullName: `${item.json.firstName} ${item.json.lastName}`,
    emailDomain: item.json.email.split('@')[1],
    createdAt: new Date().toISOString()
  }
}));
 
return results;

# Code Node (Python): Transform data
import json
 
items = $input.all()
results = []
 
for item in items:
    data = item['json']
    results.append({
        'json': {
            **data,
            'fullName': f"{data['firstName']} {data['lastName']}",
            'processedAt': datetime.now().isoformat()
        }
    })
 
return results

# 1. Create a Docker volume for persistent data
docker volume create n8n_data
 
# 2. Run n8n
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

# docker-compose.yml
version: '3.8'
 
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      # Basic configuration
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - GENERIC_TIMEZONE=America/New_York
      - TZ=America/New_York
      
      # Database (use PostgreSQL for production)
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=n8n_password_change_me
      
      # Security
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your_secure_password
      
      # Webhook URL (for production)
      - WEBHOOK_URL=https://n8n.example.com/
      
      # Encryption key for credentials
      - N8N_ENCRYPTION_KEY=your-encryption-key-here
    volumes:
      - n8n_data:/home/node/.n8n
      - ./custom-nodes:/opt/custom-nodes
    depends_on:
      - postgres
 
  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=n8n_password_change_me
      - POSTGRES_DB=n8n
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
 
volumes:
  n8n_data:
  postgres_data:

docker compose up -d

# .env file for Docker Compose
 
# === Database ===
DB_TYPE=postgresdb
DB_POSTGRESDB_HOST=postgres
DB_POSTGRESDB_PORT=5432
DB_POSTGRESDB_DATABASE=n8n
DB_POSTGRESDB_USER=n8n
DB_POSTGRESDB_PASSWORD=your_secure_password
 
# === Security ===
N8N_BASIC_AUTH_ACTIVE=true
N8N_BASIC_AUTH_USER=admin
N8N_BASIC_AUTH_PASSWORD=your_secure_password
N8N_ENCRYPTION_KEY=generate_a_random_key_here
 
# === Execution ===
# Save all workflow executions
EXECUTIONS_DATA_SAVE_ON_SUCCESS=all
EXECUTIONS_DATA_SAVE_ON_ERROR=all
# Keep execution data for 7 days
EXECUTIONS_DATA_PRUNE=true
EXECUTIONS_DATA_MAX_AGE=10080
 
# === Webhook ===
WEBHOOK_URL=https://n8n.example.com/
 
# === Timezone ===
GENERIC_TIMEZONE=America/New_York
TZ=America/New_York

# Make sure Node.js 18+ is installed
node --version
 
# Run n8n directly
npx n8n

# Custom node structure
my-custom-node/
├── package.json
├── credentials/
│   └── MyApi.credentials.ts
├── nodes/
│   └── MyCustomNode.node.ts
└── tsconfig.json

// nodes/MyCustomNode.node.ts
import {
  INodeType,
  INodeTypeDescription,
  IExecuteFunctions,
  INodeExecutionData,
} from 'n8n-workflow';
 
export class MyCustomNode implements INodeType {
  description: INodeTypeDescription = {
    displayName: 'My Custom Node',
    name: 'myCustomNode',
    group: ['transform'],
    version: 1,
    description: 'Custom node for specific needs',
    defaults: {
      name: 'My Custom Node',
    },
    inputs: ['main'],
    outputs: ['main'],
    credentials: [
      {
        name: 'myApi',
        required: true,
      },
    ],
    properties: [
      {
        displayName: 'Operation',
        name: 'operation',
        type: 'options',
        options: [
          {
            name: 'GetData',
            value: 'getData',
          },
        ],
        default: 'getData',
      },
    ],
  };
 
  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
    const items = this.getInputData();
    const returnData: INodeExecutionData[] = [];
 
    for (let i = 0; i < items.length; i++) {
      // Your custom node logic goes here
      returnData.push({
        json: {
          ...items[i].json,
          customField: 'value from custom node',
        },
      });
    }
 
    return [returnData];
  }
}

Type: Webhook
Method: POST
Path: /my-webhook

// Transform webhook data into the desired format
const data = $input.first().json;
 
return {
  json: {
    message: `📢 New Notification!\n\nFrom: ${data.from}\nMessage: ${data.message}\nTime: ${new Date().toLocaleString('en-US')}`,
    chatId: data.chatId
  }
};

Type: Telegram
Operation: Send Message
Chat ID: {{ $json.chatId }}
Text: {{ $json.message }}

{
  "name": "Webhook to Telegram",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "my-webhook",
        "responseMode": "onReceived",
        "responseData": "allEntries"
      },
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "values": {
          "string": [
            {
              "name": "message",
              "value": "=📢 New Notification!\n\nFrom: {{ $json.body.from }}\nMessage: {{ $json.body.message }}\nTime: {{ $now.format('dd/MM/yyyy HH:mm') }}"
            }
          ]
        }
      },
      "name": "Set",
      "type": "n8n-nodes-base.set",
      "typeVersion": 1,
      "position": [450, 300]
    },
    {
      "parameters": {
        "chatId": "YOUR_TELEGRAM_CHAT_ID",
        "text": "={{ $json.message }}",
        "additionalFields": {}
      },
      "name": "Telegram",
      "type": "n8n-nodes-base.telegram",
      "typeVersion": 1,
      "position": [650, 300],
      "credentials": {
        "telegramApi": {
          "id": "YOUR_CREDENTIAL_ID",
          "name": "Telegram Bot"
        }
      }
    }
  ],
  "connections": {
    "Webhook": {
      "main": [
        [
          {
            "node": "Set",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set": {
      "main": [
        [
          {
            "node": "Telegram",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

# Send data to the webhook
curl -X POST http://localhost:5678/webhook/my-webhook \
  -H "Content-Type: application/json" \
  -d '{
    "from": "John",
    "message": "Hello, this is a message from the webhook!",
    "chatId": "YOUR_CHAT_ID"
  }'

[Webhook] → [Vector Store Retrieval] → [AI Agent] → [Response]
     ↑                                        ↓
[Prompt]                               [OpenAI Model]
                                            ↓
                                      [Tools: Search]

Method: POST
Path: /ai-chat
Body: { "question": "What is the company leave policy?" }

// Query the vector store for relevant documents
const question = $input.first().json.body.question;
 
// n8n will automatically query Pinecone
// and return relevant document chunks

{
  "model": "gpt-4o",
  "systemMessage": "You are a company HR assistant. Answer questions based on the provided documents. If the information is not in the documents, say that you don't have that information.",
  "tools": ["pineconeVectorStore", "httpRequest"],
  "maxIterations": 3,
  "temperature": 0.3
}

Return the AI response as JSON

// Before using the RAG workflow,
// you need to index your documents into Pinecone first
 
// Additional workflow: Document Indexer
// Trigger: Manual (or scheduled)
 
const documents = [
  {
    text: "Annual leave policy: Every employee is entitled to 12 days of leave per year.",
    metadata: { category: "policy", source: "hr-handbook.pdf" }
  },
  {
    text: "Sick leave: Employees can take sick leave with a doctor's note.",
    metadata: { category: "policy", source: "hr-handbook.pdf" }
  },
  // ... other documents
];
 
// Save to Pinecone using the n8n Pinecone node
// or another supported vector store

[Email Trigger] → [Switch Node] → [Auto-Reply (Sales)]
                    ↓
              [Auto-Reply (Support)]
                    ↓
              [Auto-Reply (General)]

{
  "mailbox": "INBOX",
  "options": {
    "forceReconnect": "everyMinute"
  }
}

// Classify based on email subject
const subject = $input.first().json.subject.toLowerCase();
 
let category = 'general';
 
if (subject.includes('sale') || subject.includes('price') || subject.includes('demo')) {
  category = 'sales';
} else if (subject.includes('error') || subject.includes('bug') || subject.includes('help')) {
  category = 'support';
}
 
return { json: { ...$input.first().json, category } };

// Reply templates for each category
const templates = {
  sales: {
    subject: 'Re: {{ $json.subject }}',
    body: `Hello!
 
Thank you for reaching out. Our sales team will get back to you shortly.
 
For a quick reference, here's our demo link: https://example.com/demo
 
Best regards,
Sales Team`
  },
  support: {
    subject: 'Re: {{ $json.subject }}',
    body: `Hello!
 
We've received your report. Our support team will follow up within 24 hours.
 
In the meantime, you can check our FAQ at: https://example.com/faq
 
Best regards,
Support Team`
  },
  general: {
    subject: 'Re: {{ $json.subject }}',
    body: `Hello!
 
Thank you for reaching out. We've received your email and will process it shortly.
 
Best regards,
Our Team`
  }
};

// Add error handling at every critical workflow point
// Node: IF
// Condition: {{ $json.error }} exists
// True → send error notification
// False → continue workflow

// Use batching for operations involving large amounts of data
// Node: Split In Batches
// Batch Size: 50 (or adjust to match API limits)

# 1. Always use environment variables for credentials
# 2. Use a strong encryption key
# 3. Restrict access to the n8n editor
# 4. Use HTTPS for webhooks
# 5. Back up the database regularly

# Enable log streaming to SIEM
# Example: send logs to Elasticsearch
LOG_OUTPUT=console
EXECUTIONS_DATA_SAVE_ON_SUCCESS=all
EXECUTIONS_DATA_SAVE_ON_ERROR=all

# Export workflows as JSON and store them in Git
# n8n supports Git-based workflow management
# in the enterprise edition

# 1. Install and run n8n
docker volume create n8n_data
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n
 
# 2. Open http://localhost:5678
# 3. Create an admin account
# 4. Import a workflow template from https://n8n.io/workflows
# 5. Explore and experiment!