How to Fix Variable Scoping Issues with User Context in n8n Prompts

In n8n, each node receives data from its directly connected upstream node. The data is an array of items, each with a json property containing the node's output. The expression $json refers to the first item from the immediately previous node. To access data from a node further upstream, you must use the $('NodeName') syntax which looks up the output of any executed node by name. Critically, $('NodeName') only works for nodes that are in the same execution branch and have already executed. If a node is on a parallel branch that has not been merged, its output is inaccessible. Understanding this scoping model is essential for building prompts that require data from multiple sources.

1// $json = first item from immediately previous node
2// $input.all() = all items from immediately previous node
3// $('Webhook').first().json = first item from the 'Webhook' node
4// $('Database Query').all() = all items from the 'Database Query' node
5// $('Set User Data').first().json.name = specific field from a named node

Open the LLM node (AI Agent or Basic LLM Chain) and click on the expression editor for the prompt or system message field. Use the variable selector on the left panel to browse available data from upstream nodes. Nodes that appear in the selector are in scope; those that are missing are either on an unmerged parallel branch or have not been connected upstream. For each variable in your prompt that shows 'undefined', check whether the source node appears in the variable selector. If it does not, you have a scoping issue. Note which nodes are missing and trace the workflow connections to understand why they are out of scope.

If your user context data comes from parallel branches (e.g., one branch fetches user profile from a database while another fetches conversation history from Redis), these branches must be merged before the data reaches the LLM node. Add a Merge node that combines both branches. Use the Combine mode with Merge by Position to create a single item that contains data from both branches. Then use a Code node after the Merge to combine the fields from both sources into a clean context object. Without the Merge, the LLM node only sees data from whichever branch is directly connected to it.

1// Code node after Merge: Combine context from both branches
2// Mode: Run Once for All Items
3
4const items = $input.all();
5
6// After Merge by Position, each item has fields from both branches
7const merged = items[0]?.json || {};
8
9// Build consolidated context
10const context = {
11  // From database branch
12  userName: merged.name || merged.userName || 'User',
13  email: merged.email || '',
14  plan: merged.subscriptionPlan || 'free',
15  
16  // From conversation history branch
17  previousMessages: merged.messages || merged.history || [],
18  lastInteraction: merged.lastMessageAt || null,
19  
20  // From webhook (original trigger)
21  currentMessage: merged.message || merged.text || '',
22  sessionId: merged.sessionId || ''
23};
24
25return [{ json: context }];

The most reliable approach is to add a Code node immediately before the LLM node that collects all necessary data into a single context object. This node uses the $('NodeName') syntax to reach back to any upstream node, regardless of how many nodes are between them. It then outputs a single item with all fields the LLM prompt needs. The LLM node can then reference any field with simple $json.fieldName expressions. This pattern centralizes all data access in one place, making it easy to debug and maintain.

1// Code node: Context Collector
2// Mode: Run Once for All Items
3
4// Reach back to specific upstream nodes
5const webhookData = $('Webhook').first().json;
6const userData = $('Fetch User Profile').first().json;
7const historyData = $('Load Chat History').all();
8
9// Build the context object
10const context = {
11  // User identity
12  chatInput: webhookData.body?.message || '',
13  sessionId: webhookData.body?.sessionId || '',
14  
15  // User profile
16  userName: userData.name || 'User',
17  userPlan: userData.plan || 'free',
18  userTimezone: userData.timezone || 'UTC',
19  
20  // Conversation history (last 10 messages)
21  conversationHistory: historyData
22    .slice(-10)
23    .map(item => ({
24      role: item.json.role,
25      content: item.json.content
26    })),
27  
28  // Dynamic system prompt additions
29  systemContext: `The user's name is ${userData.name || 'User'}. `
30    + `They are on the ${userData.plan || 'free'} plan. `
31    + `Their timezone is ${userData.timezone || 'UTC'}.`
32};
33
34return [{ json: context }];

When an upstream node outputs multiple items (e.g., a database query returning multiple rows), the LLM node processes each item separately by default. If you need all items combined into a single prompt (e.g., a list of user orders to summarize), you must aggregate them first. Use a Code node set to Run Once for All Items that collects all items and combines them into a single output item. Format arrays as readable text for the prompt: convert rows to a numbered list or a formatted table. Do not pass raw JSON arrays to the LLM prompt unless you specifically want JSON output.

1// Code node: Aggregate multiple items into single prompt context
2// Mode: Run Once for All Items
3
4const items = $input.all();
5
6// Example: Convert order records into a readable list
7const orders = items.map((item, i) => {
8  const o = item.json;
9  return `${i + 1}. Order #${o.orderId} - ${o.product} - $${o.amount} - ${o.status}`;
10});
11
12const orderSummary = orders.length > 0
13  ? `The user has ${orders.length} recent orders:\n${orders.join('\n')}`
14  : 'The user has no recent orders.';
15
16return [{
17  json: {
18    orderContext: orderSummary,
19    totalOrders: orders.length
20  }
21}];

With the context object built in the previous step, configure your LLM node to reference it with straightforward expressions. In the AI Agent's system message, use {{ $json.systemContext }}. In the prompt or chatInput field, use {{ $json.chatInput }}. If you need to inject the order summary into the system prompt, include {{ $json.orderContext }} in the system message template. Because the Code node outputs a single item with all fields at the top level, every expression is a simple $json.fieldName lookup with no complex paths or node name references needed. This makes the LLM node configuration clean and easy to maintain.

1// AI Agent node configuration:
2
3// System Message field:
4// {{ $json.systemContext }}
5// 
6// The user's recent order history:
7// {{ $json.orderContext }}
8
9// Prompt / chatInput field:
10// {{ $json.chatInput }}
11
12// Session ID (in Memory sub-node):
13// {{ $json.sessionId }}