Pinecone Pythonクライアントライブラリ 徹底解説！

pip install pinecone

# asyncioサポートを追加 (aiohttpに依存)
pip install "pinecone[asyncio]"

# gRPCサポートを追加 (grpcioに依存, パフォーマンス向上に寄与)
pip install "pinecone[grpc]"

# 両方を追加
pip install "pinecone[asyncio,grpc]"

import os
from pinecone import Pinecone, ServerlessSpec, PodSpec # Serverless/Podインデックス作成時に使用

# 環境変数からAPIキーを読み込む (推奨)
# 事前に `export PINECONE_API_KEY="YOUR_API_KEY"` のように設定しておくか、
# .env ファイルなどを使用する (例: python-dotenvライブラリ)
# from dotenv import load_dotenv
# load_dotenv()
api_key = os.getenv("PINECONE_API_KEY")

if not api_key:
    raise ValueError("APIキーが環境変数 'PINECONE_API_KEY' に設定されていません。")

# Pineconeクライアントを初期化 (APIキーのみでOK)
try:
    pc = Pinecone(api_key=api_key)
    print("Pineconeクライアントの初期化が完了しました。")

    # 利用可能なインデックス一覧を表示 (接続確認と情報取得)
    print("利用可能なインデックス:")
    index_list = pc.list_indexes()
    if index_list.names:
        for index_info in index_list: # list_indexes() は IndexList オブジェクトを返す
             print(f"- {index_info.name} (Host: {index_info.host}, Spec: {index_info.spec})")
    else:
        print("  (利用可能なインデックスはありません)")

except Exception as e:
    print(f"Pineconeクライアントの初期化またはインデックスリストの取得中にエラーが発生しました: {e} ")
    pc = None # エラーの場合はNoneにしておく

from pinecone import PodSpec, ServerlessSpec
import time

index_name = "my-semantic-search-index"
dimension = 768 # 格納するベクトルの次元数 (例: SentenceTransformerのモデル)
metric = "cosine" # 類似度計算メトリクス: cosine, euclidean, dotproduct

# Serverlessインデックスの仕様 (推奨されることが多い)
serverless_spec = ServerlessSpec(
    cloud="aws",       # クラウドプロバイダー (aws or gcp)
    region="us-east-1" # リージョン (利用可能なリージョンを確認)
)

# Podベースのインデックスの仕様 (特定のパフォーマンス要件がある場合など)
# pod_spec = PodSpec(
#     environment="gcp-starter", # Podベースの場合、環境名を指定 (例: 無料枠のStarterプラン)
#     pod_type="p1.x1", # Podのタイプとサイズ (例: p1.x1, s1.x2 など)
#     pods=1, # Podの数
#     replicas=1 # レプリカ数 (可用性向上のため)
#     # metadata_config={"indexed": ["category", "year"]} # オプション: 特定メタデータのみインデックス化
# )

if pc: # クライアントが正常に初期化されているか確認
    # インデックスが存在しない場合のみ作成
    if index_name not in pc.list_indexes().names:
        print(f"インデックス '{index_name}' を作成します (タイプ: Serverless)...")
        try:
            pc.create_index(
                name=index_name,
                dimension=dimension,
                metric=metric,
                spec=serverless_spec # ここでServerlessかPodのspecを指定
                # spec=pod_spec # Podベースの場合
            )
            # インデックスが準備完了になるまで待機 (重要！)
            print("インデックス作成中... ")
            while not pc.describe_index(index_name).status['ready']:
                time.sleep(5)
                print(".", end="")
            print(f"\nインデックス '{index_name}' が準備完了しました！ ")
        except Exception as e:
            print(f"インデックスの作成中にエラーが発生しました: {e} ")
    else:
        print(f"インデックス '{index_name}' は既に存在します。")

    # インデックスの詳細情報を取得
    try:
        index_description = pc.describe_index(index_name)
        print("\nインデックス詳細情報:")
        print(f"  Name: {index_description.name}")
        print(f"  Host: {index_description.host}")
        print(f"  Dimension: {index_description.dimension}")
        print(f"  Metric: {index_description.metric}")
        print(f"  Status: {'Ready' if index_description.status['ready'] else 'Not Ready'}")
        print(f"  Spec: {index_description.spec}")
    except Exception as e:
        print(f"インデックス情報の取得中にエラー: {e}")

else:
    print("Pineconeクライアントが初期化されていません。")

index = None # 先に初期化しておく
if pc and index_name in pc.list_indexes().names:
    try:
        # インデックス名でIndexオブジェクトを取得
        index = pc.Index(index_name)
        print(f"インデックス '{index_name}' への接続 (オブジェクト取得) 完了。")

        # インデックスの統計情報を表示 (接続確認と状態把握)
        stats = index.describe_index_stats()
        print("現在のインデックス統計情報:")
        print(f"  Total vectors: {stats.total_vector_count}")
        print(f"  Namespaces: {len(stats.namespaces)}")
        if stats.namespaces:
            for ns, ns_stats in stats.namespaces.items():
                print(f"    - '{ns if ns else '(default)'}': {ns_stats.vector_count} vectors")

    except Exception as e:
        print(f"インデックス '{index_name}' への接続または統計情報取得中にエラーが発生しました: {e} ")
        index = None # エラーの場合はNoneに戻す
elif pc:
     print(f"インデックス '{index_name}' が見つかりません。")
else:
    print("Pineconeクライアントが初期化されていません。")

if index:
    vectors_to_upsert = [
        # 形式1: (ID, ベクトル値) のタプル
        ("doc_001", [0.1, 0.2] + [0.0]*(dimension-2)),

        # 形式2: (ID, ベクトル値, メタデータ辞書) のタプル
        ("doc_002", [0.9, 0.8] + [0.0]*(dimension-2), {"category": "news", "year": 2024}),

        # 形式3: 辞書形式 (推奨されることが多い)
        {"id": "doc_003",
         "values": [0.5] * dimension,
         "metadata": {"category": "blog", "published": True, "tags": ["ai", "vector-database"]}},

        # スパースベクトル付き (ハイブリッド検索用, metric='dotproduct' のインデックスが必要)
        # {"id": "doc_004",
        #  "values": [0.2] * dimension, # 密ベクトル
        #  "sparse_values": {"indices": [10, 105, 500], "values": [0.5, 0.6, 0.2]}, # 疎ベクトル
        #  "metadata": {"type": "hybrid_example"}
        # }
    ]

    target_namespace = "articles" # データを格納する名前空間 (オプション)

    try:
        print(f"\n{len(vectors_to_upsert)}個のベクトルを名前空間 '{target_namespace}' にupsertします...")
        upsert_response = index.upsert(
            vectors=vectors_to_upsert,
            namespace=target_namespace # 名前空間を指定
        )
        print(f"Upsert完了: {upsert_response.upserted_count} 個のベクトルが処理されました。")

        # 完了まで少し待つ (任意、ただし統計情報はすぐには反映されない場合がある)
        time.sleep(2)
        stats = index.describe_index_stats()
        print("\nUpsert後のインデックス統計情報:")
        if target_namespace in stats.namespaces:
             print(f"  Namespace '{target_namespace}': {stats.namespaces[target_namespace].vector_count} vectors")
        else:
             print(f"  Namespace '{target_namespace}' が見つかりません。")
        print(f"  Total vectors: {stats.total_vector_count}")


    except Exception as e:
        print(f"Upsert中にエラーが発生しました: {e} ")
else:
    print("インデックスオブジェクトが利用できません。Upsertを実行できません。")

if index:
    # 検索に使用するクエリベクトル (通常は検索文を埋め込みモデルでベクトル化する)
    query_vector = [0.15] * dimension
    # 基準となるベクトルID (このIDのベクトルに近いものを探す)
    query_id_example = "doc_001"
    # 検索対象の名前空間
    search_namespace = "articles"

    try:
        print("\n類似ベクトルを検索します (クエリベクトル指定)...")
        # クエリベクトルを指定して検索
        query_results_by_vector = index.query(
            vector=query_vector,
            top_k=2,                 # 上位何件を取得するか
            include_values=False,    # 結果にベクトル値を含めるか (通常は不要ならFalseで軽量化)
            include_metadata=True,   # 結果にメタデータを含めるか (フィルタリングや結果表示に有用)
            namespace=search_namespace, # 検索対象の名前空間
            # filter={"year": {"$gte": 2024}} # オプション: メタデータでフィルタリング (詳細は後述)
        )
        print("検索結果 (ベクトル指定):")
        if query_results_by_vector.matches:
            for match in query_results_by_vector.matches:
                print(f"  ID: {match.id}, Score: {match.score:.4f}, Metadata: {match.metadata}")
        else:
            print("  (該当なし)")

        print("\n類似ベクトルを検索します (既存ID指定)...")
        # 既存のベクトルIDを指定して、そのベクトルに近いものを検索
        query_results_by_id = index.query(
            id=query_id_example, # このIDのベクトルを基準にする
            top_k=2,
            include_metadata=True,
            namespace=search_namespace
        )
        print(f"検索結果 ({query_id_example} に類似):")
        if query_results_by_id.matches:
             for match in query_results_by_id.matches:
                 print(f"  ID: {match.id}, Score: {match.score:.4f}, Metadata: {match.metadata}")
        else:
             print("  (該当なし)")

        # ハイブリッド検索の例 (metric='dotproduct' のインデックスが必要)
        # query_sparse_vec = {"indices": [10, 500], "values": [0.5, 0.3]}
        # query_results_hybrid = index.query(
        #     vector=query_vector,          # 密ベクトル
        #     sparse_vector=query_sparse_vec, # 疎ベクトル
        #     top_k=3,
        #     include_metadata=True,
        #     namespace=search_namespace
        # )
        # print("\n検索結果 (ハイブリッド):", query_results_hybrid)

    except Exception as e:
        print(f"Query中にエラーが発生しました: {e} ")
else:
    print("インデックスオブジェクトが利用できません。Queryを実行できません。")

if index:
    ids_to_fetch = ["doc_001", "doc_003", "non_existent_id"]
    fetch_namespace = "articles"
    try:
        print(f"\nID {ids_to_fetch} のベクトルを名前空間 '{fetch_namespace}' から取得します...")
        fetch_response = index.fetch(ids=ids_to_fetch, namespace=fetch_namespace)
        print("Fetch結果:")
        if fetch_response.vectors:
            for vec_id, vec_data in fetch_response.vectors.items():
                print(f"  ID: {vec_id}")
                # print(f"    Values: {vec_data.values[:5]}...") # ベクトル値は長いので一部表示
                print(f"    Metadata: {vec_data.metadata}")
                # print(f"    SparseValues: {vec_data.sparse_values}") # 存在すれば表示
        else:
            print("  (該当するベクトルが見つかりませんでした)")

    except Exception as e:
        print(f"Fetch中にエラーが発生しました: {e} ")
else:
    print("インデックスオブジェクトが利用できません。Fetchを実行できません。")

if index:
    ids_to_delete = ["doc_002"]
    metadata_filter_to_delete = {"category": {"$eq": "blog"}} # categoryがblogのものを削除
    delete_namespace = "articles"

    try:
        # IDを指定して削除
        print(f"\nID {ids_to_delete} のベクトルを名前空間 '{delete_namespace}' から削除します...")
        delete_response_by_id = index.delete(ids=ids_to_delete, namespace=delete_namespace)
        # delete()は成功した場合、空の辞書 {} を返す
        print(f"IDによる削除結果: {'成功' if delete_response_by_id == {} else delete_response_by_id} ")

        # メタデータフィルターで削除
        # print(f"\nメタデータフィルター {metadata_filter_to_delete} に一致するベクトルを削除します...")
        # delete_response_by_filter = index.delete(filter=metadata_filter_to_delete, namespace=delete_namespace)
        # print(f"メタデータフィルターによる削除結果: {'成功' if delete_response_by_filter == {} else delete_response_by_filter} ")

        # 名前空間内の全ベクトルを削除 ( 注意: 復元できません！)
        # print(f"\n名前空間 '{delete_namespace}' の全ベクトルを削除します...")
        # delete_response_all = index.delete(delete_all=True, namespace=delete_namespace)
        # print(f"名前空間 '{delete_namespace}' の全削除結果: {'成功' if delete_response_all == {} else delete_response_all} ")

        # 削除が反映されるまで少し待つ
        time.sleep(2)
        stats = index.describe_index_stats()
        print("\n削除後のインデックス統計情報:")
        if delete_namespace in stats.namespaces:
             print(f"  Namespace '{delete_namespace}': {stats.namespaces[delete_namespace].vector_count} vectors")
        else:
             print(f"  Namespace '{delete_namespace}' が見つかりません (または空になりました)。")
        print(f"  Total vectors: {stats.total_vector_count}")


    except Exception as e:
        print(f"Delete中にエラーが発生しました: {e} ")
else:
    print("インデックスオブジェクトが利用できません。Deleteを実行できません。")

if index:
    try:
        print("\nインデックス統計情報を取得します...")
        stats = index.describe_index_stats()
        print("インデックス統計情報:")
        print(f"  次元数 (Dimension): {stats.dimension}")
        print(f"  インデックス充填率 (Index Fullness): {stats.index_fullness:.4f} (Podベースのみ関連)")
        print(f"  総ベクトル数 (Total Vector Count): {stats.total_vector_count}")
        print(f"  名前空間 (Namespaces):")
        if stats.namespaces:
            for ns, ns_stats in stats.namespaces.items():
                print(f"    - '{ns if ns else '(default)'}': {ns_stats.vector_count} ベクトル")
        else:
            print("    (名前空間はありません)")
    except Exception as e:
        print(f"インデックス統計情報の取得中にエラーが発生しました: {e} ")
else:
    print("インデックスオブジェクトが利用できません。")

index_to_delete = "my-semantic-search-index" # 削除したいインデックス名

if pc:
    try:
        if index_to_delete in pc.list_indexes().names:
            print(f"\nインデックス '{index_to_delete}' を削除します...  この操作は元に戻せません！")
            # ユーザーに確認を促すなどの処理を入れるのが安全
            # confirm = input(f"本当にインデックス '{index_to_delete}' を削除しますか？ (yes/no): ")
            # if confirm.lower() == 'yes':
            pc.delete_index(index_to_delete, timeout=300) # タイムアウトを長めに設定することも可能
            print(f"インデックス '{index_to_delete}' が削除されました。")
            # else:
            #     print("削除をキャンセルしました。")
        else:
            print(f"\nインデックス '{index_to_delete}' は存在しません。")
    except Exception as e:
        print(f"インデックス '{index_to_delete}' の削除中にエラーが発生しました: {e} ")

    # 削除後のインデックスリストを確認
    print("\n現在のインデックスリスト:")
    index_list = pc.list_indexes()
    if index_list.names:
        for index_info in index_list:
             print(f"- {index_info.name}")
    else:
        print("  (利用可能なインデックスはありません)")

else:
    print("Pineconeクライアントが初期化されていません。")

if index:
    query_vector = [0.6] * dimension
    filter_namespace = "articles"

    # 例1: categoryが 'blog' で、publishedが True のベクトルを検索 (暗黙のAND)
    filter_condition_1 = {
        "category": "blog", # {"$eq": "blog"} と同じ
        "published": True   # {"$eq": True} と同じ
    }
    # 例2: yearが2024以上、または tagsに 'vector-database' が含まれるベクトルを検索
    # (注: $or は直接サポートされていない可能性があります。代替策として複数クエリやデータ設計を検討)
    # Pineconeのドキュメントで最新のフィルター構文を確認することが重要です。
    # ここではAND条件の例を示します: year >= 2024 AND 'vector-database' in tags
    filter_condition_complex = {
         "year": {"$gte": 2024},
         "tags": {"$in": ["vector-database"]} # tagsがリストの場合、$in で含むかチェック
    }


    try:
        print(f"\nフィルター条件1 ({filter_condition_1}) で検索します...")
        query_results_1 = index.query(
            vector=query_vector,
            top_k=5,
            filter=filter_condition_1,
            include_metadata=True,
            namespace=filter_namespace
        )
        print("検索結果1:")
        if query_results_1.matches:
            for match in query_results_1.matches:
                print(f"  ID: {match.id}, Score: {match.score:.4f}, Metadata: {match.metadata}")
        else:
            print("  (該当なし)")

        print(f"\n複雑なフィルター条件 ({filter_condition_complex}) で検索します...")
        query_results_complex = index.query(
            vector=query_vector,
            top_k=5,
            filter=filter_condition_complex,
            include_metadata=True,
            namespace=filter_namespace
        )
        print("検索結果 (複雑条件):")
        if query_results_complex.matches:
            for match in query_results_complex.matches:
                 print(f"  ID: {match.id}, Score: {match.score:.4f}, Metadata: {match.metadata}")
        else:
             print("  (該当なし)")


    except Exception as e:
        print(f"メタデータフィルタリング付きQuery中にエラーが発生しました: {e} ")
else:
    print("インデックスオブジェクトが利用できません。Queryを実行できません。")

if index:
    ns_user_a = "tenant-a-data"
    ns_user_b = "tenant-b-data"

    # 異なる名前空間にデータをUpsert
    try:
        print(f"\n名前空間 '{ns_user_a}' と '{ns_user_b}' にデータをUpsertします...")
        index.upsert(vectors=[("userA_doc1", [0.11]*dimension, {"owner": "userA"})], namespace=ns_user_a)
        index.upsert(vectors=[("userB_doc1", [0.99]*dimension, {"owner": "userB"})], namespace=ns_user_b)
        index.upsert(vectors=[("userA_doc2", [0.12]*dimension, {"owner": "userA"})], namespace=ns_user_a)
        print("異なる名前空間へのUpsert完了。")
        time.sleep(2)
        stats = index.describe_index_stats()
        print("名前空間ごとの統計:")
        if stats.namespaces:
            for ns, ns_stats in stats.namespaces.items():
                print(f"  - '{ns if ns else '(default)'}': {ns_stats.vector_count} vectors")
        else:
            print("  (名前空間なし)")
    except Exception as e:
        print(f"名前空間へのUpsert中にエラー: {e} ")

    # 特定の名前空間をクエリ (他の名前空間のデータは返されない)
    try:
        print(f"\n名前空間 '{ns_user_a}' のみをクエリ:")
        query_results_user_a = index.query(
            vector=[0.115]*dimension,
            top_k=2,
            include_metadata=True,
            namespace=ns_user_a # ここで名前空間を指定
        )
        print("検索結果 (テナントA):")
        if query_results_user_a.matches:
            for match in query_results_user_a.matches:
                 print(f"  ID: {match.id}, Score: {match.score:.4f}, Metadata: {match.metadata}")
        else:
             print("  (該当なし)")

    except Exception as e:
        print(f"名前空間 '{ns_user_a}' のQuery中にエラー: {e} ")

    # 特定の名前空間のデータを削除
    try:
        print(f"\n名前空間 '{ns_user_b}' の全データを削除:")
        index.delete(delete_all=True, namespace=ns_user_b) # 指定した名前空間のデータのみ削除
        print("削除完了。")
        time.sleep(2)
        stats = index.describe_index_stats()
        print("削除後の名前空間ごとの統計:")
        if stats.namespaces:
            for ns, ns_stats in stats.namespaces.items():
                print(f"  - '{ns if ns else '(default)'}': {ns_stats.vector_count} vectors")
        else:
            print("  (名前空間なし)") # user_bが消えているはず
    except Exception as e:
        print(f"名前空間 '{ns_user_b}' のDelete中にエラー: {e} ")

else:
    print("インデックスオブジェクトが利用できません。")

# 必要なライブラリをインストール
pip install pinecone pinecone-text "pinecone-text[bm25]" sentence-transformers

# --- この例は概念的な流れを示すものであり、完全な動作には環境設定やエラー処理が必要です ---
from pinecone_text.sparse import BM25Encoder
from pinecone_text.hybrid import hybrid_convex_scale
from sentence_transformers import SentenceTransformer
import pinecone # 既にインポート済みのはず

# --- 0. モデルの準備 ---
try:
    # 密ベクトルモデル (例: 多言語対応モデル)
    dense_model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
    # 疎ベクトルモデル (BM25) - 日本語の場合は形態素解析器が必要 (後述の注意点参照)
    bm25_encoder = BM25Encoder()
    print("モデルのロード完了。")
except Exception as e:
    print(f"モデルのロード中にエラー: {e} ")
    dense_model, bm25_encoder = None, None

# --- 1. BM25エンコーダーの学習 (通常は代表的な文書コーパスで行う) ---
corpus = [
    "Pineconeは高性能なベクトルデータベースです。",
    "ハイブリッド検索はキーワード検索と意味検索を組み合わせます。",
    "BM25は古典的な情報検索アルゴリズムの一つです。",
    "ベクトル検索はAIアプリケーションで重要です。",
]
if bm25_encoder:
    try:
        print("\nBM25エンコーダーを学習させます...")
        bm25_encoder.fit(corpus)
        print("BM25エンコーダーの学習完了。")
        # 学習済みエンコーダーは保存/ロード可能
        # bm25_encoder.dump("bm25_encoder_jp.json")
        # bm25_encoder = BM25Encoder.load("bm25_encoder_jp.json")
    except Exception as e:
        # 日本語の場合、デフォルトのトークナイザーではエラーになる可能性が高い
        print(f"BM25の学習中にエラー: {e}  (日本語対応が必要かも)")
        # ここで処理を中断するか、代替手段を講じる

# --- 2. ハイブリッド検索用インデックスの作成/接続 ---
hybrid_index = None
if pc and dense_model: # pc と dense_model が利用可能かチェック
    hybrid_index_name = "jp-hybrid-search-demo"
    hybrid_dimension = dense_model.get_sentence_embedding_dimension() # モデルの次元数を取得
    metric = "dotproduct" # ハイブリッド検索にはdotproductが必要

    if hybrid_index_name not in pc.list_indexes().names:
        print(f"\nハイブリッドインデックス '{hybrid_index_name}' (dim={hybrid_dimension}, metric={metric}) を作成します...")
        try:
            pc.create_index(
                name=hybrid_index_name,
                dimension=hybrid_dimension,
                metric=metric,
                spec=ServerlessSpec(cloud="aws", region="us-east-1") # 例
            )
            print("インデックス作成中... ")
            while not pc.describe_index(hybrid_index_name).status['ready']: time.sleep(5); print(".", end="")
            print("\nインデックス準備完了！ ")
        except Exception as e:
            print(f"ハイブリッドインデックス作成エラー: {e} ")

    try:
        hybrid_index = pc.Index(hybrid_index_name)
        print(f"ハイブリッドインデックス '{hybrid_index_name}' に接続しました。")
    except Exception as e:
        print(f"ハイブリッドインデックス接続エラー: {e} ")
        hybrid_index = None

# --- 3. データの準備とUpsert ---
if hybrid_index and dense_model and bm25_encoder: # 必要なものが揃っているか確認
    docs_to_upsert = [
        {"id": "jp_doc1", "text": "Pineconeの基本的な使い方を解説します。"},
        {"id": "jp_doc2", "text": "ベクトルデータベースを用いた類似文書検索システム。"},
        {"id": "jp_doc3", "text": "ハイブリッド検索でキーワードと意味の両方を考慮する。"},
    ]
    hybrid_vectors_to_upsert = []
    print("\nハイブリッドベクトルを生成してUpsert準備...")
    for doc in docs_to_upsert:
        try:
            dense_vec = dense_model.encode(doc["text"]).tolist()
            # 日本語対応したBM25Encoderを使う必要がある (後述)
            # ここでは仮に bm25_encoder が日本語対応済みとする
            sparse_vec = bm25_encoder.encode_documents(doc["text"])[0] # BM25Encoderはリストで返す
            hybrid_vectors_to_upsert.append({
                "id": doc["id"],
                "values": dense_vec,
                "sparse_values": sparse_vec,
                "metadata": {"text": doc["text"]}
            })
            print(f"  ID: {doc['id']} のベクトル生成完了。")
        except Exception as e:
            print(f"  ID: {doc['id']} のベクトル生成エラー: {e}  (日本語トークナイザー未対応?)")

    if hybrid_vectors_to_upsert:
        try:
            print("ハイブリッドベクトルをUpsertします...")
            upsert_response = hybrid_index.upsert(vectors=hybrid_vectors_to_upsert)
            print(f"Upsert完了: {upsert_response.upserted_count} 個処理。")
        except Exception as e:
            print(f"ハイブリッドUpsertエラー: {e} ")

# --- 4. ハイブリッド検索の実行 ---
if hybrid_index and dense_model and bm25_encoder:
    query_text = "ベクトル検索のキーワード"
    alpha = 0.7 # 密ベクトルをやや重視 (0.0-1.0)

    try:
        print(f"\n'{query_text}' でハイブリッド検索 (alpha={alpha})...")
        query_dense_vec = dense_model.encode(query_text).tolist()
        # 日本語対応したBM25Encoderを使う必要がある
        query_sparse_vec = bm25_encoder.encode_queries(query_text)[0]

        # Alpha値で重み付け (pinecone-text を使う方法)
        scaled_dense, scaled_sparse = hybrid_convex_scale(
            query_dense_vec, query_sparse_vec, alpha
        )

        hybrid_query_results = hybrid_index.query(
            vector=scaled_dense,       # スケール済み密ベクトル
            sparse_vector=scaled_sparse, # スケール済み疎ベクトル
            top_k=3,
            include_metadata=True,
        )
        print("ハイブリッド検索結果:")
        if hybrid_query_results.matches:
            for match in hybrid_query_results.matches:
                 print(f"  ID: {match.id}, Score: {match.score:.4f}, Text: {match.metadata.get('text', 'N/A')}")
        else:
             print("  (該当なし)")

    except Exception as e:
        print(f"ハイブリッドQueryエラー: {e}  (日本語トークナイザー未対応?)")

import itertools
import time
import random # ダミーデータ生成用

def generate_batches(iterable, batch_size=100):
    """イテラブルを指定されたバッチサイズに分割するジェネレータ"""
    it = iter(iterable)
    while True:
        # イテレータからbatch_size個取り出す
        batch = tuple(itertools.islice(it, batch_size))
        if not batch:
            # バッチが空になったら終了
            break
        yield batch

if index:
    # 大量のダミーデータを生成 (例: 10,000ベクトル)
    num_vectors_to_batch_upsert = 10000
    print(f"\n{num_vectors_to_batch_upsert}個のベクトルをバッチUpsertします...")

    # ベクトルデータ生成 (ジェネレータ式でメモリ効率化)
    all_vectors_generator = (
        {"id": f"batch_vec_{i}",
         "values": [random.random() for _ in range(dimension)],
         "metadata": {"group": i // 100, "timestamp": time.time()}}
        for i in range(num_vectors_to_batch_upsert)
    )

    batch_size = 100 # Pinecone推奨のバッチサイズ (Serverlessは最大250だが、2MB制限に注意)
    batch_namespace = "large-batch-test"

    start_time = time.time()
    total_upserted_count = 0
    error_count = 0
    max_retries = 3

    try:
        # バッチジェネレータを使ってデータを分割し、ループでUpsert
        for i, batch_vectors_tuple in enumerate(generate_batches(all_vectors_generator, batch_size)):
            batch_vectors_list = list(batch_vectors_tuple) # Upsertにはリスト形式が必要
            for attempt in range(max_retries):
                try:
                    upsert_response = index.upsert(vectors=batch_vectors_list, namespace=batch_namespace)
                    current_batch_count = upsert_response.upserted_count
                    total_upserted_count += current_batch_count
                    if (i + 1) % 10 == 0: # 10バッチごとに進捗表示
                        elapsed_time = time.time() - start_time
                        print(f"  バッチ {i+1}完了 ({total_upserted_count}/{num_vectors_to_batch_upsert} vectors). "
                              f"経過時間: {elapsed_time:.2f}秒")
                    break # 成功したらリトライループを抜ける
                except Exception as e:
                    print(f"  バッチ {i+1} Upsertエラー (試行 {attempt+1}/{max_retries}): {e}")
                    if attempt + 1 == max_retries:
                        print(f"  バッチ {i+1} のUpsertに失敗しました。スキップします。")
                        error_count += len(batch_vectors_list)
                    else:
                        time.sleep(2 ** attempt) # Exponential backoff

        end_time = time.time()
        print(f"\nバッチUpsert完了。")
        print(f"  合計Upsert数: {total_upserted_count}")
        print(f"  エラー/スキップ数: {error_count}")
        print(f"  総所要時間: {end_time - start_time:.2f} 秒 ")

        # 統計情報が更新されるまで少し待つ
        time.sleep(5)
        stats = index.describe_index_stats()
        print("\nバッチUpsert後の統計:")
        if batch_namespace in stats.namespaces:
             print(f"  Namespace '{batch_namespace}': {stats.namespaces[batch_namespace].vector_count} vectors")
        print(f"  Total vectors: {stats.total_vector_count}")


    except Exception as e:
        print(f"バッチUpsert処理全体で予期せぬエラーが発生しました: {e} ")

    # バッチ削除の例 (同様にバッチ処理を行う)
    # ids_to_delete_batch_gen = (f"batch_vec_{i}" for i in range(0, num_vectors_to_batch_upsert, 2)) # 偶数ID
    # print(f"\n偶数IDのベクトルをバッチDeleteします...")
    # start_time_del = time.time()
    # total_deleted_count = 0
    # for batch_ids_tuple in generate_batches(ids_to_delete_batch_gen, batch_size * 5): # Deleteは大きめのバッチでも可
    #     batch_ids_list = list(batch_ids_tuple)
    #     try:
    #         index.delete(ids=batch_ids_list, namespace=batch_namespace)
    #         total_deleted_count += len(batch_ids_list)
    #     except Exception as e:
    #         print(f"バッチDelete中にエラー: {e}")
    # end_time_del = time.time()
    # print(f"バッチDelete完了。合計: {total_deleted_count}, 時間: {end_time_del - start_time_del:.2f}秒")


else:
    print("インデックスオブジェクトが利用できません。")

import time

source_index_name = index_name # 上で作成したインデックス名を使用
collection_name = f"{source_index_name}-backup-{time.strftime('%Y%m%d')}"
new_index_from_collection = f"{source_index_name}-restored"

if pc:
    try:
        # --- 1. コレクションの作成 ---
        if source_index_name in pc.list_indexes().names:
            if collection_name not in pc.list_collections().names:
                print(f"\nインデックス '{source_index_name}' からコレクション '{collection_name}' を作成します...")
                pc.create_collection(name=collection_name, source=source_index_name)
                print(f"コレクション '{collection_name}' の作成を開始しました。完了まで時間がかかる場合があります。")

                # コレクション作成完了を待つ (ポーリング)
                while True:
                    try:
                        collection_desc = pc.describe_collection(collection_name)
                        status = collection_desc.status # statusは文字列
                        print(f"  コレクションステータス: {status}")
                        if status == 'Ready':
                            print("コレクション作成完了！ ")
                            print(f"  Name: {collection_desc.name}")
                            print(f"  Dimension: {collection_desc.dimension}")
                            print(f"  Vector Count: {collection_desc.vector_count}")
                            print(f"  Size (bytes): {collection_desc.size}")
                            break
                        elif status == 'Failed':
                            print("コレクション作成失敗。")
                            break
                        # 他のステータス (Initializing, Terminating) の場合は待機
                    except Exception as desc_e:
                         print(f"コレクション状態の取得中にエラー: {desc_e}")
                         # 無限ループを防ぐためのタイムアウト処理などを追加するのが望ましい
                    time.sleep(15) # ポーリング間隔
            else:
                print(f"\nコレクション '{collection_name}' は既に存在します。")
                collection_desc = pc.describe_collection(collection_name)
                print(f"  Name: {collection_desc.name}, Status: {collection_desc.status}, Size: {collection_desc.size}")
        else:
            print(f"\nソースインデックス '{source_index_name}' が存在しません。コレクションを作成できません。")


        # --- 2. コレクションから新しいインデックスを作成 ---
        if collection_name in pc.list_collections().names:
            try:
                collection_desc = pc.describe_collection(collection_name)
                if collection_desc.status == 'Ready':
                    if new_index_from_collection not in pc.list_indexes().names:
                        print(f"\nコレクション '{collection_name}' から新しいインデックス '{new_index_from_collection}' を作成します...")
                        # specは新たに指定する必要がある (元のインデックスと同じである必要はないが、次元数とメトリクスは通常合わせる)
                        # コレクションにはspec情報は含まれないため、別途定義する
                        restore_spec = ServerlessSpec(cloud="aws", region="us-east-1") # 例

                        pc.create_index(
                            name=new_index_from_collection,
                            dimension=collection_desc.dimension, # コレクションの次元数を指定
                            metric=metric, # 元のメトリクスを指定 (ここでは上で定義した 'cosine')
                            spec=restore_spec,
                            source_collection=collection_name # ★ ここでソースコレクションを指定
                        )
                        print(f"インデックス '{new_index_from_collection}' の作成を開始しました。完了まで待機します...")
                        while not pc.describe_index(new_index_from_collection).status['ready']: time.sleep(5); print(".", end="")
                        print(f"\nインデックス '{new_index_from_collection}' がコレクションから復元されました！ ")
                    else:
                        print(f"\nインデックス '{new_index_from_collection}' は既に存在します。")
                else:
                    print(f"\nコレクション '{collection_name}' が 'Ready' 状態ではありません (Status: {collection_desc.status})。インデックスを作成できません。")
            except Exception as create_idx_e:
                 print(f"コレクションからのインデックス作成中にエラー: {create_idx_e} ")
        else:
             print(f"\nコレクション '{collection_name}' が存在しません。")

        # --- 3. コレクションの一覧表示と削除 ---
        print("\n現在のコレクションリスト:")
        collection_list = pc.list_collections()
        if collection_list.names:
            for col_name in collection_list.names:
                desc = pc.describe_collection(col_name)
                print(f"- {desc.name} (Status: {desc.status}, Size: {desc.size}, Count: {desc.vector_count})")
        else:
             print("  (コレクションはありません)")

        # コレクションの削除 (不要になったら)
        # if collection_name in pc.list_collections().names:
        #     print(f"\nコレクション '{collection_name}' を削除します...")
        #     try:
        #         pc.delete_collection(collection_name)
        #         print(f"コレクション '{collection_name}' 削除完了。")
        #         print("\n削除後のコレクションリスト:", pc.list_collections().names)
        #     except Exception as del_col_e:
        #          print(f"コレクション削除エラー: {del_col_e} ")

    except Exception as e:
        print(f"\nコレクション操作中に予期せぬエラーが発生しました: {e} ")
else:
    print("Pineconeクライアントが初期化されていません。")