voctar 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Voctar contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+<p align="center">
+  <img src="./docs/assets/vectar.png" alt="Voctar logo" width="180" />
+</p>
+
+<h1 align="center">Voctar</h1>
+
+<p align="center">
+  Simple TypeScript library with RAG primitives for embeddings, chunking, storage, and semantic retrieval.
+</p>
+
+<p align="center">
+  <img alt="npm version" src="https://img.shields.io/npm/v/voctar?logo=npm&color=CB3837" />
+  <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-5.x-3178C6?logo=typescript&logoColor=white" />
+  <img alt="Node" src="https://img.shields.io/badge/Node-%3E%3D18-339933?logo=node.js&logoColor=white" />
+  <img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-yellow.svg" />
+</p>
+
+## Features
+
+- Supports multiple vector stores: SQLite, Qdrant, in-memory, or custom store providers
+- Automatic chunking for long documents with multiple strategies (`fixed`, `recursive`, `sentence`, `paragraph`, `semantic`)
+- Semantic search with score thresholds and metadata filtering
+- Simple primitives: `embed`, `search` and more
+- TypeScript-first.
+
+## Quick Start
+
+```bash
+yarn add voctar
+```
+
+```typescript
+import { Voctar } from 'voctar';
+
+const vector = new Voctar({
+  embedding: {
+    type: 'openai',
+    apiKey: '<your-api-key>',
+  },
+  store: {
+    type: 'sqlite',
+    path: 'data/vector.db',
+  },
+});
+
+const { documentId } = await vector.embed('documents', "Very long text...", {
+  metadata: { author: 'Alice' },
+});
+
+const results = await vector.search('documents', 'Some query');
+```
+
+## Primitives API
+
+### `embed(collection, text, options?)`
+
+Embeds a document into a collection.  
+If the text exceeds model limits, Voctar auto-chunks and stores chunk vectors.
+
+```typescript
+const { documentId, chunkIds } = await vector.embed('documents', longText, {
+  documentId: 'doc-1',                 // optional; auto-generated if omitted
+  metadata: { source: 'guide' },       // optional user metadata
+  chunkSize: 1000,                     // optional
+  chunkStrategy: 'recursive',          // fixed | recursive | sentence | paragraph | semantic
+  chunkOverlap: 200,                   // optional
+  autoChunk: true,                     // optional override
+});
+```
+
+Returns:
+
+- `documentId`: stable parent id for the document
+- `chunkIds`: stored ids (single id for unchunked docs, multiple for chunked docs)
+
+### `search(collection, query, options?)`
+
+Retrieves semantically similar text from a collection.
+
+```typescript
+const results = await vector.search('documents', 'how does chunking work', {
+  limit: 5,                            // optional, default provider behavior
+  scoreThreshold: 0,                   // optional
+  filter: { source: 'guide' },         // optional metadata filter
+  includeSystem: false,                // optional; include internal metadata when true
+});
+```
+
+Each result includes:
+
+- `id`
+- `text`
+- `score`
+- `createdAt`
+- `metadata` (and optional `system` when `includeSystem: true`)
+
+## Documentation
+
+- [Docs Index](./docs/README.md)
+- [Storage Backends](./docs/STORAGE_BACKENDS.md)
+- [Chunking](./docs/CHUNKING.md)
+

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { Vector, Vector as Voctar } from './src/vector';
+export * from './src/providers';
+export * from './src/types';
+export { chunking, ChunkingService } from './src/chunking';
+export * from './src/chunking/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AACxD,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAG5B,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC3D,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkingService = exports.chunking = exports.Voctar = exports.Vector = void 0;
+// Voctar exports
+var vector_1 = require("./src/vector");
+Object.defineProperty(exports, "Vector", { enumerable: true, get: function () { return vector_1.Vector; } });
+Object.defineProperty(exports, "Voctar", { enumerable: true, get: function () { return vector_1.Vector; } });
+__exportStar(require("./src/providers"), exports);
+__exportStar(require("./src/types"), exports);
+// Chunking exports
+var chunking_1 = require("./src/chunking");
+Object.defineProperty(exports, "chunking", { enumerable: true, get: function () { return chunking_1.chunking; } });
+Object.defineProperty(exports, "ChunkingService", { enumerable: true, get: function () { return chunking_1.ChunkingService; } });
+__exportStar(require("./src/chunking/types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,iBAAiB;AACjB,uCAAwD;AAA/C,gGAAA,MAAM,OAAA;AAAE,gGAAA,MAAM,OAAU;AACjC,kDAAgC;AAChC,8CAA4B;AAE5B,mBAAmB;AACnB,2CAA2D;AAAlD,oGAAA,QAAQ,OAAA;AAAE,2GAAA,eAAe,OAAA;AAClC,uDAAqC"}

package/dist/src/chunking/index.d.ts

@@ -0,0 +1,48 @@
+import type { ChunkingOptions, ChunkingStrategy, DocumentChunkResult } from './types';
+export declare class ChunkingService {
+    private strategies;
+    private defaultStrategy;
+    constructor();
+    /**
+     * Register a custom chunking strategy
+     */
+    registerStrategy(strategy: ChunkingStrategy): void;
+    /**
+     * Chunk a single document
+     */
+    chunkDocument(text: string, options?: ChunkingOptions, documentId?: string): DocumentChunkResult;
+    /**
+     * Chunk multiple documents
+     */
+    chunkDocuments(documents: Array<{
+        text: string;
+        id?: string;
+        metadata?: Record<string, any>;
+    }>, options?: ChunkingOptions): DocumentChunkResult[];
+    /**
+     * Estimate token count using accurate tokenizer
+     */
+    estimateTokens(text: string): number;
+    /**
+     * Get optimal chunk size based on embedding model's token limit
+     * Now returns tokens directly, not characters
+     */
+    getOptimalChunkSize(modelTokenLimit?: number, safetyMargin?: number): number;
+    /**
+     * Set default chunking strategy
+     */
+    setDefaultStrategy(strategy: string): void;
+    /**
+     * Get list of available strategies
+     */
+    getAvailableStrategies(): string[];
+}
+export declare const chunking: ChunkingService;
+export * from './types';
+export { FixedSizeChunkingStrategy } from './strategies/fixed';
+export { RecursiveChunkingStrategy } from './strategies/recursive';
+export { SentenceChunkingStrategy } from './strategies/sentence';
+export { ParagraphChunkingStrategy } from './strategies/paragraph';
+export { SemanticChunkingStrategy } from './strategies/semantic';
+export type { SemanticChunkingOptions } from './strategies/semantic';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/chunking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/chunking/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAS,eAAe,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAO7F,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,eAAe,CAAuB;;IAa9C;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAIlD;;OAEG;IACH,aAAa,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,EAC7B,UAAU,CAAC,EAAE,MAAM,GAClB,mBAAmB;IAuBtB;;OAEG;IACH,cAAc,CACZ,SAAS,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC,EAC/E,OAAO,GAAE,eAAoB,GAC5B,mBAAmB,EAAE;IAWxB;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAKpC;;;OAGG;IACH,mBAAmB,CAAC,eAAe,GAAE,MAAa,EAAE,YAAY,GAAE,MAAY,GAAG,MAAM;IAMvF;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAO1C;;OAEG;IACH,sBAAsB,IAAI,MAAM,EAAE;CAGnC;AAGD,eAAO,MAAM,QAAQ,iBAAwB,CAAC;AAG9C,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,YAAY,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/chunking/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticChunkingStrategy = exports.ParagraphChunkingStrategy = exports.SentenceChunkingStrategy = exports.RecursiveChunkingStrategy = exports.FixedSizeChunkingStrategy = exports.chunking = exports.ChunkingService = void 0;
+// Main chunking service
+const uuid_1 = require("uuid");
+const fixed_1 = require("./strategies/fixed");
+const recursive_1 = require("./strategies/recursive");
+const sentence_1 = require("./strategies/sentence");
+const paragraph_1 = require("./strategies/paragraph");
+const semantic_1 = require("./strategies/semantic");
+class ChunkingService {
+    constructor() {
+        this.defaultStrategy = 'recursive';
+        this.strategies = new Map();
+        // Register built-in strategies
+        this.registerStrategy(new fixed_1.FixedSizeChunkingStrategy());
+        this.registerStrategy(new recursive_1.RecursiveChunkingStrategy());
+        this.registerStrategy(new sentence_1.SentenceChunkingStrategy());
+        this.registerStrategy(new paragraph_1.ParagraphChunkingStrategy());
+        this.registerStrategy(new semantic_1.SemanticChunkingStrategy());
+    }
+    /**
+     * Register a custom chunking strategy
+     */
+    registerStrategy(strategy) {
+        this.strategies.set(strategy.getName(), strategy);
+    }
+    /**
+     * Chunk a single document
+     */
+    chunkDocument(text, options = {}, documentId) {
+        const docId = documentId || (0, uuid_1.v4)();
+        const strategy = options.strategy || this.defaultStrategy;
+        const chunkingStrategy = this.strategies.get(strategy);
+        if (!chunkingStrategy) {
+            throw new Error(`Unknown chunking strategy: ${strategy}`);
+        }
+        const chunks = chunkingStrategy.chunk(text, docId, options);
+        return {
+            documentId: docId,
+            chunks,
+            metadata: {
+                originalLength: text.length,
+                totalChunks: chunks.length,
+                strategy,
+                ...options.metadata,
+            },
+        };
+    }
+    /**
+     * Chunk multiple documents
+     */
+    chunkDocuments(documents, options = {}) {
+        return documents.map(doc => {
+            const docOptions = {
+                ...options,
+                metadata: { ...options.metadata, ...doc.metadata },
+            };
+            return this.chunkDocument(doc.text, docOptions, doc.id);
+        });
+    }
+    /**
+     * Estimate token count using accurate tokenizer
+     */
+    estimateTokens(text) {
+        const { countTokens } = require('./utils/tokenizer');
+        return countTokens(text);
+    }
+    /**
+     * Get optimal chunk size based on embedding model's token limit
+     * Now returns tokens directly, not characters
+     */
+    getOptimalChunkSize(modelTokenLimit = 8192, safetyMargin = 0.8) {
+        const effectiveLimit = Math.floor(modelTokenLimit * safetyMargin);
+        // Return tokens directly (not characters)
+        return effectiveLimit;
+    }
+    /**
+     * Set default chunking strategy
+     */
+    setDefaultStrategy(strategy) {
+        if (!this.strategies.has(strategy)) {
+            throw new Error(`Unknown strategy: ${strategy}`);
+        }
+        this.defaultStrategy = strategy;
+    }
+    /**
+     * Get list of available strategies
+     */
+    getAvailableStrategies() {
+        return Array.from(this.strategies.keys());
+    }
+}
+exports.ChunkingService = ChunkingService;
+// Export singleton instance
+exports.chunking = new ChunkingService();
+// Export types and strategies
+__exportStar(require("./types"), exports);
+var fixed_2 = require("./strategies/fixed");
+Object.defineProperty(exports, "FixedSizeChunkingStrategy", { enumerable: true, get: function () { return fixed_2.FixedSizeChunkingStrategy; } });
+var recursive_2 = require("./strategies/recursive");
+Object.defineProperty(exports, "RecursiveChunkingStrategy", { enumerable: true, get: function () { return recursive_2.RecursiveChunkingStrategy; } });
+var sentence_2 = require("./strategies/sentence");
+Object.defineProperty(exports, "SentenceChunkingStrategy", { enumerable: true, get: function () { return sentence_2.SentenceChunkingStrategy; } });
+var paragraph_2 = require("./strategies/paragraph");
+Object.defineProperty(exports, "ParagraphChunkingStrategy", { enumerable: true, get: function () { return paragraph_2.ParagraphChunkingStrategy; } });
+var semantic_2 = require("./strategies/semantic");
+Object.defineProperty(exports, "SemanticChunkingStrategy", { enumerable: true, get: function () { return semantic_2.SemanticChunkingStrategy; } });
+//# sourceMappingURL=index.js.map

package/dist/src/chunking/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/chunking/index.ts"],"names":[],"mappings":"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"}

package/dist/src/chunking/strategies/fixed.d.ts

@@ -0,0 +1,14 @@
+import type { Chunk, ChunkingOptions, ChunkingStrategy } from '../types';
+export declare class FixedSizeChunkingStrategy implements ChunkingStrategy {
+    getName(): string;
+    chunk(text: string, documentId: string, options: ChunkingOptions): Chunk[];
+    /**
+     * Get text up to a token limit
+     */
+    private getTextUpToTokenLimit;
+    /**
+     * Get overlap text that is approximately 'overlapTokens' tokens
+     */
+    private getOverlapText;
+}
+//# sourceMappingURL=fixed.d.ts.map

package/dist/src/chunking/strategies/fixed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed.d.ts","sourceRoot":"","sources":["../../../../src/chunking/strategies/fixed.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGzE,qBAAa,yBAA0B,YAAW,gBAAgB;IAChE,OAAO,IAAI,MAAM;IAIjB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,KAAK,EAAE;IA4D1E;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA0B7B;;OAEG;IACH,OAAO,CAAC,cAAc;CAuBvB"}

package/dist/src/chunking/strategies/fixed.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixedSizeChunkingStrategy = void 0;
+// Fixed-size chunking strategy
+const uuid_1 = require("uuid");
+const tokenizer_1 = require("../utils/tokenizer");
+class FixedSizeChunkingStrategy {
+    getName() {
+        return 'fixed';
+    }
+    chunk(text, documentId, options) {
+        // Get token limit and ensure maxSize doesn't exceed it
+        const tokenLimit = options.tokenLimit ?? 8192;
+        const maxSize = Math.min(options.maxChunkSize ?? 1000, tokenLimit);
+        const overlap = Math.min(options.overlap ?? 200, Math.floor(maxSize * 0.2));
+        const preserveFormatting = options.preserveFormatting ?? false;
+        // Normalize text if not preserving formatting
+        const normalizedText = preserveFormatting
+            ? text
+            : text.replace(/\s+/g, ' ').trim();
+        const chunks = [];
+        let startChar = 0;
+        let chunkIndex = 0;
+        while (startChar < normalizedText.length) {
+            // Get text up to token limit
+            const remainingText = normalizedText.slice(startChar);
+            const chunkText = this.getTextUpToTokenLimit(remainingText, maxSize);
+            if (!chunkText || chunkText.length === 0) {
+                break;
+            }
+            const endChar = startChar + chunkText.length;
+            chunks.push({
+                id: (0, uuid_1.v4)(),
+                text: chunkText,
+                metadata: {
+                    documentId,
+                    chunkIndex,
+                    totalChunks: 0, // Will be updated after all chunks are created
+                    startChar,
+                    endChar,
+                    tokens: (0, tokenizer_1.countTokens)(chunkText),
+                    ...options.metadata,
+                },
+            });
+            // Calculate overlap position using token count
+            const overlapText = this.getOverlapText(chunkText, overlap);
+            startChar = endChar - overlapText.length;
+            chunkIndex++;
+            // Avoid creating tiny overlapping chunks at the end
+            if (normalizedText.length - startChar < overlapText.length) {
+                break;
+            }
+        }
+        // Update totalChunks for all chunks
+        chunks.forEach(chunk => {
+            chunk.metadata.totalChunks = chunks.length;
+        });
+        return chunks;
+    }
+    /**
+     * Get text up to a token limit
+     */
+    getTextUpToTokenLimit(text, maxTokens) {
+        if ((0, tokenizer_1.countTokens)(text) <= maxTokens) {
+            return text;
+        }
+        // Binary search for the right character position
+        let start = 0;
+        let end = text.length;
+        let bestMatch = '';
+        while (start < end) {
+            const mid = Math.floor((start + end) / 2);
+            const candidate = text.slice(0, mid);
+            const tokens = (0, tokenizer_1.countTokens)(candidate);
+            if (tokens <= maxTokens) {
+                bestMatch = candidate;
+                start = mid + 1;
+            }
+            else {
+                end = mid;
+            }
+        }
+        return bestMatch || text.slice(0, Math.floor(text.length * 0.8)); // Fallback to 80%
+    }
+    /**
+     * Get overlap text that is approximately 'overlapTokens' tokens
+     */
+    getOverlapText(text, overlapTokens) {
+        if (overlapTokens === 0)
+            return '';
+        // Binary search for the right amount of text
+        let start = 0;
+        let end = text.length;
+        let bestMatch = '';
+        while (start < end) {
+            const mid = Math.floor((start + end) / 2);
+            const candidate = text.slice(mid);
+            const tokens = (0, tokenizer_1.countTokens)(candidate);
+            if (tokens <= overlapTokens) {
+                bestMatch = candidate;
+                end = mid;
+            }
+            else {
+                start = mid + 1;
+            }
+        }
+        return bestMatch || text.slice(-Math.floor(text.length * 0.1)); // Fallback to last 10%
+    }
+}
+exports.FixedSizeChunkingStrategy = FixedSizeChunkingStrategy;
+//# sourceMappingURL=fixed.js.map

package/dist/src/chunking/strategies/fixed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed.js","sourceRoot":"","sources":["../../../../src/chunking/strategies/fixed.ts"],"names":[],"mappings":"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"}

package/dist/src/chunking/strategies/paragraph.d.ts

@@ -0,0 +1,6 @@
+import type { Chunk, ChunkingOptions, ChunkingStrategy } from '../types';
+export declare class ParagraphChunkingStrategy implements ChunkingStrategy {
+    getName(): string;
+    chunk(text: string, documentId: string, options: ChunkingOptions): Chunk[];
+}
+//# sourceMappingURL=paragraph.d.ts.map

package/dist/src/chunking/strategies/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../src/chunking/strategies/paragraph.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGzE,qBAAa,yBAA0B,YAAW,gBAAgB;IAChE,OAAO,IAAI,MAAM;IAIjB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,KAAK,EAAE;CAgF3E"}

package/dist/src/chunking/strategies/paragraph.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParagraphChunkingStrategy = void 0;
+// Paragraph-based chunking strategy
+const uuid_1 = require("uuid");
+const tokenizer_1 = require("../utils/tokenizer");
+class ParagraphChunkingStrategy {
+    getName() {
+        return 'paragraph';
+    }
+    chunk(text, documentId, options) {
+        // Get token limit and ensure maxSize doesn't exceed it
+        const tokenLimit = options.tokenLimit ?? 8192;
+        const maxSize = Math.min(options.maxChunkSize ?? 2000, tokenLimit);
+        const overlap = options.overlap ?? 1; // Overlap in number of paragraphs
+        // Split text into paragraphs
+        const paragraphs = text
+            .split(/\n\s*\n/)
+            .map(p => p.trim())
+            .filter(p => p.length > 0);
+        const chunks = [];
+        let currentChunk = [];
+        let currentTokens = 0;
+        let chunkIndex = 0;
+        let startChar = 0;
+        for (let i = 0; i < paragraphs.length; i++) {
+            const paragraph = paragraphs[i];
+            const paragraphTokens = (0, tokenizer_1.countTokens)(paragraph);
+            // If adding this paragraph would exceed maxSize (in tokens) and we have content, create a chunk
+            if (currentTokens + paragraphTokens > maxSize && currentChunk.length > 0) {
+                const chunkText = currentChunk.join('\n\n').trim();
+                const endChar = startChar + chunkText.length;
+                chunks.push({
+                    id: (0, uuid_1.v4)(),
+                    text: chunkText,
+                    metadata: {
+                        documentId,
+                        chunkIndex,
+                        totalChunks: 0, // Will be updated later
+                        startChar,
+                        endChar,
+                        paragraphs: currentChunk.length,
+                        ...options.metadata,
+                    },
+                });
+                // Keep last N paragraphs for overlap
+                const overlapParagraphs = currentChunk.slice(-overlap);
+                currentChunk = [...overlapParagraphs, paragraph];
+                currentTokens = (0, tokenizer_1.countTokens)(overlapParagraphs.join('\n\n')) + paragraphTokens;
+                startChar = endChar - (overlapParagraphs.join('\n\n').length);
+                chunkIndex++;
+            }
+            else {
+                currentChunk.push(paragraph);
+                currentTokens += paragraphTokens;
+            }
+        }
+        // Add remaining content as final chunk
+        if (currentChunk.length > 0) {
+            const chunkText = currentChunk.join('\n\n').trim();
+            const endChar = startChar + chunkText.length;
+            chunks.push({
+                id: (0, uuid_1.v4)(),
+                text: chunkText,
+                metadata: {
+                    documentId,
+                    chunkIndex,
+                    totalChunks: 0,
+                    startChar,
+                    endChar,
+                    paragraphs: currentChunk.length,
+                    ...options.metadata,
+                },
+            });
+        }
+        // Update totalChunks
+        chunks.forEach(chunk => {
+            chunk.metadata.totalChunks = chunks.length;
+        });
+        return chunks;
+    }
+}
+exports.ParagraphChunkingStrategy = ParagraphChunkingStrategy;
+//# sourceMappingURL=paragraph.js.map

package/dist/src/chunking/strategies/paragraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.js","sourceRoot":"","sources":["../../../../src/chunking/strategies/paragraph.ts"],"names":[],"mappings":"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"}

package/dist/src/chunking/strategies/recursive.d.ts

@@ -0,0 +1,17 @@
+import type { Chunk, ChunkingOptions, ChunkingStrategy } from '../types';
+export declare class RecursiveChunkingStrategy implements ChunkingStrategy {
+    getName(): string;
+    chunk(text: string, documentId: string, options: ChunkingOptions): Chunk[];
+    private recursiveSplit;
+    private mergeSplits;
+    /**
+     * Get overlap text that is approximately 'overlapTokens' tokens
+     */
+    private getOverlapText;
+    private splitByCharacters;
+    /**
+     * Get text up to a token limit
+     */
+    private getTextUpToTokenLimit;
+}
+//# sourceMappingURL=recursive.d.ts.map

package/dist/src/chunking/strategies/recursive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursive.d.ts","sourceRoot":"","sources":["../../../../src/chunking/strategies/recursive.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGzE,qBAAa,yBAA0B,YAAW,gBAAgB;IAChE,OAAO,IAAI,MAAM;IAIjB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,KAAK,EAAE;IAoD1E,OAAO,CAAC,cAAc;IA8CtB,OAAO,CAAC,WAAW;IAsCnB;;OAEG;IACH,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,iBAAiB;IAyBzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAyB9B"}