sonamu 0.7.8 → 0.7.9

package/dist/vector/embedding.js

@@ -1,8 +1,11 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { embedMany } from "ai";
+import { VoyageAIClient } from "voyageai";
 import { Sonamu } from "../api/sonamu.js";
 import { DEFAULT_VECTOR_CONFIG } from "./config.js";
 /**
  * 임베딩 클라이언트
- * Voyage AI와 OpenAI 임베딩을 통합 지원
+ * Voyage AI와 OpenAI 임베딩을 SDK 방식으로 통합 지원
  */ export class Embedding {
     config;
     constructor(config = {}){
@@ -30,16 +33,46 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
         };
     }
     /**
+   * Voyage AI 클라이언트 초기화
+   */ getVoyageClient() {
+        const apiKey = Sonamu.secrets?.voyage_api_key ?? process.env.VOYAGE_API_KEY;
+        if (!apiKey) {
+            throw new Error("VOYAGE_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.");
+        }
+        return new VoyageAIClient({
+            apiKey
+        });
+    }
+    /**
+   * OpenAI provider 생성
+   */ getOpenAIProvider() {
+        const apiKey = Sonamu.secrets?.openai_api_key ?? process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error("OPENAI_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.");
+        }
+        return createOpenAI({
+            apiKey
+        });
+    }
+    /**
    * 텍스트 임베딩 생성
-   * @param texts - 임베딩할 텍스트 배열
+   * @param texts - 임베딩할 텍스트 배열 (batchSize이상 시 자동 분할)
    * @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);
+   * @param onProgress - 진행률 콜백
+   */ async embed(texts, provider, inputType = "document", onProgress) {
+        const maxBatchSize = provider === "voyage" ? this.config.voyage.batchSize : this.config.openai.batchSize;
+        // batchSize이하면 바로 호출
+        if (texts.length <= maxBatchSize) {
+            return provider === "voyage" ? await this.embedVoyage(texts, inputType) : await this.embedOpenAI(texts);
         }
+        // batchSize이상이면 자동으로 나눠서 처리
+        const batches = Array.from({
+            length: Math.ceil(texts.length / maxBatchSize)
+        }, (_, i)=>texts.slice(i * maxBatchSize, (i + 1) * maxBatchSize));
+        const results = await Promise.all(batches.map((batch)=>provider === "voyage" ? this.embedVoyage(batch, inputType) : this.embedOpenAI(batch)));
+        onProgress?.(texts.length, texts.length);
+        return results.flat();
     }
     /**
    * 단일 텍스트 임베딩 (편의 메서드)
@@ -52,84 +85,39 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
     /**
    * Voyage AI 임베딩
    */ async embedVoyage(texts, inputType) {
+        const client = this.getVoyageClient();
         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
-            })
+        const response = await client.embed({
+            input: texts,
+            model: voyageConfig.model,
+            inputType: inputType
         });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Voyage API error: ${response.status} - ${error}`);
+        if (!response.data) {
+            throw new Error("Voyage API: 응답 데이터가 없습니다.");
         }
-        const data = await response.json();
-        return data.data.map((item)=>({
-                embedding: item.embedding,
+        return response.data.map((item)=>({
+                embedding: item.embedding ?? [],
                 model: voyageConfig.model,
-                tokenCount: data.usage?.total_tokens || 0
+                tokenCount: response.usage?.totalTokens ?? 0
             }));
     }
     /**
    * OpenAI 임베딩
    */ async embedOpenAI(texts) {
+        const openai = this.getOpenAIProvider();
         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
-            })
+        const model = openai.embeddingModel(openaiConfig.model);
+        const { embeddings, usage } = await embedMany({
+            model: model,
+            values: texts
         });
-        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,
+        return embeddings.map((embedding)=>({
+                embedding,
                 model: openaiConfig.model,
-                tokenCount: data.usage?.total_tokens || 0
+                tokenCount: usage?.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(",")}]`;
@@ -139,9 +127,6 @@ import { DEFAULT_VECTOR_CONFIG } from "./config.js";
    */ 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":"AAAA,SAASA,MAAM,QAAQ,mBAAgB;AACvC,SAASC,qBAAqB,QAAQ,cAAW;AASjD;;;CAGC,GACD,OAAO,MAAMC;IACHC,OAAqB;IAE7B,YAAYA,SAAgC,CAAC,CAAC,CAAE;QAC9C,IAAI,CAACA,MAAM,GAAG;YACZC,QAAQ;gBAAE,GAAGH,sBAAsBG,MAAM;gBAAE,GAAGD,OAAOC,MAAM;YAAC;YAC5DC,QAAQ;gBAAE,GAAGJ,sBAAsBI,MAAM;gBAAE,GAAGF,OAAOE,MAAM;YAAC;YAC5DC,UAAU;gBAAE,GAAGL,sBAAsBK,QAAQ;gBAAE,GAAGH,OAAOG,QAAQ;YAAC;YAClEC,QAAQ;gBAAE,GAAGN,sBAAsBM,MAAM;gBAAE,GAAGJ,OAAOI,MAAM;YAAC;YAC5DC,UAAU;gBAAE,GAAGP,sBAAsBO,QAAQ;gBAAE,GAAGL,OAAOK,QAAQ;YAAC;QACpE;IACF;IAEA;;;;;GAKC,GACD,MAAMC,MACJC,KAAe,EACfC,QAA2B,EAC3BC,YAA6B,UAAU,EACX;QAC5B,IAAID,aAAa,UAAU;YACzB,OAAO,IAAI,CAACE,WAAW,CAACH,OAAOE;QACjC,OAAO;YACL,OAAO,IAAI,CAACE,WAAW,CAACJ;QAC1B;IACF;IAEA;;GAEC,GACD,MAAMK,SACJC,IAAY,EACZL,QAA2B,EAC3BC,YAA6B,UAAU,EACb;QAC1B,MAAMK,UAAU,MAAM,IAAI,CAACR,KAAK,CAAC;YAACO;SAAK,EAAEL,UAAUC;QACnD,OAAOK,OAAO,CAAC,EAAE;IACnB;IAEA;;GAEC,GACD,MAAcJ,YACZH,KAAe,EACfE,SAA0B,EACE;QAC5B,MAAMM,eAAe,IAAI,CAACf,MAAM,CAACC,MAAM;QAEvC,kDAAkD;QAClD,MAAMe,SAASD,aAAaC,MAAM,IAAInB,OAAOoB,OAAO,EAAEC;QACtD,IAAI,CAACF,QAAQ;YACX,MAAM,IAAIG,MACR;QAEJ;QAEA,MAAMC,WAAW,MAAMC,MAAMN,aAAaO,OAAO,EAAE;YACjDC,QAAQ;YACRC,SAAS;gBACP,gBAAgB;gBAChBC,eAAe,CAAC,OAAO,EAAET,QAAQ;YACnC;YACAU,MAAMC,KAAKC,SAAS,CAAC;gBACnBC,OAAOtB;gBACPuB,OAAOf,aAAae,KAAK;gBACzBC,YAAYtB;YACd;QACF;QAEA,IAAI,CAACW,SAASY,EAAE,EAAE;YAChB,MAAMC,QAAQ,MAAMb,SAASP,IAAI;YACjC,MAAM,IAAIM,MAAM,CAAC,kBAAkB,EAAEC,SAASc,MAAM,CAAC,GAAG,EAAED,OAAO;QACnE;QAEA,MAAME,OAAO,MAAMf,SAASgB,IAAI;QAEhC,OAAOD,KAAKA,IAAI,CAACE,GAAG,CAAC,CAACC,OAAmC,CAAA;gBACvDC,WAAWD,KAAKC,SAAS;gBACzBT,OAAOf,aAAae,KAAK;gBACzBU,YAAYL,KAAKM,KAAK,EAAEC,gBAAgB;YAC1C,CAAA;IACF;IAEA;;GAEC,GACD,MAAc/B,YAAYJ,KAAe,EAA8B;QACrE,MAAMoC,eAAe,IAAI,CAAC3C,MAAM,CAACE,MAAM;QAEvC,kDAAkD;QAClD,MAAMc,SAAS2B,aAAa3B,MAAM,IAAInB,OAAOoB,OAAO,EAAE2B;QACtD,IAAI,CAAC5B,QAAQ;YACX,MAAM,IAAIG,MACR;QAEJ;QAEA,MAAMC,WAAW,MAAMC,MAAMsB,aAAarB,OAAO,EAAE;YACjDC,QAAQ;YACRC,SAAS;gBACP,gBAAgB;gBAChBC,eAAe,CAAC,OAAO,EAAET,QAAQ;YACnC;YACAU,MAAMC,KAAKC,SAAS,CAAC;gBACnBC,OAAOtB;gBACPuB,OAAOa,aAAab,KAAK;YAC3B;QACF;QAEA,IAAI,CAACV,SAASY,EAAE,EAAE;YAChB,MAAMC,QAAQ,MAAMb,SAASP,IAAI;YACjC,MAAM,IAAIM,MAAM,CAAC,kBAAkB,EAAEC,SAASc,MAAM,CAAC,GAAG,EAAED,OAAO;QACnE;QAEA,MAAME,OAAO,MAAMf,SAASgB,IAAI;QAEhC,OAAOD,KAAKA,IAAI,CAACE,GAAG,CAAC,CAACC,OAAmC,CAAA;gBACvDC,WAAWD,KAAKC,SAAS;gBACzBT,OAAOa,aAAab,KAAK;gBACzBU,YAAYL,KAAKM,KAAK,EAAEC,gBAAgB;YAC1C,CAAA;IACF;IAEA;;GAEC,GACD,MAAMG,WACJtC,KAAe,EACfC,QAA2B,EAC3BC,YAA6B,UAAU,EACvCqC,UAA6B,EACD;QAC5B,MAAMC,YACJvC,aAAa,WACT,IAAI,CAACR,MAAM,CAACC,MAAM,CAAC8C,SAAS,GAC5B,IAAI,CAAC/C,MAAM,CAACE,MAAM,CAAC6C,SAAS;QAElC,MAAMjC,UAA6B,EAAE;QAErC,IAAK,IAAIkC,IAAI,GAAGA,IAAIzC,MAAM0C,MAAM,EAAED,KAAKD,UAAW;YAChD,MAAMG,QAAQ3C,MAAM4C,KAAK,CAACH,GAAGA,IAAID;YACjC,MAAMK,eAAe,MAAM,IAAI,CAAC9C,KAAK,CAAC4C,OAAO1C,UAAUC;YACvDK,QAAQuC,IAAI,IAAID;YAEhBN,aAAaQ,KAAKC,GAAG,CAACP,IAAID,WAAWxC,MAAM0C,MAAM,GAAG1C,MAAM0C,MAAM;YAEhE,wCAAwC;YACxC,IAAID,IAAID,YAAYxC,MAAM0C,MAAM,EAAE;gBAChC,MAAM,IAAI,CAACO,KAAK,CAAC;YACnB;QACF;QAEA,OAAO1C;IACT;IAEA;;GAEC,GACD,OAAO2C,eAAelB,SAAmB,EAAU;QACjD,OAAO,CAAC,CAAC,EAAEA,UAAUmB,IAAI,CAAC,KAAK,CAAC,CAAC;IACnC;IAEA;;GAEC,GACDC,cAAcnD,QAA2B,EAAU;QACjD,OAAOA,aAAa,WAChB,IAAI,CAACR,MAAM,CAACC,MAAM,CAAC2D,UAAU,GAC7B,IAAI,CAAC5D,MAAM,CAACE,MAAM,CAAC0D,UAAU;IACnC;IAEQJ,MAAMK,EAAU,EAAiB;QACvC,OAAO,IAAIC,QAAQ,CAACC,UAAYC,WAAWD,SAASF;IACtD;AACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/vector/embedding.ts"],"sourcesContent":["import { createOpenAI, type OpenAIProvider } from \"@ai-sdk/openai\";\nimport { type EmbeddingModel, embedMany } from \"ai\";\nimport { VoyageAIClient } from \"voyageai\";\nimport { 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 임베딩을 SDK 방식으로 통합 지원\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   * Voyage AI 클라이언트 초기화\n   */\n  private getVoyageClient(): VoyageAIClient {\n    const apiKey = Sonamu.secrets?.voyage_api_key ?? process.env.VOYAGE_API_KEY;\n    if (!apiKey) {\n      throw new Error(\"VOYAGE_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\");\n    }\n    return new VoyageAIClient({ apiKey });\n  }\n\n  /**\n   * OpenAI provider 생성\n   */\n  private getOpenAIProvider(): OpenAIProvider {\n    const apiKey = Sonamu.secrets?.openai_api_key ?? process.env.OPENAI_API_KEY;\n    if (!apiKey) {\n      throw new Error(\"OPENAI_API_KEY가 설정되지 않았습니다. 환경변수를 확인하세요.\");\n    }\n    return createOpenAI({ apiKey });\n  }\n\n  /**\n   * 텍스트 임베딩 생성\n   * @param texts - 임베딩할 텍스트 배열 (batchSize이상 시 자동 분할)\n   * @param provider - 'voyage' | 'openai'\n   * @param inputType - 'document' | 'query' (Voyage AI만 해당)\n   * @param onProgress - 진행률 콜백\n   */\n  async embed(\n    texts: string[],\n    provider: EmbeddingProvider,\n    inputType: VectorInputType = \"document\",\n    onProgress?: ProgressCallback,\n  ): Promise<EmbeddingResult[]> {\n    const maxBatchSize =\n      provider === \"voyage\" ? this.config.voyage.batchSize : this.config.openai.batchSize;\n\n    // batchSize이하면 바로 호출\n    if (texts.length <= maxBatchSize) {\n      return provider === \"voyage\"\n        ? await this.embedVoyage(texts, inputType)\n        : await this.embedOpenAI(texts);\n    }\n\n    // batchSize이상이면 자동으로 나눠서 처리\n    const batches = Array.from({ length: Math.ceil(texts.length / maxBatchSize) }, (_, i) =>\n      texts.slice(i * maxBatchSize, (i + 1) * maxBatchSize),\n    );\n\n    const results = await Promise.all(\n      batches.map((batch) =>\n        provider === \"voyage\" ? this.embedVoyage(batch, inputType) : this.embedOpenAI(batch),\n      ),\n    );\n\n    onProgress?.(texts.length, texts.length);\n    return results.flat();\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 client = this.getVoyageClient();\n    const voyageConfig = this.config.voyage;\n\n    const response = await client.embed({\n      input: texts,\n      model: voyageConfig.model,\n      inputType: inputType,\n    });\n    if (!response.data) {\n      throw new Error(\"Voyage API: 응답 데이터가 없습니다.\");\n    }\n\n    return response.data.map((item) => ({\n      embedding: item.embedding ?? [],\n      model: voyageConfig.model,\n      tokenCount: response.usage?.totalTokens ?? 0,\n    }));\n  }\n\n  /**\n   * OpenAI 임베딩\n   */\n  private async embedOpenAI(texts: string[]): Promise<EmbeddingResult[]> {\n    const openai = this.getOpenAIProvider();\n    const openaiConfig = this.config.openai;\n    const model = openai.embeddingModel(openaiConfig.model);\n\n    const { embeddings, usage } = await embedMany({\n      model: model as EmbeddingModel,\n      values: texts,\n    });\n\n    return embeddings.map((embedding) => ({\n      embedding,\n      model: openaiConfig.model,\n      tokenCount: usage?.tokens ?? 0,\n    }));\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\" ? this.config.voyage.dimensions : this.config.openai.dimensions;\n  }\n}\n"],"names":["createOpenAI","embedMany","VoyageAIClient","Sonamu","DEFAULT_VECTOR_CONFIG","Embedding","config","voyage","openai","chunking","search","pgvector","getVoyageClient","apiKey","secrets","voyage_api_key","process","env","VOYAGE_API_KEY","Error","getOpenAIProvider","openai_api_key","OPENAI_API_KEY","embed","texts","provider","inputType","onProgress","maxBatchSize","batchSize","length","embedVoyage","embedOpenAI","batches","Array","from","Math","ceil","_","i","slice","results","Promise","all","map","batch","flat","embedOne","text","client","voyageConfig","response","input","model","data","item","embedding","tokenCount","usage","totalTokens","openaiConfig","embeddingModel","embeddings","values","tokens","toVectorString","join","getDimensions","dimensions"],"mappings":"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"}

package/dist/vector/vector-search.js

@@ -48,7 +48,7 @@ import { Embedding } from "./embedding.js";
    * 여러 항목에 임베딩 일괄 저장
    */ async saveEmbeddingsBatch(items, provider, embeddingColumn = "content_embedding", onProgress) {
         const texts = items.map((item)=>item.text);
-        const embeddings = await this.embedding.embedBatch(texts, provider, "document", onProgress);
+        const embeddings = await this.embedding.embed(texts, provider, "document", onProgress);
         await this.db.transaction(async (trx)=>{
             for(let i = 0; i < items.length; i++){
                 await trx(this.tableName).where("id", items[i].id).update({
@@ -173,4 +173,4 @@ import { Embedding } from "./embedding.js";
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/vector/vector-search.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport pgvector from \"pgvector/knex\";\nimport { DEFAULT_VECTOR_CONFIG } from \"./config\";\nimport { Embedding } from \"./embedding\";\nimport type {\n  EmbeddingItem,\n  EmbeddingProvider,\n  HybridSearchOptions,\n  HybridSearchResult,\n  ProgressCallback,\n  VectorConfig,\n  VectorSearchOptions,\n  VectorSearchResult,\n} from \"./types\";\n\n/**\n * 벡터 검색\n * pgvector를 활용한 벡터 검색 및 하이브리드 검색 지원\n */\nexport class VectorSearch<T = Record<string, unknown>> {\n  private db: Knex;\n  private config: VectorConfig;\n  private embedding: Embedding;\n  private tableName: string;\n\n  constructor(db: Knex, tableName: string, config: Partial<VectorConfig> = {}) {\n    this.db = db;\n    this.tableName = tableName;\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    this.embedding = new Embedding(config);\n  }\n\n  /**\n   * 단일 항목에 임베딩 저장\n   */\n  async saveEmbedding(\n    id: number,\n    text: string,\n    provider: EmbeddingProvider,\n    embeddingColumn: string = \"content_embedding\",\n  ): Promise<void> {\n    const { embedding } = await this.embedding.embedOne(text, provider, \"document\");\n\n    await this.db(this.tableName)\n      .where(\"id\", id)\n      .update({\n        [embeddingColumn]: pgvector.toSql(embedding),\n      });\n  }\n\n  /**\n   * 여러 항목에 임베딩 일괄 저장\n   */\n  async saveEmbeddingsBatch(\n    items: EmbeddingItem[],\n    provider: EmbeddingProvider,\n    embeddingColumn: string = \"content_embedding\",\n    onProgress?: ProgressCallback,\n  ): Promise<void> {\n    const texts = items.map((item) => item.text);\n    const embeddings = await this.embedding.embedBatch(texts, provider, \"document\", onProgress);\n\n    await this.db.transaction(async (trx) => {\n      for (let i = 0; i < items.length; i++) {\n        await trx(this.tableName)\n          .where(\"id\", items[i].id)\n          .update({\n            [embeddingColumn]: pgvector.toSql(embeddings[i].embedding),\n          });\n      }\n    });\n  }\n\n  /**\n   * 벡터 검색 (코사인 유사도)\n   */\n  async search(\n    query: string,\n    provider: EmbeddingProvider,\n    options: VectorSearchOptions = {},\n  ): Promise<VectorSearchResult<T>[]> {\n    const {\n      embeddingColumn = \"content_embedding\",\n      limit = this.config.search.defaultLimit,\n      threshold = this.config.search.similarityThreshold,\n      where,\n    } = options;\n\n    // 쿼리 임베딩 (input_type: 'query' 중요!)\n    const { embedding } = await this.embedding.embedOne(query, provider, \"query\");\n\n    // pgvector 세션 설정\n    if (this.config.pgvector.iterativeScan) {\n      await this.db.raw(\"SET hnsw.iterative_scan = relaxed_order\");\n    }\n    await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);\n\n    // 코사인 유사도 = 1 - 코사인 거리\n    const vectorStr = pgvector.toSql(embedding);\n    let queryBuilder = this.db(this.tableName)\n      .select(\"*\")\n      .select(this.db.raw(`1 - (${embeddingColumn} <=> ?::vector) AS similarity`, [vectorStr]))\n      .whereNotNull(embeddingColumn)\n      .orderByRaw(`${embeddingColumn} <=> ?::vector`, [vectorStr])\n      .limit(limit);\n\n    if (where) {\n      queryBuilder = queryBuilder.whereRaw(where);\n    }\n\n    const rows = await queryBuilder;\n\n    return rows\n      .filter((row: { similarity: number }) => row.similarity >= threshold)\n      .map((row: T & { similarity: number }) => ({\n        id: (row as unknown as { id: number }).id,\n        similarity: parseFloat(String(row.similarity)),\n        data: row as T,\n      }));\n  }\n\n  /**\n   * 하이브리드 검색 (Vector + FTS)\n   */\n  async hybridSearch(\n    query: string,\n    provider: EmbeddingProvider,\n    options: HybridSearchOptions = {},\n  ): Promise<HybridSearchResult<T>[]> {\n    const {\n      embeddingColumn = \"content_embedding\",\n      ftsColumn = \"content_tsv\",\n      limit = this.config.search.defaultLimit,\n      vectorWeight = this.config.search.vectorWeight,\n      ftsWeight = this.config.search.ftsWeight,\n    } = options;\n\n    const { embedding } = await this.embedding.embedOne(query, provider, \"query\");\n    const vectorStr = pgvector.toSql(embedding);\n\n    // pgvector 세션 설정\n    if (this.config.pgvector.iterativeScan) {\n      await this.db.raw(\"SET hnsw.iterative_scan = relaxed_order\");\n    }\n    await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);\n\n    const sql = `\n      WITH vector_search AS (\n        SELECT\n          id,\n          ROW_NUMBER() OVER (ORDER BY ${embeddingColumn} <=> ?::vector) AS rank\n        FROM ${this.tableName}\n        WHERE ${embeddingColumn} IS NOT NULL\n        ORDER BY ${embeddingColumn} <=> ?::vector\n        LIMIT 50\n      ),\n      fts_search AS (\n        SELECT\n          id,\n          ROW_NUMBER() OVER (ORDER BY ts_rank(${ftsColumn}, query) DESC) AS rank\n        FROM ${this.tableName}, plainto_tsquery('simple', ?) query\n        WHERE ${ftsColumn} @@ query\n        LIMIT 50\n      ),\n      combined AS (\n        SELECT\n          COALESCE(v.id, f.id) AS id,\n          COALESCE(1.0 / (60 + v.rank), 0) AS vector_score,\n          COALESCE(1.0 / (60 + f.rank), 0) AS fts_score\n        FROM vector_search v\n        FULL OUTER JOIN fts_search f ON v.id = f.id\n      )\n      SELECT\n        t.*,\n        c.vector_score,\n        c.fts_score,\n        (c.vector_score * ? + c.fts_score * ?) AS similarity\n      FROM combined c\n      JOIN ${this.tableName} t ON c.id = t.id\n      ORDER BY similarity DESC\n      LIMIT ?\n    `;\n\n    const { rows } = await this.db.raw(sql, [\n      vectorStr,\n      vectorStr,\n      query,\n      vectorWeight,\n      ftsWeight,\n      limit,\n    ]);\n\n    return rows.map(\n      (\n        row: T & {\n          similarity: number;\n          vector_score: number;\n          fts_score: number;\n        },\n      ) => ({\n        id: (row as unknown as { id: number }).id,\n        similarity: parseFloat(String(row.similarity)),\n        vectorScore: parseFloat(String(row.vector_score)),\n        ftsScore: parseFloat(String(row.fts_score)),\n        data: row as T,\n      }),\n    );\n  }\n\n  /**\n   * 임베딩 현황 조회\n   */\n  async getEmbeddingStatus(embeddingColumn: string = \"content_embedding\"): Promise<{\n    total: number;\n    withEmbedding: number;\n    withoutEmbedding: number;\n  }> {\n    const result = await this.db(this.tableName)\n      .count(\"* as total\")\n      .count(`${embeddingColumn} as with_embedding`)\n      .first();\n\n    const total = parseInt(String(result?.total ?? 0), 10);\n    const withEmbedding = parseInt(String(result?.with_embedding ?? 0), 10);\n\n    return {\n      total,\n      withEmbedding,\n      withoutEmbedding: total - withEmbedding,\n    };\n  }\n\n  /**\n   * 임베딩이 없는 항목 ID 조회\n   */\n  async getItemsWithoutEmbedding(\n    embeddingColumn: string = \"content_embedding\",\n    limit: number = 100,\n  ): Promise<number[]> {\n    const rows = await this.db(this.tableName)\n      .select(\"id\")\n      .whereNull(embeddingColumn)\n      .orderBy(\"id\")\n      .limit(limit);\n\n    return rows.map((row: { id: number }) => row.id);\n  }\n\n  /**\n   * Embedding 인스턴스 반환 (고급 사용)\n   */\n  getEmbedding(): Embedding {\n    return this.embedding;\n  }\n}\n"],"names":["pgvector","DEFAULT_VECTOR_CONFIG","Embedding","VectorSearch","db","config","embedding","tableName","voyage","openai","chunking","search","saveEmbedding","id","text","provider","embeddingColumn","embedOne","where","update","toSql","saveEmbeddingsBatch","items","onProgress","texts","map","item","embeddings","embedBatch","transaction","trx","i","length","query","options","limit","defaultLimit","threshold","similarityThreshold","iterativeScan","raw","efSearch","vectorStr","queryBuilder","select","whereNotNull","orderByRaw","whereRaw","rows","filter","row","similarity","parseFloat","String","data","hybridSearch","ftsColumn","vectorWeight","ftsWeight","sql","vectorScore","vector_score","ftsScore","fts_score","getEmbeddingStatus","result","count","first","total","parseInt","withEmbedding","with_embedding","withoutEmbedding","getItemsWithoutEmbedding","whereNull","orderBy","getEmbedding"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/vector/vector-search.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport pgvector from \"pgvector/knex\";\nimport { DEFAULT_VECTOR_CONFIG } from \"./config\";\nimport { Embedding } from \"./embedding\";\nimport type {\n  EmbeddingItem,\n  EmbeddingProvider,\n  HybridSearchOptions,\n  HybridSearchResult,\n  ProgressCallback,\n  VectorConfig,\n  VectorSearchOptions,\n  VectorSearchResult,\n} from \"./types\";\n\n/**\n * 벡터 검색\n * pgvector를 활용한 벡터 검색 및 하이브리드 검색 지원\n */\nexport class VectorSearch<T = Record<string, unknown>> {\n  private db: Knex;\n  private config: VectorConfig;\n  private embedding: Embedding;\n  private tableName: string;\n\n  constructor(db: Knex, tableName: string, config: Partial<VectorConfig> = {}) {\n    this.db = db;\n    this.tableName = tableName;\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    this.embedding = new Embedding(config);\n  }\n\n  /**\n   * 단일 항목에 임베딩 저장\n   */\n  async saveEmbedding(\n    id: number,\n    text: string,\n    provider: EmbeddingProvider,\n    embeddingColumn: string = \"content_embedding\",\n  ): Promise<void> {\n    const { embedding } = await this.embedding.embedOne(text, provider, \"document\");\n\n    await this.db(this.tableName)\n      .where(\"id\", id)\n      .update({\n        [embeddingColumn]: pgvector.toSql(embedding),\n      });\n  }\n\n  /**\n   * 여러 항목에 임베딩 일괄 저장\n   */\n  async saveEmbeddingsBatch(\n    items: EmbeddingItem[],\n    provider: EmbeddingProvider,\n    embeddingColumn: string = \"content_embedding\",\n    onProgress?: ProgressCallback,\n  ): Promise<void> {\n    const texts = items.map((item) => item.text);\n    const embeddings = await this.embedding.embed(texts, provider, \"document\", onProgress);\n\n    await this.db.transaction(async (trx) => {\n      for (let i = 0; i < items.length; i++) {\n        await trx(this.tableName)\n          .where(\"id\", items[i].id)\n          .update({\n            [embeddingColumn]: pgvector.toSql(embeddings[i].embedding),\n          });\n      }\n    });\n  }\n\n  /**\n   * 벡터 검색 (코사인 유사도)\n   */\n  async search(\n    query: string,\n    provider: EmbeddingProvider,\n    options: VectorSearchOptions = {},\n  ): Promise<VectorSearchResult<T>[]> {\n    const {\n      embeddingColumn = \"content_embedding\",\n      limit = this.config.search.defaultLimit,\n      threshold = this.config.search.similarityThreshold,\n      where,\n    } = options;\n\n    // 쿼리 임베딩 (input_type: 'query' 중요!)\n    const { embedding } = await this.embedding.embedOne(query, provider, \"query\");\n\n    // pgvector 세션 설정\n    if (this.config.pgvector.iterativeScan) {\n      await this.db.raw(\"SET hnsw.iterative_scan = relaxed_order\");\n    }\n    await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);\n\n    // 코사인 유사도 = 1 - 코사인 거리\n    const vectorStr = pgvector.toSql(embedding);\n    let queryBuilder = this.db(this.tableName)\n      .select(\"*\")\n      .select(this.db.raw(`1 - (${embeddingColumn} <=> ?::vector) AS similarity`, [vectorStr]))\n      .whereNotNull(embeddingColumn)\n      .orderByRaw(`${embeddingColumn} <=> ?::vector`, [vectorStr])\n      .limit(limit);\n\n    if (where) {\n      queryBuilder = queryBuilder.whereRaw(where);\n    }\n\n    const rows = await queryBuilder;\n\n    return rows\n      .filter((row: { similarity: number }) => row.similarity >= threshold)\n      .map((row: T & { similarity: number }) => ({\n        id: (row as unknown as { id: number }).id,\n        similarity: parseFloat(String(row.similarity)),\n        data: row as T,\n      }));\n  }\n\n  /**\n   * 하이브리드 검색 (Vector + FTS)\n   */\n  async hybridSearch(\n    query: string,\n    provider: EmbeddingProvider,\n    options: HybridSearchOptions = {},\n  ): Promise<HybridSearchResult<T>[]> {\n    const {\n      embeddingColumn = \"content_embedding\",\n      ftsColumn = \"content_tsv\",\n      limit = this.config.search.defaultLimit,\n      vectorWeight = this.config.search.vectorWeight,\n      ftsWeight = this.config.search.ftsWeight,\n    } = options;\n\n    const { embedding } = await this.embedding.embedOne(query, provider, \"query\");\n    const vectorStr = pgvector.toSql(embedding);\n\n    // pgvector 세션 설정\n    if (this.config.pgvector.iterativeScan) {\n      await this.db.raw(\"SET hnsw.iterative_scan = relaxed_order\");\n    }\n    await this.db.raw(`SET hnsw.ef_search = ${this.config.pgvector.efSearch}`);\n\n    const sql = `\n      WITH vector_search AS (\n        SELECT\n          id,\n          ROW_NUMBER() OVER (ORDER BY ${embeddingColumn} <=> ?::vector) AS rank\n        FROM ${this.tableName}\n        WHERE ${embeddingColumn} IS NOT NULL\n        ORDER BY ${embeddingColumn} <=> ?::vector\n        LIMIT 50\n      ),\n      fts_search AS (\n        SELECT\n          id,\n          ROW_NUMBER() OVER (ORDER BY ts_rank(${ftsColumn}, query) DESC) AS rank\n        FROM ${this.tableName}, plainto_tsquery('simple', ?) query\n        WHERE ${ftsColumn} @@ query\n        LIMIT 50\n      ),\n      combined AS (\n        SELECT\n          COALESCE(v.id, f.id) AS id,\n          COALESCE(1.0 / (60 + v.rank), 0) AS vector_score,\n          COALESCE(1.0 / (60 + f.rank), 0) AS fts_score\n        FROM vector_search v\n        FULL OUTER JOIN fts_search f ON v.id = f.id\n      )\n      SELECT\n        t.*,\n        c.vector_score,\n        c.fts_score,\n        (c.vector_score * ? + c.fts_score * ?) AS similarity\n      FROM combined c\n      JOIN ${this.tableName} t ON c.id = t.id\n      ORDER BY similarity DESC\n      LIMIT ?\n    `;\n\n    const { rows } = await this.db.raw(sql, [\n      vectorStr,\n      vectorStr,\n      query,\n      vectorWeight,\n      ftsWeight,\n      limit,\n    ]);\n\n    return rows.map(\n      (\n        row: T & {\n          similarity: number;\n          vector_score: number;\n          fts_score: number;\n        },\n      ) => ({\n        id: (row as unknown as { id: number }).id,\n        similarity: parseFloat(String(row.similarity)),\n        vectorScore: parseFloat(String(row.vector_score)),\n        ftsScore: parseFloat(String(row.fts_score)),\n        data: row as T,\n      }),\n    );\n  }\n\n  /**\n   * 임베딩 현황 조회\n   */\n  async getEmbeddingStatus(embeddingColumn: string = \"content_embedding\"): Promise<{\n    total: number;\n    withEmbedding: number;\n    withoutEmbedding: number;\n  }> {\n    const result = await this.db(this.tableName)\n      .count(\"* as total\")\n      .count(`${embeddingColumn} as with_embedding`)\n      .first();\n\n    const total = parseInt(String(result?.total ?? 0), 10);\n    const withEmbedding = parseInt(String(result?.with_embedding ?? 0), 10);\n\n    return {\n      total,\n      withEmbedding,\n      withoutEmbedding: total - withEmbedding,\n    };\n  }\n\n  /**\n   * 임베딩이 없는 항목 ID 조회\n   */\n  async getItemsWithoutEmbedding(\n    embeddingColumn: string = \"content_embedding\",\n    limit: number = 100,\n  ): Promise<number[]> {\n    const rows = await this.db(this.tableName)\n      .select(\"id\")\n      .whereNull(embeddingColumn)\n      .orderBy(\"id\")\n      .limit(limit);\n\n    return rows.map((row: { id: number }) => row.id);\n  }\n\n  /**\n   * Embedding 인스턴스 반환 (고급 사용)\n   */\n  getEmbedding(): Embedding {\n    return this.embedding;\n  }\n}\n"],"names":["pgvector","DEFAULT_VECTOR_CONFIG","Embedding","VectorSearch","db","config","embedding","tableName","voyage","openai","chunking","search","saveEmbedding","id","text","provider","embeddingColumn","embedOne","where","update","toSql","saveEmbeddingsBatch","items","onProgress","texts","map","item","embeddings","embed","transaction","trx","i","length","query","options","limit","defaultLimit","threshold","similarityThreshold","iterativeScan","raw","efSearch","vectorStr","queryBuilder","select","whereNotNull","orderByRaw","whereRaw","rows","filter","row","similarity","parseFloat","String","data","hybridSearch","ftsColumn","vectorWeight","ftsWeight","sql","vectorScore","vector_score","ftsScore","fts_score","getEmbeddingStatus","result","count","first","total","parseInt","withEmbedding","with_embedding","withoutEmbedding","getItemsWithoutEmbedding","whereNull","orderBy","getEmbedding"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.7.8",
+  "version": "0.7.9",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
@@ -70,16 +70,15 @@
     "minimatch": "^10.0.3",
     "node-sql-parser": "^5.2.0",
     "pg": "^8.16.3",
-    "pgvector": "^0.2.1",
     "prompts": "^2.4.2",
     "qs": "^6.11.0",
     "radashi": "^12.2.0",
     "tsicli": "^1.0.5",
     "vitest": "^4.0.10",
     "zod": "^4.1.12",
-    "@sonamu-kit/hmr-hook": "^0.4.1",
     "@sonamu-kit/hmr-runner": "^0.1.1",
-    "@sonamu-kit/ts-loader": "^2.1.3"
+    "@sonamu-kit/ts-loader": "^2.1.3",
+    "@sonamu-kit/hmr-hook": "^0.4.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.7",
@@ -103,7 +102,9 @@
     "ai": "^6.0.0-beta.138",
     "fastify": "^4.23.2",
     "knex": "^3.1.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "pgvector": "^0.2.1",
+    "voyageai": "^0.0.8"
   },
   "peerDependenciesMeta": {
     "@ai-sdk/openai": {
@@ -117,6 +118,12 @@
     },
     "ai": {
       "optional": true
+    },
+    "pgvector": {
+      "optional": true
+    },
+    "voyageai": {
+      "optional": true
     }
   },
   "scripts": {

package/src/database/base-model.ts

@@ -3,9 +3,20 @@
 import type { Knex } from "knex";
 import { group, isObject, omit, set } from "radashi";
 import { Sonamu } from "../api";
+import { EntityManager } from "../entity/entity-manager";
 import type { DatabaseSchemaExtend } from "../types/types";
 import { getJoinTables, getTableNamesFromWhere } from "../utils/sql-parser";
 import { chunk } from "../utils/utils";
+import type {
+  EmbeddingItem,
+  EmbeddingProvider,
+  HybridSearchOptions,
+  HybridSearchResult,
+  ProgressCallback,
+  VectorSearchOptions,
+  VectorSearchResult,
+} from "../vector/types";
+import { VectorSearch } from "../vector/vector-search";
 import type {
   EnhancerMap,
   ExecuteSubsetQueryResult,
@@ -58,7 +69,118 @@ export class BaseModelClass<
     return new PuriWrapper(db, new UpsertBuilder());
   }
 
+  // VectorSearch 인스턴스 캐시
+  private _vectorSearch: VectorSearch<any> | null = null;
+
+  /**
+   * 벡터 검색 인스턴스 반환
+   * - 기본 provider: voyage
+   * - 기본 dimensions: 1024 (DEFAULT_VECTOR_CONFIG 사용)
+   */
+  getVector<T = Record<string, unknown>>(): VectorSearch<T> {
+    if (this._vectorSearch) {
+      return this._vectorSearch as VectorSearch<T>;
+    }
+
+    const entity = EntityManager.get(this.modelName);
+
+    this._vectorSearch = new VectorSearch<T>(this.getDB("w"), entity.table);
+
+    return this._vectorSearch as VectorSearch<T>;
+  }
+
+  /**
+   * 벡터 검색 (코사인 유사도)
+   * @param query - 검색어
+   * @param options - 검색 옵션
+   */
+  async vectorSearch<T = Record<string, unknown>>(
+    query: string,
+    options: VectorSearchOptions & { provider?: EmbeddingProvider } = {},
+  ): Promise<VectorSearchResult<T>[]> {
+    const entity = EntityManager.get(this.modelName);
+    const vectorProp = entity.getVectorColumn();
+    if (!vectorProp) {
+      throw new Error(`${this.modelName} Entity에 vector 컬럼이 정의되지 않았습니다.`);
+    }
+
+    const vs = new VectorSearch<T>(this.getDB("w"), entity.table);
+    return vs.search(query, options.provider ?? "voyage", {
+      ...options,
+      embeddingColumn: options.embeddingColumn ?? vectorProp.name,
+    });
+  }
+
+  /**
+   * 하이브리드 검색 (Vector + FTS)
+   * @param query - 검색어
+   * @param options - 검색 옵션
+   */
+  async hybridSearch<T = Record<string, unknown>>(
+    query: string,
+    options: HybridSearchOptions & { provider?: EmbeddingProvider } = {},
+  ): Promise<HybridSearchResult<T>[]> {
+    const entity = EntityManager.get(this.modelName);
+    const vectorProp = entity.getVectorColumn();
+    if (!vectorProp) {
+      throw new Error(`${this.modelName} Entity에 vector 컬럼이 정의되지 않았습니다.`);
+    }
+
+    const vs = new VectorSearch<T>(this.getDB("w"), entity.table);
+    return vs.hybridSearch(query, options.provider ?? "voyage", {
+      ...options,
+      embeddingColumn: options.embeddingColumn ?? vectorProp.name,
+    });
+  }
+
+  /**
+   * 단일 레코드에 임베딩 저장
+   * @param id - 레코드 ID
+   * @param text - 임베딩할 텍스트
+   * @param options - provider, embeddingColumn 옵션
+   */
+  async saveEmbedding(
+    id: number,
+    text: string,
+    options: { provider?: EmbeddingProvider; embeddingColumn?: string } = {},
+  ): Promise<void> {
+    const entity = EntityManager.get(this.modelName);
+    const vectorProp = entity.getVectorColumn(options.embeddingColumn);
+    if (!vectorProp) {
+      throw new Error(`${this.modelName} Entity에 vector 컬럼이 정의되지 않았습니다.`);
+    }
+
+    const { provider = "voyage" } = options;
+    const vs = this.getVector();
+    return vs.saveEmbedding(id, text, provider, vectorProp.name);
+  }
+
+  /**
+   * 여러 레코드에 임베딩 일괄 저장
+   * @param items - { id, text } 배열
+   * @param options - provider, embeddingColumn, onProgress 옵션
+   */
+  async saveEmbeddingsBatch(
+    items: EmbeddingItem[],
+    options: {
+      provider?: EmbeddingProvider;
+      embeddingColumn?: string;
+      onProgress?: ProgressCallback;
+    } = {},
+  ): Promise<void> {
+    const entity = EntityManager.get(this.modelName);
+    const vectorProp = entity.getVectorColumn(options.embeddingColumn);
+    if (!vectorProp) {
+      throw new Error(`${this.modelName} Entity에 vector 컬럼이 정의되지 않았습니다.`);
+    }
+
+    const { provider = "voyage", onProgress } = options;
+    const vs = this.getVector();
+    return vs.saveEmbeddingsBatch(items, provider, vectorProp.name, onProgress);
+  }
+
   async destroy() {
+    this._vectorSearch = null;
     return DB.destroy();
   }
 
@@ -158,8 +280,8 @@ export class BaseModelClass<
       subset: T;
       qb: Puri<any, any, any>;
       params: {
-        num?: number;
-        page?: number;
+        num: number;
+        page: number;
         queryMode?: "list" | "count" | "both";
       };
       debug?: boolean;
@@ -172,10 +294,6 @@ export class BaseModelClass<
       throw new Error("loaderQueries is not defined");
     }
 
-    if (!queryParams.num || !queryParams.page) {
-      throw new Error("num and page are required");
-    }
-
     const { num, page } = queryParams;
 
     // COUNT 쿼리 실행
@@ -253,7 +371,14 @@ export class BaseModelClass<
       return [];
     }
 
-    let unloadedRows = (await qb.limit(num).offset(num * (page - 1))) as any[];
+    const limitedQb = (() => {
+      if (num === 0) {
+        return qb;
+      } else {
+        return qb.limit(num).offset(num * (page - 1));
+      }
+    })();
+    let unloadedRows = (await limitedQb) as any[];
 
     if (debug) {
       qb.debug();

package/src/entity/entity.ts

@@ -720,6 +720,25 @@ export class Entity {
       .filter(nonNullable);
   }
 
+  /**
+   * Entity에 정의된 모든 vector 타입 컬럼 반환
+   */
+  getVectorColumns(): EntityProp[] {
+    return this.props.filter((p) => p.type === "vector");
+  }
+
+  /**
+   * 특정 vector 컬럼 반환
+   * @param columnName - 컬럼명 (생략 시 첫 번째 vector 컬럼)
+   */
+  getVectorColumn(columnName?: string): EntityProp | undefined {
+    const vectorProps = this.getVectorColumns();
+    if (columnName) {
+      return vectorProps.find((p) => p.name === columnName);
+    }
+    return vectorProps[0];
+  }
+
   async registerModulePaths() {
     const basePath = `${this.names.parentFs}`;
 

package/src/migration/code-generation.ts

@@ -1,5 +1,5 @@
 import equal from "fast-deep-equal";
-import { alphabetical, diff, omit } from "radashi";
+import { alphabetical, diff } from "radashi";
 import { Naite } from "..";
 import type {
   GenMigrationCode,
@@ -218,18 +218,24 @@ function genIndexDefinition(index: MigrationIndex, table: string): string {
 
   const methodMap = {
     index: "INDEX",
-    fulltext: "INDEX",
     unique: "UNIQUE INDEX",
   };
 
   const nullsNotDistinctClause =
-    index.nullsNotDistinct === undefined
-      ? ""
-      : ` NULLS ${index.nullsNotDistinct ? "NOT DISTINCT" : "DISTINCT"}`;
+    index.type === "unique" && index.nullsNotDistinct !== undefined
+      ? ` NULLS ${index.nullsNotDistinct ? "NOT DISTINCT" : "DISTINCT"}`
+      : "";
+
+  const usingClause = index.using === undefined ? "" : `USING ${index.using}`;
 
   return `await knex.raw(
-  \`CREATE ${methodMap[index.type]} ${index.name} ON ${table} (${index.columns
+  \`CREATE ${methodMap[index.type]} ${index.name} ON ${table} ${usingClause}(${index.columns
     .map((col) => {
+      // 정렬 옵션은 btree만 사용 가능
+      if (index.using !== "btree" && index.using !== undefined) {
+        return `${col.name}`;
+      }
+
       const sortOrderClause = col.sortOrder === undefined ? "" : ` ${col.sortOrder}`;
       const nullsFirstClause =
         col.nullsFirst === undefined ? "" : ` NULLS ${col.nullsFirst ? "FIRST" : "LAST"}`;
@@ -741,6 +747,7 @@ function setMigrationIndexDefaults(index: MigrationIndex): MigrationIndex {
       nullsFirst: col.nullsFirst ?? col.sortOrder === "DESC",
     })),
     nullsNotDistinct: index.nullsNotDistinct ?? false,
+    using: index.using ?? "btree",
   };
 }
 
@@ -959,8 +966,8 @@ export async function generateAlterCode(
     dbColumns.map(normalizeColumnForComparison),
   );
   const isEqualIndexes = equal(
-    entityIndexes.map((index) => omit(index, ["parser"])).map(setMigrationIndexDefaults),
-    dbIndexes,
+    entityIndexes.map(setMigrationIndexDefaults),
+    dbIndexes.map(setMigrationIndexDefaults),
   );
   if (!isEqualColumns || !isEqualIndexes) {
     alterCodes.push(

package/src/migration/migration-set.ts

@@ -232,6 +232,8 @@ function resolveEntityPropTypeToMigrationColumnType(prop: EntityProp): Migration
       return "vector";
     case "vector[]":
       return "vector[]";
+    case "tsvector":
+      return "tsvector";
     default:
       exhaustive(prop);
       throw new Error(`Unknown entity prop type: ${(prop as { type: string }).type}`);

package/src/migration/postgresql-schema-reader.ts

@@ -148,6 +148,7 @@ class PostgreSQLSchemaReaderClass {
           sortOrder: idx.sort_order,
         })),
         nullsNotDistinct: firstIndex.nulls_not_distinct,
+        using: firstIndex.index_type as "btree" | "hash" | "gin" | "gist" | undefined,
       };
     });