AI for Text Analysis

Hello! Welcome back to our module on AI and LLM Integrations.

In our last lesson, you successfully built your first AI-powered workflow, learning how to connect n8n to OpenAI to generate text. You instructed the AI on what to do by giving it a persona and a prompt. We essentially turned n8n into a content creator.

Today, we're going to explore the other side of the coin: using AI for analysis. Instead of generating new content, we'll teach the AI to understand, categorize, and deconstruct existing unstructured text. This is a critical skill for automating real-world processes that deal with messy data like emails, documents, and customer feedback.

By the end of this lesson, you will be able to use AI to classify, summarize, or extract structured data from unstructured text. We'll cover three core AI capabilities:

1. Classification: Automatically categorizing text into predefined buckets (e.g., sentiment, support ticket type).
2. Summarization: Condensing long-form text into concise summaries.
3. Extraction: Pulling specific, structured information (like a JSON object) from a block of text.

An Architectural Choice: Specialized Nodes vs. the AI Agent

In the last lesson, we used the general-purpose AI Agent node. It's incredibly flexible, but for common tasks, n8n provides specialized, high-level nodes that are often easier and more reliable.

• Specialized AI Nodes: Text Classifier, Sentiment Analysis, Summarization Chain, Information Extractor. These are pre-configured for a single task, with optimized internal prompts. They are your go-to for standard jobs.
• The AI Agent Node: Your "Swiss Army knife". You can prompt it to do anything, but you're responsible for telling it how to do it and how to format the output. This is more powerful for custom or complex multi-step reasoning.

As a developer, you can think of this as using a dedicated library function (e.g., JSON.parse()) versus writing your own parser with regular expressions. The former is easier and more robust for the intended task, while the latter offers more control for unique cases. We will explore both approaches.

1. Classification: Bringing Order to Chaos

Classification is about assigning a label to a piece of text. Is this customer feedback positive or negative? Is this email a sales lead or a support request? AI excels at this.

n8n provides two key nodes for this: Sentiment Analysis and Text Classifier.

As you saw, these nodes abstract away the prompt engineering. You simply provide the text and the categories, and n8n handles the communication with the LLM.

Example: Classifying Support Emails

Let's look at a practical example. The following article from Codecademy demonstrates building an email support bot that uses an AI node to classify incoming emails as "SIMPLE", "COMPLEX", or "URGENT".

2. Summarization: Getting the Gist

Summarization is invaluable when dealing with large volumes of text. You can use it to get the essence of an article, a meeting transcript, or a long email thread before deciding how to act on it.

n8n has a dedicated Summarization Chain node for this purpose.

This task seems simple, but there's a key technical challenge: an LLM's context window. Models can only process a limited amount of text at once (a few thousand to a couple hundred thousand tokens). If your document is larger than the context window, you can't just send the whole thing.

The Summarization Chain node solves this with chunking strategies. It automatically breaks the large text into smaller pieces, summarizes each piece, and then combines the summaries. The "MapReduce" method mentioned in the video is a classic computer science pattern, applied here to LLMs.

3. Extraction: Creating Structure from Unstructured Text

This is arguably one of the most powerful uses of LLMs in automation. You can take a blob of text—like an email body or a PDF invoice—and extract a clean, predictable JSON object from it.

As a developer, this is the AI equivalent of creating a robust parser for inconsistent, human-generated text, without writing a single line of regex.

The Simple Way: Information Extractor Node

First, let's look at the specialized node for this task. It's great for simple extractions where you just need to pull out a few fields.

The "Pro" Way: AI Agent with a Structured Output Parser

The Information Extractor is good, but for more complex requirements, you'll want more control. The most robust method is to use the AI Agent node and explicitly tell it to return data in a specific JSON schema. This is done using an Output Parser.

The following video is a masterclass in this technique. It builds a workflow to extract structured data from resumes—a classic real-world problem.

By defining an output schema, you force the LLM to think in a structured way and provide a response that your workflow can reliably use in subsequent nodes, just like consuming a well-defined API endpoint.

Hands-On: Build an Intelligent Email Processor

Let's combine these concepts into a single workflow that processes an incoming customer email.

1. Create a new workflow. Start with a Manual trigger.
2. Add a Set node to simulate an incoming email. Name it Sample Email.
   • Set Mode to Set Key/Value Pairs.
   • Add a key named email_body (Type: String).
   • For the value, paste this text:

     Hi, I'm writing to complain about my recent order #A-12345. The Quantum Sprocket 9000 I received is faulty and shows 'Error 51'. I need a replacement immediately. This is very frustrating. Thanks, Bob.

3. Add a Text Classifier node connected to the Set node.
   • Text to Classify: Use an expression to get the email body: {{ $json.email_body }}
   • Categories: Add two categories:
     • Name: Complaint, Description: The user is unhappy, complaining, or expressing frustration.
     • Name: Question, Description: The user is asking a question or requesting information.
   • Make sure you have your OpenAI (or other) credential and a model selected.
4. Add an IF node to route based on the classification.
   • Add a condition: {{ $last.json.class }} String Equals Complaint.
   • This will create two outputs: true (for complaints) and false (for everything else).
5. Connect an AI Agent node to the true output. This will be our extractor.
   • Model: Connect your preferred chat model (e.g., OpenAI Chat Model).
   • Prompt (System Message): You are an expert at extracting key information from customer support emails. Extract the details from the user's message into a structured JSON format.
   • Prompt (User Message): {{ $('Sample Email').item.json.email_body }}
   • Output Parser: Add a Structured Output Parser.
   • Schema: Define a schema to extract the important details. Paste this JSON into the schema field:

     {
       "type": "object",
       "properties": {
         "order_number": {
           "type": "string",
           "description": "The customer's order number, if mentioned."
         },
         "product_name": {
           "type": "string",
           "description": "The name of the product the customer is writing about."
         },
         "issue_summary": {
           "type": "string",
           "description": "A brief summary of the customer's problem."
         }
       },
       "required": ["product_name", "issue_summary"]
     }
     

6. Execute the workflow.
   • Execute the Set node first, then the Text Classifier. It should output Complaint.
   • Now execute the AI Agent node. Inspect its output. You should see a clean JSON object with the extracted order_number, product_name, and issue_summary.

You've now built a workflow that can understand the intent of an email and then extract structured data from it, ready to be inserted into a database, sent to a Slack channel, or used to create a support ticket.

Conclusion

Today you've added three powerful AI analysis skills to your n8n toolkit. You've gone beyond simple text generation and learned how to make AI work as an analytical engine within your automations.

Key Takeaways:

• Classification lets you sort unstructured text into meaningful categories using nodes like Text Classifier.
• Summarization allows you to handle large documents by condensing them, using the Summarization Chain node which cleverly manages context window limits.
• Structured Data Extraction is a game-changer for automation, turning messy text into predictable JSON using either the simple Information Extractor or the more powerful AI Agent with a Structured Output Parser.
• Choosing between specialized nodes and the general AI Agent is a key architectural decision based on the complexity and specificity of your task.

Preview of the Next Lesson:

So far, our AI interactions have been one-shot requests. In the next lesson, "Manage conversation history for stateful, chat-based AI workflows," we'll revisit the concept of Memory that we touched on in the first lesson. You'll learn how to manage and manipulate conversation history to build sophisticated, multi-turn chatbots and agents that remember context over time.