import { WarpPipeline } from 'warpvector';
import { MlpAdapter } from 'warpvector/ml';
import { QuantizationAdapter } from 'warpvector/extras';

// MLP アダプタと量子化アダプタを事前に作成
const mlp = new MlpAdapter(layers);
const quantizer = new QuantizationAdapter({ type: "int8", dim: 1536 });

// 1. パイプラインの構築
const pipeline = new WarpPipeline(1536)
  .addStep("MlpAdapter", mlp)                 // 非線形変換 (WASM使用)
  .addIntent({ "domain_x": intentWeights })   // ユーザーごとに空間を歪める
  .setFinalStage("QuantizationAdapter", quantizer); // 最後に Int8 に量子化して圧縮

// 2. 非同期初期化 (WASMモジュールのセットアップなどを一括実行)
await pipeline.init();

// 3. 超高速バッチ処理 (WASM/SIMD対応)
const batchVectors = [[0.1, ...], [0.5, ...]]; // 大量データ
const results = pipeline.runBatch(batchVectors, { intent: "domain_x" });

// 4. Vector DB 用フォーマットへの直接出力
const pineconeQuery = pipeline.runAndFormat(
  rawVector, 
  { format: "pinecone", topK: 10, filter: { genre: "action" } }
);

// 5. パイプライン丸ごとの永続化と復元
const stateJson = pipeline.exportState(); 
const restoredPipeline = WarpPipeline.importState(stateJson);

import { IntentAdapter } from 'warpvector';

// 意図ごとの変換行列とバイアスを定義
const myIntents = {
  riskAnalysis: {
    matrix: [
      [1.2, 0.1, -0.4],
      [-0.1, 1.5, 0.2],
      [0.3, -0.2, 1.1],
    ],
    bias: [0.05, -0.1, 0.2]
  }
};

const adapter = new IntentAdapter(myIntents);
const baseVector = [0.15, -0.23, 0.88];

// "riskAnalysis" の意図に合わせてベクトルをワープ
const warpedVector = adapter.tune(baseVector, "riskAnalysis");

import { MlpAdapter } from 'warpvector';

// 1536次元から128次元の中間層を経て2次元に出力する2層MLP
const mlp = new MlpAdapter([
  { matrix: matrix1, bias: bias1, activation: "relu" },   // 1536 -> 128
  { matrix: matrix2, bias: bias2, activation: "linear" }  // 128 -> 2
]);

// WASM の初期化 (重みもWASMメモリに永続化される)
await mlp.init();

// 超高速非線形推論 (WASM)
const output = mlp.tune(baseVector);

import { WhiteningAdapter } from 'warpvector';

// トップ1つの主成分（偏り）をストリーミング学習して除去するアダプター
const adapter = new WhiteningAdapter(1536, { learningRate: 0.01, numComponents: 1 });

// ベクトルを受信するたびに自動で偏りの方向を学習 (Oja's Rule)
adapter.update(rawVector1);
adapter.update(rawVector2);

// 検索時に偏りを除去（検索の解像度が劇的に向上）
const whitenedVector = adapter.tune(searchVector);

import { PrismaClient } from '@prisma/client';
import { withWarpVector } from 'warpvector/integrations/prisma';
import { WhiteningAdapter } from 'warpvector';

const adapter = new WhiteningAdapter(1536);

// Prisma Client に WarpVector 拡張をアタッチ
const prisma = new PrismaClient().$extends(
  withWarpVector({
    adapter: adapter,
    vectorField: "embedding", // DB上の pgvector 保存先カラム名
    distanceOperator: "<=>"   // コサイン距離を使用
  })
);

// 生のベクトルを渡すだけ！（内部でWarpVector推論とpgvector用SQL生成が自動で行われる）
const results = await prisma.document.searchByVector({
  vector: rawSearchVector,
  topK: 10,
  where: "category = 'science'" // 通常のSQL WHERE条件も併用可能
});

import { ColbertAdapter } from 'warpvector';

const adapter = new ColbertAdapter();

// queryTokens: クエリのトークン行列 (平坦化された Float32Array)
// documentTokensArray: 各ドキュメントのトークン行列の配列
const results = adapter.rank(queryTokens, [doc1Tokens, doc2Tokens, doc3Tokens], 1536);

console.log(results); // [{ index: 1, score: 1.44 }, { index: 0, score: 0.76 }, ...]

import { rrf, rsf } from 'warpvector';

const denseResults = [
  { id: "doc1", score: 0.95 }, 
  { id: "doc2", score: 0.88 }
];

const sparseResults = [
  { id: "doc2", score: 15.2 }, 
  { id: "doc1", score: 12.1 }
];

// RRF (Reciprocal Rank Fusion): スコアの絶対値に依存せず、順位(Rank)のみを使って公平に統合
const rrfResults = rrf([denseResults, sparseResults]);

// RSF (Relative Score Fusion): Min-Max正規化を行い、重み(Dense 70%, Sparse 30%)をつけて加算統合
const rsfResults = rsf([denseResults, sparseResults], [0.7, 0.3]);

import { QuantizationAdapter } from 'warpvector';

// Int8 量子化 (メモリを 1/4 に削減)
const int8Adapter = new QuantizationAdapter({ type: "int8", dim: 1536 });
const int8Vec = int8Adapter.tune(floatVector); // Int8Array
const dot = QuantizationAdapter.int8DotProduct(int8Vec, int8Vec2);

// Binary 量子化 (メモリを 1/32 に削減)
const binaryAdapter = new QuantizationAdapter({ type: "binary", dim: 1536 });
const binVec = binaryAdapter.tune(floatVector); // Uint8Array(192バイト)
const dist = QuantizationAdapter.hammingDistance(binVec, binVec2); // 超高速なXORハミング距離計算

import { InfoNCETrainer } from 'warpvector';

const trainer = new InfoNCETrainer(1536);

// 1つの正解と複数の不正解（In-batch Negatives）を同時に学習
const updatedWeights = await trainer.updateOnline(
  currentWeights,
  {
    anchor: anchorVector,
    positive: positiveVector,
    negatives: [negativeVector1, negativeVector2],
  },
  { learningRate: 0.001, temperature: 0.1 }
);

import { OpenAIEmbeddings } from "@langchain/openai";
import { IntentAdapter } from "warpvector";
import { WarpEmbeddings } from "warpvector/integrations/langchain";

const baseEmbeddings = new OpenAIEmbeddings();
const adapter = new IntentAdapter(myIntents);

const warpEmbeddings = new WarpEmbeddings({
  baseEmbeddings, adapter, intentName: "riskAnalysis"
});
// 検索時のみ動的ワープが適用されます
const vectorStore = new MemoryVectorStore(warpEmbeddings);

import { OpenAIEmbedding } from "llamaindex";
import { WarpLlamaIndexEmbeddings } from "warpvector/integrations/llama-index";

const warpLlamaIndexEmbeddings = new WarpLlamaIndexEmbeddings({
  baseEmbeddings: new OpenAIEmbedding(),
  adapter: intentAdapter,
  intentName: "riskAnalysis"
});
// LlamaIndex の VectorStoreIndex などに直接渡せます

import { WhiteningAdapter } from 'warpvector';

const adapter = new WhiteningAdapter(1536);
// ... オンライン学習 (update) を実行 ...

// 状態をシリアライズしてRedis等に保存
const stateJson = adapter.exportState();

// 次回起動時や別インスタンスで即座に復元
const restoredAdapter = WhiteningAdapter.importState(stateJson);

import { ProjectionAdapter } from 'warpvector';

// 1536次元から512次元への射影行列を設定
const adapter = new ProjectionAdapter(1536, 512, {
  v1: { matrix: projectionMatrix, bias: projectionBias }
});

// 次元削減を実行 (WASM使用)
const compressedVector = adapter.tune(baseVector, "v1"); // 512次元

import { MigrationTrainer } from 'warpvector';

// 旧モデル(1536次元)から新モデル(512次元)への翻訳行列を学習
const trainer = new MigrationTrainer(1536, 512);

// 同一テキストを新旧モデルで埋め込み、ペアとして学習データに追加
trainer.addExample({ source: adaVector, target: v3SmallVector });
trainer.addExample({ source: adaVector2, target: v3SmallVector2 });

// 射影行列を学習 (Adam Optimizer)
const projectionWeights = await trainer.train({ epochs: 200, autoTune: true });

import { TaskArithmetic } from 'warpvector';

// 「法律ドメイン」と「金融ドメイン」の学習済み重みをマージ
const mergedWeights = TaskArithmetic.merge([
  { weights: legalWeights, scale: 0.7 },   // 法律を70%
  { weights: financeWeights, scale: 0.3 },  // 金融を30%
]);

// マージされた重みは通常の IntentWeights として即座に使用可能
adapter.addIntent("legal_finance", mergedWeights);

import { VsaAdapter } from 'warpvector';

// バンドル（重ね合わせ）: 複数の概念を1つのベクトルに統合
const bundled = VsaAdapter.bundle([scienceVec, technologyVec]);

// バインド（結合）: キーと値をアダマール積で結合
const bound = VsaAdapter.bind(userIdVec, preferenceVec);

// アンバインド（抽出）: キーを使って値を取り出す
const recovered = VsaAdapter.unbind(bound, userIdVec);

// Binary VSA: 量子化ベクトルに対するXOR演算による超高速処理
const binaryBound = VsaAdapter.bindBinary(binKey, binValue);
const binaryRecovered = VsaAdapter.unbindBinary(binaryBound, binKey);

import { slerp, reject } from 'warpvector';

// 球面線形補間 (Slerp): コサイン類似度を保ちながらベクトル間を滑らかに補間
const interpolated = slerp(vectorA, vectorB, 0.3); // A寄り30%の中間点

// 直交射影 (Reject / Negative Prompting): 特定の概念を完全に除去
// 例: 検索クエリから「政治」の方向成分を取り除く
const filteredQuery = reject(searchVector, politicsVector);