@n8n/n8n-nodes-langchain
Version:
317 lines • 15.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TextClassifier = void 0;
const output_parsers_1 = require("@langchain/classic/output_parsers");
const sleep_1 = require("@n8n/utils/sleep");
const n8n_workflow_1 = require("n8n-workflow");
const ai_utilities_1 = require("@n8n/ai-utilities");
const langchainParserError_1 = require("../../../utils/output_parsers/langchainParserError");
const classification_1 = require("./classification");
const processItem_1 = require("./processItem");
const SYSTEM_PROMPT_TEMPLATE = "Please classify the text provided by the user into one of the following categories: {categories}, and use the provided formatting instructions below. Don't explain, and only output the json.";
const configuredOutputs = (parameters) => {
const categories = parameters.categories?.categories ?? [];
const fallback = parameters.options?.fallback;
const ret = categories.map((cat) => {
return { type: 'main', displayName: cat.category };
});
if (fallback === 'other')
ret.push({ type: 'main', displayName: 'Other' });
return ret;
};
const OTHER_LABEL = 'Other';
function routeItem(options) {
const { result, item, itemIndex, categories, hasOtherBranch, withConfidence, returnData } = options;
const scores = result.scores
? Object.fromEntries(categories
.filter((category) => result.scores?.[category.category] !== undefined)
.map((category) => [category.category, result.scores?.[category.category]]))
: undefined;
const copy = (label, decisionKey) => {
const json = { ...item.json };
if (withConfidence) {
const confidence = result.scores?.[decisionKey];
json.classification = {
category: label,
...(confidence !== undefined && { confidence }),
...(scores && Object.keys(scores).length > 0 && { scores: { ...scores } }),
};
}
return { ...item, json, pairedItem: { item: itemIndex } };
};
categories.forEach((category, index) => {
if (result.matched.includes(category.category))
returnData[index].push(copy(category.category, category.category));
});
if (hasOtherBranch && result.fallback)
returnData[returnData.length - 1].push(copy(OTHER_LABEL, classification_1.FALLBACK_KEY));
}
class TextClassifier {
constructor() {
this.description = {
displayName: 'Text Classifier',
name: 'textClassifier',
icon: 'node:text-classifier',
iconColor: 'black',
group: ['transform'],
version: [1, 1.1],
description: 'Classify your text into distinct categories',
codex: {
categories: ['AI'],
subcategories: {
AI: ['Chains', 'Root Nodes'],
},
resources: {
primaryDocumentation: [
{
url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.text-classifier/',
},
],
},
},
defaults: {
name: 'Text Classifier',
},
inputs: [
{ displayName: '', type: n8n_workflow_1.NodeConnectionTypes.Main },
{
displayName: 'Model',
maxConnections: 1,
type: n8n_workflow_1.NodeConnectionTypes.AiLanguageModel,
required: true,
},
],
outputs: `={{(${configuredOutputs})($parameter)}}`,
builderHint: {
inputs: {
ai_languageModel: { required: true },
},
searchHint: 'Each category defined creates a separate output branch. Output 0 corresponds to the first category, output 1 to the second, and so on. Use .output(index).to() to connect from a specific category. @example textClassifier.output(0).to(nodeA) and textClassifier.output(1).to(nodeB)',
},
properties: [
{
displayName: 'Text to Classify',
name: 'inputText',
type: 'string',
required: true,
default: '',
description: 'Use an expression to reference data in previous nodes or enter static text',
typeOptions: {
rows: 2,
},
},
{
displayName: 'Categories',
name: 'categories',
placeholder: 'Add Category',
type: 'fixedCollection',
default: {},
typeOptions: {
multipleValues: true,
},
options: [
{
name: 'categories',
displayName: 'Categories',
values: [
{
displayName: 'Category',
name: 'category',
type: 'string',
default: '',
description: 'Category to add',
required: true,
},
{
displayName: 'Description',
name: 'description',
type: 'string',
default: '',
description: "Describe your category if it's not obvious",
},
],
},
],
},
{
displayName: 'Confidence scores are estimates from the model, not measured probabilities. They can change between runs, so treat them as a rough signal, not a threshold.',
name: 'confidenceScoresNotice',
type: 'notice',
default: '',
displayOptions: {
show: {
'/options.includeConfidenceScores': [true],
},
},
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
default: {},
placeholder: 'Add Option',
options: [
{
displayName: 'Allow Multiple Classes To Be True',
name: 'multiClass',
type: 'boolean',
default: false,
},
{
displayName: 'When No Clear Match',
name: 'fallback',
type: 'options',
default: 'discard',
description: 'What to do with items that don’t match the categories exactly',
options: [
{
name: 'Discard Item',
value: 'discard',
description: 'Ignore the item and drop it from the output',
},
{
name: "Output on Extra, 'Other' Branch",
value: 'other',
description: "Create a separate output branch called 'Other'",
},
],
},
{
displayName: 'Include Confidence Scores',
name: 'includeConfidenceScores',
type: 'boolean',
default: false,
description: "Whether to add a classification field to each item with the model's confidence score for every category",
},
{
displayName: 'System Prompt Template',
name: 'systemPromptTemplate',
type: 'string',
default: SYSTEM_PROMPT_TEMPLATE,
description: 'String to use directly as the system prompt template',
typeOptions: {
rows: 6,
},
},
{
displayName: 'Enable Auto-Fixing',
name: 'enableAutoFixing',
type: 'boolean',
default: true,
description: 'Whether to enable auto-fixing (may trigger an additional LLM call if output is broken)',
},
(0, ai_utilities_1.getBatchingOptionFields)({
show: {
'@version': [{ _cnd: { gte: 1.1 } }],
},
}),
],
},
],
};
}
async execute() {
const items = this.getInputData();
const batchSize = this.getNodeParameter('options.batching.batchSize', 0, 5);
const delayBetweenBatches = this.getNodeParameter('options.batching.delayBetweenBatches', 0, 0);
const llm = (await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiLanguageModel, 0));
const categories = this.getNodeParameter('categories.categories', 0, []);
if (categories.length === 0) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'At least one category must be defined');
}
const options = this.getNodeParameter('options', 0, {});
const multiClass = options?.multiClass ?? false;
const fallback = options?.fallback ?? 'discard';
const withConfidence = options?.includeConfidenceScores ?? false;
const reserved = withConfidence ? (0, classification_1.findReservedCategory)(categories) : undefined;
if (reserved) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The category name "${reserved}" is reserved when confidence scores are on`, {
description: 'The node reports the scores under that name. Rename the category, or turn off Include Confidence Scores.',
});
}
const schema = (0, classification_1.buildClassificationSchema)(categories, fallback === 'other', withConfidence);
const structuredParser = output_parsers_1.StructuredOutputParser.fromZodSchema(schema);
const parser = options.enableAutoFixing
? output_parsers_1.OutputFixingParser.fromLLM(llm, structuredParser)
: structuredParser;
const multiClassPrompt = multiClass
? 'Categories are not mutually exclusive, and multiple can be true'
: 'Categories are mutually exclusive, and only one can be true';
const fallbackPrompt = {
other: 'If no categories apply, select the "fallback" option.',
discard: 'If there is not a very fitting category, select none of the categories.',
}[fallback];
const returnData = Array.from({ length: categories.length + (fallback === 'other' ? 1 : 0) }, (_) => []);
if (this.getNode().typeVersion >= 1.1 && batchSize > 1) {
for (let i = 0; i < items.length; i += batchSize) {
const batch = items.slice(i, i + batchSize);
const batchPromises = batch.map(async (_item, batchItemIndex) => {
const itemIndex = i + batchItemIndex;
return await (0, processItem_1.processItem)(this, itemIndex, llm, parser, categories, multiClassPrompt, fallbackPrompt);
});
const batchResults = await Promise.allSettled(batchPromises);
batchResults.forEach((response, batchItemIndex) => {
const index = i + batchItemIndex;
if (response.status === 'rejected') {
const error = (0, langchainParserError_1.wrapLangChainParserError)(response.reason, this.getNode(), index);
if (this.continueOnFail()) {
returnData[0].push({
json: { error: error.message },
pairedItem: { item: index },
});
return;
}
else {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), error);
}
}
else {
routeItem({
result: response.value,
item: items[index],
itemIndex: index,
categories,
hasOtherBranch: fallback === 'other',
withConfidence,
returnData,
});
}
});
if (i + batchSize < items.length && delayBetweenBatches > 0) {
await (0, sleep_1.sleep)(delayBetweenBatches);
}
}
}
else {
for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
const item = items[itemIndex];
try {
const output = await (0, processItem_1.processItem)(this, itemIndex, llm, parser, categories, multiClassPrompt, fallbackPrompt);
routeItem({
result: output,
item,
itemIndex,
categories,
hasOtherBranch: fallback === 'other',
withConfidence,
returnData,
});
}
catch (error) {
const executionError = (0, langchainParserError_1.wrapLangChainParserError)(error, this.getNode(), itemIndex);
if (this.continueOnFail()) {
returnData[0].push({
json: { error: executionError.message },
pairedItem: { item: itemIndex },
});
continue;
}
throw executionError;
}
}
}
return returnData;
}
}
exports.TextClassifier = TextClassifier;
//# sourceMappingURL=TextClassifier.node.js.map