sonamu 0.7.4 → 0.7.5

package/dist/vector/chunking.js

@@ -0,0 +1,97 @@
+import { DEFAULT_VECTOR_CONFIG } from "./config.js";
+/**
+ * 텍스트 청킹
+ * - 현재 가이드에서는 400토큰 이하만 저장하므로 기본적으로 사용하지 않음
+ * - 추후 긴 문서 처리 시 사용
+ */ export class Chunking {
+    config;
+    constructor(config = {}){
+        this.config = {
+            ...DEFAULT_VECTOR_CONFIG.chunking,
+            ...config
+        };
+    }
+    /**
+   * 텍스트를 청크로 분할
+   */ chunk(text) {
+        if (text.length < this.config.skipThreshold) {
+            return [
+                {
+                    index: 0,
+                    text: text.trim(),
+                    startOffset: 0,
+                    endOffset: text.length
+                }
+            ];
+        }
+        const chunks = [];
+        let currentPosition = 0;
+        while(currentPosition < text.length){
+            const remainingText = text.slice(currentPosition);
+            const { chunk, length } = this.extractChunk(remainingText);
+            if (chunk.trim().length >= this.config.minChunkSize) {
+                chunks.push({
+                    index: chunks.length,
+                    text: chunk.trim(),
+                    startOffset: currentPosition,
+                    endOffset: currentPosition + length
+                });
+            }
+            const advance = Math.max(length - this.config.chunkOverlap, this.config.minChunkSize);
+            currentPosition += advance;
+        }
+        return chunks;
+    }
+    /**
+   * 청킹이 필요한지 확인
+   */ needsChunking(text) {
+        return text.length > this.config.chunkSize;
+    }
+    /**
+   * 예상 청크 수 계산
+   */ estimateChunkCount(text) {
+        if (text.length <= this.config.chunkSize) {
+            return 1;
+        }
+        const effectiveChunkSize = this.config.chunkSize - this.config.chunkOverlap;
+        return Math.ceil(text.length / effectiveChunkSize);
+    }
+    extractChunk(text) {
+        if (text.length <= this.config.chunkSize) {
+            return {
+                chunk: text,
+                length: text.length
+            };
+        }
+        for (const separator of this.config.separators){
+            const result = this.splitBySeparator(text, separator);
+            if (result) return result;
+        }
+        return {
+            chunk: text.slice(0, this.config.chunkSize),
+            length: this.config.chunkSize
+        };
+    }
+    splitBySeparator(text, separator) {
+        const searchRange = text.slice(0, this.config.chunkSize + 100);
+        let lastIndex = -1;
+        let index = 0;
+        while(true){
+            index = searchRange.indexOf(separator, index);
+            if (index === -1) break;
+            if (index <= this.config.chunkSize) {
+                lastIndex = index + separator.length;
+            }
+            index++;
+        }
+        if (lastIndex > this.config.minChunkSize) {
+            return {
+                chunk: text.slice(0, lastIndex),
+                length: lastIndex
+            };
+        }
+        return null;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/vector/config.d.ts

@@ -0,0 +1,12 @@
+import type { VectorConfig } from "./types";
+/**
+ * 벡터 검색 기본 설정
+ * 사용자는 이 설정을 override하여 커스터마이즈할 수 있음
+ */
+export declare const DEFAULT_VECTOR_CONFIG: VectorConfig;
+/**
+ * 설정 생성 헬퍼 함수
+ * 부분 설정만 제공하면 나머지는 기본값 사용
+ */
+export declare function createVectorConfig(overrides?: Partial<VectorConfig>): VectorConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/vector/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/vector/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,YA6CnC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,GAAE,OAAO,CAAC,YAAY,CAAM,GACpC,YAAY,CAQd"}

package/dist/vector/config.js

@@ -0,0 +1,83 @@
+/**
+ * 벡터 검색 기본 설정
+ * 사용자는 이 설정을 override하여 커스터마이즈할 수 있음
+ */ export const DEFAULT_VECTOR_CONFIG = {
+    // Voyage AI 설정
+    // apiKey는 Sonamu.secrets에서 로드되므로 여기서는 빈 문자열
+    voyage: {
+        apiKey: "",
+        baseUrl: "https://api.voyageai.com/v1/embeddings",
+        model: "voyage-3",
+        dimensions: 1024,
+        maxTokens: 32000,
+        batchSize: 100
+    },
+    // OpenAI 설정
+    // apiKey는 Sonamu.secrets에서 로드되므로 여기서는 빈 문자열
+    openai: {
+        apiKey: "",
+        baseUrl: "https://api.openai.com/v1/embeddings",
+        model: "text-embedding-3-small",
+        dimensions: 1536,
+        maxTokens: 8191,
+        batchSize: 100
+    },
+    // 청킹 설정 (필요시 사용)
+    chunking: {
+        chunkSize: 500,
+        chunkOverlap: 50,
+        minChunkSize: 50,
+        skipThreshold: 200,
+        separators: [
+            "\n\n",
+            "\n",
+            "。",
+            ". ",
+            "! ",
+            "? ",
+            ", ",
+            " "
+        ]
+    },
+    // 검색 설정
+    search: {
+        defaultLimit: 10,
+        similarityThreshold: 0.5,
+        vectorWeight: 0.7,
+        ftsWeight: 0.3
+    },
+    // pgvector 설정
+    pgvector: {
+        iterativeScan: true,
+        efSearch: 100
+    }
+};
+/**
+ * 설정 생성 헬퍼 함수
+ * 부분 설정만 제공하면 나머지는 기본값 사용
+ */ export function createVectorConfig(overrides = {}) {
+    return {
+        voyage: {
+            ...DEFAULT_VECTOR_CONFIG.voyage,
+            ...overrides.voyage
+        },
+        openai: {
+            ...DEFAULT_VECTOR_CONFIG.openai,
+            ...overrides.openai
+        },
+        chunking: {
+            ...DEFAULT_VECTOR_CONFIG.chunking,
+            ...overrides.chunking
+        },
+        search: {
+            ...DEFAULT_VECTOR_CONFIG.search,
+            ...overrides.search
+        },
+        pgvector: {
+            ...DEFAULT_VECTOR_CONFIG.pgvector,
+            ...overrides.pgvector
+        }
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/vector/embedding.d.ts

@@ -0,0 +1,42 @@
+import type { EmbeddingProvider, EmbeddingResult, ProgressCallback, VectorConfig, VectorInputType } from "./types";
+/**
+ * 임베딩 클라이언트
+ * Voyage AI와 OpenAI 임베딩을 통합 지원
+ */
+export declare class Embedding {
+    private config;
+    constructor(config?: Partial<VectorConfig>);
+    /**
+     * 텍스트 임베딩 생성
+     * @param texts - 임베딩할 텍스트 배열
+     * @param provider - 'voyage' | 'openai'
+     * @param inputType - 'document' | 'query' (Voyage AI만 해당)
+     */
+    embed(texts: string[], provider: EmbeddingProvider, inputType?: VectorInputType): Promise<EmbeddingResult[]>;
+    /**
+     * 단일 텍스트 임베딩 (편의 메서드)
+     */
+    embedOne(text: string, provider: EmbeddingProvider, inputType?: VectorInputType): Promise<EmbeddingResult>;
+    /**
+     * Voyage AI 임베딩
+     */
+    private embedVoyage;
+    /**
+     * OpenAI 임베딩
+     */
+    private embedOpenAI;
+    /**
+     * 배치 임베딩 (대량 처리)
+     */
+    embedBatch(texts: string[], provider: EmbeddingProvider, inputType?: VectorInputType, onProgress?: ProgressCallback): Promise<EmbeddingResult[]>;
+    /**
+     * 벡터를 PostgreSQL vector 타입 문자열로 변환
+     */
+    static toVectorString(embedding: number[]): string;
+    /**
+     * 임베딩 provider의 차원 수 반환
+     */
+    getDimensions(provider: EmbeddingProvider): number;
+    private delay;
+}
+//# sourceMappingURL=embedding.d.ts.map

package/dist/vector/embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/vector/embedding.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAU9C;;;;;OAKG;IACG,KAAK,CACT,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,GAAE,eAA4B,GACtC,OAAO,CAAC,eAAe,EAAE,CAAC;IAQ7B;;OAEG;IACG,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,GAAE,eAA4B,GACtC,OAAO,CAAC,eAAe,CAAC;IAK3B;;OAEG;YACW,WAAW;IAyCzB;;OAEG;YACW,WAAW;IAqCzB;;OAEG;IACG,UAAU,CACd,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,GAAE,eAA4B,EACvC,UAAU,CAAC,EAAE,gBAAgB,GAC5B,OAAO,CAAC,eAAe,EAAE,CAAC;IAwB7B;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM;IAIlD;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM;IAMlD,OAAO,CAAC,KAAK;CAGd"}

package/dist/vector/embedding.js

@@ -0,0 +1,147 @@
+import { Sonamu } from "../api/sonamu.js";
+import { DEFAULT_VECTOR_CONFIG } from "./config.js";
+/**
+ * 임베딩 클라이언트
+ * Voyage AI와 OpenAI 임베딩을 통합 지원
+ */ export class Embedding {
+    config;
+    constructor(config = {}){
+        this.config = {
+            voyage: {
+                ...DEFAULT_VECTOR_CONFIG.voyage,
+                ...config.voyage
+            },
+            openai: {
+                ...DEFAULT_VECTOR_CONFIG.openai,
+                ...config.openai
+            },
+            chunking: {
+                ...DEFAULT_VECTOR_CONFIG.chunking,
+                ...config.chunking
+            },
+            search: {
+                ...DEFAULT_VECTOR_CONFIG.search,
+                ...config.search
+            },
+            pgvector: {
+                ...DEFAULT_VECTOR_CONFIG.pgvector,
+                ...config.pgvector
+            }
+        };
+    }
+    /**
+   * 텍스트 임베딩 생성
+   * @param texts - 임베딩할 텍스트 배열
+   * @param provider - 'voyage' | 'openai'
+   * @param inputType - 'document' | 'query' (Voyage AI만 해당)
+   */ async embed(texts, provider, inputType = "document") {
+        if (provider === "voyage") {
+            return this.embedVoyage(texts, inputType);
+        } else {
+            return this.embedOpenAI(texts);
+        }
+    }
+    /**
+   * 단일 텍스트 임베딩 (편의 메서드)
+   */ async embedOne(text, provider, inputType = "document") {
+        const results = await this.embed([
+            text
+        ], provider, inputType);
+        return results[0];
+    }
+    /**
+   * Voyage AI 임베딩
+   */ async embedVoyage(texts, inputType) {
+        const voyageConfig = this.config.voyage;
+        // config에서 설정된 apiKey 우선, 없으면 Sonamu.secrets에서 로드
+        const apiKey = voyageConfig.apiKey || Sonamu.secrets?.voyage_api_key;
+        if (!apiKey) {
+            throw new Error("VOYAGE_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.");
+        }
+        const response = await fetch(voyageConfig.baseUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+                input: texts,
+                model: voyageConfig.model,
+                input_type: inputType
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Voyage API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return data.data.map((item)=>({
+                embedding: item.embedding,
+                model: voyageConfig.model,
+                tokenCount: data.usage?.total_tokens || 0
+            }));
+    }
+    /**
+   * OpenAI 임베딩
+   */ async embedOpenAI(texts) {
+        const openaiConfig = this.config.openai;
+        // config에서 설정된 apiKey 우선, 없으면 Sonamu.secrets에서 로드
+        const apiKey = openaiConfig.apiKey || Sonamu.secrets?.openai_api_key;
+        if (!apiKey) {
+            throw new Error("OPENAI_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.");
+        }
+        const response = await fetch(openaiConfig.baseUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+                input: texts,
+                model: openaiConfig.model
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return data.data.map((item)=>({
+                embedding: item.embedding,
+                model: openaiConfig.model,
+                tokenCount: data.usage?.total_tokens || 0
+            }));
+    }
+    /**
+   * 배치 임베딩 (대량 처리)
+   */ async embedBatch(texts, provider, inputType = "document", onProgress) {
+        const batchSize = provider === "voyage" ? this.config.voyage.batchSize : this.config.openai.batchSize;
+        const results = [];
+        for(let i = 0; i < texts.length; i += batchSize){
+            const batch = texts.slice(i, i + batchSize);
+            const batchResults = await this.embed(batch, provider, inputType);
+            results.push(...batchResults);
+            onProgress?.(Math.min(i + batchSize, texts.length), texts.length);
+            // Rate limiting (100ms between batches)
+            if (i + batchSize < texts.length) {
+                await this.delay(100);
+            }
+        }
+        return results;
+    }
+    /**
+   * 벡터를 PostgreSQL vector 타입 문자열로 변환
+   */ static toVectorString(embedding) {
+        return `[${embedding.join(",")}]`;
+    }
+    /**
+   * 임베딩 provider의 차원 수 반환
+   */ getDimensions(provider) {
+        return provider === "voyage" ? this.config.voyage.dimensions : this.config.openai.dimensions;
+    }
+    delay(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/vector/embedding.ts"],"sourcesContent":["import { Sonamu } from \"../api/sonamu\";\nimport { DEFAULT_VECTOR_CONFIG } from \"./config\";\nimport type {\n  EmbeddingProvider,\n  EmbeddingResult,\n  ProgressCallback,\n  VectorConfig,\n  VectorInputType,\n} from \"./types\";\n\n/**\n * 임베딩 클라이언트\n * Voyage AI와 OpenAI 임베딩을 통합 지원\n */\nexport class Embedding {\n  private config: VectorConfig;\n\n  constructor(config: Partial<VectorConfig> = {}) {\n    this.config = {\n      voyage: { ...DEFAULT_VECTOR_CONFIG.voyage, ...config.voyage },\n      openai: { ...DEFAULT_VECTOR_CONFIG.openai, ...config.openai },\n      chunking: { ...DEFAULT_VECTOR_CONFIG.chunking, ...config.chunking },\n      search: { ...DEFAULT_VECTOR_CONFIG.search, ...config.search },\n      pgvector: { ...DEFAULT_VECTOR_CONFIG.pgvector, ...config.pgvector },\n    };\n  }\n\n  /**\n   * 텍스트 임베딩 생성\n   * @param texts - 임베딩할 텍스트 배열\n   * @param provider - 'voyage' | 'openai'\n   * @param inputType - 'document' | 'query' (Voyage AI만 해당)\n   */\n  async embed(\n    texts: string[],\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\"\n  ): Promise<EmbeddingResult[]> {\n    if (provider === \"voyage\") {\n      return this.embedVoyage(texts, inputType);\n    } else {\n      return this.embedOpenAI(texts);\n    }\n  }\n\n  /**\n   * 단일 텍스트 임베딩 (편의 메서드)\n   */\n  async embedOne(\n    text: string,\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\"\n  ): Promise<EmbeddingResult> {\n    const results = await this.embed([text], provider, inputType);\n    return results[0];\n  }\n\n  /**\n   * Voyage AI 임베딩\n   */\n  private async embedVoyage(\n    texts: string[],\n    inputType: VectorInputType\n  ): Promise<EmbeddingResult[]> {\n    const voyageConfig = this.config.voyage;\n\n    // config에서 설정된 apiKey 우선, 없으면 Sonamu.secrets에서 로드\n    const apiKey = voyageConfig.apiKey || Sonamu.secrets?.voyage_api_key;\n    if (!apiKey) {\n      throw new Error(\n        \"VOYAGE_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\"\n      );\n    }\n\n    const response = await fetch(voyageConfig.baseUrl, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${apiKey}`,\n      },\n      body: JSON.stringify({\n        input: texts,\n        model: voyageConfig.model,\n        input_type: inputType,\n      }),\n    });\n\n    if (!response.ok) {\n      const error = await response.text();\n      throw new Error(`Voyage API error: ${response.status} - ${error}`);\n    }\n\n    const data = await response.json();\n\n    return data.data.map((item: { embedding: number[] }) => ({\n      embedding: item.embedding,\n      model: voyageConfig.model,\n      tokenCount: data.usage?.total_tokens || 0,\n    }));\n  }\n\n  /**\n   * OpenAI 임베딩\n   */\n  private async embedOpenAI(texts: string[]): Promise<EmbeddingResult[]> {\n    const openaiConfig = this.config.openai;\n\n    // config에서 설정된 apiKey 우선, 없으면 Sonamu.secrets에서 로드\n    const apiKey = openaiConfig.apiKey || Sonamu.secrets?.openai_api_key;\n    if (!apiKey) {\n      throw new Error(\n        \"OPENAI_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\"\n      );\n    }\n\n    const response = await fetch(openaiConfig.baseUrl, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${apiKey}`,\n      },\n      body: JSON.stringify({\n        input: texts,\n        model: openaiConfig.model,\n      }),\n    });\n\n    if (!response.ok) {\n      const error = await response.text();\n      throw new Error(`OpenAI API error: ${response.status} - ${error}`);\n    }\n\n    const data = await response.json();\n\n    return data.data.map((item: { embedding: number[] }) => ({\n      embedding: item.embedding,\n      model: openaiConfig.model,\n      tokenCount: data.usage?.total_tokens || 0,\n    }));\n  }\n\n  /**\n   * 배치 임베딩 (대량 처리)\n   */\n  async embedBatch(\n    texts: string[],\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\",\n    onProgress?: ProgressCallback\n  ): Promise<EmbeddingResult[]> {\n    const batchSize =\n      provider === \"voyage\"\n        ? this.config.voyage.batchSize\n        : this.config.openai.batchSize;\n\n    const results: EmbeddingResult[] = [];\n\n    for (let i = 0; i < texts.length; i += batchSize) {\n      const batch = texts.slice(i, i + batchSize);\n      const batchResults = await this.embed(batch, provider, inputType);\n      results.push(...batchResults);\n\n      onProgress?.(Math.min(i + batchSize, texts.length), texts.length);\n\n      // Rate limiting (100ms between batches)\n      if (i + batchSize < texts.length) {\n        await this.delay(100);\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * 벡터를 PostgreSQL vector 타입 문자열로 변환\n   */\n  static toVectorString(embedding: number[]): string {\n    return `[${embedding.join(\",\")}]`;\n  }\n\n  /**\n   * 임베딩 provider의 차원 수 반환\n   */\n  getDimensions(provider: EmbeddingProvider): number {\n    return provider === \"voyage\"\n      ? this.config.voyage.dimensions\n      : this.config.openai.dimensions;\n  }\n\n  private delay(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n}\n"],"names":["Sonamu","DEFAULT_VECTOR_CONFIG","Embedding","config","voyage","openai","chunking","search","pgvector","embed","texts","provider","inputType","embedVoyage","embedOpenAI","embedOne","text","results","voyageConfig","apiKey","secrets","voyage_api_key","Error","response","fetch","baseUrl","method","headers","Authorization","body","JSON","stringify","input","model","input_type","ok","error","status","data","json","map","item","embedding","tokenCount","usage","total_tokens","openaiConfig","openai_api_key","embedBatch","onProgress","batchSize","i","length","batch","slice","batchResults","push","Math","min","delay","toVectorString","join","getDimensions","dimensions","ms","Promise","resolve","setTimeout"],"mappings":"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"}

package/dist/vector/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * pgvector 통합을 위한 타입 정의
+ */
+/** 임베딩 제공자 */
+export type EmbeddingProvider = "voyage" | "openai";
+/** 입력 타입 (Voyage AI 전용 - 비대칭 임베딩) */
+export type VectorInputType = "document" | "query";
+/** 임베딩 결과 */
+export interface EmbeddingResult {
+    embedding: number[];
+    model: string;
+    tokenCount: number;
+}
+/** 청크 정보 */
+export interface Chunk {
+    index: number;
+    text: string;
+    startOffset: number;
+    endOffset: number;
+}
+/** 벡터 검색 결과 */
+export interface VectorSearchResult<T = Record<string, unknown>> {
+    id: number | string;
+    similarity: number;
+    data: T;
+}
+/** 하이브리드 검색 결과 (Vector + FTS) */
+export interface HybridSearchResult<T = Record<string, unknown>> extends VectorSearchResult<T> {
+    vectorScore?: number;
+    ftsScore?: number;
+}
+/** 벤치마크 결과 */
+export interface BenchmarkResult {
+    provider: EmbeddingProvider;
+    embedTime: number;
+    searchTime: number;
+    results: VectorSearchResult[];
+}
+/** Voyage AI 설정 */
+export interface VoyageConfig {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    dimensions: number;
+    maxTokens: number;
+    batchSize: number;
+}
+/** OpenAI 설정 */
+export interface OpenAIConfig {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    dimensions: number;
+    maxTokens: number;
+    batchSize: number;
+}
+/** 청킹 설정 */
+export interface ChunkingConfig {
+    chunkSize: number;
+    chunkOverlap: number;
+    minChunkSize: number;
+    skipThreshold: number;
+    separators: string[];
+}
+/** 검색 설정 */
+export interface SearchConfig {
+    defaultLimit: number;
+    similarityThreshold: number;
+    vectorWeight: number;
+    ftsWeight: number;
+}
+/** pgvector 설정 */
+export interface PgvectorConfig {
+    iterativeScan: boolean;
+    efSearch: number;
+}
+/** 전체 벡터 설정 */
+export interface VectorConfig {
+    voyage: VoyageConfig;
+    openai: OpenAIConfig;
+    chunking: ChunkingConfig;
+    search: SearchConfig;
+    pgvector: PgvectorConfig;
+}
+/** 벡터 검색 옵션 */
+export interface VectorSearchOptions {
+    embeddingColumn?: string;
+    limit?: number;
+    threshold?: number;
+    where?: string;
+}
+/** 하이브리드 검색 옵션 */
+export interface HybridSearchOptions extends VectorSearchOptions {
+    vectorWeight?: number;
+    ftsWeight?: number;
+    ftsColumn?: string;
+}
+/** 임베딩 저장 항목 */
+export interface EmbeddingItem {
+    id: number;
+    text: string;
+}
+/** 진행률 콜백 */
+export type ProgressCallback = (processed: number, total: number) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/vector/types.d.ts.map

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

package/dist/vector/types.js

@@ -0,0 +1,5 @@
+/**
+ * pgvector 통합을 위한 타입 정의
+ */ /** 임베딩 제공자 */ /** 진행률 콜백 */ export { };
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/vector/vector-search.d.ts

@@ -0,0 +1,47 @@
+import type { Knex } from "knex";
+import { Embedding } from "./embedding";
+import type { EmbeddingItem, EmbeddingProvider, HybridSearchOptions, HybridSearchResult, ProgressCallback, VectorConfig, VectorSearchOptions, VectorSearchResult } from "./types";
+/**
+ * 벡터 검색
+ * pgvector를 활용한 벡터 검색 및 하이브리드 검색 지원
+ */
+export declare class VectorSearch<T = Record<string, unknown>> {
+    private db;
+    private config;
+    private embedding;
+    private tableName;
+    constructor(db: Knex, tableName: string, config?: Partial<VectorConfig>);
+    /**
+     * 단일 항목에 임베딩 저장
+     */
+    saveEmbedding(id: number, text: string, provider: EmbeddingProvider, embeddingColumn?: string): Promise<void>;
+    /**
+     * 여러 항목에 임베딩 일괄 저장
+     */
+    saveEmbeddingsBatch(items: EmbeddingItem[], provider: EmbeddingProvider, embeddingColumn?: string, onProgress?: ProgressCallback): Promise<void>;
+    /**
+     * 벡터 검색 (코사인 유사도)
+     */
+    search(query: string, provider: EmbeddingProvider, options?: VectorSearchOptions): Promise<VectorSearchResult<T>[]>;
+    /**
+     * 하이브리드 검색 (Vector + FTS)
+     */
+    hybridSearch(query: string, provider: EmbeddingProvider, options?: HybridSearchOptions): Promise<HybridSearchResult<T>[]>;
+    /**
+     * 임베딩 현황 조회
+     */
+    getEmbeddingStatus(embeddingColumn?: string): Promise<{
+        total: number;
+        withEmbedding: number;
+        withoutEmbedding: number;
+    }>;
+    /**
+     * 임베딩이 없는 항목 ID 조회
+     */
+    getItemsWithoutEmbedding(embeddingColumn?: string, limit?: number): Promise<number[]>;
+    /**
+     * Embedding 인스턴스 반환 (고급 사용)
+     */
+    getEmbedding(): Embedding;
+}
+//# sourceMappingURL=vector-search.d.ts.map

package/dist/vector/vector-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-search.d.ts","sourceRoot":"","sources":["../../src/vector/vector-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,qBAAa,YAAY,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACnD,OAAO,CAAC,EAAE,CAAO;IACjB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,SAAS,CAAS;gBAEd,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAa3E;;OAEG;IACG,aAAa,CACjB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,GAAE,MAA4B,GAC5C,OAAO,CAAC,IAAI,CAAC;IAUhB;;OAEG;IACG,mBAAmB,CACvB,KAAK,EAAE,aAAa,EAAE,EACtB,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,GAAE,MAA4B,EAC7C,UAAU,CAAC,EAAE,gBAAgB,GAC5B,OAAO,CAAC,IAAI,CAAC;IAehB;;OAEG;IACG,MAAM,CACV,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;IAyCnC;;OAEG;IACG,YAAY,CAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;IAiFnC;;OAEG;IACG,kBAAkB,CAAC,eAAe,GAAE,MAA4B,GAAG,OAAO,CAAC;QAC/E,KAAK,EAAE,MAAM,CAAC;QACd,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IAgBF;;OAEG;IACG,wBAAwB,CAC5B,eAAe,GAAE,MAA4B,EAC7C,KAAK,GAAE,MAAY,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC;IAUpB;;OAEG;IACH,YAAY,IAAI,SAAS;CAG1B"}