pull:初次提交

n8n-n8n-1.109.2/packages/@n8n/nodes-langchain/nodes/chains/ChainSummarization/ChainSummarization.node.ts

@@ -0,0 +1,41 @@
+import type { INodeTypeBaseDescription, IVersionedNodeType } from 'n8n-workflow';
+import { VersionedNodeType } from 'n8n-workflow';
+
+import { ChainSummarizationV1 } from './V1/ChainSummarizationV1.node';
+import { ChainSummarizationV2 } from './V2/ChainSummarizationV2.node';
+
+export class ChainSummarization extends VersionedNodeType {
+	constructor() {
+		const baseDescription: INodeTypeBaseDescription = {
+			displayName: 'Summarization Chain',
+			name: 'chainSummarization',
+			icon: 'fa:link',
+			iconColor: 'black',
+			group: ['transform'],
+			description: 'Transforms text into a concise summary',
+			codex: {
+				alias: ['LangChain'],
+				categories: ['AI'],
+				subcategories: {
+					AI: ['Chains', 'Root Nodes'],
+				},
+				resources: {
+					primaryDocumentation: [
+						{
+							url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.chainsummarization/',
+						},
+					],
+				},
+			},
+			defaultVersion: 2.1,
+		};
+
+		const nodeVersions: IVersionedNodeType['nodeVersions'] = {
+			1: new ChainSummarizationV1(baseDescription),
+			2: new ChainSummarizationV2(baseDescription),
+			2.1: new ChainSummarizationV2(baseDescription),
+		};
+
+		super(nodeVersions, baseDescription);
+	}
+}

n8n-n8n-1.109.2/packages/@n8n/nodes-langchain/nodes/chains/ChainSummarization/V1/ChainSummarizationV1.node.ts

@@ -0,0 +1,264 @@
+import type { Document } from '@langchain/core/documents';
+import type { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { PromptTemplate } from '@langchain/core/prompts';
+import type { SummarizationChainParams } from 'langchain/chains';
+import { loadSummarizationChain } from 'langchain/chains';
+import {
+	NodeConnectionTypes,
+	type INodeTypeBaseDescription,
+	type IExecuteFunctions,
+	type INodeExecutionData,
+	type INodeType,
+	type INodeTypeDescription,
+} from 'n8n-workflow';
+
+import { N8nBinaryLoader } from '@utils/N8nBinaryLoader';
+import { N8nJsonLoader } from '@utils/N8nJsonLoader';
+import { getTemplateNoticeField } from '@utils/sharedFields';
+
+import { REFINE_PROMPT_TEMPLATE, DEFAULT_PROMPT_TEMPLATE } from '../prompt';
+
+export class ChainSummarizationV1 implements INodeType {
+	description: INodeTypeDescription;
+
+	constructor(baseDescription: INodeTypeBaseDescription) {
+		this.description = {
+			...baseDescription,
+			version: 1,
+			defaults: {
+				name: 'Summarization Chain',
+				color: '#909298',
+			},
+
+			inputs: [
+				NodeConnectionTypes.Main,
+				{
+					displayName: 'Model',
+					maxConnections: 1,
+					type: NodeConnectionTypes.AiLanguageModel,
+					required: true,
+				},
+				{
+					displayName: 'Document',
+					maxConnections: 1,
+					type: NodeConnectionTypes.AiDocument,
+					required: true,
+				},
+			],
+			outputs: [NodeConnectionTypes.Main],
+			credentials: [],
+			properties: [
+				getTemplateNoticeField(1951),
+				{
+					displayName: 'Type',
+					name: 'type',
+					type: 'options',
+					description: 'The type of summarization to run',
+					default: 'map_reduce',
+					options: [
+						{
+							name: 'Map Reduce (Recommended)',
+							value: 'map_reduce',
+							description:
+								'Summarize each document (or chunk) individually, then summarize those summaries',
+						},
+						{
+							name: 'Refine',
+							value: 'refine',
+							description:
+								'Summarize the first document (or chunk). Then update that summary based on the next document (or chunk), and repeat.',
+						},
+						{
+							name: 'Stuff',
+							value: 'stuff',
+							description: 'Pass all documents (or chunks) at once. Ideal for small datasets.',
+						},
+					],
+				},
+				{
+					displayName: 'Options',
+					name: 'options',
+					type: 'collection',
+					default: {},
+					placeholder: 'Add Option',
+					options: [
+						{
+							displayName: 'Final Prompt to Combine',
+							name: 'combineMapPrompt',
+							type: 'string',
+							hint: 'The prompt to combine individual summaries',
+							displayOptions: {
+								show: {
+									'/type': ['map_reduce'],
+								},
+							},
+							default: DEFAULT_PROMPT_TEMPLATE,
+							typeOptions: {
+								rows: 6,
+							},
+						},
+						{
+							displayName: 'Individual Summary Prompt',
+							name: 'prompt',
+							type: 'string',
+							default: DEFAULT_PROMPT_TEMPLATE,
+							hint: 'The prompt to summarize an individual document (or chunk)',
+							displayOptions: {
+								show: {
+									'/type': ['map_reduce'],
+								},
+							},
+							typeOptions: {
+								rows: 6,
+							},
+						},
+						{
+							displayName: 'Prompt',
+							name: 'prompt',
+							type: 'string',
+							default: DEFAULT_PROMPT_TEMPLATE,
+							displayOptions: {
+								show: {
+									'/type': ['stuff'],
+								},
+							},
+							typeOptions: {
+								rows: 6,
+							},
+						},
+						{
+							displayName: 'Subsequent (Refine) Prompt',
+							name: 'refinePrompt',
+							type: 'string',
+							displayOptions: {
+								show: {
+									'/type': ['refine'],
+								},
+							},
+							default: REFINE_PROMPT_TEMPLATE,
+							hint: 'The prompt to refine the summary based on the next document (or chunk)',
+							typeOptions: {
+								rows: 6,
+							},
+						},
+						{
+							displayName: 'Initial Prompt',
+							name: 'refineQuestionPrompt',
+							type: 'string',
+							displayOptions: {
+								show: {
+									'/type': ['refine'],
+								},
+							},
+							default: DEFAULT_PROMPT_TEMPLATE,
+							hint: 'The prompt for the first document (or chunk)',
+							typeOptions: {
+								rows: 6,
+							},
+						},
+					],
+				},
+			],
+		};
+	}
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		this.logger.debug('Executing Vector Store QA Chain');
+		const type = this.getNodeParameter('type', 0) as 'map_reduce' | 'stuff' | 'refine';
+
+		const model = (await this.getInputConnectionData(
+			NodeConnectionTypes.AiLanguageModel,
+			0,
+		)) as BaseLanguageModel;
+
+		const documentInput = (await this.getInputConnectionData(NodeConnectionTypes.AiDocument, 0)) as
+			| N8nJsonLoader
+			| Array<Document<Record<string, unknown>>>;
+
+		const options = this.getNodeParameter('options', 0, {}) as {
+			prompt?: string;
+			refineQuestionPrompt?: string;
+			refinePrompt?: string;
+			combineMapPrompt?: string;
+		};
+
+		const chainArgs: SummarizationChainParams = {
+			type,
+		};
+
+		// Map reduce prompt override
+		if (type === 'map_reduce') {
+			const mapReduceArgs = chainArgs as SummarizationChainParams & {
+				type: 'map_reduce';
+			};
+			if (options.combineMapPrompt) {
+				mapReduceArgs.combineMapPrompt = new PromptTemplate({
+					template: options.combineMapPrompt,
+					inputVariables: ['text'],
+				});
+			}
+			if (options.prompt) {
+				mapReduceArgs.combinePrompt = new PromptTemplate({
+					template: options.prompt,
+					inputVariables: ['text'],
+				});
+			}
+		}
+
+		// Stuff prompt override
+		if (type === 'stuff') {
+			const stuffArgs = chainArgs as SummarizationChainParams & {
+				type: 'stuff';
+			};
+			if (options.prompt) {
+				stuffArgs.prompt = new PromptTemplate({
+					template: options.prompt,
+					inputVariables: ['text'],
+				});
+			}
+		}
+
+		// Refine prompt override
+		if (type === 'refine') {
+			const refineArgs = chainArgs as SummarizationChainParams & {
+				type: 'refine';
+			};
+
+			if (options.refinePrompt) {
+				refineArgs.refinePrompt = new PromptTemplate({
+					template: options.refinePrompt,
+					inputVariables: ['existing_answer', 'text'],
+				});
+			}
+
+			if (options.refineQuestionPrompt) {
+				refineArgs.questionPrompt = new PromptTemplate({
+					template: options.refineQuestionPrompt,
+					inputVariables: ['text'],
+				});
+			}
+		}
+
+		const chain = loadSummarizationChain(model, chainArgs);
+
+		const items = this.getInputData();
+		const returnData: INodeExecutionData[] = [];
+
+		for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+			let processedDocuments: Document[];
+			if (documentInput instanceof N8nJsonLoader || documentInput instanceof N8nBinaryLoader) {
+				processedDocuments = await documentInput.processItem(items[itemIndex], itemIndex);
+			} else {
+				processedDocuments = documentInput;
+			}
+
+			const response = await chain.call({
+				input_documents: processedDocuments,
+			});
+
+			returnData.push({ json: { response } });
+		}
+
+		return [returnData];
+	}
+}

n8n-n8n-1.109.2/packages/@n8n/nodes-langchain/nodes/chains/ChainSummarization/V2/ChainSummarizationV2.node.ts

@@ -0,0 +1,388 @@
+import type {
+	INodeTypeBaseDescription,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeDescription,
+	IDataObject,
+	INodeInputConfiguration,
+} from 'n8n-workflow';
+import { NodeConnectionTypes, sleep } from 'n8n-workflow';
+
+import { getBatchingOptionFields, getTemplateNoticeField } from '@utils/sharedFields';
+
+import { processItem } from './processItem';
+import { REFINE_PROMPT_TEMPLATE, DEFAULT_PROMPT_TEMPLATE } from '../prompt';
+
+function getInputs(parameters: IDataObject) {
+	const chunkingMode = parameters?.chunkingMode;
+	const operationMode = parameters?.operationMode;
+	const inputs: INodeInputConfiguration[] = [
+		{ displayName: '', type: 'main' },
+		{
+			displayName: 'Model',
+			maxConnections: 1,
+			type: 'ai_languageModel',
+			required: true,
+		},
+	];
+
+	if (operationMode === 'documentLoader') {
+		inputs.push({
+			displayName: 'Document',
+			type: 'ai_document',
+			required: true,
+			maxConnections: 1,
+		});
+		return inputs;
+	}
+
+	if (chunkingMode === 'advanced') {
+		inputs.push({
+			displayName: 'Text Splitter',
+			type: 'ai_textSplitter',
+			required: false,
+			maxConnections: 1,
+		});
+		return inputs;
+	}
+	return inputs;
+}
+
+export class ChainSummarizationV2 implements INodeType {
+	description: INodeTypeDescription;
+
+	constructor(baseDescription: INodeTypeBaseDescription) {
+		this.description = {
+			...baseDescription,
+			version: [2, 2.1],
+			defaults: {
+				name: 'Summarization Chain',
+				color: '#909298',
+			},
+
+			inputs: `={{ ((parameter) => { ${getInputs.toString()}; return getInputs(parameter) })($parameter) }}`,
+			outputs: [NodeConnectionTypes.Main],
+			credentials: [],
+			properties: [
+				getTemplateNoticeField(1951),
+				{
+					displayName: 'Data to Summarize',
+					name: 'operationMode',
+					noDataExpression: true,
+					type: 'options',
+					description: 'How to pass data into the summarization chain',
+					default: 'nodeInputJson',
+					options: [
+						{
+							name: 'Use Node Input (JSON)',
+							value: 'nodeInputJson',
+							description: 'Summarize the JSON data coming into this node from the previous one',
+						},
+						{
+							name: 'Use Node Input (Binary)',
+							value: 'nodeInputBinary',
+							description: 'Summarize the binary data coming into this node from the previous one',
+						},
+						{
+							name: 'Use Document Loader',
+							value: 'documentLoader',
+							description: 'Use a loader sub-node with more configuration options',
+						},
+					],
+				},
+				{
+					displayName: 'Chunking Strategy',
+					name: 'chunkingMode',
+					noDataExpression: true,
+					type: 'options',
+					description: 'Chunk splitting strategy',
+					default: 'simple',
+					options: [
+						{
+							name: 'Simple (Define Below)',
+							value: 'simple',
+						},
+						{
+							name: 'Advanced',
+							value: 'advanced',
+							description: 'Use a splitter sub-node with more configuration options',
+						},
+					],
+					displayOptions: {
+						show: {
+							'/operationMode': ['nodeInputJson', 'nodeInputBinary'],
+						},
+					},
+				},
+				{
+					displayName: 'Characters Per Chunk',
+					name: 'chunkSize',
+					description:
+						'Controls the max size (in terms of number of characters) of the final document chunk',
+					type: 'number',
+					default: 1000,
+					displayOptions: {
+						show: {
+							'/chunkingMode': ['simple'],
+						},
+					},
+				},
+				{
+					displayName: 'Chunk Overlap (Characters)',
+					name: 'chunkOverlap',
+					type: 'number',
+					description: 'Specifies how much characters overlap there should be between chunks',
+					default: 200,
+					displayOptions: {
+						show: {
+							'/chunkingMode': ['simple'],
+						},
+					},
+				},
+				{
+					displayName: 'Options',
+					name: 'options',
+					type: 'collection',
+					default: {},
+					placeholder: 'Add Option',
+					options: [
+						{
+							displayName: 'Input Data Field Name',
+							name: 'binaryDataKey',
+							type: 'string',
+							default: 'data',
+							description:
+								'The name of the field in the agent or chain’s input that contains the binary file to be processed',
+							displayOptions: {
+								show: {
+									'/operationMode': ['nodeInputBinary'],
+								},
+							},
+						},
+						{
+							displayName: 'Summarization Method and Prompts',
+							name: 'summarizationMethodAndPrompts',
+							type: 'fixedCollection',
+							default: {
+								values: {
+									summarizationMethod: 'map_reduce',
+									prompt: DEFAULT_PROMPT_TEMPLATE,
+									combineMapPrompt: DEFAULT_PROMPT_TEMPLATE,
+								},
+							},
+							placeholder: 'Add Option',
+							typeOptions: {},
+							options: [
+								{
+									name: 'values',
+									displayName: 'Values',
+									values: [
+										{
+											displayName: 'Summarization Method',
+											name: 'summarizationMethod',
+											type: 'options',
+											description: 'The type of summarization to run',
+											default: 'map_reduce',
+											options: [
+												{
+													name: 'Map Reduce (Recommended)',
+													value: 'map_reduce',
+													description:
+														'Summarize each document (or chunk) individually, then summarize those summaries',
+												},
+												{
+													name: 'Refine',
+													value: 'refine',
+													description:
+														'Summarize the first document (or chunk). Then update that summary based on the next document (or chunk), and repeat.',
+												},
+												{
+													name: 'Stuff',
+													value: 'stuff',
+													description:
+														'Pass all documents (or chunks) at once. Ideal for small datasets.',
+												},
+											],
+										},
+										{
+											displayName: 'Individual Summary Prompt',
+											name: 'combineMapPrompt',
+											type: 'string',
+											hint: 'The prompt to summarize an individual document (or chunk)',
+											displayOptions: {
+												hide: {
+													'/options.summarizationMethodAndPrompts.values.summarizationMethod': [
+														'stuff',
+														'refine',
+													],
+												},
+											},
+											default: DEFAULT_PROMPT_TEMPLATE,
+											typeOptions: {
+												rows: 9,
+											},
+										},
+										{
+											displayName: 'Final Prompt to Combine',
+											name: 'prompt',
+											type: 'string',
+											default: DEFAULT_PROMPT_TEMPLATE,
+											hint: 'The prompt to combine individual summaries',
+											displayOptions: {
+												hide: {
+													'/options.summarizationMethodAndPrompts.values.summarizationMethod': [
+														'stuff',
+														'refine',
+													],
+												},
+											},
+											typeOptions: {
+												rows: 9,
+											},
+										},
+										{
+											displayName: 'Prompt',
+											name: 'prompt',
+											type: 'string',
+											default: DEFAULT_PROMPT_TEMPLATE,
+											displayOptions: {
+												hide: {
+													'/options.summarizationMethodAndPrompts.values.summarizationMethod': [
+														'refine',
+														'map_reduce',
+													],
+												},
+											},
+											typeOptions: {
+												rows: 9,
+											},
+										},
+										{
+											displayName: 'Subsequent (Refine) Prompt',
+											name: 'refinePrompt',
+											type: 'string',
+											displayOptions: {
+												hide: {
+													'/options.summarizationMethodAndPrompts.values.summarizationMethod': [
+														'stuff',
+														'map_reduce',
+													],
+												},
+											},
+											default: REFINE_PROMPT_TEMPLATE,
+											hint: 'The prompt to refine the summary based on the next document (or chunk)',
+											typeOptions: {
+												rows: 9,
+											},
+										},
+										{
+											displayName: 'Initial Prompt',
+											name: 'refineQuestionPrompt',
+											type: 'string',
+											displayOptions: {
+												hide: {
+													'/options.summarizationMethodAndPrompts.values.summarizationMethod': [
+														'stuff',
+														'map_reduce',
+													],
+												},
+											},
+											default: DEFAULT_PROMPT_TEMPLATE,
+											hint: 'The prompt for the first document (or chunk)',
+											typeOptions: {
+												rows: 9,
+											},
+										},
+									],
+								},
+							],
+						},
+						getBatchingOptionFields({
+							show: {
+								'@version': [{ _cnd: { gte: 2.1 } }],
+							},
+						}),
+					],
+				},
+			],
+		};
+	}
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		this.logger.debug('Executing Summarization Chain V2');
+		const operationMode = this.getNodeParameter('operationMode', 0, 'nodeInputJson') as
+			| 'nodeInputJson'
+			| 'nodeInputBinary'
+			| 'documentLoader';
+		const chunkingMode = this.getNodeParameter('chunkingMode', 0, 'simple') as
+			| 'simple'
+			| 'advanced';
+
+		const items = this.getInputData();
+		const returnData: INodeExecutionData[] = [];
+
+		const batchSize = this.getNodeParameter('options.batching.batchSize', 0, 5) as number;
+		const delayBetweenBatches = this.getNodeParameter(
+			'options.batching.delayBetweenBatches',
+			0,
+			0,
+		) as number;
+
+		if (this.getNode().typeVersion >= 2.1 && batchSize > 1) {
+			// Batch processing
+			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 processItem(this, itemIndex, item, operationMode, chunkingMode);
+				});
+
+				const batchResults = await Promise.allSettled(batchPromises);
+				batchResults.forEach((response, index) => {
+					if (response.status === 'rejected') {
+						const error = response.reason as Error;
+						if (this.continueOnFail()) {
+							returnData.push({
+								json: { error: error.message },
+								pairedItem: { item: i + index },
+							});
+						} else {
+							throw error;
+						}
+					} else {
+						const output = response.value;
+						returnData.push({ json: { output } });
+					}
+				});
+
+				// Add delay between batches if not the last batch
+				if (i + batchSize < items.length && delayBetweenBatches > 0) {
+					await sleep(delayBetweenBatches);
+				}
+			}
+		} else {
+			for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+				try {
+					const response = await processItem(
+						this,
+						itemIndex,
+						items[itemIndex],
+						operationMode,
+						chunkingMode,
+					);
+					returnData.push({ json: { response } });
+				} catch (error) {
+					if (this.continueOnFail()) {
+						returnData.push({ json: { error: error.message }, pairedItem: { item: itemIndex } });
+						continue;
+					}
+
+					throw error;
+				}
+			}
+		}
+
+		return [returnData];
+	}
+}

n8n-n8n-1.109.2/packages/@n8n/nodes-langchain/nodes/chains/ChainSummarization/V2/processItem.ts

@@ -0,0 +1,107 @@
+import type { Document } from '@langchain/core/documents';
+import type { BaseLanguageModel } from '@langchain/core/language_models/base';
+import type { ChainValues } from '@langchain/core/utils/types';
+import { RecursiveCharacterTextSplitter, type TextSplitter } from '@langchain/textsplitters';
+import { loadSummarizationChain } from 'langchain/chains';
+import { type IExecuteFunctions, type INodeExecutionData, NodeConnectionTypes } from 'n8n-workflow';
+
+import { N8nBinaryLoader } from '@utils/N8nBinaryLoader';
+import { N8nJsonLoader } from '@utils/N8nJsonLoader';
+import { getTracingConfig } from '@utils/tracing';
+
+import { getChainPromptsArgs } from '../helpers';
+
+export async function processItem(
+	ctx: IExecuteFunctions,
+	itemIndex: number,
+	item: INodeExecutionData,
+	operationMode: string,
+	chunkingMode: 'simple' | 'advanced' | 'none',
+): Promise<ChainValues | undefined> {
+	const model = (await ctx.getInputConnectionData(
+		NodeConnectionTypes.AiLanguageModel,
+		0,
+	)) as BaseLanguageModel;
+
+	const summarizationMethodAndPrompts = ctx.getNodeParameter(
+		'options.summarizationMethodAndPrompts.values',
+		itemIndex,
+		{},
+	) as {
+		prompt?: string;
+		refineQuestionPrompt?: string;
+		refinePrompt?: string;
+		summarizationMethod: 'map_reduce' | 'stuff' | 'refine';
+		combineMapPrompt?: string;
+	};
+
+	const chainArgs = getChainPromptsArgs(
+		summarizationMethodAndPrompts.summarizationMethod ?? 'map_reduce',
+		summarizationMethodAndPrompts,
+	);
+
+	const chain = loadSummarizationChain(model, chainArgs);
+
+	let processedDocuments: Document[];
+
+	// Use dedicated document loader input to load documents
+	if (operationMode === 'documentLoader') {
+		const documentInput = (await ctx.getInputConnectionData(NodeConnectionTypes.AiDocument, 0)) as
+			| N8nJsonLoader
+			| Array<Document<Record<string, unknown>>>;
+
+		const isN8nLoader =
+			documentInput instanceof N8nJsonLoader || documentInput instanceof N8nBinaryLoader;
+
+		processedDocuments = isN8nLoader
+			? await documentInput.processItem(item, itemIndex)
+			: documentInput;
+
+		return await chain.withConfig(getTracingConfig(ctx)).invoke({
+			input_documents: processedDocuments,
+		});
+	} else if (['nodeInputJson', 'nodeInputBinary'].includes(operationMode)) {
+		// Take the input and use binary or json loader
+		let textSplitter: TextSplitter | undefined;
+
+		switch (chunkingMode) {
+			// In simple mode we use recursive character splitter with default settings
+			case 'simple':
+				const chunkSize = ctx.getNodeParameter('chunkSize', itemIndex, 1000) as number;
+				const chunkOverlap = ctx.getNodeParameter('chunkOverlap', itemIndex, 200) as number;
+
+				textSplitter = new RecursiveCharacterTextSplitter({ chunkOverlap, chunkSize });
+				break;
+
+			// In advanced mode user can connect text splitter node so we just retrieve it
+			case 'advanced':
+				textSplitter = (await ctx.getInputConnectionData(NodeConnectionTypes.AiTextSplitter, 0)) as
+					| TextSplitter
+					| undefined;
+				break;
+			default:
+				break;
+		}
+
+		let processor: N8nJsonLoader | N8nBinaryLoader;
+		if (operationMode === 'nodeInputBinary') {
+			const binaryDataKey = ctx.getNodeParameter(
+				'options.binaryDataKey',
+				itemIndex,
+				'data',
+			) as string;
+			processor = new N8nBinaryLoader(ctx, 'options.', binaryDataKey, textSplitter);
+		} else {
+			processor = new N8nJsonLoader(ctx, 'options.', textSplitter);
+		}
+
+		const processedItem = await processor.processItem(item, itemIndex);
+		return await chain.invoke(
+			{
+				input_documents: processedItem,
+			},
+			{ signal: ctx.getExecutionCancelSignal() },
+		);
+	}
+	return undefined;
+}

n8n-n8n-1.109.2/packages/@n8n/nodes-langchain/nodes/chains/ChainSummarization/helpers.ts

@@ -0,0 +1,71 @@
+import { PromptTemplate } from '@langchain/core/prompts';
+import type { SummarizationChainParams } from 'langchain/chains';
+interface ChainTypeOptions {
+	combineMapPrompt?: string;
+	prompt?: string;
+	refinePrompt?: string;
+	refineQuestionPrompt?: string;
+}
+
+export function getChainPromptsArgs(
+	type: 'stuff' | 'map_reduce' | 'refine',
+	options: ChainTypeOptions,
+) {
+	const chainArgs: SummarizationChainParams = {
+		type,
+	};
+	// Map reduce prompt override
+	if (type === 'map_reduce') {
+		const mapReduceArgs = chainArgs as SummarizationChainParams & {
+			type: 'map_reduce';
+		};
+		if (options.combineMapPrompt) {
+			mapReduceArgs.combineMapPrompt = new PromptTemplate({
+				template: options.combineMapPrompt,
+				inputVariables: ['text'],
+			});
+		}
+		if (options.prompt) {
+			mapReduceArgs.combinePrompt = new PromptTemplate({
+				template: options.prompt,
+				inputVariables: ['text'],
+			});
+		}
+	}
+
+	// Stuff prompt override
+	if (type === 'stuff') {
+		const stuffArgs = chainArgs as SummarizationChainParams & {
+			type: 'stuff';
+		};
+		if (options.prompt) {
+			stuffArgs.prompt = new PromptTemplate({
+				template: options.prompt,
+				inputVariables: ['text'],
+			});
+		}
+	}
+
+	// Refine prompt override
+	if (type === 'refine') {
+		const refineArgs = chainArgs as SummarizationChainParams & {
+			type: 'refine';
+		};
+
+		if (options.refinePrompt) {
+			refineArgs.refinePrompt = new PromptTemplate({
+				template: options.refinePrompt,
+				inputVariables: ['existing_answer', 'text'],
+			});
+		}
+
+		if (options.refineQuestionPrompt) {
+			refineArgs.questionPrompt = new PromptTemplate({
+				template: options.refineQuestionPrompt,
+				inputVariables: ['text'],
+			});
+		}
+	}
+
+	return chainArgs;
+}

n8n-n8n-1.109.2/packages/@n8n/nodes-langchain/nodes/chains/ChainSummarization/prompt.ts

@@ -0,0 +1,20 @@
+export const REFINE_PROMPT_TEMPLATE = `Your job is to produce a final summary
+We have provided an existing summary up to a certain point: "{existing_answer}"
+We have the opportunity to refine the existing summary
+(only if needed) with some more context below.
+------------
+"{text}"
+------------
+
+Given the new context, refine the original summary
+If the context isn't useful, return the original summary.
+
+REFINED SUMMARY:`;
+
+export const DEFAULT_PROMPT_TEMPLATE = `Write a concise summary of the following:
+
+
+"{text}"
+
+
+CONCISE SUMMARY:`;