chain-llm-pattern

分类: 数据与AI | 上传者: masteranime | 下载: 0 | 版本: v1.0（最新）

使用 Groq、OpenAI 或 Claude 在 n8n 中构建多步骤 LLM 推理链，以进行结构化数据提取、分类、评分和分析。每当用户想要在 n8n 工作流程中将多个 LLM 调用链接在一起时，请使用此技能 - 例如“提取实体然后分类”、“多步骤 LLM 提示”、“chain_llm”、“LLM 管道”、“分类和评分”、“实体提取然后丰富”等短语。还可以在通过 n8n 中的多个分析过程处理通话记录、客户消息或任何非结构化文本时使用。当输出需要提取和推理时，更喜欢这种模式而不是单次提示，因为单次提示会产生类别，而链让每个步骤验证前一个步骤。

更新日志: Source: GitHub https://github.com/masteranime/n8n-claude-skills

目录结构

当前层级: tree/main/skills/chain-llm-pattern/

📁 references/
- 📄 groq-chain-example.json 7.2 KB
📄 SKILL.md 5.7 KB

SKILL.md

---
name: chain-llm-pattern
description: Build multi-step LLM reasoning chains in n8n using Groq, OpenAI, or Claude for structured data extraction, categorization, scoring, and analysis. Use this skill whenever the user wants to chain multiple LLM calls together in an n8n workflow — phrases like "extract entities then categorize", "multi-step LLM prompt", "chain_llm", "LLM pipeline", "classify and score", "entity extraction then enrichment". Also use when processing call transcripts, customer messages, or any unstructured text through multiple analysis passes in n8n. Prefer this pattern over single-shot prompts whenever the output requires both extraction AND reasoning, since single-shot hallucinates categories while chains let each step verify the previous.
---

# Chain LLM Pattern for n8n

Multi-step LLM chains outperform single-shot prompts on any task that combines extraction + reasoning. This skill encodes the production pattern.

## When to use a chain vs a single prompt

| Single prompt works | Chain is better |
|---|---|
| "Summarize this email" | "Extract entities, then categorize by urgency, then decide routing" |
| "Translate this to English" | "Detect language, translate, then extract structured fields" |
| "Is this spam? yes/no" | "Score spam probability from email, phone, IP, content separately, then combine" |

Rule of thumb: if the task has ≥2 distinct reasoning steps OR the final decision depends on intermediate structured data, use a chain.

## The pattern (3-stage default)

```
Input → [Extract] → [Analyze/Classify] → [Score/Decide] → Output
```

Each stage is its own LLM node with its own prompt. Between stages, use `Set` or `Code` nodes to transform and validate.

### Stage 1: Extract (schema-bound)

Use **`Information Extractor`** node (LangChain). NOT a generic `AI Agent` or raw HTTP call.

Why: `Information Extractor` binds output to a JSON schema. It parses, retries on invalid JSON, and fails loudly — instead of silently returning prose you then regex.

Define schema explicitly:

```json
{
  "type": "object",
  "properties": {
    "customer_name": { "type": "string" },
    "product_mentioned": { "type": "string" },
    "sentiment": { "enum": ["positive", "neutral", "negative"] },
    "urgency_score": { "type": "number", "minimum": 0, "maximum": 10 }
  },
  "required": ["customer_name", "sentiment"]
}
```

System prompt for this stage: short, one job. "Extract the fields defined in the schema from the transcript. If a field is absent, omit it. Do not infer or guess."

### Stage 2: Analyze (reason over extracted data)

Use **`Basic LLM Chain`** with the extracted JSON from Stage 1 as input.

This stage reasons: categorize, cluster, identify patterns, detect issues. The input is structured (from Stage 1) so the model isn't juggling parsing + reasoning simultaneously.

Example system prompt:
> Given the extracted customer data below, classify into one of: [technical_issue, billing_question, cancellation_risk, upsell_opportunity]. Then identify the single most important next action. Return JSON with `category` and `next_action`.

### Stage 3: Score / decide (deterministic where possible)

If the final step is arithmetic (e.g., composite scoring: 0.4 × email_score + 0.3 × phone_score + 0.3 × content_score), use a **`Code` node**, NOT an LLM.

LLMs are bad at arithmetic. They fail silently. Use `Code` (JavaScript) for any math involving weights, thresholds, or aggregation.

## Model selection

| Stage | Recommended model | Why |
|---|---|---|
| Extract | Groq `llama-3.3-70b-versatile` or `openai/gpt-4o-mini` | Fast, cheap, good at schema adherence |
| Analyze | Claude Sonnet 4 or GPT-4o | Reasoning quality matters more |
| Score (if LLM) | `gpt-4o-mini` | Arithmetic weakness, keep cheap |

Groq is the fastest provider for extract stages — 500+ tokens/sec. Use it unless you need Claude/OpenAI specifically.

## Production rules

1. **Pin example data at each stage during development.** Right-click node → "Pin Data". Without pinning, changing Stage 1 invalidates all downstream test data and you waste API calls.

2. **Budget tokens explicitly.** Set `maxTokens` on every LLM node. Stage 1 extract rarely needs >500. Stage 2 analyze rarely >1000.

3. **Validate between stages.** Insert a `Code` node between LLM stages that checks required fields exist. Fail fast with a clear error — don't let a missing field propagate and produce a confusing Stage 3 failure.

4. **Log stage outputs.** Add a `MySQL` or `Google Sheets` insert after Stage 1 and Stage 2 that records the raw output (truncated to 1000 chars). You WILL need this for debugging.

5. **Temperature: 0 for extract, 0.2–0.4 for analyze, 0 for scoring.** Extract must be deterministic. Analysis benefits from slight variance. Scoring must be deterministic.

## Common multi-language variant (EN/ES/PT)

For transcripts in mixed languages, add a Stage 0:

```
Stage 0 (Groq): Detect language → route to language-specific prompts
Stage 1 (language-specific): Extract in source language
Stage 2: Translate structured output to English (cheap, short)
Stage 3: Analyze in English
```

Language-specific prompts extract better than a single multilingual prompt because entity names (cities, products) follow different patterns per language.

## Anti-patterns

- **Don't use `AI Agent` for extraction.** Agents are for tool use, not structured output. Use `Information Extractor`.
- **Don't concatenate all steps into one mega-prompt.** Each hallucination compounds. Separate stages let you evaluate each independently.
- **Don't loop an LLM on retry without a counter.** Infinite loops cost money. Cap retries at 3 via a counter in a `Set` node.

## Reference

- `references/groq-chain-example.json` — a working 4-node chain ready to import into n8n

登录后下载/点赞/收藏 ❤ 17 | ★ 0

chain-llm-pattern

目录结构

SKILL.md

举报内容

提示