Context length exceeded errors in n8n AI workflows happen when the combined prompt, conversation history, and input data exceed the model's token limit. Fix this by limiting the memory window to the last few messages, summarizing long inputs before sending them to the LLM, and using vector store retrieval to send only relevant chunks instead of the entire document.
Why Context Length Errors Happen in n8n AI Workflows
Every language model has a maximum context window — the total number of tokens it can process in a single request. This includes the system prompt, conversation history, user input, and any injected context. When an n8n workflow sends more tokens than the model supports, the API returns a context length exceeded error. This commonly happens in chatbot workflows where conversation history grows with each message, in RAG workflows that inject large documents, or when user inputs are unexpectedly long. The solution is to manage how much data you send by limiting history, summarizing content, and retrieving only relevant chunks.
Prerequisites
- An n8n workflow using an LLM node (OpenAI, Anthropic, etc.)
- Basic understanding of tokens and context windows
- Familiarity with n8n's AI/LangChain nodes
Step-by-step guide
Understand your model's token limit
Understand your model's token limit
Check the maximum context window for the model you are using. GPT-4o supports 128K tokens, Claude 3.5 Sonnet supports 200K tokens, and GPT-3.5-turbo supports 16K tokens. Your total input (system prompt + history + user message + injected context) must stay under this limit. A rough rule: 1 token is approximately 4 characters in English. Use the model's documentation to find the exact limit.
Expected result: You know the maximum token limit for your model and can estimate how many tokens your workflow sends per request.
Limit the conversation memory window
Limit the conversation memory window
In chatbot workflows, each new message adds to the conversation history. Without limits, this history grows until it exceeds the context window. Use n8n's Window Buffer Memory node and set the Memory Window to a fixed number of messages (e.g., the last 10 messages). This keeps only recent messages and drops older ones. For the AI Agent node, connect a Window Buffer Memory sub-node and configure the window size.
1// Window Buffer Memory configuration:2// Memory Key: chat_history3// Window Size: 10 (keeps last 10 messages — 5 user + 5 assistant)4// Session ID: {{ $json.session_id }} (unique per user)56// This ensures conversation history never grows beyond 10 messages,7// keeping total token usage predictable.Expected result: Conversation history is limited to the last 10 messages. Older messages are dropped, preventing context overflow.
Summarize long inputs before the LLM call
Summarize long inputs before the LLM call
If user inputs or injected documents are long, summarize them before sending to the main LLM. Add a separate LLM call that takes the long text and produces a concise summary, then pass the summary to your main workflow LLM. This is cheaper than sending the full text and prevents context overflow.
1// Code node: Check input length and decide if summarization is needed2const input = $input.first().json.text;3const estimatedTokens = Math.ceil(input.length / 4);4const MAX_TOKENS = 3000;56if (estimatedTokens > MAX_TOKENS) {7 // Flag for summarization (route to LLM summarizer)8 return [{ json: { text: input, needs_summary: true, estimated_tokens: estimatedTokens } }];9} else {10 // Pass through directly11 return [{ json: { text: input, needs_summary: false, estimated_tokens: estimatedTokens } }];12}Expected result: Long inputs are routed to a summarization step. Short inputs pass through directly. The main LLM always receives manageable-sized input.
Use vector store retrieval instead of full documents
Use vector store retrieval instead of full documents
For RAG (Retrieval-Augmented Generation) workflows, do not inject entire documents into the prompt. Instead, split documents into chunks, store them in a vector database (e.g., Supabase Vector Store, Pinecone, or in-memory store), and retrieve only the most relevant chunks based on the user's question. n8n provides Vector Store nodes for this purpose. This way, you send only 3-5 relevant paragraphs instead of the entire document.
Expected result: The LLM receives only the most relevant document chunks (typically 500-2,000 tokens) instead of the full document, staying well within the context window.
Set max_tokens to control output length
Set max_tokens to control output length
The context window includes both input and output tokens. If your input is close to the limit, the model has no room for a response. Set the max_tokens parameter on your LLM node to reserve space for the output. For example, if your model supports 16K tokens and your input uses 12K, set max_tokens to 2,000 to leave a buffer.
1// In the LLM node settings:2// Max Tokens: 20003// Temperature: 0.74// Model: gpt-4o56// Rule of thumb:7// max_tokens = model_limit - estimated_input_tokens - 500 (buffer)Expected result: The model generates responses within the specified token limit. No context length errors occur because input plus max output stays within the model's window.
Complete working example
1// n8n Code node — Token estimation and context management2// Place before your LLM node to ensure inputs stay within limits34const MODEL_LIMITS = {5 'gpt-4o': 128000,6 'gpt-4o-mini': 128000,7 'gpt-3.5-turbo': 16384,8 'claude-3-5-sonnet': 200000,9 'claude-3-haiku': 20000010};1112// Configuration13const model = 'gpt-4o';14const maxOutputTokens = 2000;15const systemPromptTokens = 500; // estimate for your system prompt16const bufferTokens = 500;1718// Calculate available tokens for user input + history19const modelLimit = MODEL_LIMITS[model] || 16384;20const availableForInput = modelLimit - maxOutputTokens - systemPromptTokens - bufferTokens;2122// Get inputs23const userMessage = $input.first().json.user_message || '';24const chatHistory = $input.first().json.chat_history || [];25const context = $input.first().json.context || '';2627// Estimate tokens (rough: 1 token ≈ 4 chars)28function estimateTokens(text) {29 return Math.ceil(String(text).length / 4);30}3132let totalInputTokens = estimateTokens(userMessage) + estimateTokens(context);3334// Trim chat history from oldest to newest until it fits35let trimmedHistory = [...chatHistory];36while (trimmedHistory.length > 0) {37 const historyTokens = trimmedHistory.reduce(38 (sum, msg) => sum + estimateTokens(msg.content), 039 );40 if (totalInputTokens + historyTokens <= availableForInput) break;41 trimmedHistory.shift(); // remove oldest message42}4344// Truncate context if still too large45let trimmedContext = context;46const historyTokens = trimmedHistory.reduce(47 (sum, msg) => sum + estimateTokens(msg.content), 048);49const remaining = availableForInput - estimateTokens(userMessage) - historyTokens;5051if (estimateTokens(trimmedContext) > remaining) {52 trimmedContext = trimmedContext.substring(0, remaining * 4);53}5455return [{56 json: {57 user_message: userMessage,58 chat_history: trimmedHistory,59 context: trimmedContext,60 token_estimate: totalInputTokens + historyTokens + estimateTokens(trimmedContext),61 available_tokens: availableForInput,62 messages_trimmed: chatHistory.length - trimmedHistory.length63 }64}];Common mistakes when handling Context Length Exceeded Errors in n8n AI Workflows
Why it's a problem: Not limiting conversation memory, letting it grow with every message
How to avoid: Use the Window Buffer Memory node with a fixed window size (e.g., 10 messages). This drops older messages automatically.
Why it's a problem: Injecting entire documents into the system prompt
How to avoid: Split documents into chunks and use vector store retrieval to inject only the relevant sections. Full documents quickly exceed context limits.
Why it's a problem: Setting max_tokens too high for the remaining context space
How to avoid: Calculate: max_tokens should be less than (model_limit - input_tokens). If input is 14K tokens on a 16K model, set max_tokens to 1,500 or less.
Why it's a problem: Using a small context model (GPT-3.5 16K) for long conversations
How to avoid: Switch to a model with a larger context window like GPT-4o (128K) or Claude 3.5 Sonnet (200K) for multi-turn conversations with context injection.
Best practices
- Always set a memory window size on conversation memory nodes — never let history grow unbounded
- Estimate token usage before the LLM call and trim inputs proactively rather than waiting for errors
- Use vector store retrieval for document-heavy workflows instead of injecting full documents
- Reserve at least 2,000 tokens for the model's output by setting max_tokens appropriately
- Summarize long user inputs in a separate, cheaper LLM call before the main processing step
- Monitor token usage over time to identify workflows that are approaching context limits
- Choose models with larger context windows (GPT-4o 128K, Claude 200K) for complex multi-step conversations
- Use the IF node to route long inputs to a summarization path and short inputs directly to the LLM
Still stuck?
Copy one of these prompts to get a personalized, step-by-step explanation.
My n8n AI chatbot workflow throws a 'context length exceeded' error after a few messages. How do I limit the conversation memory window, summarize long inputs, and estimate token usage to prevent this error?
I keep hitting context length limits in my n8n LangChain workflow. How do I configure the Window Buffer Memory node and manage token usage across conversation turns?
Frequently asked questions
What does 'context length exceeded' mean?
It means the total number of tokens in your request (system prompt + conversation history + user input + injected context) exceeds the model's maximum context window. You need to reduce the input size.
How do I estimate how many tokens my input uses?
A rough estimate is 1 token per 4 characters in English. For precise counting, use a tokenizer library like tiktoken (for OpenAI models). Most LLM APIs also return token usage in their response headers.
What is the Window Buffer Memory node?
It is an n8n memory node that stores conversation history but keeps only the most recent N messages. When the window is full, the oldest messages are dropped. This prevents conversation history from growing beyond the context limit.
Can I use multiple memory strategies together?
Yes. You can combine window-based memory (keep last 10 messages) with summarization (summarize dropped messages into a summary that stays in the prompt). This preserves context while staying within token limits.
Does this error cost me API credits?
Usually no. Most LLM APIs reject the request before processing it and do not charge for context length errors. However, the failed request still counts against rate limits.
Can RapidDev help design token-efficient n8n AI workflows?
Yes. RapidDev can architect AI workflows with optimized context management, memory strategies, and RAG pipelines that stay within token limits while maintaining conversation quality. Contact RapidDev for expert help.
Talk to an Expert
Our team has built 600+ apps. Get personalized help with your project.
Book a free consultation