@n8n/n8n-nodes-langchain 2.22.2 → 2.23.0

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v12/mode_retrieve_as_tool.ts

@@ -0,0 +1,112 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.2
+ * Discriminator: mode=retrieve-as-tool
+ */
+
+
+interface Credentials {
+  oracleDBApi: CredentialReference;
+}
+
+/** Retrieve documents from vector store to be used as tool with AI nodes */
+export type LcVectorStoreOracleDBVectorV12RetrieveAsToolParams = {
+  /**
+   * Canonical RAG mode — declare with the `tool({...})` factory (NOT `vectorStore`) and plug into an AI Agent's `subnodes.tools`. Required subnodes: `embedding`. Set `toolDescription` so the agent knows when to call it.
+   * <patterns>
+   * <pattern title="retrieve-as-tool mode — RAG via AI Agent (generic, works for any vectorStore* node)">
+   * // Substitute the type literal and provider-specific parameters — see the rest of this file
+   * // for the exact shape (e.g. pineconeIndex, qdrantCollection, supabaseTableName).
+   * const knowledgeBase = tool({
+   *   type: '@n8n/n8n-nodes-langchain.vectorStoreXxx',
+   *   config: {
+   *     name: 'Knowledge Base',
+   *     parameters: {
+   *       mode: 'retrieve-as-tool',
+   *       toolDescription: 'Search the product knowledge base',
+   *       // ...provider-specific parameters
+   *     },
+   *     subnodes: { embedding: embeddingsOpenAi }
+   *   }
+   * });
+   * 
+   * const agent = node({
+   *   type: '@n8n/n8n-nodes-langchain.agent',
+   *   config: {
+   *     name: 'Support Agent',
+   *     parameters: { promptType: 'define', text: expr('{{ $json.question }}') },
+   *     subnodes: { model: openAiModel, tools: [knowledgeBase] }
+   *   }
+   * });
+   * </pattern>
+   * </patterns>
+   */
+  mode: 'retrieve-as-tool';
+/**
+ * Name of the vector store
+ */
+    toolName: string | Expression<string>;
+/**
+ * Explain to the LLM what this tool does, a good, specific description would allow LLMs to produce expected results much more often
+ */
+    toolDescription: string | Expression<string>;
+/**
+ * The table name to store the vectors in. If table does not exist, it will be created.
+ * @default n8n_vectors
+ */
+    tableName?: string | Expression<string>;
+/**
+ * Number of top results to fetch from vector store
+ * @default 4
+ */
+    topK?: number | Expression<number>;
+/**
+ * Whether or not to include document metadata
+ * @default true
+ */
+    includeDocumentMetadata?: boolean | Expression<boolean>;
+/**
+ * Whether or not to rerank results
+ * @default false
+ */
+    useReranker?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** The method to calculate the distance between two vectors
+     * @default COSINE
+     */
+    distanceStrategy?: 'COSINE' | 'DOT' | 'EUCLIDEAN' | 'MANHATTAN' | 'EUCLIDEAN_SQUARED' | 'HAMMING' | Expression<string>;
+    /** Metadata to filter the document by
+     * @default {}
+     */
+    metadata?: {
+        /** Fields to Set
+     */
+    metadataValues?: Array<{
+      /** Name
+       */
+      name?: string | Expression<string>;
+      /** Value
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+  };
+};
+
+export interface LcVectorStoreOracleDBVectorV12RetrieveAsToolSubnodeConfig {
+  embedding: EmbeddingInstance | EmbeddingInstance[];
+  /**
+   * @displayOptions.show { useReranker: [true] }
+   */
+  reranker: RerankerInstance;
+}
+
+export type LcVectorStoreOracleDBVectorV12RetrieveAsToolNode = {
+  type: '@n8n/n8n-nodes-langchain.vectorStoreOracleDBVector';
+  version: 1.2;
+  credentials?: Credentials;
+  config: NodeConfig<LcVectorStoreOracleDBVectorV12RetrieveAsToolParams> & { subnodes: LcVectorStoreOracleDBVectorV12RetrieveAsToolSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/index.schema.js

@@ -0,0 +1,26 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3 - Zod Schema Factory
+ * Exports a factory that unions all discriminator schemas.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+const getInsertSchema = require('./mode_insert.schema');
+const getLoadSchema = require('./mode_load.schema');
+const getRetrieveSchema = require('./mode_retrieve.schema');
+const getRetrieveAsToolSchema = require('./mode_retrieve_as_tool.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply discriminator default if not set
+  const effectiveParams = parameters.mode === undefined ? { ...parameters, mode: 'retrieve' } : parameters;
+  return z.union([
+    getInsertSchema({ ...helpers, parameters: effectiveParams }),
+    getLoadSchema({ ...helpers, parameters: effectiveParams }),
+    getRetrieveSchema({ ...helpers, parameters: effectiveParams }),
+    getRetrieveAsToolSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3
+ * Re-exports all discriminator combinations.
+ */
+
+import type { LcVectorStoreOracleDBVectorV13InsertNode } from './mode_insert';
+import type { LcVectorStoreOracleDBVectorV13LoadNode } from './mode_load';
+import type { LcVectorStoreOracleDBVectorV13RetrieveNode } from './mode_retrieve';
+import type { LcVectorStoreOracleDBVectorV13RetrieveAsToolNode } from './mode_retrieve_as_tool';
+
+export * from './mode_insert';
+export * from './mode_load';
+export * from './mode_retrieve';
+export * from './mode_retrieve_as_tool';
+
+export type LcVectorStoreOracleDBVectorV13Node =
+  | LcVectorStoreOracleDBVectorV13InsertNode
+  | LcVectorStoreOracleDBVectorV13LoadNode
+  | LcVectorStoreOracleDBVectorV13RetrieveNode
+  | LcVectorStoreOracleDBVectorV13RetrieveAsToolNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_insert.schema.js

@@ -0,0 +1,30 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3 - Zod Schema
+ * Discriminator: mode=insert
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, embeddingInstanceSchema, documentLoaderInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    embedding: z.union([embeddingInstanceSchema, z.array(embeddingInstanceSchema)]),
+    documentLoader: z.union([documentLoaderInstanceSchema, z.array(documentLoaderInstanceSchema)]),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      mode: z.literal('insert'),
+      tableName: stringOrExpression.optional(),
+      embeddingBatchSize: numberOrExpression.optional(),
+      options: z.record(z.string(), z.unknown()).optional(),
+    }).optional(),
+    subnodes: subnodesSchema,
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_insert.ts

@@ -0,0 +1,61 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3
+ * Discriminator: mode=insert
+ */
+
+
+interface Credentials {
+  oracleDBApi: CredentialReference;
+}
+
+/** Insert documents into vector store */
+export type LcVectorStoreOracleDBVectorV13InsertParams = {
+  /**
+   * Sits on the main flow — pipe the documents you want to embed into this node. Declare with `vectorStore({...})`. Required subnodes: `embedding` and `documentLoader`. If the goal is letting an LLM query the store, use `mode: 'retrieve-as-tool'` instead.
+   * <patterns>
+   * <pattern title="insert mode — upsert documents (generic, works for any vectorStore* node)">
+   * // Substitute the type literal and provider-specific parameters (e.g. pineconeIndex,
+   * // qdrantCollection, supabaseTableName) — see the rest of this file for the exact shape.
+   * const store = vectorStore({
+   *   type: '@n8n/n8n-nodes-langchain.vectorStoreXxx',
+   *   config: {
+   *     name: 'Knowledge Base',
+   *     parameters: {
+   *       mode: 'insert',
+   *       // ...provider-specific parameters
+   *     },
+   *     subnodes: { embedding: embeddingsOpenAi, documentLoader: defaultDataLoader }
+   *   }
+   * });
+   * </pattern>
+   * </patterns>
+   */
+  mode: 'insert';
+/**
+ * The table name to store the vectors in. If table does not exist, it will be created.
+ * @default n8n_vectors
+ */
+    tableName?: string | Expression<string>;
+/**
+ * Number of documents to embed in a single batch
+ * @default 200
+ */
+    embeddingBatchSize?: number | Expression<number>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: Record<string, unknown>;
+};
+
+export interface LcVectorStoreOracleDBVectorV13InsertSubnodeConfig {
+  embedding: EmbeddingInstance | EmbeddingInstance[];
+  documentLoader: DocumentLoaderInstance | DocumentLoaderInstance[];
+}
+
+export type LcVectorStoreOracleDBVectorV13InsertNode = {
+  type: '@n8n/n8n-nodes-langchain.vectorStoreOracleDBVector';
+  version: 1.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcVectorStoreOracleDBVectorV13InsertParams> & { subnodes: LcVectorStoreOracleDBVectorV13InsertSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_load.schema.js

@@ -0,0 +1,35 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3 - Zod Schema
+ * Discriminator: mode=load
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, resolveSchema, embeddingInstanceSchema, rerankerInstanceSchema }) {
+
+  // Helper function for conditional subnode schema
+  function getSubnodesSchema() {
+    return z.object({
+      embedding: z.union([embeddingInstanceSchema, z.array(embeddingInstanceSchema)]),
+      reranker: resolveSchema({ parameters, schema: rerankerInstanceSchema, required: true, displayOptions: {"show":{"useReranker":[true]}}, defaults: {"useReranker":false} }),
+    }).strict();
+  }
+
+  return z.object({
+    parameters: z.object({
+      mode: z.literal('load'),
+      tableName: stringOrExpression.optional(),
+      prompt: stringOrExpression,
+      topK: numberOrExpression.optional(),
+      includeDocumentMetadata: booleanOrExpression.optional(),
+      useReranker: booleanOrExpression.optional(),
+      options: z.object({ distanceStrategy: z.union([z.literal('COSINE'), z.literal('DOT'), z.literal('EUCLIDEAN'), z.literal('MANHATTAN'), z.literal('EUCLIDEAN_SQUARED'), z.literal('HAMMING'), expressionSchema]).optional(), metadata: z.object({ metadataValues: z.array(z.object({ name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }).optional() }).optional(),
+    }).optional(),
+    subnodes: getSubnodesSchema(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_load.ts

@@ -0,0 +1,98 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3
+ * Discriminator: mode=load
+ */
+
+
+interface Credentials {
+  oracleDBApi: CredentialReference;
+}
+
+/** Get many ranked documents from vector store for query */
+export type LcVectorStoreOracleDBVectorV13LoadParams = {
+  /**
+   * One-shot similarity search on the main flow using the `prompt` parameter. Declare with `vectorStore({...})`. Required subnodes: `embedding`. For LLM-driven querying (RAG), use `mode: 'retrieve-as-tool'` instead.
+   * <patterns>
+   * <pattern title="load mode — one-shot similarity search (generic)">
+   * // Substitute the type literal and provider-specific parameters — see the rest of this file.
+   * const lookup = vectorStore({
+   *   type: '@n8n/n8n-nodes-langchain.vectorStoreXxx',
+   *   config: {
+   *     name: 'Knowledge Base',
+   *     parameters: {
+   *       mode: 'load',
+   *       prompt: expr('{{ $json.query }}'),
+   *       // ...provider-specific parameters
+   *     },
+   *     subnodes: { embedding: embeddingsOpenAi }
+   *   }
+   * });
+   * </pattern>
+   * </patterns>
+   */
+  mode: 'load';
+/**
+ * The table name to store the vectors in. If table does not exist, it will be created.
+ * @default n8n_vectors
+ */
+    tableName?: string | Expression<string>;
+/**
+ * Search prompt to retrieve matching documents from the vector store using similarity-based ranking
+ */
+    prompt: string | Expression<string>;
+/**
+ * Number of top results to fetch from vector store
+ * @default 4
+ */
+    topK?: number | Expression<number>;
+/**
+ * Whether or not to include document metadata
+ * @default true
+ */
+    includeDocumentMetadata?: boolean | Expression<boolean>;
+/**
+ * Whether or not to rerank results
+ * @default false
+ */
+    useReranker?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** The method to calculate the distance between two vectors
+     * @default COSINE
+     */
+    distanceStrategy?: 'COSINE' | 'DOT' | 'EUCLIDEAN' | 'MANHATTAN' | 'EUCLIDEAN_SQUARED' | 'HAMMING' | Expression<string>;
+    /** Metadata to filter the document by
+     * @default {}
+     */
+    metadata?: {
+        /** Fields to Set
+     */
+    metadataValues?: Array<{
+      /** Name
+       */
+      name?: string | Expression<string>;
+      /** Value
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+  };
+};
+
+export interface LcVectorStoreOracleDBVectorV13LoadSubnodeConfig {
+  embedding: EmbeddingInstance | EmbeddingInstance[];
+  /**
+   * @displayOptions.show { useReranker: [true] }
+   */
+  reranker: RerankerInstance;
+}
+
+export type LcVectorStoreOracleDBVectorV13LoadNode = {
+  type: '@n8n/n8n-nodes-langchain.vectorStoreOracleDBVector';
+  version: 1.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcVectorStoreOracleDBVectorV13LoadParams> & { subnodes: LcVectorStoreOracleDBVectorV13LoadSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_retrieve.schema.js

@@ -0,0 +1,32 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3 - Zod Schema
+ * Discriminator: mode=retrieve
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, resolveSchema, embeddingInstanceSchema, rerankerInstanceSchema }) {
+
+  // Helper function for conditional subnode schema
+  function getSubnodesSchema() {
+    return z.object({
+      embedding: z.union([embeddingInstanceSchema, z.array(embeddingInstanceSchema)]),
+      reranker: resolveSchema({ parameters, schema: rerankerInstanceSchema, required: true, displayOptions: {"show":{"useReranker":[true]}}, defaults: {"useReranker":false} }),
+    }).strict();
+  }
+
+  return z.object({
+    parameters: z.object({
+      mode: z.literal('retrieve').default('retrieve'),
+      tableName: stringOrExpression.optional(),
+      useReranker: booleanOrExpression.optional(),
+      options: z.object({ distanceStrategy: z.union([z.literal('COSINE'), z.literal('DOT'), z.literal('EUCLIDEAN'), z.literal('MANHATTAN'), z.literal('EUCLIDEAN_SQUARED'), z.literal('HAMMING'), expressionSchema]).optional(), metadata: z.object({ metadataValues: z.array(z.object({ name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }).optional() }).optional(),
+    }).optional(),
+    subnodes: getSubnodesSchema(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_retrieve.ts

@@ -0,0 +1,89 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3
+ * Discriminator: mode=retrieve
+ */
+
+
+interface Credentials {
+  oracleDBApi: CredentialReference;
+}
+
+/** Retrieve documents from vector store to be used as vector store with AI nodes */
+export type LcVectorStoreOracleDBVectorV13RetrieveParams = {
+  /**
+   * Exposes the store as an `ai_vectorStore` subnode for another node (e.g. `toolVectorStore`). Declare with `vectorStore({...})`. Required subnodes: `embedding`. For RAG with an AI Agent directly, prefer `mode: 'retrieve-as-tool'`.
+   * <patterns>
+   * <pattern title="retrieve mode — feed another node as a subnode (generic)">
+   * // Substitute the type literal and provider-specific parameters — see the rest of this file.
+   * const store = vectorStore({
+   *   type: '@n8n/n8n-nodes-langchain.vectorStoreXxx',
+   *   config: {
+   *     name: 'Knowledge Base',
+   *     parameters: { mode: 'retrieve' /* + provider-specific parameters *\/ },
+   *     subnodes: { embedding: embeddingsOpenAi }
+   *   }
+   * });
+   * 
+   * const retrieverTool = tool({
+   *   type: '@n8n/n8n-nodes-langchain.toolVectorStore',
+   *   config: {
+   *     name: 'KB Retriever',
+   *     parameters: { description: 'Search the product knowledge base' },
+   *     subnodes: { vectorStore: store, model: openAiModel }
+   *   }
+   * });
+   * </pattern>
+   * </patterns>
+   */
+  mode: 'retrieve';
+/**
+ * The table name to store the vectors in. If table does not exist, it will be created.
+ * @default n8n_vectors
+ */
+    tableName?: string | Expression<string>;
+/**
+ * Whether or not to rerank results
+ * @default false
+ */
+    useReranker?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** The method to calculate the distance between two vectors
+     * @default COSINE
+     */
+    distanceStrategy?: 'COSINE' | 'DOT' | 'EUCLIDEAN' | 'MANHATTAN' | 'EUCLIDEAN_SQUARED' | 'HAMMING' | Expression<string>;
+    /** Metadata to filter the document by
+     * @default {}
+     */
+    metadata?: {
+        /** Fields to Set
+     */
+    metadataValues?: Array<{
+      /** Name
+       */
+      name?: string | Expression<string>;
+      /** Value
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+  };
+};
+
+export interface LcVectorStoreOracleDBVectorV13RetrieveSubnodeConfig {
+  embedding: EmbeddingInstance | EmbeddingInstance[];
+  /**
+   * @displayOptions.show { useReranker: [true] }
+   */
+  reranker: RerankerInstance;
+}
+
+export type LcVectorStoreOracleDBVectorV13RetrieveNode = {
+  type: '@n8n/n8n-nodes-langchain.vectorStoreOracleDBVector';
+  version: 1.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcVectorStoreOracleDBVectorV13RetrieveParams> & { subnodes: LcVectorStoreOracleDBVectorV13RetrieveSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_retrieve_as_tool.schema.js

@@ -0,0 +1,35 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3 - Zod Schema
+ * Discriminator: mode=retrieve-as-tool
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, resolveSchema, embeddingInstanceSchema, rerankerInstanceSchema }) {
+
+  // Helper function for conditional subnode schema
+  function getSubnodesSchema() {
+    return z.object({
+      embedding: z.union([embeddingInstanceSchema, z.array(embeddingInstanceSchema)]),
+      reranker: resolveSchema({ parameters, schema: rerankerInstanceSchema, required: true, displayOptions: {"show":{"useReranker":[true]}}, defaults: {"useReranker":false} }),
+    }).strict();
+  }
+
+  return z.object({
+    parameters: z.object({
+      mode: z.literal('retrieve-as-tool'),
+      toolDescription: stringOrExpression,
+      tableName: stringOrExpression.optional(),
+      topK: numberOrExpression.optional(),
+      includeDocumentMetadata: booleanOrExpression.optional(),
+      useReranker: booleanOrExpression.optional(),
+      options: z.object({ distanceStrategy: z.union([z.literal('COSINE'), z.literal('DOT'), z.literal('EUCLIDEAN'), z.literal('MANHATTAN'), z.literal('EUCLIDEAN_SQUARED'), z.literal('HAMMING'), expressionSchema]).optional(), metadata: z.object({ metadataValues: z.array(z.object({ name: stringOrExpression.optional(), value: stringOrExpression.optional() })).optional() }).optional() }).optional(),
+    }).optional(),
+    subnodes: getSubnodesSchema(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/vectorStoreOracleDBVector/v13/mode_retrieve_as_tool.ts

@@ -0,0 +1,108 @@
+/**
+ * Oracle Database Vector Store Node - Version 1.3
+ * Discriminator: mode=retrieve-as-tool
+ */
+
+
+interface Credentials {
+  oracleDBApi: CredentialReference;
+}
+
+/** Retrieve documents from vector store to be used as tool with AI nodes */
+export type LcVectorStoreOracleDBVectorV13RetrieveAsToolParams = {
+  /**
+   * Canonical RAG mode — declare with the `tool({...})` factory (NOT `vectorStore`) and plug into an AI Agent's `subnodes.tools`. Required subnodes: `embedding`. Set `toolDescription` so the agent knows when to call it.
+   * <patterns>
+   * <pattern title="retrieve-as-tool mode — RAG via AI Agent (generic, works for any vectorStore* node)">
+   * // Substitute the type literal and provider-specific parameters — see the rest of this file
+   * // for the exact shape (e.g. pineconeIndex, qdrantCollection, supabaseTableName).
+   * const knowledgeBase = tool({
+   *   type: '@n8n/n8n-nodes-langchain.vectorStoreXxx',
+   *   config: {
+   *     name: 'Knowledge Base',
+   *     parameters: {
+   *       mode: 'retrieve-as-tool',
+   *       toolDescription: 'Search the product knowledge base',
+   *       // ...provider-specific parameters
+   *     },
+   *     subnodes: { embedding: embeddingsOpenAi }
+   *   }
+   * });
+   * 
+   * const agent = node({
+   *   type: '@n8n/n8n-nodes-langchain.agent',
+   *   config: {
+   *     name: 'Support Agent',
+   *     parameters: { promptType: 'define', text: expr('{{ $json.question }}') },
+   *     subnodes: { model: openAiModel, tools: [knowledgeBase] }
+   *   }
+   * });
+   * </pattern>
+   * </patterns>
+   */
+  mode: 'retrieve-as-tool';
+/**
+ * Explain to the LLM what this tool does, a good, specific description would allow LLMs to produce expected results much more often
+ */
+    toolDescription: string | Expression<string>;
+/**
+ * The table name to store the vectors in. If table does not exist, it will be created.
+ * @default n8n_vectors
+ */
+    tableName?: string | Expression<string>;
+/**
+ * Number of top results to fetch from vector store
+ * @default 4
+ */
+    topK?: number | Expression<number>;
+/**
+ * Whether or not to include document metadata
+ * @default true
+ */
+    includeDocumentMetadata?: boolean | Expression<boolean>;
+/**
+ * Whether or not to rerank results
+ * @default false
+ */
+    useReranker?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** The method to calculate the distance between two vectors
+     * @default COSINE
+     */
+    distanceStrategy?: 'COSINE' | 'DOT' | 'EUCLIDEAN' | 'MANHATTAN' | 'EUCLIDEAN_SQUARED' | 'HAMMING' | Expression<string>;
+    /** Metadata to filter the document by
+     * @default {}
+     */
+    metadata?: {
+        /** Fields to Set
+     */
+    metadataValues?: Array<{
+      /** Name
+       */
+      name?: string | Expression<string>;
+      /** Value
+       */
+      value?: string | Expression<string>;
+    }>;
+  };
+  };
+};
+
+export interface LcVectorStoreOracleDBVectorV13RetrieveAsToolSubnodeConfig {
+  embedding: EmbeddingInstance | EmbeddingInstance[];
+  /**
+   * @displayOptions.show { useReranker: [true] }
+   */
+  reranker: RerankerInstance;
+}
+
+export type LcVectorStoreOracleDBVectorV13RetrieveAsToolNode = {
+  type: '@n8n/n8n-nodes-langchain.vectorStoreOracleDBVector';
+  version: 1.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcVectorStoreOracleDBVectorV13RetrieveAsToolParams> & { subnodes: LcVectorStoreOracleDBVectorV13RetrieveAsToolSubnodeConfig };
+};

package/dist/nodes/document_loaders/DocumentBinaryInputLoader/DocumentBinaryInputLoader.node.d.ts

@@ -1,7 +1,6 @@
 import { type INodeType, type INodeTypeDescription, type ISupplyDataFunctions, type SupplyData } from 'n8n-workflow';
 import 'mammoth';
 import 'epub2';
-import 'pdf-parse';
 export declare class DocumentBinaryInputLoader implements INodeType {
     description: INodeTypeDescription;
     supplyData(this: ISupplyDataFunctions): Promise<SupplyData>;

package/dist/nodes/document_loaders/DocumentBinaryInputLoader/DocumentBinaryInputLoader.node.js

@@ -5,7 +5,6 @@ const n8n_workflow_1 = require("n8n-workflow");
 const ai_utilities_1 = require("@n8n/ai-utilities");
 require("mammoth");
 require("epub2");
-require("pdf-parse");
 class DocumentBinaryInputLoader {
     constructor() {
         this.description = {