cag-js/dist/cag.d.ts

Chunked Augmented Generation (CAG) algorithm for processing large text inputs with AI models

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
/**
 * Configuration options for CAG processing
 * @typedef {Object} CAGConfig
 * @property {number} chunkSize - Size of each text chunk in characters
 * @property {number} chunkOverlap - Number of overlapping characters between chunks
 * @property {number} [iteration_limit] - Maximum number of recursive processing iterations (2-100)
 * @property {number} [iteration_output_token_limit] - Maximum length of processed output before stopping
 */
type CAGConfig = {
    chunkSize: number;
    chunkOverlap: number;
    iteration_limit?: number;
    iteration_output_token_limit?: number;
};
/**
 * CAG (Chunked Augmented Generation) class for handling large text inputs with Chrome's built-in Gemini Nano.
 * This class implements intelligent chunking strategies to overcome context window limitations while
 * maintaining semantic coherence across processed chunks.
 *
 * @class
 * @example
 * ```typescript
 * const config = {
 *   chunkSize: 24576, // 6144 tokens * 4 chars/token
 *   chunkOverlap: 200,
 *   iteration_limit: 3,
 *   iteration_output_token_limit: 1000
 * };
 * const promptTemplate = "Summarize the following text: {text}";
 * const cag = new CAG(config, promptTemplate);
 * const result = await cag.generate_recursive(longText);
 * ```
 */
declare class CAG {
    _ai: any;
    _role: any;
    splitter: RecursiveCharacterTextSplitter;
    prompt_template: string;
    config: CAGConfig;
    /**
     * Creates a new CAG instance
     * @constructor
     * @param {CAGConfig} config - Configuration options for text chunking and processing
     * @param {string} prompt_template - Template string for AI prompts with {text} placeholder
     * @throws {Error} If configuration parameters are invalid
     */
    constructor(config: CAGConfig, prompt_template: string);
    /**
     * Validates the configuration parameters
     * @private
     * @param {CAGConfig} config - Configuration to validate
     * @throws {Error} If any configuration parameters are invalid
     */
    validateConfig: (config: CAGConfig) => void;
    /**
     * Sets up the text splitter with configured chunk size and overlap
     * @private
     * @param {CAGConfig} config - Configuration for text splitting
     * @returns {RecursiveCharacterTextSplitter} Configured text splitter instance
     */
    setupSplitter: (config: CAGConfig) => RecursiveCharacterTextSplitter;
    /**
     * Initializes the AI model instance
     * @private
     * @param {string} [aiType='languageModel'] - Type of AI model to initialize
     * @param {Object} [config={}] - Additional configuration for AI model
     * @returns {Promise<any>} Initialized AI model instance
     */
    initialize: (aiType?: string, config?: {}) => Promise<any>;
    /**
     * Processes input text sequentially in chunks
     * Sequential processing handles each chunk independently and combines results linearly.
     *
     * @param {string} longInput - Long text input to process
     * @returns {Promise<string>} Combined output from all chunks
     */
    generate_sequential: (longInput: string) => Promise<string>;
    /**
     * Processes input text recursively with refinement iterations
     * Recursive processing allows for progressive refinement of the output through multiple passes.
     *
     * @param {string} longInput - Long text input to process
     * @param {number} [iterationCount=0] - Current iteration count for recursive processing
     * @returns {Promise<string>} Refined output after processing
     * @throws {Error} If neither iteration_limit nor iteration_output_token_limit is set
     */
    generate_recursive: (longInput: string, iterationCount?: number) => Promise<string>;
}
export default CAG;