TurboVec 完全ガイド：FAISS より高速なオープンソースベクトル検索ライブラリ

pip install turbovec

# LangChain 統合
pip install turbovec[langchain]

# LlamaIndex 統合
pip install turbovec[llama-index]

# Haystack 統合
pip install turbovec[haystack]

# Agno 統合
pip install turbovec[agno]

[dependencies]
turbovec = "0.1"

import numpy as np
from turbovec import TurboQuantIndex

# インデックス作成：次元 1536（OpenAI embedding のデフォルト次元）、4-bit 量子化
index = TurboQuantIndex(dim=1536, bit_width=4)

# サンプルベクトル生成（実際の使用では embedding ベクトルに置き換えてください）
vectors = np.random.rand(10000, 1536).astype(np.float32)

# ベクトルをインデックスに追加
index.add(vectors)

# さらにベクトルを追加可能。再構築不要
more_vectors = np.random.rand(5000, 1536).astype(np.float32)
index.add(more_vectors)

print(f"インデックスには {len(index)} 個のベクトルがあります")

# クエリベクトル生成
query = np.random.rand(1536).astype(np.float32)

# 最も類似した 10 個のベクトルを検索
scores, indices = index.search(query, k=10)

print("類似度スコア:", scores)
print("ベクトルインデックス:", indices)

# インデックスをディスクに保存
index.write("my_index.tq")

# ディスクからインデックスを読み込み
loaded_index = TurboQuantIndex.load("my_index.tq")

# 読み込み成功を確認
scores, indices = loaded_index.search(query, k=10)

import numpy as np
from turbovec import IdMapIndex

# 外部 ID をサポートするインデックスを作成
index = IdMapIndex(dim=1536, bit_width=4)

# 3 つのベクトルがあり、対応する外部 ID が 1001, 1002, 1003 と仮定
vectors = np.random.rand(3, 1536).astype(np.float32)
external_ids = np.array([1001, 1002, 1003], dtype=np.uint64)

# ベクトルと対応する外部 ID を追加
index.add_with_ids(vectors, external_ids)

# 検索結果は内部インデックスではなく外部 ID を返す
query = np.random.rand(1536).astype(np.float32)
scores, ids = index.search(query, k=10)

print("返された外部 ID:", ids)  # [1001, 1003, 1002, ...]

# ID 1002 のベクトルを削除
index.remove(1002)

# 再度検索すると、1002 は結果に含まれない
scores, ids = index.search(query, k=10)
print("削除後の ID:", ids)  # 1002 を含まない

# 保存
index.write("my_index.tvim")

# 読み込み
loaded_index = IdMapIndex.load("my_index.tvim")

import numpy as np
from turbovec import IdMapIndex

# インデックス作成
idx = IdMapIndex(dim=1536, bit_width=4)

# 10000 個のベクトルがあり、各ベクトルがドキュメント ID に対応していると仮定
vectors = np.random.rand(10000, 1536).astype(np.float32)
doc_ids = np.arange(1, 10001, dtype=np.uint64)
idx.add_with_ids(vectors, doc_ids)

# データベースクエリのシミュレーション：テナント A のドキュメント ID リストを取得
# 実際のシナリオでは、PostgreSQL / MySQL からのクエリ結果になる
tenant_a_docs = np.array([1, 5, 10, 15, 20, 25, 30, 35, 40, 45], dtype=np.uint64)

# テナント A のドキュメント範囲内で検索
query = np.random.rand(1536).astype(np.float32)
scores, ids = idx.search(query, k=5, allowlist=tenant_a_docs)

print("テナント A の最も関連性の高いドキュメント:", ids)
# 出力は tenant_a_docs 内の ID のみを含む

from langchain_community.vectorstores import TurboVec
from langchain_openai import OpenAIEmbeddings

# embeddings の初期化
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# TurboVec ベクトルストアを作成
vector_store = TurboVec.from_documents(
    documents=documents,  # Document リスト
    embedding=embeddings,
    bit_width=4  # 4-bit 量子化
)

# 類似性検索
results = vector_store.similarity_search("あなたの質問", k=5)

# 永続化
vector_store.save_local("turbovec_index")

# 読み込み
loaded_store = TurboVec.load_local("turbovec_index", embeddings)

from llama_index.vector_stores.turbovec import TurboVecVectorStore
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# ドキュメント読み込み
documents = SimpleDirectoryReader("./data").load_data()

# TurboVec ベクトルストアを作成
vector_store = TurboVecVectorStore(dim=1536, bit_width=4)

# インデックス作成
index = VectorStoreIndex.from_documents(
    documents,
    vector_store=vector_store
)

# クエリエンジン
query_engine = index.as_query_engine()
response = query_engine.query("あなたの質問")
print(response)

from haystack_integrations.document_stores.turbovec import TurboVecDocumentStore
from haystack.components.embedders import SentenceTransformersDocumentEmbedder
from haystack import Pipeline

# ドキュメントストアを作成
document_store = TurboVecDocumentStore(dim=768, bit_width=4)

# エンベッダー
embedder = SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")

# パイプライン構築
pipeline = Pipeline()
pipeline.add_component("embedder", embedder)
# ... 他のコンポーネントを追加

use turbovec::TurboQuantIndex;
use ndarray::Array2;

fn main() {
    // インデックス作成：1536 次元、4-bit 量子化
    let mut index = TurboQuantIndex::new(1536, 4);

    // ベクトルデータの準備（ここでは乱数を使用）
    let vectors = Array2::<f32>::random((10000, 1536), &mut rand::thread_rng());

    // ベクトル追加
    index.add(&vectors);

    // クエリベクトル準備
    let query = Array1::<f32>::random(1536, &mut rand::thread_rng());

    // 最も類似した 10 個のベクトルを検索
    let results = index.search(&query, 10);

    println!("Top 10 結果: {:?}", results);

    // 永続化
    index.write("index.tv").unwrap();

    // 読み込み
    let loaded = TurboQuantIndex::load("index.tv").unwrap();
}

use turbovec::IdMapIndex;

fn main() {
    let mut index = IdMapIndex::new(1536, 4);

    let vectors = Array2::<f32>::random((100, 1536), &mut rand::thread_rng());
    let ids = vec![1001u64, 1002, 1003, /* ... */];

    index.add_with_ids(&vectors, &ids);

    let query = Array1::<f32>::random(1536, &mut rand::thread_rng());
    let (scores, returned_ids) = index.search(&query, 10);

    println!("返された外部 ID: {:?}", returned_ids);

    // 削除
    index.remove(1002);

    // 永続化
    index.write("index.tvim").unwrap();
    let loaded = IdMapIndex::load("index.tvim").unwrap();
}

pip install turbovec sentence-transformers langchain-community langchain-openai

import numpy as np
from turbovec import IdMapIndex
from sentence_transformers import SentenceTransformer
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# 1. 埋め込みモデルの読み込み（ローカル実行、API Key 不要）
print("埋め込みモデルを読み込んでいます...")
model = SentenceTransformer('all-MiniLM-L6-v2')  # 384 次元
dim = 384

# 2. ドキュメントの読み込みと分割
print("ドキュメントを読み込んでいます...")
loader = TextLoader('./data/my_documents.txt', encoding='utf-8')
documents = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = splitter.split_documents(documents)

print(f"{len(chunks)} 個のテキストチャンクに分割")

# 3. ベクトル生成とインデックス構築
print("ベクトルを生成し、インデックスを構築しています...")
index = IdMapIndex(dim=dim, bit_width=4)

texts = [chunk.page_content for chunk in chunks]
metadata_list = [chunk.metadata for chunk in chunks]

# バッチでベクトル生成
embeddings = model.encode(texts, show_progress_bar=True)

# ベクトルとメタデータを追加（インデックスを外部 ID として使用）
external_ids = np.arange(len(texts), dtype=np.uint64)
index.add_with_ids(embeddings.astype(np.float32), external_ids)

# インデックスを保存
index.write("rag_index.tvim")
print("インデックスを保存しました")

# 4. 検索関数
def search(query: str, k: int = 5):
    """最も関連性の高いテキストチャンクを検索"""
    # インデックスを読み込み
    idx = IdMapIndex.load("rag_index.tvim")

    # クエリベクトル生成
    query_embedding = model.encode([query])[0].astype(np.float32)

    # 検索
    scores, ids = idx.search(query_embedding, k=k)

    # 結果を返す
    results = []
    for score, doc_id in zip(scores, ids):
        doc_id = int(doc_id)
        results.append({
            'text': texts[doc_id],
            'score': float(score),
            'metadata': metadata_list[doc_id]
        })

    return results

# 5. 検索テスト
if __name__ == "__main__":
    query = "TurboVec とは何ですか？"
    results = search(query, k=3)

    print("\n=== 検索結果 ===")
    for i, result in enumerate(results, 1):
        print(f"\n[{i}] 類似度: {result['score']:.4f}")
        print(f"内容: {result['text'][:200]}...")

def search_with_filter(query: str, category: str, k: int = 5):
    """分類フィルタ付き検索"""
    idx = IdMapIndex.load("rag_index.tvim")

    # 指定された分類に属するドキュメント ID を特定
    allowed_ids = np.array([
        i for i, meta in enumerate(metadata_list)
        if meta.get('category') == category
    ], dtype=np.uint64)

    if len(allowed_ids) == 0:
        return []

    # クエリベクトル生成
    query_embedding = model.encode([query])[0].astype(np.float32)

    # フィルタ付き検索
    scores, ids = idx.search(query_embedding, k=k, allowlist=allowed_ids)

    results = []
    for score, doc_id in zip(scores, ids):
        doc_id = int(doc_id)
        results.append({
            'text': texts[doc_id],
            'score': float(score),
            'metadata': metadata_list[doc_id]
        })

    return results

# 「技術」分類のドキュメントのみを検索
results = search_with_filter("インストール方法は？", category="技術", k=3)