用户输入 → LLM 处理 → 文本输出

目标设定 → 环境感知 → 计划制定 → 工具调用 → 任务执行

// Chatbot 模式
interface Chatbot {
  input: string;
  process(): string;  // 仅返回文本
}

// Agent 模式
interface Agent {
  goal: string;
  perceive(): Context;
  plan(context: Context): Action[];
  act(actions: Action[]): Result;
  tools: Tool[];  // 可调用外部工具
}

"根据天气预报,明天有 60% 的降雨概率。"

1. 调用天气 API 获取实时数据
2. 分析降雨概率
3. 如果 > 50%:
   - 发送提醒通知
   - 在日历中添加"带伞"备注
   - 调整出行计划建议
4. 返回综合建议

Preparing diagram...

interface PerceptionModule {
  sensors: Sensor[];
  context: Context;
  
  perceive(): EnvironmentState {
    const inputs = this.sensors.map(s => s.read());
    return this.buildState(inputs, this.context);
  }
}

interface PlanningModule {
  goal: Goal;
  state: EnvironmentState;
  
  async plan(): Promise<Action[]> {
    const prompt = `
      当前状态: ${this.state}
      目标: ${this.goal}
      
      请制定达成目标的步骤计划。
    `;
    
    const plan = await llm.generate(prompt);
    return this.parseActions(plan);
  }
}

interface ActionModule {
  tools: Tool[];
  
  async act(action: Action): Promise<Result> {
    const tool = this.tools.find(t => t.name === action.tool);
    return await tool.execute(action.parameters);
  }
}

class Agent {
  private perception: PerceptionModule;
  private planning: PlanningModule;
  private action: ActionModule;
  
  async run(goal: Goal): Promise<void> {
    while (!this.isGoalAchieved(goal)) {
      // 1. Perceive
      const state = this.perception.perceive();
      
      // 2. Plan
      this.planning.setState(state);
      const actions = await this.planning.plan();
      
      // 3. Act
      for (const action of actions) {
        const result = await this.action.act(action);
        
        // 更新状态
        this.perception.updateContext(result);
        
        // 检查是否需要重新规划
        if (this.needsReplanning(result)) {
          break;
        }
      }
    }
  }
}

Preparing diagram...

interface WorkflowExecution {
  id: string;
  workflowId: string;
  mode: 'manual' | 'trigger' | 'webhook';
  startedAt: Date;
  stoppedAt?: Date;
  status: 'running' | 'success' | 'error';
  data: ExecutionData;
}

interface ExecutionData {
  resultData: {
    runData: {
      [nodeName: string]: NodeRunData[];
    };
  };
}

interface NodeRunData {
  startTime: number;
  executionTime: number;
  data: {
    main: INodeExecutionData[][];
  };
}

Preparing diagram...

Webhook Trigger
  ↓
HTTP Request (调用 API)
  ↓
Set Node (数据转换)
  ↓
Slack (发送通知)

// 在 Set Node 中处理数据
{
  "processedData": "{{ $json.rawData.toUpperCase() }}",
  "timestamp": "{{ new Date().toISOString() }}",
  "isValid": "{{ $json.value > 100 }}"
}

// Code Node 示例
const items = $input.all();

const processed = items.map(item => {
  const data = item.json;
  
  // 复杂业务逻辑
  const result = complexCalculation(data);
  
  // 调用自定义库
  const enriched = await enrichData(result);
  
  return {
    json: enriched
  };
});

return processed;

# 基础安装
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

# 持久化 + 环境变量
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e N8N_BASIC_AUTH_USER=admin \
  -e N8N_BASIC_AUTH_PASSWORD=password \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

version: '3.8'

services:
  n8n:
    image: n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your_password
      - N8N_HOST=localhost
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - NODE_ENV=production
      - WEBHOOK_URL=http://localhost:5678/
    volumes:
      - ~/.n8n:/home/node/.n8n

# .env 文件
N8N_BASIC_AUTH_ACTIVE=true
N8N_BASIC_AUTH_USER=admin
N8N_BASIC_AUTH_PASSWORD=secure_password

# 数据库配置 (可选)
DB_TYPE=postgresdb
DB_POSTGRESDB_HOST=localhost
DB_POSTGRESDB_PORT=5432
DB_POSTGRESDB_DATABASE=n8n
DB_POSTGRESDB_USER=n8n
DB_POSTGRESDB_PASSWORD=n8n_password

# Webhook 配置
WEBHOOK_URL=https://your-domain.com/

# 执行模式
EXECUTIONS_MODE=regular
EXECUTIONS_TIMEOUT=300
EXECUTIONS_TIMEOUT_MAX=3600

# 启动后访问
http://localhost:5678

# 首次访问会要求:
# 1. 创建账户
# 2. 设置工作区名称
# 3. 选择使用场景

interface INode {
  name: string;
  type: string;
  position: [number, number];
  parameters: INodeParameters;
  credentials?: INodeCredentials;
}

interface INodeExecutionData {
  json: IDataObject;
  binary?: IBinaryKeyData;
  pairedItem?: IPairedItemData;
}

// 节点间数据传递
const nodeA_output = {
  json: {
    name: "John",
    age: 30,
    email: "john@example.com"
  }
};

// 在下游节点中访问
const nodeB_input = $json;  // 获取上游数据
const name = $json.name;    // "John"
const age = $json.age;      // 30

// 表达式语法
const fullName = "{{ $json.name }}";
const isAdult = "{{ $json.age >= 18 }}";
const upperEmail = "{{ $json.email.toUpperCase() }}";

// HTTP Request Node 配置
{
  "method": "POST",
  "url": "https://api.example.com/users",
  "authentication": "predefinedCredentialType",
  "nodeCredentialType": "httpBasicAuth",
  "sendHeaders": true,
  "headerParameters": {
    "parameters": [
      {
        "name": "Content-Type",
        "value": "application/json"
      }
    ]
  },
  "sendBody": true,
  "bodyParameters": {
    "parameters": [
      {
        "name": "name",
        "value": "={{ $json.name }}"
      },
      {
        "name": "email",
        "value": "={{ $json.email }}"
      }
    ]
  }
}

Preparing diagram...

{
  "rule": {
    "interval": [
      {
        "field": "cronExpression",
        "expression": "0 8 * * *"
      }
    ]
  }
}

{
  "method": "GET",
  "url": "https://api.openweathermap.org/data/2.5/weather",
  "qs": {
    "q": "Beijing",
    "appid": "YOUR_API_KEY",
    "units": "metric"
  }
}

const items = $input.all();
const weatherData = items[0].json;

const processed = {
  city: weatherData.name,
  temperature: weatherData.main.temp,
  weather: weatherData.weather[0].main,
  description: weatherData.weather[0].description,
  willRain: weatherData.weather[0].main.toLowerCase().includes('rain'),
  humidity: weatherData.main.humidity
};

return [{ json: processed }];

{
  "conditions": {
    "boolean": [
      {
        "value1": "={{ $json.willRain }}",
        "value2": true
      }
    ]
  }
}

{
  "channel": "#weather-alerts",
  "text": "🌧️ 今天会下雨！\n\n城市: {{ $json.city }}\n温度: {{ $json.temperature }}°C\n天气: {{ $json.description }}\n湿度: {{ $json.humidity }}%\n\n记得带伞哦！"
}

{
  "name": "Weather Alert Agent",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "cronExpression",
              "expression": "0 8 * * *"
            }
          ]
        }
      },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "position": [250, 300]
    },
    {
      "parameters": {
        "url": "https://api.openweathermap.org/data/2.5/weather",
        "qs": {
          "q": "Beijing",
          "appid": "YOUR_API_KEY",
          "units": "metric"
        }
      },
      "name": "Get Weather",
      "type": "n8n-nodes-base.httpRequest",
      "position": [450, 300]
    },
    {
      "parameters": {
        "jsCode": "const items = $input.all();\nconst weatherData = items[0].json;\n\nconst processed = {\n  city: weatherData.name,\n  temperature: weatherData.main.temp,\n  weather: weatherData.weather[0].main,\n  description: weatherData.weather[0].description,\n  willRain: weatherData.weather[0].main.toLowerCase().includes('rain'),\n  humidity: weatherData.main.humidity\n};\n\nreturn [{ json: processed }];"
      },
      "name": "Parse Weather",
      "type": "n8n-nodes-base.code",
      "position": [650, 300]
    },
    {
      "parameters": {
        "conditions": {
          "boolean": [
            {
              "value1": "={{ $json.willRain }}",
              "value2": true
            }
          ]
        }
      },
      "name": "Check Rain",
      "type": "n8n-nodes-base.if",
      "position": [850, 300]
    },
    {
      "parameters": {
        "channel": "#weather-alerts",
        "text": "🌧️ 今天会下雨！\\n\\n城市: {{ $json.city }}\\n温度: {{ $json.temperature }}°C\\n天气: {{ $json.description }}\\n湿度: {{ $json.humidity }}%\\n\\n记得带伞哦！"
      },
      "name": "Send Alert",
      "type": "n8n-nodes-base.slack",
      "position": [1050, 200]
    }
  ],
  "connections": {
    "Schedule Trigger": {
      "main": [[{ "node": "Get Weather", "type": "main", "index": 0 }]]
    },
    "Get Weather": {
      "main": [[{ "node": "Parse Weather", "type": "main", "index": 0 }]]
    },
    "Parse Weather": {
      "main": [[{ "node": "Check Rain", "type": "main", "index": 0 }]]
    },
    "Check Rain": {
      "main": [[{ "node": "Send Alert", "type": "main", "index": 0 }]]
    }
  }
}

// 理解数据流
console.log($json);  // 查看当前节点输入
console.log($input.all());  // 查看所有输入项
console.log($node["NodeName"].json);  // 访问特定节点输出

// 基础语法
{{ $json.field }}

// 函数调用
{{ $json.text.toUpperCase() }}
{{ $json.date.toISOString() }}

// 条件表达式
{{ $json.value > 100 ? 'high' : 'low' }}

// 数组操作
{{ $json.items.map(item => item.name) }}
{{ $json.items.filter(item => item.active) }}

❌ 错误: 一开始就构建复杂系统
✅ 正确: 从最小可用工作流开始,逐步迭代

在添加节点前,先理解:
- 输入数据结构是什么?
- 需要什么输出?
- 如何转换?

每个节点都要:
1. 查看输入数据
2. 执行节点
3. 验证输出
4. 再连接下一个节点

// 1. 批处理而非逐项处理
// ❌ 错误
for (const item of items) {
  await httpRequest(item);
}

// ✅ 正确
const batch = items.slice(0, 100);
await httpRequest(batch);

// 2. 使用缓存
const cache = new Map();
if (cache.has(key)) {
  return cache.get(key);
}

// 3. 限制并发
const limit = 5;
const chunks = chunkArray(items, limit);
for (const chunk of chunks) {
  await Promise.all(chunk.map(process));
}

// 1. 凭证管理
// ✅ 使用 n8n Credentials 系统
// ❌ 硬编码 API Key

// 2. 数据验证
function validateInput(data: unknown): boolean {
  // 验证数据结构
  // 防止注入攻击
  return isValid(data);
}

// 3. 错误处理
try {
  const result = await riskyOperation();
} catch (error) {
  // 记录错误
  // 不暴露敏感信息
  logger.error('Operation failed', { error: sanitize(error) });
}

// 1. 错误处理工作流
Trigger → Try → Main Logic → Catch → Error Handler

// 2. 并行处理
Trigger → Split → [Process A, Process B, Process C] → Merge

// 3. 循环处理
Trigger → Loop Start → Process → Decision → Loop End

// 4. 子工作流
Main Workflow → Execute Workflow → Sub Workflow

// 1. ReAct Agent
Perceive → Reason → Act → Observe → Repeat

// 2. Planning Agent
Goal → Plan → Execute Steps → Verify → Adjust

// 3. Multi-Agent
Coordinator → [Agent A, Agent B, Agent C] → Aggregator

interface ProjectIdea {
  name: string;
  complexity: 'beginner' | 'intermediate' | 'advanced';
  technologies: string[];
}

const projects: ProjectIdea[] = [
  {
    name: '智能客服 Agent',
    complexity: 'beginner',
    technologies: ['n8n', 'OpenAI', 'Slack']
  },
  {
    name: '内容创作自动化',
    complexity: 'intermediate',
    technologies: ['n8n', 'OpenAI', 'RAG', 'Database']
  },
  {
    name: '数据分析 Agent',
    complexity: 'advanced',
    technologies: ['n8n', 'LLM', 'Python', 'BI Tools']
  }
];