How to Fix Workflow Crashes on Large Responses from Gemini in n8n

Open your workflow and click on the AI Agent or Basic LLM Chain node. Under the Language Model section, click the Gemini Chat Model sub-node. In the Options section, set 'Maximum Number of Tokens' to a safe value such as 4096 or 8192. This prevents Gemini from generating unbounded responses that consume excessive memory. The exact limit depends on your use case — summarization tasks can often use 1024, while code generation may need 4096. Setting this value is the single most effective fix for memory-related crashes.

Even with token limits, edge cases can produce unexpectedly large payloads. Add a Code node after your LLM node to validate and truncate the response. Set the Code node to 'Run Once for Each Item' mode. This acts as a safety net — if the response exceeds your maximum allowed character count, it gets truncated with an indicator that content was cut. This prevents downstream nodes from choking on massive strings.

1const MAX_CHARS = 50000;
2
3for (const item of $input.all()) {
4  const text = item.json.text || item.json.output || '';
5  if (text.length > MAX_CHARS) {
6    item.json.text = text.substring(0, MAX_CHARS) + '\n\n[Response truncated — exceeded ' + MAX_CHARS + ' characters]';
7    item.json.was_truncated = true;
8  } else {
9    item.json.was_truncated = false;
10  }
11}
12
13return $input.all();

If you self-host n8n and frequently process large LLM responses, increase the Node.js memory limit. For Docker deployments, set the NODE_OPTIONS environment variable in your docker-compose.yml or container configuration. The default heap is about 1.4 GB; raising it to 4 GB gives you significant headroom for concurrent large responses. On n8n Cloud, you cannot change this directly — focus on token limits and truncation instead.

1# Docker Compose example
2services:
3  n8n:
4    image: n8nio/n8n:latest
5    environment:
6      - NODE_OPTIONS=--max-old-space-size=4096
7      - N8N_DEFAULT_BINARY_DATA_MODE=filesystem
8    volumes:
9      - n8n_data:/home/node/.n8n
10      - n8n_files:/files

If you are sending large documents to Gemini for summarization or analysis, split them into smaller chunks using a Code node before the LLM call. This reduces the likelihood that Gemini generates a massive single response and also avoids hitting context length limits. Use the SplitInBatches node after the Code node to process chunks sequentially, then aggregate results in a final Code node.

1const fullText = $json.document_text || '';
2const CHUNK_SIZE = 8000;
3const chunks = [];
4
5for (let i = 0; i < fullText.length; i += CHUNK_SIZE) {
6  chunks.push({
7    json: {
8      chunk_index: Math.floor(i / CHUNK_SIZE),
9      chunk_text: fullText.substring(i, i + CHUNK_SIZE),
10      total_chunks: Math.ceil(fullText.length / CHUNK_SIZE)
11    }
12  });
13}
14
15return chunks;

Configure error handling on your AI Agent or LLM Chain node so that if a crash does occur, the workflow does not silently fail. Click the node, go to Settings, and enable 'Continue On Fail'. Then add an IF node after it to check for errors. Route error cases to a notification node (such as Slack or Email) so you know when a response was too large. This does not prevent the crash but ensures you are notified and can act on it.

1// In a Code node after the LLM node (with Continue On Fail enabled)
2const items = $input.all();
3const results = [];
4
5for (const item of items) {
6  if (item.json.error) {
7    results.push({
8      json: {
9        status: 'error',
10        error_message: item.json.error.message || 'Unknown LLM error',
11        suggestion: 'Reduce prompt size or lower max tokens',
12        timestamp: new Date().toISOString()
13      }
14    });
15  } else {
16    results.push(item);
17  }
18}
19
20return results;