@virstack/doc-ingest 1.0.0

package/dist/nodes/textExtractorNode.js

@@ -0,0 +1,39 @@
+import fs from "node:fs/promises";
+import officeparser from "officeparser";
+import { parse } from "csv-parse/sync";
+import { logger, LogSource } from "../core/logger.js";
+/**
+ * Extracts raw text from office documents (DOCX, PPTX, XLSX) using officeparser,
+ * CSV files using csv-parse, and TXT files via direct read.
+ */
+export async function textExtractorNode(state) {
+    const { filePath, mimeType } = state;
+    logger.info(LogSource.TEXT_EXTRACTOR, `Parsing: ${filePath} (${mimeType})`);
+    let rawText;
+    if (mimeType === "text/plain") {
+        // Plain text — just read directly
+        rawText = filePath ? await fs.readFile(filePath, "utf-8") : state.rawText;
+    }
+    else if (mimeType === "text/csv") {
+        // CSV — parse and convert to a readable text table
+        if (!filePath)
+            throw new Error("filePath required for CSV parsing");
+        const csvBuffer = await fs.readFile(filePath, "utf-8");
+        const records = parse(csvBuffer, {
+            skip_empty_lines: true,
+        });
+        // Convert to a simple text representation
+        rawText = records
+            .map((row) => row.join(" | "))
+            .join("\n");
+    }
+    else {
+        // DOCX, PPTX, XLSX — use officeparser
+        if (!filePath)
+            throw new Error("filePath required for office document parsing");
+        rawText = await officeparser.parseOfficeAsync(filePath);
+    }
+    logger.info(LogSource.TEXT_EXTRACTOR, `Extracted ${rawText.length} chars of raw text`);
+    return { rawText };
+}
+//# sourceMappingURL=textExtractorNode.js.map

package/dist/nodes/textExtractorNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textExtractorNode.js","sourceRoot":"","sources":["../../src/nodes/textExtractorNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,YAAY,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,KAAoB;IAEpB,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;IAErC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,YAAY,QAAQ,KAAK,QAAQ,GAAG,CAAC,CAAC;IAE5E,IAAI,OAAe,CAAC;IAEpB,IAAI,QAAQ,KAAK,YAAY,EAAE,CAAC;QAC9B,kCAAkC;QAClC,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;IAC5E,CAAC;SAAM,IAAI,QAAQ,KAAK,UAAU,EAAE,CAAC;QACnC,mDAAmD;QACnD,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACpE,MAAM,SAAS,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACvD,MAAM,OAAO,GAAe,KAAK,CAAC,SAAS,EAAE;YAC3C,gBAAgB,EAAE,IAAI;SACvB,CAAC,CAAC;QAEH,0CAA0C;QAC1C,OAAO,GAAG,OAAO;aACd,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAC7B,IAAI,CAAC,IAAI,CAAC,CAAC;IAChB,CAAC;SAAM,CAAC;QACN,sCAAsC;QACtC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QAChF,OAAO,GAAG,MAAM,YAAY,CAAC,gBAAgB,CAAC,QAAQ,CAAW,CAAC;IACpE,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,aAAa,OAAO,CAAC,MAAM,oBAAoB,CAAC,CAAC;IAEvF,OAAO,EAAE,OAAO,EAAE,CAAC;AACrB,CAAC"}

package/dist/nodes/upstashUpsert.d.ts

@@ -0,0 +1,7 @@
+import type { PipelineState } from "../state.js";
+/**
+ * Upserts text chunks + their embedding vectors into Upstash Vector.
+ * Each chunk is stored with rich metadata for RAG filtering.
+ */
+export declare function upstashUpsert(state: PipelineState): Promise<Partial<PipelineState>>;
+//# sourceMappingURL=upstashUpsert.d.ts.map

package/dist/nodes/upstashUpsert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstashUpsert.d.ts","sourceRoot":"","sources":["../../src/nodes/upstashUpsert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;GAGG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CA0CjC"}

package/dist/nodes/upstashUpsert.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import crypto from "node:crypto";
+import { vectorIndex, requireInit } from "../config.js";
+import { logger, LogSource } from "../logger.js";
+/**
+ * Upserts text chunks + their embedding vectors into Upstash Vector.
+ * Each chunk is stored with rich metadata for RAG filtering.
+ */
+export async function upstashUpsert(state) {
+    requireInit();
+    const { filePath, mimeType, textChunks, vectors } = state;
+    // Generate a stable document ID from the file path
+    const docId = crypto
+        .createHash("sha256")
+        .update(filePath || "pasted_text")
+        .digest("hex")
+        .slice(0, 8);
+    logger.info(LogSource.UPSTASH_UPSERT, `Upserting ${textChunks.length} chunks for doc ${docId}`);
+    // Upstash Vector supports batch upserts
+    const upsertPayload = textChunks.map((chunk, i) => ({
+        id: `${docId}-chunk-${i}`,
+        vector: vectors[i],
+        data: chunk,
+        metadata: {
+            text: chunk,
+            source: state.filePath ? path.basename(state.filePath) : "pasted_text",
+            sourcePath: filePath,
+            mimeType: mimeType,
+            chunkIndex: i,
+            totalChunks: textChunks.length,
+            docId: docId,
+            ingestedAt: new Date().toISOString(),
+        },
+    }));
+    // Upsert in batches of 100 (Upstash limit)
+    const BATCH_SIZE = 100;
+    for (let i = 0; i < upsertPayload.length; i += BATCH_SIZE) {
+        const batch = upsertPayload.slice(i, i + BATCH_SIZE);
+        await vectorIndex.upsert(batch);
+        logger.info(LogSource.UPSTASH_UPSERT, `Upserted batch ${Math.floor(i / BATCH_SIZE) + 1}: ${batch.length} vectors`);
+    }
+    logger.success(LogSource.UPSTASH_UPSERT, `All ${textChunks.length} chunks upserted`);
+    return {};
+}
+//# sourceMappingURL=upstashUpsert.js.map

package/dist/nodes/upstashUpsert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstashUpsert.js","sourceRoot":"","sources":["../../src/nodes/upstashUpsert.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEjD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,KAAoB;IAEpB,WAAW,EAAE,CAAC;IACd,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IAE1D,mDAAmD;IACnD,MAAM,KAAK,GAAG,MAAM;SACjB,UAAU,CAAC,QAAQ,CAAC;SACpB,MAAM,CAAC,QAAQ,IAAI,aAAa,CAAC;SACjC,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEf,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,aAAa,UAAU,CAAC,MAAM,mBAAmB,KAAK,EAAE,CAAC,CAAC;IAEhG,wCAAwC;IACxC,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAClD,EAAE,EAAE,GAAG,KAAK,UAAU,CAAC,EAAE;QACzB,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QAClB,IAAI,EAAE,KAAK;QACX,QAAQ,EAAE;YACR,IAAI,EAAE,KAAK;YACX,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,aAAa;YACtE,UAAU,EAAE,QAAQ;YACpB,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,UAAU,CAAC,MAAM;YAC9B,KAAK,EAAE,KAAK;YACZ,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACrC;KACF,CAAC,CAAC,CAAC;IAEJ,2CAA2C;IAC3C,MAAM,UAAU,GAAG,GAAG,CAAC;IACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC;QAC1D,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;QACrD,MAAM,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAEhC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,kBAAkB,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,MAAM,UAAU,CAAC,CAAC;IACrH,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE,OAAO,UAAU,CAAC,MAAM,kBAAkB,CAAC,CAAC;IAErF,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/nodes/vectorEmbedderNode.d.ts

@@ -0,0 +1,7 @@
+import type { PipelineState } from "../core/state.js";
+/**
+ * Embeds all textChunks using the injected EmbeddingAdapter.
+ * Processes in batches to stay within API limits.
+ */
+export declare function vectorEmbedderNode(state: PipelineState): Promise<Partial<PipelineState>>;
+//# sourceMappingURL=vectorEmbedderNode.d.ts.map

package/dist/nodes/vectorEmbedderNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorEmbedderNode.d.ts","sourceRoot":"","sources":["../../src/nodes/vectorEmbedderNode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGtD;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAsBjC"}

package/dist/nodes/vectorEmbedderNode.js

@@ -0,0 +1,23 @@
+import { pipelineConfig, requireInit } from "../core/config.js";
+import { logger, LogSource } from "../core/logger.js";
+/**
+ * Embeds all textChunks using the injected EmbeddingAdapter.
+ * Processes in batches to stay within API limits.
+ */
+export async function vectorEmbedderNode(state) {
+    requireInit();
+    const { textChunks } = state;
+    logger.info(LogSource.VECTOR_EMBEDDER, `Embedding ${textChunks.length} chunks via injected Embedder Node`);
+    const allVectors = [];
+    const BATCH_SIZE = 50; // Common safe default, though adapters might handle their own batching internally
+    for (let i = 0; i < textChunks.length; i += BATCH_SIZE) {
+        const batch = textChunks.slice(i, i + BATCH_SIZE);
+        logger.info(LogSource.VECTOR_EMBEDDER, `Batch ${Math.floor(i / BATCH_SIZE) + 1}: ${batch.length} chunk(s)`);
+        // Call the injected Embedding adapter!
+        const vectors = await pipelineConfig.embedder.embed(batch);
+        allVectors.push(...vectors);
+    }
+    logger.info(LogSource.VECTOR_EMBEDDER, `Generated ${allVectors.length} vectors (${allVectors[0]?.length ?? 0}d)`);
+    return { vectors: allVectors };
+}
+//# sourceMappingURL=vectorEmbedderNode.js.map

package/dist/nodes/vectorEmbedderNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorEmbedderNode.js","sourceRoot":"","sources":["../../src/nodes/vectorEmbedderNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,KAAoB;IAEpB,WAAW,EAAE,CAAC;IACd,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAE7B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,aAAa,UAAU,CAAC,MAAM,oCAAoC,CAAC,CAAC;IAE3G,MAAM,UAAU,GAAe,EAAE,CAAC;IAClC,MAAM,UAAU,GAAG,EAAE,CAAC,CAAC,kFAAkF;IAEzG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC;QACvD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;QAElD,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,SAAS,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,MAAM,WAAW,CAAC,CAAC;QAE5G,uCAAuC;QACvC,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3D,UAAU,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,aAAa,UAAU,CAAC,MAAM,aAAa,UAAU,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC;IAElH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AACjC,CAAC"}

package/dist/nodes/vectorUpsertNode.d.ts

@@ -0,0 +1,7 @@
+import type { PipelineState } from "../core/state.js";
+/**
+ * Upserts text chunks + their embedding vectors into a generic Vector Store Adapter.
+ * Each chunk is stored with rich metadata for vector filtering.
+ */
+export declare function vectorUpsertNode(state: PipelineState): Promise<Partial<PipelineState>>;
+//# sourceMappingURL=vectorUpsertNode.d.ts.map

package/dist/nodes/vectorUpsertNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorUpsertNode.d.ts","sourceRoot":"","sources":["../../src/nodes/vectorUpsertNode.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CA2CjC"}

package/dist/nodes/vectorUpsertNode.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import crypto from "node:crypto";
+import { pipelineConfig, requireInit } from "../core/config.js";
+import { logger, LogSource } from "../core/logger.js";
+/**
+ * Upserts text chunks + their embedding vectors into a generic Vector Store Adapter.
+ * Each chunk is stored with rich metadata for vector filtering.
+ */
+export async function vectorUpsertNode(state) {
+    requireInit();
+    const { filePath, mimeType, textChunks, vectors } = state;
+    // Generate a stable document ID from the file path
+    const docId = crypto
+        .createHash("sha256")
+        .update(filePath || "pasted_text")
+        .digest("hex")
+        .slice(0, 8);
+    logger.info(LogSource.VECTOR_UPSERT, `Upserting ${textChunks.length} chunks via Vector Store Adapter for doc ${docId}`);
+    // Format the data into our standard contract
+    const records = textChunks.map((chunk, i) => ({
+        id: `${docId}-chunk-${i}`,
+        vector: vectors[i],
+        metadata: {
+            text: chunk,
+            source: state.filePath ? path.basename(state.filePath) : "pasted_text",
+            sourcePath: filePath,
+            mimeType: mimeType,
+            chunkIndex: i,
+            totalChunks: textChunks.length,
+            docId: docId,
+            ingestedAt: new Date().toISOString(),
+        },
+    }));
+    // Upsert in batches of 100 (Common limit for many vector DBs)
+    const BATCH_SIZE = 100;
+    for (let i = 0; i < records.length; i += BATCH_SIZE) {
+        const batch = records.slice(i, i + BATCH_SIZE);
+        // Call the user's database adapter instead of Upstash directly!
+        await pipelineConfig.vectorStore.upsert(batch);
+        logger.info(LogSource.VECTOR_UPSERT, `Upserted batch ${Math.floor(i / BATCH_SIZE) + 1} (${batch.length} vectors)`);
+    }
+    logger.success(LogSource.VECTOR_UPSERT, `All ${textChunks.length} chunks upserted`);
+    return {};
+}
+//# sourceMappingURL=vectorUpsertNode.js.map

package/dist/nodes/vectorUpsertNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorUpsertNode.js","sourceRoot":"","sources":["../../src/nodes/vectorUpsertNode.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAGtD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,KAAoB;IAEpB,WAAW,EAAE,CAAC;IACd,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IAE1D,mDAAmD;IACnD,MAAM,KAAK,GAAG,MAAM;SACjB,UAAU,CAAC,QAAQ,CAAC;SACpB,MAAM,CAAC,QAAQ,IAAI,aAAa,CAAC;SACjC,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEf,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,aAAa,UAAU,CAAC,MAAM,4CAA4C,KAAK,EAAE,CAAC,CAAC;IAExH,6CAA6C;IAC7C,MAAM,OAAO,GAAmB,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC5D,EAAE,EAAE,GAAG,KAAK,UAAU,CAAC,EAAE;QACzB,MAAM,EAAE,OAAO,CAAC,CAAC,CAAa;QAC9B,QAAQ,EAAE;YACR,IAAI,EAAE,KAAK;YACX,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,aAAa;YACtE,UAAU,EAAE,QAAQ;YACpB,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,UAAU,CAAC,MAAM;YAC9B,KAAK,EAAE,KAAK;YACZ,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACrC;KACF,CAAC,CAAC,CAAC;IAEJ,8DAA8D;IAC9D,MAAM,UAAU,GAAG,GAAG,CAAC;IACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,UAAU,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;QAE/C,gEAAgE;QAChE,MAAM,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAE/C,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,kBAAkB,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,MAAM,WAAW,CAAC,CAAC;IACrH,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,aAAa,EAAE,OAAO,UAAU,CAAC,MAAM,kBAAkB,CAAC,CAAC;IAEpF,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/pipeline.d.ts

@@ -0,0 +1,303 @@
+export declare function buildPipeline(): import("@langchain/langgraph").CompiledStateGraph<import("@langchain/langgraph").StateType<{
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}>, import("@langchain/langgraph").UpdateType<{
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}>, "markdownMerger" | "markdownNormalizer" | "llmExtractionNode" | "__start__" | "fileTypeRouter" | "libreOfficeToPdf" | "pdfSplitter" | "textExtractorNode" | "saveMarkdown" | "markdownChunker" | "vectorEmbedderNode" | "vectorUpsertNode", {
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}, {
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}, import("@langchain/langgraph").StateDefinition>;
+/**
+ * The compiled graph instance.
+ * Exported specifically for LangGraph Studio and the LangGraph CLI.
+ */
+export declare const graph: import("@langchain/langgraph").CompiledStateGraph<import("@langchain/langgraph").StateType<{
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}>, import("@langchain/langgraph").UpdateType<{
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}>, "markdownMerger" | "markdownNormalizer" | "llmExtractionNode" | "__start__" | "fileTypeRouter" | "libreOfficeToPdf" | "pdfSplitter" | "textExtractorNode" | "saveMarkdown" | "markdownChunker" | "vectorEmbedderNode" | "vectorUpsertNode", {
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}, {
+    filePath: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    mimeType: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    rawText: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    pdfChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    markdownParts: import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+    markdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    textChunks: {
+        (): import("@langchain/langgraph").LastValue<string[]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string[], string[]>): import("@langchain/langgraph").BinaryOperatorAggregate<string[], string[]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    vectors: {
+        (): import("@langchain/langgraph").LastValue<number[][]>;
+        (annotation: import("@langchain/langgraph").SingleReducer<number[][], number[][]>): import("@langchain/langgraph").BinaryOperatorAggregate<number[][], number[][]>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}, import("@langchain/langgraph").StateDefinition>;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AA0CA,wBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDA4D5B;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAkB,CAAC"}

package/dist/pipeline.js

@@ -0,0 +1,93 @@
+import { StateGraph, END, Send } from "@langchain/langgraph";
+import { PipelineStateAnnotation } from "./state.js";
+import { fileTypeRouter, routeByMimeType } from "./nodes/fileTypeRouter.js";
+import { pdfSplitter } from "./nodes/pdfSplitter.js";
+import { llmExtractionNode, routeAfterLlm } from "./nodes/llmExtractionNode.js";
+import { markdownMerger } from "./nodes/markdownMerger.js";
+import { textExtractorNode } from "./nodes/textExtractorNode.js";
+import { markdownNormalizer } from "./nodes/markdownNormalizer.js";
+import { markdownChunker } from "./nodes/markdownChunker.js";
+import { vectorEmbedderNode } from "./nodes/vectorEmbedderNode.js";
+import { vectorUpsertNode } from "./nodes/vectorUpsertNode.js";
+import { saveMarkdown } from "./nodes/saveMarkdown.js";
+import { libreOfficeToPdf } from "./nodes/libreOfficeToPdf.js";
+/**
+ * Builds and compiles the RAG ingestion pipeline as a LangGraph StateGraph.
+ *
+ * Flow:
+ *   START → fileTypeRouter
+ *     ├─ "pdf"     → pdfSplitter → [llmExtractionNode (Parallel)] → markdownMerger → markdownNormalizer
+ *     ├─ "convert" → libreOfficeToPdf → pdfSplitter → (same as pdf branch)
+ *     └─ "extract" → textExtractorNode → llmExtractionNode → markdownNormalizer
+ *   markdownNormalizer → saveMarkdown → markdownChunker → vectorEmbedderNode → vectorUpsertNode → END
+ */
+/**
+ * Returns an array of 'Send' objects to process each PDF chunk in parallel.
+ */
+function dispatchPdfChunks(state) {
+    if (!state.pdfChunks || state.pdfChunks.length === 0) {
+        console.warn("[dispatchPdfChunks] No PDF chunks found to process.");
+        return [];
+    }
+    return state.pdfChunks.map((chunk, index) => {
+        return new Send("llmExtractionNode", {
+            chunk,
+            index,
+            totalChunks: state.pdfChunks.length,
+        });
+    });
+}
+export function buildPipeline() {
+    const graph = new StateGraph(PipelineStateAnnotation)
+        // ── Phase 1: Routing ──
+        .addNode("fileTypeRouter", fileTypeRouter)
+        // ── Phase 2a: PDF Branch ──
+        .addNode("libreOfficeToPdf", libreOfficeToPdf)
+        .addNode("pdfSplitter", pdfSplitter)
+        .addNode("markdownMerger", markdownMerger)
+        // ── Phase 2b: Text / Data Extraction Branch ──
+        .addNode("textExtractorNode", textExtractorNode)
+        .addNode("llmExtractionNode", llmExtractionNode)
+        // ── Phase 3: Normalization & Chunking ──
+        .addNode("markdownNormalizer", markdownNormalizer)
+        .addNode("saveMarkdown", saveMarkdown)
+        .addNode("markdownChunker", markdownChunker)
+        // ── Phase 4: Embedding & Indexing ──
+        .addNode("vectorEmbedderNode", vectorEmbedderNode)
+        .addNode("vectorUpsertNode", vectorUpsertNode)
+        // ── Edges ──
+        // Start → Router
+        .addEdge("__start__", "fileTypeRouter")
+        // Router → conditional branch
+        .addConditionalEdges("fileTypeRouter", routeByMimeType, {
+        pdf: "pdfSplitter",
+        convert: "libreOfficeToPdf",
+        extract: "textExtractorNode",
+    })
+        // Convert branch: LibreOffice → pdfSplitter → (joins PDF branch)
+        .addEdge("libreOfficeToPdf", "pdfSplitter")
+        // PDF branch dispatcher
+        .addConditionalEdges("pdfSplitter", dispatchPdfChunks, ["llmExtractionNode"])
+        // Unified Document/Text branch flow
+        .addEdge("textExtractorNode", "llmExtractionNode")
+        // After llmExtractionNode, conditionally merge PDF chunks or normalize Text
+        .addConditionalEdges("llmExtractionNode", routeAfterLlm, {
+        markdownMerger: "markdownMerger",
+        markdownNormalizer: "markdownNormalizer",
+    })
+        // If PDF branch, finish merger
+        .addEdge("markdownMerger", "markdownNormalizer")
+        // Shared tail: normalize → save → chunk → embed → upsert → end
+        .addEdge("markdownNormalizer", "saveMarkdown")
+        .addEdge("saveMarkdown", "markdownChunker")
+        .addEdge("markdownChunker", "vectorEmbedderNode")
+        .addEdge("vectorEmbedderNode", "vectorUpsertNode")
+        .addEdge("vectorUpsertNode", END);
+    return graph.compile();
+}
+/**
+ * The compiled graph instance.
+ * Exported specifically for LangGraph Studio and the LangGraph CLI.
+ */
+export const graph = buildPipeline();
+//# sourceMappingURL=pipeline.js.map