Quick Summary: Build a complex, battle-tested n8n workflow for real-time sentiment analysis using LLMs. Master API integration, robust error handling, and node e...

You're here because you demand efficiency. You understand that manual processes are a drain, a bottleneck, a relic. We're not just automating; we're architecting a robust, production-grade system with n8n. Our mission: turn raw customer feedback into actionable, categorized insights, powered by an LLM, and delivered precisely where it's needed. This isn't theoretical; this is battle-tested.

Consider this your blueprint for a complex n8n workflow that pulls customer feedback, leverages an AI model for sentiment analysis and keyword extraction, and routes critical insights to your team. We’ll cover everything from data ingestion to sophisticated error handling. Let's build.

The Architecture: A Multi-Stage Processing Pipeline

Our workflow operates in distinct, logical stages, ensuring modularity and easier debugging. Each stage is an n8n node, meticulously configured for peak performance.

1. Ingestion: Scheduled daily fetch from a Google Sheet.
2. Pre-processing: Prepare data for the LLM API.
3. AI Brain: Call an LLM API for sentiment and keyword analysis.
4. Post-processing: Parse LLM response and structure data.
5. Decision & Action: Route based on sentiment; log all results.

Step-by-Step Implementation

1. Trigger & Data Ingestion (Cron & Google Sheets)

Start with a Cron node. Set it to trigger daily at a low-traffic hour. Connect this to a Google Sheets node. Configure it to read data from your feedback sheet, pulling all rows since the last run. Ensure your sheet has columns like feedback_id, customer_email, and feedback_text.

2. Data Preparation (Code Node)

The raw Google Sheet data needs cleaning and formatting for our LLM. Use a Code node. This is where we craft the precise JSON payload the LLM expects. We’ll iterate through each incoming item (each feedback entry) and format it.

for (const item of items) {
  const feedbackText = item.json.feedback_text;
  item.json.llmPayload = {
    "model": "mistral-tiny", // Or your preferred LLM model
    "messages": [
      {"role": "system", "content": "You are a sentiment analysis and keyword extraction expert. Analyze the following customer feedback."}, 
      {"role": "user", "content": `Analyze sentiment (positive, negative, neutral) and extract up to 3 key topics/keywords from this feedback: "${feedbackText}"`}
    ]
  };
  output.push(item);
}

3. LLM Integration (HTTP Request)

Now, the core intelligence. Add an HTTP Request node. Configure it to POST to your LLM provider's API endpoint (e.g., https://api.mistral.ai/v1/chat/completions). Set the HTTP Method to POST. The Body Parameters should be JSON, and the Body will be the llmPayload we created in the previous Code node. Authenticate using an API Key (Bearer Token) credential. For LLM choices, consider options like Mistral 7B v0.3: The Production Beast You're Ignoring (And Why You're Wrong) for its efficiency.

4. Response Post-processing (Code Node)

The LLM response needs parsing. Add another Code node. Extract the sentiment and keywords from the LLM’s JSON output. This will likely involve traversing nested JSON paths.

for (const item of items) {
  try {
    const llmResponse = item.json.llmPayload.data.choices[0].message.content;
    // Simple regex or string parsing for sentiment and keywords
    const sentimentMatch = llmResponse.match(/Sentiment:\s*(positive|negative|neutral)/i);
    const keywordsMatch = llmResponse.match(/Keywords:\s*(.*)/i);

    item.json.sentiment = sentimentMatch ? sentimentMatch[1].toLowerCase() : 'unknown';
    item.json.keywords = keywordsMatch ? keywordsMatch[1].split(',').map(k => k.trim()) : [];

  } catch (error) {
    console.error("Error parsing LLM response:", error.message);
    item.json.sentiment = 'error_parsing';
    item.json.keywords = [];
  }
  output.push(item);
}

5. Conditional Routing & Actions (IF & Slack)

Use an IF node to branch the workflow. If item.json.sentiment is 'negative', route it to a Slack node. Configure the Slack node to send a message to your support channel, including feedback_id, customer_email, and the original feedback_text. For all sentiment types, you might want a second branch to insert the processed data (including sentiment and keywords) into a database via another HTTP Request node (e.g., to a custom API endpoint or PostgreSQL via Gravity-Defying Scale: Engineering Distributed Systems at FAANG principles).

Node Breakdown: Essential Components

A quick reference for the core nodes used:

Node	Core Function	API Credential Requirements
Cron	Schedule workflow execution	N/A
Google Sheets	Read/Write data to Google Sheets	Google Sheets OAuth2
Code	Custom JavaScript logic for data transformation, advanced manipulation, error handling	N/A (or passed within code for external calls)
HTTP Request	Make HTTP calls to any external API (LLM, Database, etc.)	API Key (Bearer/Custom Header), Basic Auth, OAuth2
IF	Conditional branching based on data values	N/A
Slack	Send messages, create posts, or retrieve data from Slack	Slack OAuth2
Try/Catch	Robust error handling for any failing branch	N/A

Production Gotchas

Forewarned is forearmed. These obscure edge-cases can cripple your workflow if not anticipated.

1. The LLM Rate Limit Trap

LLM APIs, especially under heavy load, will rate-limit you. Default n8n retries are often too simplistic. The problem is a generic retry won't implement exponential backoff or respect Retry-After headers. You'll smash against the wall repeatedly. The solution? Wrap your HTTP Request to the LLM within a Try/Catch block. In the Catch branch, use a Code node to implement custom exponential backoff. Track the attempt count in context data. Introduce a Wait node based on the backoff calculation before looping back via a conditional path to re-attempt the HTTP Request. This requires careful state management, but it ensures resilience.

2. JSON Payload Mapping – The Array Flattening Nightmare

You’ve fetched data from API_A, which returns an array of objects: {"items": [{"id": 1, "name": "A"}, {"id": 2, "name": "B"}]}. Your next node, let's say a Set node, tries to map a field like "itemId": "{{ $json.items.id }}". n8n might implicitly try to flatten this, often resulting in only the first item's ID being mapped, or an error if the downstream system expects a single value. The fix is to use an Item Lists node (specifically 'Split Out Items') or a Split In Batches node immediately after receiving the array. This transforms the single incoming item with an array into multiple individual items, each containing one element of the original array, allowing subsequent nodes to process them correctly one by one. Always inspect the JSON output of each node meticulously.

Workflow Implementation Snippet (Code Node Logic)

While a full n8n workflow JSON is extensive, here's the core logic for a Code Node that dynamically retries an HTTP request with exponential backoff if a 429 (Too Many Requests) is encountered, before ultimately failing.

const MAX_RETRIES = 3;

// Get data from previous node (e.g., `feedback_text`)
const feedbackItems = items.map(item => item.json);

// Iterate over each item to process
for (let i = 0; i < feedbackItems.length; i++) {
  let currentItem = feedbackItems[i];
  let retries = currentItem.retryCount || 0;
  let success = false;

  while (!success && retries < MAX_RETRIES) {
    try {
      const llmPayload = {
        "model": "mistral-tiny",
        "messages": [
          {"role": "system", "content": "You are a sentiment analysis expert."}, 
          {"role": "user", "content": `Analyze sentiment of: "${currentItem.feedback_text}"`}
        ]
      };

      // This part simulates an HTTP Request node call
      // In a real n8n workflow, you'd use the HTTP Request node itself
      // and handle retries with Try/Catch and branching logic.
      // For this Code node example, we'll simulate the call.
      const response = await n8n.helpers.httpRequest({
        method: 'POST',
        url: 'https://api.mistral.ai/v1/chat/completions',
        headers: {
          'Authorization': `Bearer {{ $connections.mistralApi.accessToken }}`, // Use n8n connection credentials
          'Content-Type': 'application/json'
        },
        body: llmPayload,
        json: true
      });

      // Parse LLM response
      currentItem.sentiment = response.choices[0].message.content.match(/Sentiment:\s*(positive|negative|neutral)/i)[1].toLowerCase();
      success = true;

    } catch (error) {
      if (error.statusCode === 429) {
        retries++;
        currentItem.retryCount = retries;
        const delay = Math.pow(2, retries) * 1000; // Exponential backoff
        console.warn(`Rate limited. Retrying in ${delay / 1000} seconds. Attempt ${retries}/${MAX_RETRIES}`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        console.error("LLM API Error:", error.message);
        currentItem.sentiment = 'api_error';
        success = true; // Exit loop on non-429 error
      }
    }
  }
  
  if (!success) {
    currentItem.sentiment = 'failed_after_retries';
  }
  output.push(currentItem);
}

This Code node example demonstrates the logic for handling retries. In a real n8n setup, you’d typically use a Try/Catch node, an IF node to check for 429 status, a Wait node for delay, and then route back to the HTTP Request using a conditional path for actual retries, managed by a counter stored in item data. The critical takeaway is to build explicit retry mechanisms for external APIs.

Conclusion

You now possess the foundational knowledge to construct an n8n workflow that's not just functional, but resilient. Automate not just to save time, but to build systems that operate with unwavering reliability. Test, iterate, and continuously optimize. The digital battlefield is unforgiving; your automations must be bulletproof.