@llamaindex/core/query-engine/dist/index.d.ts

LlamaIndex Core Module

import { MessageContent } from '../../llms/dist/index.js';
import { PromptMixin } from '../../prompts/dist/index.js';
import * as ___schema from '../../schema/dist/index.js';
import { EngineResponse, NodeWithScore } from '../../schema/dist/index.js';
import { BaseNodePostprocessor } from '../../postprocessor/dist/index.js';
import { BaseSynthesizer } from '../../response-synthesizers/dist/index.js';
import { BaseRetriever } from '../../retriever/dist/index.js';

/**
 * @link https://docs.llamaindex.ai/en/stable/api_reference/schema/?h=querybundle#llama_index.core.schema.QueryBundle
 *
 *  We don't have `image_path` here, because it is included in the `query` field.
 */
type QueryBundle = {
    query: MessageContent;
    customEmbeddings?: string[];
    embeddings?: number[];
};
type QueryType = string | QueryBundle;
type BaseQueryParams = {
    query: QueryType;
};
interface StreamingQueryParams extends BaseQueryParams {
    stream: true;
}
interface NonStreamingQueryParams extends BaseQueryParams {
    stream?: false;
}
declare abstract class BaseQueryEngine extends PromptMixin {
    abstract _query(strOrQueryBundle: QueryType, stream?: boolean): Promise<AsyncIterable<EngineResponse> | EngineResponse>;
    retrieve(params: QueryType): Promise<NodeWithScore[]>;
    query(params: StreamingQueryParams): Promise<AsyncIterable<EngineResponse>>;
    query(params: NonStreamingQueryParams): Promise<EngineResponse>;
}

declare class RetrieverQueryEngine extends BaseQueryEngine {
    retriever: BaseRetriever;
    responseSynthesizer: BaseSynthesizer;
    nodePostprocessors: BaseNodePostprocessor[];
    constructor(retriever: BaseRetriever, responseSynthesizer?: BaseSynthesizer, nodePostprocessors?: BaseNodePostprocessor[]);
    _query(strOrQueryBundle: QueryType, stream?: boolean): Promise<___schema.EngineResponse | AsyncIterable<___schema.EngineResponse>>;
    protected _getPrompts(): {};
    protected _updatePrompts(): void;
    _getPromptModules(): {
        responseSynthesizer: BaseSynthesizer;
    };
    private applyNodePostprocessors;
    retrieve(query: QueryType): Promise<NodeWithScore<___schema.Metadata>[]>;
}

type QueryStartEvent = {
    id: string;
    query: QueryType;
};
type QueryEndEvent = {
    id: string;
    response: EngineResponse | AsyncIterable<EngineResponse>;
};

export { BaseQueryEngine, type QueryBundle, type QueryEndEvent, type QueryStartEvent, type QueryType, RetrieverQueryEngine };