first commit

MULTI_MODEL_DESIGN.md

@@ -0,0 +1,378 @@
+# マルチモデル対応設計案
+
+## 概要
+現在のLLMViewはLlama 3.2 3B（transformers）のみ対応していますが、他のTransformersモデル（Qwen、Mistral、Gemma等）にも対応できるように拡張します。
+
+**重要**: Hugging Face Spacesでの使用を前提とする場合、**APIを使う必要はありません**。
+Transformersライブラリでローカルにモデルをロードする方法（TransformersAI）を使用してください。
+これにより、完全なトークン確率情報が取得でき、コストもかかりません。
+
+外部API（OpenAI、Anthropic、Google）のサポートは、ローカル環境やテスト目的でのみ使用することを想定しています。
+
+## アーキテクチャ設計
+
+### 1. アダプターパターンの導入
+
+```
+AI (基底クラス/インターフェース)
+├── TransformersAI (現在の実装 - Llama等のローカルモデル)
+├── OpenAIAI (ChatGPT API)
+├── AnthropicAI (Claude API)
+├── GoogleAI (Gemini API)
+└── HuggingFaceInferenceAI (Hugging Face Inference API)
+```
+
+### 2. 統一インターフェース
+
+すべてのモデルアダプターが実装すべきメソッド：
+
+```python
+class BaseAI:
+    def get_token_probabilities(self, text: str, k: int = 5) -> List[Tuple[str, float]]:
+        """
+        テキストから次のトークン候補と確率を取得
+        
+        Returns:
+            List[Tuple[str, float]]: (トークン, 確率)のリスト
+        """
+        raise NotImplementedError
+    
+    def build_chat_prompt(self, user_content: str, system_content: str = "") -> str:
+        """
+        モデル固有のチャットプロンプト形式に変換
+        """
+        raise NotImplementedError
+```
+
+### 3. モデルタイプの識別
+
+環境変数または設定ファイルでモデルタイプを指定：
+
+```python
+MODEL_TYPE = os.getenv("MODEL_TYPE", "transformers")  # transformers, openai, anthropic, google, hf_inference
+MODEL_PATH = os.getenv("HF_MODEL_REPO", "meta-llama/Llama-3.2-3B-Instruct")  # モデル識別子（Hugging FaceリポジトリID）
+```
+
+**Hugging Face Spacesでの推奨設定**:
+```python
+# 環境変数例（Hugging Face Spaces用）
+MODEL_TYPE=transformers
+HF_MODEL_REPO=Qwen/Qwen2.5-3B-Instruct  # または他のモデル
+HF_TOKEN=your_hf_token  # プライベートモデルの場合
+```
+
+### 4. 各モデルの特徴と実装方針
+
+#### 4.1 TransformersAI (現在の実装)
+- **特徴**: ローカルでモデルをロード、logitsから直接確率を取得可能
+- **利点**: 完全なトークン確率情報が利用可能
+- **実装**: 現在の`AI`クラスを`TransformersAI`にリネーム
+
+#### 4.2 OpenAIAI (ChatGPT)
+- **特徴**: API経由、`logprobs`パラメータでトークン確率を取得可能
+- **API**: `openai.ChatCompletion.create()` の `logprobs=True`
+- **制約**: 
+  - トークン確率は`logprobs`で取得可能（GPT-4以降）
+  - リクエストごとにAPIコールが必要
+  - レート制限とコストが発生
+- **実装方針**:
+  ```python
+  response = openai.ChatCompletion.create(
+      model="gpt-4",
+      messages=[...],
+      logprobs=True,
+      top_logprobs=5
+  )
+  # logprobsから確率を計算
+  ```
+
+#### 4.3 AnthropicAI (Claude)
+- **特徴**: API経由、`logprobs`パラメータでトークン確率を取得可能（Claude 3.5以降）
+- **API**: `anthropic.Anthropic().messages.create()` の `logprobs=True`
+- **制約**: 
+  - トークン確率は`logprobs`で取得可能
+  - リクエストごとにAPIコールが必要
+- **実装方針**:
+  ```python
+  response = client.messages.create(
+      model="claude-3-5-sonnet-20241022",
+      messages=[...],
+      logprobs=True,
+      top_logprobs=5
+  )
+  ```
+
+#### 4.4 GoogleAI (Gemini)
+- **特徴**: API経由、`logprobs`パラメータでトークン確率を取得可能
+- **API**: `google.generativeai.GenerativeModel.generate_content()` の `logprobs=True`
+- **制約**: 
+  - トークン確率は`logprobs`で取得可能
+  - リクエストごとにAPIコールが必要
+- **実装方針**:
+  ```python
+  response = model.generate_content(
+      prompt,
+      generation_config={"logprobs": True, "top_k": 5}
+  )
+  ```
+
+#### 4.5 HuggingFaceInferenceAI
+- **特徴**: Hugging Face Inference API経由、一部のモデルでlogits取得可能
+- **API**: `huggingface_hub.InferenceClient.text_generation()` の `details=True`
+- **制約**: 
+  - すべてのモデルでlogitsが利用可能とは限らない
+  - リクエストごとにAPIコールが必要
+  - 無料プランにはレート制限あり
+
+#### 4.6 Hugging Face Spacesで利用可能なモデル（Transformers経由）
+
+Hugging Face Spacesでは、以下のモデルをTransformersライブラリで直接利用可能：
+
+##### 4.6.1 日本語対応モデル（推奨）
+
+| モデル | リポジトリID | サイズ | 特徴 | トークン確率取得 |
+|--------|------------|--------|------|----------------|
+| **Llama 3.2 3B Instruct** | `meta-llama/Llama-3.2-3B-Instruct` | 3B | 多言語対応、現在使用中 | ✅ 完全対応 |
+| **Qwen 2.5** | `Qwen/Qwen2.5-3B-Instruct` | 3B | 日本語に強い、高性能 | ✅ 完全対応 |
+| **Mistral 7B Instruct** | `mistralai/Mistral-7B-Instruct-v0.2` | 7B | 高性能、多言語対応 | ✅ 完全対応 |
+| **Gemma 2B/7B** | `google/gemma-2b-it`, `google/gemma-7b-it` | 2B/7B | Google製、軽量 | ✅ 完全対応 |
+| **Phi-3** | `microsoft/Phi-3-mini-4k-instruct` | 3.8B | 軽量、高性能 | ✅ 完全対応 |
+| **TinyLlama** | `TinyLlama/TinyLlama-1.1B-Chat-v1.0` | 1.1B | 超軽量 | ✅ 完全対応 |
+
+##### 4.6.2 日本語特化モデル
+
+| モデル | リポジトリID | サイズ | 特徴 | トークン確率取得 |
+|--------|------------|--------|------|----------------|
+| **ELYZA-japanese-Llama-2** | `elyza/ELYZA-japanese-Llama-2-7b-instruct` | 7B | 日本語特化 | ✅ 完全対応 |
+| **japanese-stablelm** | `stabilityai/japanese-stablelm-base-gamma-7b` | 7B | 日本語特化 | ✅ 完全対応 |
+| **weblab-10b** | `rinna/weblab-10b-instruction-sft` | 10B | 日本語特化、大規模 | ✅ 完全対応 |
+
+##### 4.6.3 その他の主要モデル
+
+| モデル | リポジトリID | サイズ | 特徴 | トークン確率取得 |
+|--------|------------|--------|------|----------------|
+| **Falcon** | `tiiuae/falcon-7b-instruct` | 7B | オープンソース | ✅ 完全対応 |
+| **MPT** | `mosaicml/mpt-7b-instruct` | 7B | 商用利用可能 | ✅ 完全対応 |
+| **StarCoder** | `bigcode/starcoder2-7b` | 7B | コード生成特化 | ✅ 完全対応 |
+
+##### 4.6.4 Hugging Face Inference APIで利用可能なモデル
+
+**注意**: Inference APIでは、すべてのモデルでトークン確率（logits）が取得できるわけではありません。
+以下のモデルはInference API経由でも利用可能ですが、トークン確率の取得はモデルによって異なります：
+
+- **無料プラン**: 制限あり、一部モデルのみ
+- **有料プラン**: より多くのモデルにアクセス可能
+
+**推奨アプローチ**: 
+- Hugging Face Spacesでは、**Transformersライブラリで直接モデルをロード**する方法を推奨
+- これにより、完全なトークン確率情報が取得可能
+- Inference APIは、モデルをローカルにロードできない場合の代替手段
+
+### 5. プロンプトフォーマットの統一
+
+各モデルに適したプロンプト形式に変換する`build_chat_prompt`メソッドを実装：
+
+```python
+# Llama 3.2形式
+"<|start_header_id|>system<|end_header_id|>\n{system}\n<|eot_id|>..."
+
+# OpenAI形式
+[
+    {"role": "system", "content": system},
+    {"role": "user", "content": user}
+]
+
+# Claude形式
+[
+    {"role": "user", "content": f"{system}\n\n{user}"}
+]
+
+# Gemini形式
+f"{system}\n\n{user}"
+```
+
+### 6. 設定管理の拡張
+
+`config.py`または環境変数で管理：
+
+```python
+# Hugging Face Spaces用（推奨）
+MODEL_TYPE=transformers
+HF_MODEL_REPO=Qwen/Qwen2.5-3B-Instruct  # または meta-llama/Llama-3.2-3B-Instruct
+HF_TOKEN=your_hf_token  # プライベートモデルの場合のみ
+
+# OpenAI API用
+MODEL_TYPE=openai
+OPENAI_API_KEY=sk-...
+OPENAI_MODEL=gpt-4
+
+# Anthropic API用
+MODEL_TYPE=anthropic
+ANTHROPIC_API_KEY=sk-ant-...
+ANTHROPIC_MODEL=claude-3-5-sonnet-20241022
+
+# Google API用
+MODEL_TYPE=google
+GOOGLE_API_KEY=...
+GOOGLE_MODEL=gemini-pro
+
+# Hugging Face Inference API用（オプション）
+MODEL_TYPE=hf_inference
+HF_INFERENCE_API_KEY=hf_...
+HF_INFERENCE_MODEL=meta-llama/Llama-3.2-3B-Instruct
+```
+
+**Hugging Face Spacesでの推奨設定**:
+- `MODEL_TYPE=transformers`を使用（ローカルでモデルをロード）
+- `HF_MODEL_REPO`でモデルを指定（デフォルト: `meta-llama/Llama-3.2-3B-Instruct`）
+- 他のモデルに切り替える場合は、`HF_MODEL_REPO`を変更するだけ
+
+### 7. 実装の優先順位
+
+#### Phase 1: 基盤整備（最優先）
+- `BaseAI`インターフェースの定義
+- 現在の`AI`クラスを`TransformersAI`にリファクタリング
+- モデルタイプの識別とファクトリーパターンの実装
+- **Hugging Face Spacesでの複数モデル対応**（Llama 3.2以外のモデル選択可能に）
+
+#### Phase 2: Hugging Faceモデルの拡張対応
+- **Qwen 2.5対応**: 日本語に強い、高性能
+- **Mistral 7B対応**: 多言語対応、高性能
+- **Gemma対応**: Google製、軽量
+- 各モデルのプロンプトフォーマット対応
+
+#### Phase 3: OpenAI対応
+- `OpenAIAI`クラスの実装
+- `logprobs`パラメータの活用
+- プロンプトフォーマット変換
+
+#### Phase 4: Anthropic対応
+- `AnthropicAI`クラスの実装
+- Claude固有のプロンプト形式対応
+
+#### Phase 5: Google/Gemini対応
+- `GoogleAI`クラスの実装
+
+#### Phase 6: その他
+- Hugging Face Inference API対応（オプション）
+- カスタムモデルエンドポイント対応
+
+### 8. 課題と解決策
+
+#### 課題1: APIコストとレート制限
+- **解決策**: 
+  - キャッシュ機能の実装
+  - リクエスト間隔の制御
+  - ローカルモデルとの併用推奨
+
+#### 課題2: トークン確率の取得方法の違い
+- **解決策**: 
+  - 各APIの`logprobs`パラメータを活用
+  - 確率の正規化処理を統一
+
+#### 課題3: プロンプト形式の違い
+- **解決策**: 
+  - 各モデル用の`build_chat_prompt`メソッドを実装
+  - 統一された入力インターフェースを提供
+
+#### 課題4: エラーハンドリング
+- **解決策**: 
+  - 各APIのエラーレスポンスを統一形式で処理
+  - フォールバック機能の実装
+
+### 9. ファイル構成
+
+```
+package/
+├── ai/
+│   ├── __init__.py          # ファクトリー関数
+│   ├── base.py              # BaseAIインターフェース
+│   ├── transformers_ai.py   # TransformersAI (現在のAIクラス)
+│   ├── openai_ai.py         # OpenAIAI
+│   ├── anthropic_ai.py      # AnthropicAI
+│   ├── google_ai.py         # GoogleAI
+│   └── hf_inference_ai.py   # HuggingFaceInferenceAI
+├── config.py                # 設定管理（拡張）
+└── ...
+```
+
+### 10. 使用例
+
+#### 10.1 Hugging Face Spacesでの使用（推奨）
+
+```python
+# 環境変数でモデルを指定
+# HF_MODEL_REPO=Qwen/Qwen2.5-3B-Instruct python app.py
+# HF_MODEL_REPO=mistralai/Mistral-7B-Instruct-v0.2 python app.py
+
+from package.ai import get_ai_model
+
+# ファクトリー関数で適切なモデルを取得
+ai_model = get_ai_model()  # MODEL_TYPE=transformers（デフォルト）
+
+# 統一されたインターフェースで使用
+tokens = ai_model.get_token_probabilities("こんにちは", k=5)
+```
+
+#### 10.2 OpenAI APIでの使用
+
+```python
+# MODEL_TYPE=openai OPENAI_API_KEY=sk-... python app.py
+
+from package.ai import get_ai_model
+
+ai_model = get_ai_model()  # MODEL_TYPE=openai
+tokens = ai_model.get_token_probabilities("こんにちは", k=5)
+```
+
+#### 10.3 モデルの動的切り替え
+
+```python
+# アプリ起動時に環境変数で指定
+# または、設定ファイルで管理
+
+import os
+os.environ["HF_MODEL_REPO"] = "Qwen/Qwen2.5-3B-Instruct"
+
+from package.ai import get_ai_model
+ai_model = get_ai_model()
+```
+
+### 11. Hugging Face Spacesでのモデル選択ガイド
+
+#### 11.1 モデル選択の基準
+
+1. **日本語対応**: 日本語処理が必要な場合
+   - 推奨: `Qwen/Qwen2.5-3B-Instruct`, `meta-llama/Llama-3.2-3B-Instruct`
+
+2. **軽量性**: リソース制約がある場合
+   - 推奨: `TinyLlama/TinyLlama-1.1B-Chat-v1.0`, `google/gemma-2b-it`
+
+3. **高性能**: 品質を重視する場合
+   - 推奨: `mistralai/Mistral-7B-Instruct-v0.2`, `Qwen/Qwen2.5-3B-Instruct`
+
+4. **日本語特化**: 日本語タスクに特化
+   - 推奨: `elyza/ELYZA-japanese-Llama-2-7b-instruct`, `rinna/weblab-10b-instruction-sft`
+
+#### 11.2 モデル切り替え手順
+
+1. Hugging Face Spacesの環境変数で`HF_MODEL_REPO`を設定
+2. アプリを再起動
+3. モデルが自動的にロードされる（初回はダウンロード時間がかかる場合あり）
+
+#### 11.3 注意事項
+
+- **ストレージ制約**: Hugging Face Spacesのストレージ制限に注意
+- **モデルサイズ**: 大きなモデル（7B以上）はメモリとロード時間がかかる
+- **トークン確率**: すべてのTransformersモデルで完全なトークン確率が取得可能
+- **APIコスト**: Transformersモデルは無料（ローカルロード）、APIモデルは有料
+
+## まとめ
+
+この設計により、以下のメリットが得られます：
+
+1. **拡張性**: 新しいモデルを簡単に追加可能
+2. **互換性**: 既存のコードを最小限の変更で維持
+3. **柔軟性**: ユーザーが好みのモデルを選択可能
+4. **統一性**: すべてのモデルが同じインターフェースを使用
+

README.md

@@ -1,13 +1,122 @@
----
-title: LLMView Multi Model
-emoji: 🐢
-colorFrom: yellow
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.0.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LLMView Multi-Model - Hugging Face Spaces版
+
+複数のAIモデルに対応した単語ツリー構築ツール（Gradio版）
+
+## 特徴
+
+- ✅ **マルチモデル対応**: Transformersモデル（Llama、Qwen、Mistral、Gemma等）に対応
+- ✅ **Hugging Face Spaces対応**: GradioでHFSにデプロイ可能
+- ✅ **GPU対応**: ZeroGPUを使用してGPUリソースを要求
+- ✅ **完全なトークン確率**: ローカルモデルで完全なトークン確率情報を取得
+
+## Hugging Face Spacesでのデプロイ
+
+### 1. リポジトリの作成
+
+1. Hugging Face Spacesで新しいSpaceを作成
+2. SDK: **Gradio** を選択
+3. Hardware: **GPU** を選択（推奨）
+
+### 2. 環境変数の設定
+
+Spaceの設定で以下の環境変数を設定：
+
+```bash
+# モデルタイプ（transformers推奨）
+MODEL_TYPE=transformers
+
+# 使用するモデル（Hugging FaceリポジトリID）
+HF_MODEL_REPO=meta-llama/Llama-3.2-3B-Instruct
+
+# プライベートモデルの場合のみ
+HF_TOKEN=your_hf_token
+```
+
+### 3. モデルの切り替え
+
+環境変数`HF_MODEL_REPO`を変更するだけで、他のモデルに切り替え可能：
+
+```bash
+# Qwen 2.5
+HF_MODEL_REPO=Qwen/Qwen2.5-3B-Instruct
+
+# Mistral 7B
+HF_MODEL_REPO=mistralai/Mistral-7B-Instruct-v0.2
+
+# Gemma 2B
+HF_MODEL_REPO=google/gemma-2b-it
+```
+
+## 使用方法
+
+1. **プロンプトを入力**: 質問や指示を入力
+2. **ルートテキスト（オプション）**: 既存のテキストの続きを生成する場合に指定
+3. **パラメータ調整**:
+   - `top_k`: 取得する候補数（1-20）
+   - `max_depth`: 最大探索深さ（1-50）
+4. **「単語ツリーを構築」ボタンをクリック**
+
+## ファイル構成
+
+```
+LLMView_multi_model/
+├── app.py                    # Gradioアプリ（メイン）
+├── requirements.txt          # 依存パッケージ
+├── README.md                 # このファイル
+├── MULTI_MODEL_DESIGN.md     # 設計ドキュメント
+└── package/
+    ├── __init__.py
+    ├── adapter.py            # ModelAdapter（マルチモデル対応）
+    ├── config.py             # 設定管理
+    ├── word_processor.py     # 単語処理ロジック
+    ├── word_counter.py       # 単語数カウント
+    └── ai/
+        ├── __init__.py       # ファクトリー関数
+        ├── base.py           # BaseAIインターフェース
+        ├── transformers_ai.py # TransformersAI（ローカルモデル）
+        ├── openai_ai.py      # OpenAIAI（オプション）
+        ├── anthropic_ai.py   # AnthropicAI（オプション）
+        └── google_ai.py      # GoogleAI（オプション）
+```
+
+## 依存パッケージ
+
+主要な依存パッケージ：
+
+- `gradio>=4.0.0`: Web UI
+- `spaces`: Hugging Face Spaces用
+- `transformers>=4.30.0`: Transformersモデル
+- `torch>=2.0.0`: PyTorch
+- `fugashi>=1.3.0`: 形態素解析（日本語）
+- `sudachipy>=0.6.7`: Sudachi形態素解析（オプション）
+
+詳細は`requirements.txt`を参照してください。
+
+## 注意事項
+
+1. **GPU推奨**: モデルのロードと推論にはGPUが推奨されます
+2. **モデルサイズ**: 大きなモデル（7B以上）はメモリとロード時間がかかります
+3. **初回起動**: モデルのダウンロードに時間がかかる場合があります
+4. **API非推奨**: Hugging Face Spacesでは、Transformersモデル（ローカルロード）を使用してください
+
+## トラブルシューティング
+
+### モデルがロードされない
+
+- `HF_TOKEN`が正しく設定されているか確認（プライベートモデルの場合）
+- モデルリポジトリIDが正しいか確認
+- Spaceのログを確認
+
+### GPUが利用できない
+
+- SpaceのHardware設定でGPUが有効になっているか確認
+- `spaces`パッケージがインストールされているか確認
+
+### 形態素解析エラー
+
+- `fugashi`がインストールされているか確認
+- HFSでは通常、デフォルト設定で動作します
+
+## ライセンス
+
+MIT License

app.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+LLMView Multi-Model - Gradioアプリ
+Hugging Face Spaces用
+"""
+import os
+import sys
+import threading
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+import gradio as gr
+
+# ZeroGPU対応: spacesパッケージをインポート（デコレータ用）
+try:
+    import spaces
+    SPACES_AVAILABLE = True
+    print("[SPACE] spacesパッケージをインポートしました")
+except ImportError:
+    SPACES_AVAILABLE = False
+    print("[SPACE] spacesパッケージが見つかりません（ローカル環境の可能性）")
+    # ダミーデコレータを定義
+    class DummyGPU:
+        def __call__(self, func):
+            return func
+    spaces = type('spaces', (), {'GPU': DummyGPU()})()
+
+# パッケージパスを追加
+sys.path.insert(0, str(Path(__file__).parent))
+
+from package.ai import get_ai_model
+from package.word_processor import WordDeterminer, WordPiece
+from package.adapter import ModelAdapter
+
+# グローバル変数
+adapter: Optional[ModelAdapter] = None
+status_message = "モデル初期化中..."
+status_lock = threading.Lock()
+
+# 環境変数から設定を取得
+MODEL_TYPE = os.getenv("MODEL_TYPE", "transformers")
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "meta-llama/Llama-3.2-3B-Instruct")
+
+
+def _set_status(message: str) -> None:
+    """ステータスメッセージを更新"""
+    global status_message
+    with status_lock:
+        status_message = message
+
+
+def initialize_model() -> None:
+    """モデルを初期化"""
+    global adapter
+    try:
+        print("[INIT] モデル初期化開始")
+        _set_status("モデルを読み込み中です...")
+        
+        # AIモデルを取得
+        ai_model = get_ai_model()
+        print(f"[INIT] AIモデル取得成功: {type(ai_model)}")
+        
+        # ModelAdapterを初期化
+        adapter = ModelAdapter(ai_model)
+        print("[INIT] ModelAdapter初期化完了")
+        
+        _set_status("モデル準備完了")
+        print("[INIT] モデル初期化完了")
+    except Exception as exc:
+        error_msg = f"モデル初期化に失敗しました: {exc}"
+        print(f"[INIT] エラー: {error_msg}")
+        _set_status(error_msg)
+        import traceback
+        traceback.print_exc()
+
+
+# バックグラウンドでモデルを初期化
+threading.Thread(target=initialize_model, daemon=True).start()
+
+
+def build_word_tree(
+    prompt_text: str,
+    root_text: str = "",
+    top_k: int = 5,
+    max_depth: int = 10
+) -> List[Dict[str, Any]]:
+    """
+    単語ツリーを構築
+    
+    Args:
+        prompt_text: プロンプトテキスト
+        root_text: ルートテキスト（オプション）
+        top_k: 取得する候補数
+        max_depth: 最大深さ
+        
+    Returns:
+        List[Dict[str, Any]]: 候補リスト
+    """
+    if not prompt_text.strip():
+        return [{"text": "プロンプトを入力してください", "probability": 0.0}]
+    
+    if adapter is None:
+        with status_lock:
+            current_status = status_message
+        return [{"text": f"モデル準備中: {current_status}", "probability": 0.0}]
+    
+    try:
+        results = adapter.build_word_tree(
+            prompt_text=prompt_text,
+            root_text=root_text,
+            top_k=top_k,
+            max_depth=max_depth,
+        )
+        
+        if not results:
+            return [{"text": "候補が生成されませんでした", "probability": 0.0}]
+        
+        return results
+    except Exception as exc:
+        import traceback
+        traceback.print_exc()
+        return [{"text": f"エラー: {exc}", "probability": 0.0}]
+
+
+def get_status() -> str:
+    """ステータスを取得"""
+    with status_lock:
+        current_status = status_message
+    
+    model_info = f"モデルタイプ: {MODEL_TYPE}\n"
+    if MODEL_TYPE == "transformers":
+        model_info += f"モデル: {HF_MODEL_REPO}\n"
+    
+    return f"{model_info}ステータス: {current_status}"
+
+
+# Gradioインターフェース
+with gr.Blocks(title="LLMView Multi-Model", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # LLMView Multi-Model
+    
+    複数のAIモデルに対応した単語ツリー構築ツール
+    
+    ## 使い方
+    1. プロンプトを入力
+    2. オプションでルートテキストを指定（既存のテキストの続きを生成する場合）
+    3. パラメータを調整（top_k: 候補数、max_depth: 最大深さ）
+    4. 「単語ツリーを構築」ボタンをクリック
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            prompt_input = gr.Textbox(
+                label="プロンプト",
+                placeholder="例: 電球を作ったのは誰？",
+                lines=3
+            )
+            root_input = gr.Textbox(
+                label="ルートテキスト（オプション）",
+                placeholder="例: 電球を作ったの���",
+                lines=2
+            )
+            
+            with gr.Row():
+                top_k_slider = gr.Slider(
+                    minimum=1,
+                    maximum=20,
+                    value=5,
+                    step=1,
+                    label="候補数 (top_k)"
+                )
+                max_depth_slider = gr.Slider(
+                    minimum=1,
+                    maximum=50,
+                    value=10,
+                    step=1,
+                    label="最大深さ (max_depth)"
+                )
+            
+            build_btn = gr.Button("単語ツリーを構築", variant="primary")
+        
+        with gr.Column(scale=1):
+            status_output = gr.Textbox(
+                label="ステータス",
+                value=get_status(),
+                lines=5,
+                interactive=False
+            )
+            refresh_status_btn = gr.Button("ステータス更新")
+    
+    results_output = gr.Dataframe(
+        label="結果",
+        headers=["テキスト", "確率"],
+        datatype=["str", "number"],
+        interactive=False
+    )
+    
+    # イベントハンドラ
+    def build_and_display(prompt, root, top_k, max_depth):
+        results = build_word_tree(prompt, root, int(top_k), int(max_depth))
+        # DataFrame用に変換
+        df_data = [[r["text"], f"{r['probability']:.4f}"] for r in results]
+        return df_data, get_status()
+    
+    build_btn.click(
+        fn=build_and_display,
+        inputs=[prompt_input, root_input, top_k_slider, max_depth_slider],
+        outputs=[results_output, status_output]
+    )
+    
+    refresh_status_btn.click(
+        fn=lambda: get_status(),
+        outputs=status_output
+    )
+
+
+# ZeroGPU対応: 起動時に検出されるように、デコレータ付き関数を定義
+@spaces.GPU
+def _gpu_init_function():
+    """GPU初期化用のダミー関数（Space起動時に検出される）"""
+    pass
+
+
+if __name__ == "__main__":
+    # Hugging Face Spaces用の設定
+    # GPU要求を確実に検出させる
+    if SPACES_AVAILABLE:
+        try:
+            _gpu_init_function()
+            print("[SPACE] GPU要求を送信しました")
+        except Exception as e:
+            print(f"[SPACE] GPU要求エラー: {e}")
+    
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )
+

package/__init__.py

@@ -0,0 +1,5 @@
+"""
+Other models パッケージ
+マルチモデル対応のAIアダプター
+"""
+

package/adapter.py

@@ -0,0 +1,93 @@
+"""
+ModelAdapter - マルチモデル対応アダプター
+新しいAIインターフェース（BaseAI）に対応
+"""
+from typing import Any, Dict, List, Optional
+from .word_processor import WordDeterminer, WordPiece
+from .ai.base import BaseAI
+
+
+class ModelAdapter:
+    """
+    マルチモデル対応アダプター
+    - 初期化コストの高いコンポーネント（WordDeterminer, AIモデル）を1回だけ生成して保持
+    - メソッドでビルド処理を提供
+    - 返却はシリアライズしやすい dict/list 形式
+    """
+    
+    def __init__(self, ai_model: BaseAI):
+        """
+        初期化
+        
+        Args:
+            ai_model: BaseAIを実装したモデルインスタンス
+        """
+        # WordDeterminer（内部で Sudachi C モードの WordCounter を使用）
+        self.determiner = WordDeterminer()
+        
+        # AIモデルを保持
+        self.model = ai_model
+    
+    def _clean_text(self, text: str) -> str:
+        """制御文字・不可視文字・置換文字を厳密に取り除く（最終出力用）"""
+        if not text:
+            return ""
+        
+        # 制御文字（0x00-0x1F、0x7F-0x9F）を除去
+        # ただし、改行・タブ・復帰は許可
+        cleaned = []
+        for ch in text:
+            code = ord(ch)
+            # 許可する制御文字: 改行(0x0A), タブ(0x09), 復帰(0x0D)
+            if code in [0x09, 0x0A, 0x0D]:
+                cleaned.append(ch)
+            # 通常の印刷可能文字
+            elif ch.isprintable():
+                # 置換文字（U+FFFD）を除去
+                if ch != "\uFFFD":
+                    cleaned.append(ch)
+            # その他の制御文字や不可視文字は除去
+        
+        result = "".join(cleaned)
+        # ゼロ幅文字を除去
+        result = result.replace("\u200B", "")  # Zero-width space
+        result = result.replace("\u200C", "")  # Zero-width non-joiner
+        result = result.replace("\u200D", "")  # Zero-width joiner
+        result = result.replace("\uFEFF", "")  # Zero-width no-break space
+        return result.strip()
+
+    def build_word_tree(
+        self, 
+        prompt_text: str, 
+        root_text: str = "", 
+        top_k: int = 5, 
+        max_depth: int = 10
+    ) -> List[Dict[str, Any]]:
+        """
+        単語ツリーを構築して、完成ピースを dict の配列で返す。
+        各要素: { text: str, probability: float }
+        """
+        pieces: List[WordPiece] = self.determiner.build_word_tree(
+            prompt_text=prompt_text,
+            root_text=root_text,
+            model=self.model,
+            top_k=top_k,
+            max_depth=max_depth,
+        )
+        return [
+            {"text": self._clean_text(p.get_full_word()), "probability": float(p.probability)}
+            for p in pieces
+        ]
+
+    def build_chat_prompt(
+        self, 
+        user_content: str, 
+        system_content: str = "あなたは親切で役に立つAIアシスタントです。"
+    ) -> str:
+        """チャットプロンプト文字列を返す。"""
+        return self.model.build_chat_prompt(user_content, system_content)
+
+    def count_words(self, text: str) -> int:
+        """Sudachi(C) ベースでの語数カウント。"""
+        return self.determiner._count_words(text)
+

package/ai/__init__.py

@@ -0,0 +1,80 @@
+"""
+AIモデルアダプターのファクトリー関数
+環境変数に基づいて適切なモデルを自動選択
+"""
+import os
+from typing import Optional
+from .base import BaseAI
+from .transformers_ai import TransformersAI
+from .openai_ai import OpenAIAI
+from .anthropic_ai import AnthropicAI
+from .google_ai import GoogleAI
+
+
+def get_ai_model(model_type: Optional[str] = None, **kwargs) -> BaseAI:
+    """
+    環境変数または引数に基づいて適切なAIモデルを取得
+    
+    Args:
+        model_type: モデルタイプ（"transformers", "openai", "anthropic", "google"）
+                    Noneの場合は環境変数MODEL_TYPEから取得
+        **kwargs: 各モデル固有の引数
+                  - transformers: model_path
+                  - openai: model_name, api_key
+                  - anthropic: model_name, api_key
+                  - google: model_name, api_key
+    
+    Returns:
+        BaseAI: 選択されたモデルのインスタンス
+        
+    Examples:
+        # 環境変数から自動選択
+        ai = get_ai_model()
+        
+        # 明示的に指定
+        ai = get_ai_model("transformers", model_path="Qwen/Qwen2.5-3B-Instruct")
+        ai = get_ai_model("openai", model_name="gpt-4", api_key="sk-...")
+    """
+    # モデルタイプを決定
+    if model_type is None:
+        model_type = os.getenv("MODEL_TYPE", "transformers")
+    
+    model_type = model_type.lower()
+    
+    # モデルタイプに応じて適切なクラスを返す
+    if model_type == "transformers":
+        model_path = kwargs.get("model_path") or os.getenv("HF_MODEL_REPO", "meta-llama/Llama-3.2-3B-Instruct")
+        return TransformersAI.get_model(model_path=model_path)
+    
+    elif model_type == "openai":
+        model_name = kwargs.get("model_name") or os.getenv("OPENAI_MODEL", "gpt-4")
+        api_key = kwargs.get("api_key") or os.getenv("OPENAI_API_KEY")
+        return OpenAIAI.get_model(model_name=model_name, api_key=api_key)
+    
+    elif model_type == "anthropic":
+        model_name = kwargs.get("model_name") or os.getenv("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022")
+        api_key = kwargs.get("api_key") or os.getenv("ANTHROPIC_API_KEY")
+        return AnthropicAI.get_model(model_name=model_name, api_key=api_key)
+    
+    elif model_type == "google":
+        model_name = kwargs.get("model_name") or os.getenv("GOOGLE_MODEL", "gemini-pro")
+        api_key = kwargs.get("api_key") or os.getenv("GOOGLE_API_KEY")
+        return GoogleAI.get_model(model_name=model_name, api_key=api_key)
+    
+    else:
+        raise ValueError(
+            f"不明なモデルタイプ: {model_type}. "
+            f"サポートされているタイプ: transformers, openai, anthropic, google"
+        )
+
+
+# 後方互換性のため、BaseAIもエクスポート
+__all__ = [
+    "BaseAI",
+    "TransformersAI",
+    "OpenAIAI",
+    "AnthropicAI",
+    "GoogleAI",
+    "get_ai_model",
+]
+

package/ai/anthropic_ai.py

@@ -0,0 +1,180 @@
+"""
+AnthropicAI - Anthropic API（Claude）用アダプター
+"""
+from typing import List, Tuple, Optional, Dict, Any
+import os
+import math
+from .base import BaseAI
+
+
+class AnthropicAI(BaseAI):
+    """
+    Anthropic API（Claude）用アダプター
+    
+    特徴:
+    - API経由でモデルにアクセス
+    - logprobsパラメータでトークン確率を取得可能（Claude 3.5以降）
+    - user/assistantを明確に分離する形式を推奨（messages配列形式）
+    - systemは別パラメータとして扱う（messagesとは別）
+    """
+    
+    _instances = {}  # モデルごとのインスタンスをキャッシュ
+    
+    def __new__(cls, model_name: str = None, api_key: str = None):
+        """シングルトンパターンでクライアントを常駐"""
+        model = model_name or os.getenv("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022")
+        key = api_key or os.getenv("ANTHROPIC_API_KEY")
+        
+        cache_key = f"{model}:{key}"
+        if cache_key not in cls._instances:
+            cls._instances[cache_key] = super().__new__(cls)
+            cls._instances[cache_key]._initialized = False
+        
+        return cls._instances[cache_key]
+    
+    def __init__(self, model_name: str = None, api_key: str = None):
+        """
+        初期化
+        
+        Args:
+            model_name: モデル名（例: "claude-3-5-sonnet-20241022"）
+            api_key: Anthropic APIキー
+        """
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+        
+        self.model_name = model_name or os.getenv("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022")
+        self.api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
+        self._initialized = True
+        
+        if not self.api_key:
+            raise ValueError("ANTHROPIC_API_KEYが設定されていません")
+        
+        # Anthropicクライアントを初期化
+        try:
+            from anthropic import Anthropic
+            self.client = Anthropic(api_key=self.api_key)
+            print(f"[AnthropicAI] 初期化完了: モデル={self.model_name}")
+        except ImportError:
+            raise ImportError("anthropicパッケージがインストールされていません。pip install anthropic を実行してください")
+        except Exception as e:
+            raise ValueError(f"Anthropicクライアントの初期化に失敗しました: {e}")
+    
+    @classmethod
+    def get_model(cls, model_name: str = None, api_key: str = None) -> 'AnthropicAI':
+        """モデルインスタンスを取得（常駐キャッシュから）"""
+        return cls(model_name, api_key)
+    
+    @classmethod
+    def clear_cache(cls):
+        """キャッシュをクリア（開発・テスト用）"""
+        cls._instances.clear()
+    
+    def get_token_probabilities(self, text: str, k: int = 5) -> List[Tuple[str, float]]:
+        """
+        文章とkを引数に、{token, 確率}のリストを返す
+        
+        Args:
+            text: 入力文章（messages配列または文字列）
+            k: 取得するトークン数
+            
+        Returns:
+            List[Tuple[str, float]]: (トークン, 確率)のリスト
+        """
+        try:
+            # textがmessages形式かどうかを判定
+            if isinstance(text, str):
+                # 文字列の場合は、userメッセージとして扱う
+                messages = [{"role": "user", "content": text}]
+                system = None
+            elif isinstance(text, dict):
+                # dictの場合は、messagesとsystemを分離
+                messages = text.get("messages", [])
+                system = text.get("system")
+            else:
+                messages = text
+                system = None
+            
+            # API呼び出し（logprobs=Trueでトークン確率を取得）
+            response = self.client.messages.create(
+                model=self.model_name,
+                messages=messages,
+                system=system,
+                logprobs=True,
+                top_logprobs=k,
+                max_tokens=1,  # 次のトークン1つだけを取得
+            )
+            
+            # logprobsから確率を計算
+            items: List[Tuple[str, float]] = []
+            
+            if response.content and len(response.content) > 0:
+                content_block = response.content[0]
+                if hasattr(content_block, 'logprobs') and content_block.logprobs:
+                    # top_logprobsから確率を取得
+                    for token_info in content_block.logprobs.top_logprobs:
+                        token = self._clean_text(token_info.token)
+                        if not token:
+                            continue
+                        # logprobを確率に変換
+                        prob = math.exp(token_info.logprob)
+                        items.append((token, float(prob)))
+            
+            # 確��を正規化
+            if items:
+                total_prob = sum(prob for _, prob in items)
+                if total_prob > 0:
+                    normalized_items: List[Tuple[str, float]] = []
+                    for token, prob in items:
+                        normalized_prob = prob / total_prob
+                        normalized_items.append((token, normalized_prob))
+                    return normalized_items
+            
+            return items
+            
+        except Exception as e:
+            print(f"[AnthropicAI] トークン確率取得エラー: {e}")
+            import traceback
+            traceback.print_exc()
+            return []
+    
+    def build_chat_prompt(
+        self, 
+        user_content: str, 
+        system_content: str = "あなたは親切で役に立つAIアシスタントです。簡潔な回答をしてください",
+        assistant_content: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        チャットプロンプトを構築（Anthropic messages形式）
+        
+        注意: Anthropicでは、user/assistantを明確に分離するmessages配列形式を推奨します。
+        また、systemはmessagesとは別のパラメータとして扱います。
+        
+        Args:
+            user_content: ユーザーのメッセージ
+            system_content: システムプロンプト（messagesとは別）
+            assistant_content: アシスタントの既存応答（会話履歴用、オプション）
+            
+        Returns:
+            Dict[str, Any]: {"messages": [...], "system": "..."} 形式
+        """
+        messages = []
+        
+        # 会話履歴がある場合（assistant_contentが指定されている場合）
+        if assistant_content:
+            messages.append({
+                "role": "assistant",
+                "content": assistant_content
+            })
+        
+        # 現在のUserメッセージ
+        messages.append({
+            "role": "user",
+            "content": user_content
+        })
+        
+        return {
+            "messages": messages,
+            "system": system_content if system_content else None
+        }
+

package/ai/base.py

@@ -0,0 +1,99 @@
+"""
+BaseAI - すべてのAIモデルアダプターの基底クラス
+"""
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Optional
+
+
+class BaseAI(ABC):
+    """
+    すべてのAIモデルアダプターが実装すべき基底クラス
+    
+    各モデルは以下のメソッドを実装する必要があります：
+    - get_token_probabilities: トークン確率の取得
+    - build_chat_prompt: モデル固有のプロンプト形式への変換
+    """
+    
+    @abstractmethod
+    def get_token_probabilities(self, text: str, k: int = 5) -> List[Tuple[str, float]]:
+        """
+        テキストから次のトークン候補と確率を取得
+        
+        Args:
+            text: 入力テキスト（プロンプト）
+            k: 取得するトークン候補数
+            
+        Returns:
+            List[Tuple[str, float]]: (トークン, 確率)のリスト（確率順）
+        """
+        raise NotImplementedError
+    
+    @abstractmethod
+    def build_chat_prompt(
+        self, 
+        user_content: str, 
+        system_content: str = "",
+        assistant_content: Optional[str] = None
+    ) -> str:
+        """
+        モデル固有のチャットプロンプト形式に変換
+        
+        注意: モデルによってuser/assistantの分離方法が異なります
+        - OpenAI, Claude: user/assistantを明確に分離することを推奨
+        - Gemini: user/assistantを分離しない方が良い場合もある
+        - Transformers: モデルによって異なる（Llamaは分離推奨）
+        
+        Args:
+            user_content: ユーザーのメッセージ
+            system_content: システムプロンプト（オプション）
+            assistant_content: アシスタントの既存応答（会話履歴用、オプション）
+            
+        Returns:
+            str: モデル固有のプロンプト形式
+        """
+        raise NotImplementedError
+    
+    def _clean_text(self, text: str) -> str:
+        """
+        制御文字・不可視文字・置換文字を厳密に取り除く（共通処理）
+        
+        Args:
+            text: クリーンアップするテキスト
+            
+        Returns:
+            str: クリーンアップされたテキスト
+        """
+        if not text:
+            return ""
+        
+        # 制御文字（0x00-0x1F、0x7F-0x9F）を除去
+        # ただし、改行・タブ・復帰は許可
+        cleaned = []
+        for ch in text:
+            code = ord(ch)
+            # 許可する制御文字: 改行(0x0A), タブ(0x09), 復帰(0x0D)
+            if code in [0x09, 0x0A, 0x0D]:
+                cleaned.append(ch)
+            # 通常の印刷可能文字
+            elif ch.isprintable():
+                # 置換文字（U+FFFD）を除去
+                if ch != "\uFFFD":
+                    cleaned.append(ch)
+            # その他の制御文字や不可視文字は除去
+        
+        result = "".join(cleaned)
+        # ゼロ幅文字を除去
+        result = result.replace("\u200B", "")  # Zero-width space
+        result = result.replace("\u200C", "")  # Zero-width non-joiner
+        result = result.replace("\u200D", "")  # Zero-width joiner
+        result = result.replace("\uFEFF", "")  # Zero-width no-break space
+        # その他の不可視文字（結合文字など）を除去
+        result = result.replace("\u200E", "")  # Left-to-right mark
+        result = result.replace("\u200F", "")  # Right-to-left mark
+        result = result.replace("\u202A", "")  # Left-to-right embedding
+        result = result.replace("\u202B", "")  # Right-to-left embedding
+        result = result.replace("\u202C", "")  # Pop directional formatting
+        result = result.replace("\u202D", "")  # Left-to-right override
+        result = result.replace("\u202E", "")  # Right-to-left override
+        return result.strip()
+

package/ai/google_ai.py

@@ -0,0 +1,152 @@
+"""
+GoogleAI - Google API（Gemini）用アダプター
+"""
+from typing import List, Tuple, Optional
+import os
+import math
+from .base import BaseAI
+
+
+class GoogleAI(BaseAI):
+    """
+    Google API（Gemini）用アダプター
+    
+    特徴:
+    - API経由でモデルにアクセス
+    - logprobsパラメータでトークン確率を取得可能
+    - user/assistantを分離しない方が良い場合もある（テキスト形式）
+    - systemとuserを結合したテキスト形式を推奨
+    """
+    
+    _instances = {}  # モデルごとのインスタンスをキャッシュ
+    
+    def __new__(cls, model_name: str = None, api_key: str = None):
+        """シングルトンパターンでクライアントを常駐"""
+        model = model_name or os.getenv("GOOGLE_MODEL", "gemini-pro")
+        key = api_key or os.getenv("GOOGLE_API_KEY")
+        
+        cache_key = f"{model}:{key}"
+        if cache_key not in cls._instances:
+            cls._instances[cache_key] = super().__new__(cls)
+            cls._instances[cache_key]._initialized = False
+        
+        return cls._instances[cache_key]
+    
+    def __init__(self, model_name: str = None, api_key: str = None):
+        """
+        初期化
+        
+        Args:
+            model_name: モデル名（例: "gemini-pro"）
+            api_key: Google APIキー
+        """
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+        
+        self.model_name = model_name or os.getenv("GOOGLE_MODEL", "gemini-pro")
+        self.api_key = api_key or os.getenv("GOOGLE_API_KEY")
+        self._initialized = True
+        
+        if not self.api_key:
+            raise ValueError("GOOGLE_API_KEYが設定されていません")
+        
+        # Google Generative AIクライアントを初期化
+        try:
+            import google.generativeai as genai
+            genai.configure(api_key=self.api_key)
+            self.model = genai.GenerativeModel(self.model_name)
+            print(f"[GoogleAI] 初期化完了: モデル={self.model_name}")
+        except ImportError:
+            raise ImportError("google-generativeaiパッケージがインストールされていません。pip install google-generativeai を実行してください")
+        except Exception as e:
+            raise ValueError(f"Google Generative AIクライアントの初期化に失敗しました: {e}")
+    
+    @classmethod
+    def get_model(cls, model_name: str = None, api_key: str = None) -> 'GoogleAI':
+        """モデルインスタンスを取得（常駐キャッシュから）"""
+        return cls(model_name, api_key)
+    
+    @classmethod
+    def clear_cache(cls):
+        """キャッシュをクリア（開発・テスト用）"""
+        cls._instances.clear()
+    
+    def get_token_probabilities(self, text: str, k: int = 5) -> List[Tuple[str, float]]:
+        """
+        文章とkを引数に、{token, 確率}のリストを返す
+        
+        Args:
+            text: 入力文章（プロンプト）
+            k: 取得するトークン数
+            
+        Returns:
+            List[Tuple[str, float]]: (トークン, 確率)のリスト
+        """
+        try:
+            # Gemini APIでトークン確率を取得
+            # 注意: Gemini APIのlogprobs取得方法は他のAPIと異なる可能性があります
+            response = self.model.generate_content(
+                text,
+                generation_config={
+                    "max_output_tokens": 1,  # 次のトークン1つだけを取得
+                    "temperature": 0.0,  # 確定的な結果を得るため
+                }
+            )
+            
+            # 注意: Gemini APIのlogprobs取得方法は公式ドキュメントを確認してください
+            # ここでは仮の実装です
+            items: List[Tuple[str, float]] = []
+            
+            # 実際の実装では、responseからlogprobsを取得する必要があります
+            # 現在のGemini APIでは、logprobsの直接取得が難しい可能性があります
+            # 代替案: 複数回のサンプリングで確率を推定
+            
+            print("[GoogleAI] 警告: Gemini APIのlogprobs取得は実装が不完全です")
+            return items
+            
+        except Exception as e:
+            print(f"[GoogleAI] トークン確率取得エラー: {e}")
+            import traceback
+            traceback.print_exc()
+            return []
+    
+    def build_chat_prompt(
+        self, 
+        user_content: str, 
+        system_content: str = "あなたは親切で役に立つAIアシスタントです。簡潔な回答をしてください",
+        assistant_content: Optional[str] = None
+    ) -> str:
+        """
+        チャットプロンプトを構築（Gemini形式）
+        
+        注意: Geminiでは、user/assistantを分離しない方が良い場合もあります。
+        systemとuserを結合したテキスト形式を推奨します。
+        
+        Args:
+            user_content: ユーザーのメッセージ
+            system_content: システムプロンプト
+            assistant_content: アシスタントの既存応答（会話履歴用、オプション）
+            
+        Returns:
+            str: Gemini形式のプロンプト（テキスト）
+        """
+        prompt_parts = []
+        
+        # Systemメッセージ（最初に1回だけ）
+        if system_content:
+            prompt_parts.append(f"システム: {system_content}")
+            prompt_parts.append("")
+        
+        # 会話履歴がある場合（assistant_contentが指定されている場合）
+        if assistant_content:
+            prompt_parts.append(f"ユーザー: {user_content}")
+            prompt_parts.append(f"アシスタント: {assistant_content}")
+            prompt_parts.append("")
+        
+        # 現在のUserメッセージ
+        prompt_parts.append(f"ユーザー: {user_content}")
+        prompt_parts.append("アシスタント:")
+        
+        prompt_text = "\n".join(prompt_parts)
+        return prompt_text
+

package/ai/openai_ai.py

@@ -0,0 +1,181 @@
+"""
+OpenAIAI - OpenAI API（ChatGPT）用アダプター
+"""
+from typing import List, Tuple, Optional, Dict, Any
+import os
+import math
+from .base import BaseAI
+
+
+class OpenAIAI(BaseAI):
+    """
+    OpenAI API（ChatGPT）用アダプター
+    
+    特徴:
+    - API経由でモデルにアクセス
+    - logprobsパラメータでトークン確率を取得可能（GPT-4以降）
+    - user/assistantを明確に分離する形式を推奨（messages配列形式）
+    """
+    
+    _instances = {}  # モデルごとのインスタンスをキャッシュ
+    
+    def __new__(cls, model_name: str = None, api_key: str = None):
+        """シングルトンパターンでクライアントを常駐"""
+        model = model_name or os.getenv("OPENAI_MODEL", "gpt-4")
+        key = api_key or os.getenv("OPENAI_API_KEY")
+        
+        cache_key = f"{model}:{key}"
+        if cache_key not in cls._instances:
+            cls._instances[cache_key] = super().__new__(cls)
+            cls._instances[cache_key]._initialized = False
+        
+        return cls._instances[cache_key]
+    
+    def __init__(self, model_name: str = None, api_key: str = None):
+        """
+        初期化
+        
+        Args:
+            model_name: モデル名（例: "gpt-4", "gpt-3.5-turbo"）
+            api_key: OpenAI APIキー
+        """
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+        
+        self.model_name = model_name or os.getenv("OPENAI_MODEL", "gpt-4")
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self._initialized = True
+        
+        if not self.api_key:
+            raise ValueError("OPENAI_API_KEYが設定されていません")
+        
+        # OpenAIクライアントを初期化
+        try:
+            import openai
+            self.client = openai.OpenAI(api_key=self.api_key)
+            print(f"[OpenAIAI] 初期化完了: モデル={self.model_name}")
+        except ImportError:
+            raise ImportError("openaiパッケージがインストールされていません。pip install openai を実行してください")
+        except Exception as e:
+            raise ValueError(f"OpenAIクライアントの初期化に失敗しました: {e}")
+    
+    @classmethod
+    def get_model(cls, model_name: str = None, api_key: str = None) -> 'OpenAIAI':
+        """モデルインスタンスを取得（常駐キャッシュから）"""
+        return cls(model_name, api_key)
+    
+    @classmethod
+    def clear_cache(cls):
+        """キャッシュをクリア（開発・テスト用）"""
+        cls._instances.clear()
+    
+    def get_token_probabilities(self, text: str, k: int = 5) -> List[Tuple[str, float]]:
+        """
+        文章とkを引数に、{token, 確率}のリストを返す
+        
+        Args:
+            text: 入力文章（プロンプト）
+            k: 取得するトークン数
+            
+        Returns:
+            List[Tuple[str, float]]: (トークン, 確率)のリスト
+        """
+        try:
+            # OpenAI APIでは、messages形式でリクエストする必要がある
+            # textが既にmessages形式かどうかを判定
+            if isinstance(text, str):
+                # 文字列の場合は、userメッセージとして扱う
+                messages = [{"role": "user", "content": text}]
+            else:
+                messages = text
+            
+            # API呼び出し（logprobs=Trueでトークン確率を取得）
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                logprobs=True,
+                top_logprobs=k,
+                max_tokens=1,  # 次のトークン1つだけを取得
+            )
+            
+            # logprobsから確率を計算
+            items: List[Tuple[str, float]] = []
+            
+            if response.choices and response.choices[0].logprobs:
+                logprobs = response.choices[0].logprobs.content[0] if response.choices[0].logprobs.content else None
+                
+                if logprobs:
+                    # top_logprobsから確率を取得
+                    for token_info in logprobs.top_logprobs:
+                        token = self._clean_text(token_info.token)
+                        if not token:
+                            continue
+                        # logprobを確率に変換
+                        prob = math.exp(token_info.logprob)
+                        items.append((token, float(prob)))
+            
+            # 確率を正規化
+            if items:
+                total_prob = sum(prob for _, prob in items)
+                if total_prob > 0:
+                    normalized_items: List[Tuple[str, float]] = []
+                    for token, prob in items:
+                        normalized_prob = prob / total_prob
+                        normalized_items.append((token, normalized_prob))
+                    return normalized_items
+            
+            return items
+            
+        except Exception as e:
+            print(f"[OpenAIAI] トークン確率取得エラー: {e}")
+            import traceback
+            traceback.print_exc()
+            return []
+    
+    def build_chat_prompt(
+        self, 
+        user_content: str, 
+        system_content: str = "あなたは親切で役に立つAIアシスタントです。簡潔な回答をしてください",
+        assistant_content: Optional[str] = None
+    ) -> List[Dict[str, str]]:
+        """
+        チャットプロンプトを構築（OpenAI messages形式）
+        
+        注意: OpenAIでは、user/assistantを明確に分離するmessages配列形式を推奨します。
+        このメソッドは文字列ではなく、messages配列を返します。
+        
+        Args:
+            user_content: ユーザーのメッセージ
+            system_content: システムプロンプト
+            assistant_content: アシスタントの既存応答（会話履歴用、オプション）
+            
+        Returns:
+            List[Dict[str, str]]: OpenAI messages形式の配列
+        """
+        messages = []
+        
+        # Systemメッセージ（最初に1回だけ）
+        if system_content:
+            messages.append({
+                "role": "system",
+                "content": system_content
+            })
+        
+        # 会話履歴がある場合（assistant_contentが指定されている場合）
+        if assistant_content:
+            # 前回のuserメッセージとassistant応答を追加
+            # 注意: この実装では、assistant_contentのみを追加
+            # 実際の会話履歴管理は呼び出し側で行う必要があります
+            messages.append({
+                "role": "assistant",
+                "content": assistant_content
+            })
+        
+        # 現在のUserメッセージ
+        messages.append({
+            "role": "user",
+            "content": user_content
+        })
+        
+        return messages
+

package/ai/transformers_ai.py

@@ -0,0 +1,278 @@
+"""
+TransformersAI - Hugging Face Transformersモデル用アダプター
+Llama 3.2、Qwen、Mistral、Gemma等のローカルモデルに対応
+"""
+from typing import List, Tuple, Any, Optional
+import os
+from .base import BaseAI
+
+
+class TransformersAI(BaseAI):
+    """
+    Hugging Face Transformersモデル用アダプター
+    
+    特徴:
+    - ローカルでモデルをロード
+    - logitsから直接確率を取得可能
+    - user/assistantを明確に分離する形式を推奨（Llama 3.2形式）
+    """
+    
+    _instances = {}  # モデルパスごとのインスタンスをキャッシュ（常駐）
+    
+    def __new__(cls, model_path: str = None):
+        """シングルトンパターンでモデルを常駐"""
+        path = model_path or os.getenv("HF_MODEL_REPO", "meta-llama/Llama-3.2-3B-Instruct")
+        
+        if path not in cls._instances:
+            cls._instances[path] = super().__new__(cls)
+            cls._instances[path]._initialized = False
+        
+        return cls._instances[path]
+    
+    def __init__(self, model_path: str = None):
+        """
+        モデルをロードして初期化（一度だけ実行、常駐）
+        
+        Args:
+            model_path: モデルリポジトリIDまたはローカルパス
+        """
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+        
+        self.model_path = model_path or os.getenv("HF_MODEL_REPO", "meta-llama/Llama-3.2-3B-Instruct")
+        self.model = self._load_model(self.model_path)
+        self._initialized = True
+        
+        if self.model is None:
+            raise ValueError(f"モデルのロードに失敗しました: {self.model_path}")
+    
+    @classmethod
+    def get_model(cls, model_path: str = None) -> 'TransformersAI':
+        """モデルインスタンスを取得（常駐キャッシュから）"""
+        return cls(model_path)
+    
+    @classmethod
+    def clear_cache(cls):
+        """キャッシュをクリア（開発・テスト用）"""
+        cls._instances.clear()
+    
+    def _load_model(self, model_path: str) -> Optional[Any]:
+        """モデルをロード（Transformers使用、Hubから直接読み込み）"""
+        try:
+            if not model_path:
+                return None
+            
+            # モデルパスがリポジトリID（"user/repo"形式）か、ローカルパスかを判定
+            is_repo_id = "/" in model_path and not os.path.exists(model_path)
+            
+            # リポジトリIDの場合は os.path.exists() チェックをスキップ
+            if not is_repo_id and not os.path.exists(model_path):
+                print(f"[TransformersAI] モデルパスが存在しません: {model_path}")
+                return None
+                
+            # transformersを使用してモデルをロード
+            try:
+                from transformers import AutoModelForCausalLM, AutoTokenizer
+                import torch
+                
+                # GPUが利用可能かチェック
+                device = "cuda" if torch.cuda.is_available() else "cpu"
+                if device == "cuda":
+                    print("[TransformersAI] GPU検出: CUDAを使用します")
+                else:
+                    print("[TransformersAI] GPU未検出: CPUモードで実行します")
+                
+                print(f"[TransformersAI] モデルをロード中: {model_path}")
+                print(f"[TransformersAI] デバイス: {device}")
+                
+                hf_token = os.getenv("HF_TOKEN")
+                
+                if is_repo_id:
+                    print(f"[TransformersAI] Hugging Face Hub から直接読み込み: {model_path}")
+                else:
+                    print(f"[TransformersAI] ローカルパスから読み込み: {model_path}")
+                
+                # トークナイザーとモデルをロード（Hubから直接読み込む）
+                tokenizer = AutoTokenizer.from_pretrained(
+                    model_path,
+                    token=hf_token,
+                )
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_path,
+                    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+                    device_map="auto" if device == "cuda" else None,
+                    token=hf_token,
+                )
+                
+                if device == "cpu":
+                    model = model.to(device)
+                
+                # モデルとトークナイザーをタプルで返す
+                print(f"[TransformersAI] モデルロード成功 ({device}モード)")
+                return (model, tokenizer)
+            except Exception as e:
+                import traceback
+                print(f"[TransformersAI] transformersでのロードに失敗: {e}")
+                traceback.print_exc()
+                return None
+                
+        except Exception as e:
+            import traceback
+            print(f"[TransformersAI] モデルロードエラー: {e}")
+            traceback.print_exc()
+            return None
+    
+    def get_token_probabilities(self, text: str, k: int = 5) -> List[Tuple[str, float]]:
+        """
+        文章とkを引数に、{token, 確率}のリストを返す
+        
+        Args:
+            text: 入力文章
+            k: 取得するトークン数
+            
+        Returns:
+            List[Tuple[str, float]]: (トークン, 確率)のリスト
+        """
+        if self.model is None:
+            return []
+            
+        try:
+            # transformers モデルの場合
+            if isinstance(self.model, tuple) and len(self.model) == 2:
+                model, tokenizer = self.model
+                import torch
+                
+                # テキストをトークン化
+                inputs = tokenizer(text, return_tensors="pt")
+                device = next(model.parameters()).device
+                inputs = {k: v.to(device) for k, v in inputs.items()}
+                
+                # モデルで推論（勾配計算なし）
+                with torch.no_grad():
+                    outputs = model(**inputs)
+                    logits = outputs.logits[0, -1, :]  # 最後のトークンのlogits
+                
+                # logitsを確率に変換（softmax）
+                probs = torch.softmax(logits, dim=-1)
+                
+                # 上位k個のトークンを取得
+                top_probs, top_indices = torch.topk(probs, k)
+                
+                # トークンIDを文字列に変換
+                items: List[Tuple[str, float]] = []
+                
+                # 特殊トークンを定義（Llama 3.2、Qwen、Mistral等で使用）
+                SPECIAL_TOKENS = [
+                    "<|begin_of_text|>",
+                    "<|end_of_text|>",
+                    "<|eot_id|>",
+                    "<|start_header_id|>",
+                    "<|end_header_id|>",
+                    "<|im_start|>",
+                    "<|im_end|>",
+                ]
+                
+                def _clean_text_local(text: str) -> str:
+                    """制御文字・不可視文字・置換文字・特殊トークンを厳密に取り除く"""
+                    if not text:
+                        return ""
+                    
+                    # 特殊トークンを除去
+                    for special_token in SPECIAL_TOKENS:
+                        text = text.replace(special_token, "")
+                    
+                    # 基底クラスの_clean_textを使用
+                    return self._clean_text(text)
+
+                for idx, prob in zip(top_indices, top_probs):
+                    token_id = idx.item()
+                    # skip_special_tokens=Trueで特殊トークンを除外
+                    token = tokenizer.decode([token_id], skip_special_tokens=True, clean_up_tokenization_spaces=False)
+                    token = _clean_text_local(token)
+                    # 空文字列のトークンは除外
+                    if not token:
+                        continue
+                    prob_value = prob.item()
+                    items.append((token, float(prob_value)))
+                
+                # 確率を正規化
+                if items:
+                    total_prob = sum(prob for _, prob in items)
+                    if total_prob > 0:
+                        normalized_items: List[Tuple[str, float]] = []
+                        for token, prob in items:
+                            normalized_prob = prob / total_prob
+                            normalized_items.append((token, normalized_prob))
+                        return normalized_items
+                
+                return items
+            else:
+                print("[TransformersAI] モデルがサポートされていません")
+                return []
+                
+        except Exception as e:
+            print(f"[TransformersAI] トークン確率取得エラー: {e}")
+            import traceback
+            traceback.print_exc()
+            return []
+    
+    def build_chat_prompt(
+        self, 
+        user_content: str, 
+        system_content: str = "あなたは親切で役に立つAIアシスタントです。簡潔な回答をしてください",
+        assistant_content: Optional[str] = None
+    ) -> str:
+        """
+        チャットプロンプトを構築（Llama 3.2形式）
+        
+        注意: Transformersモデル（特にLlama 3.2、Qwen等）では、
+        user/assistantを明確に分離する形式を推奨します。
+        
+        Args:
+            user_content: ユーザーのメッセージ
+            system_content: システムプロンプト
+            assistant_content: アシスタントの既存応答（会話履歴用、オプション）
+            
+        Returns:
+            str: Llama 3.2形式のプロンプト
+        """
+        # 既に整形済みのプロンプトが渡されている場合（複数行、ヘッダーを含む）
+        # そのまま返す
+        if "<|start_header_id|>" in user_content or "<|eot_id|>" in user_content:
+            return user_content
+        
+        # Llama 3.2形式でプロンプトを構築
+        prompt_parts = []
+        
+        # Systemメッセージ
+        if system_content:
+            prompt_parts.append("<|start_header_id|>system<|end_header_id|>")
+            prompt_parts.append(system_content)
+            prompt_parts.append("<|eot_id|>")
+        
+        # Userメッセージ
+        prompt_parts.append("<|start_header_id|>user<|end_header_id|>")
+        prompt_parts.append(user_content)
+        prompt_parts.append("<|eot_id|>")
+        
+        # Assistantメッセージ（会話履歴がある場合）
+        if assistant_content:
+            prompt_parts.append("<|start_header_id|>assistant<|end_header_id|>")
+            prompt_parts.append(assistant_content)
+            prompt_parts.append("<|eot_id|>")
+        
+        # 新しい応答を生成する場合は、assistantヘッダーだけを追加
+        prompt_parts.append("<|start_header_id|>assistant<|end_header_id|>")
+        
+        prompt_text = "\n".join(prompt_parts)
+        
+        # BOS(<|begin_of_text|>) の重複を抑止: 先頭のBOSを全て除去
+        # transformers側でBOSが自動付与される場合があるため
+        BOS = "<|begin_of_text|>"
+        s = prompt_text.lstrip()
+        while s.startswith(BOS):
+            s = s[len(BOS):]
+        prompt_text = s
+        
+        return prompt_text
+

package/config.py

@@ -0,0 +1,36 @@
+"""
+設定ファイル - Hugging Face Spaces用（簡易版）
+"""
+import os
+
+
+class Config:
+    """設定管理クラス（Hugging Face Spaces用）"""
+    
+    # MeCab設定（fugashi用、HFSでは通常不要だが互換性のため）
+    MECAB_CONFIG_PATH = os.getenv("MECAB_CONFIG_PATH", "/opt/homebrew/etc/mecabrc")
+    MECAB_DICT_PATH = os.getenv("MECAB_DICT_PATH", "/opt/homebrew/lib/mecab/dic/ipadic")
+    
+    # fugashi設定（MeCab/IPA用）
+    FUGASHI_ARGS = f"-r {MECAB_CONFIG_PATH}"
+    
+    @classmethod
+    def get_fugashi_args(cls) -> str:
+        """fugashi用の引数を取得"""
+        # HFSでは通常fugashiはデフォルト設定で動作
+        # 引数なしでデフォルト設定を使用できる場合は空文字列を返す
+        # そうでない場合は設定ファイルパスを返す
+        try:
+            import fugashi
+            # デフォルトのGenericTaggerを使用（引数なしで動作する場合）
+            # ただし、設定ファイルが必要な場合はパスを返す
+            if os.path.exists(cls.MECAB_CONFIG_PATH):
+                return cls.FUGASHI_ARGS
+            else:
+                # 設定ファイルが存在しない場合は空文字列（デフォルト設定を使用）
+                return ""
+        except ImportError:
+            # fugashiがインストールされていない場合は空文字列を返す
+            # （WordCounterでエラーハンドリングされる）
+            return ""
+

package/word_counter.py

@@ -0,0 +1,115 @@
+from typing import Any
+import fugashi
+from .config import Config
+
+try:
+    # SudachiPy があれば直接利用してモードCを使用
+    from sudachipy import dictionary as sudachi_dictionary
+    from sudachipy import tokenizer as sudachi_tokenizer
+    _SUDACHI_AVAILABLE = True
+except Exception:
+    _SUDACHI_AVAILABLE = False
+
+
+class WordCounter:
+    """単語数を数えるクラス（SudachiPyがあれば mode=C、なければfugashi）"""
+    
+    def __init__(self, tokenizer: Any = None):
+        """
+        初期化
+        
+        Args:
+            tokenizer: fugashiトークナイザー（Noneの場合はデフォルトを使用）
+        """
+        # 優先順位: 引数tokenizer > SudachiPy > fugashi(GenericTagger)
+        self._use_sudachi = False
+        self._sudachi_mode = None
+        if tokenizer is not None:
+            self.tokenizer = tokenizer
+        elif _SUDACHI_AVAILABLE:
+            # SudachiPyの辞書は自動で同梱辞書を参照（sudachidict_core）
+            # 外部設定不要。SplitMode.C を使用
+            self._use_sudachi = True
+            self.tokenizer = sudachi_dictionary.Dictionary().create()
+            self._sudachi_mode = sudachi_tokenizer.Tokenizer.SplitMode.C
+        else:
+            # fugashi (MeCab) フォールバック
+            fugashi_args = Config.get_fugashi_args()
+            if fugashi_args:
+                self.tokenizer = fugashi.GenericTagger(fugashi_args)
+            else:
+                # 引数なしでデフォルト設定を使用
+                self.tokenizer = fugashi.GenericTagger()
+    
+    def count_words(self, text: str) -> int:
+        """
+        テキストの単語数をカウント
+        
+        Args:
+            text: カウントするテキスト
+            
+        Returns:
+            int: 単語数
+        """
+        if not text:
+            return 0
+        
+        try:
+            # fugashiで形態素解析して単語数をカウント
+            if self._use_sudachi:
+                tokens = self.tokenizer.tokenize(text, self._sudachi_mode)
+                return len(tokens)
+            else:
+                tokens = self.tokenizer(text)
+                return len(tokens)
+        except Exception as e:
+            print(f"単語数カウントエラー: {e}")
+            # フォールバック: 空白で分割
+            return len(text.split())
+    
+    def is_word_boundary(self, text: str, position: int) -> bool:
+        """
+        指定位置が単語境界かどうかを判定
+        
+        Args:
+            text: テキスト
+            position: 位置（負の値で末尾から指定可能、-1は末尾）
+            
+        Returns:
+            bool: 単語境界かどうか
+        """
+        if not text:
+            return True
+        
+        # 負のインデックスを正のインデックスに変換
+        if position < 0:
+            position = len(text) + position
+        
+        if position >= len(text):
+            return True
+        
+        try:
+            # fugashiで形態素解析
+            if self._use_sudachi:
+                tokens = self.tokenizer.tokenize(text, self._sudachi_mode)
+                surfaces = [m.surface() for m in tokens]
+            else:
+                tokens = self.tokenizer(text)
+                surfaces = [m.surface for m in tokens]
+
+            current_pos = 0
+            for surface in surfaces:
+                token_length = len(surface)
+                if current_pos <= position < current_pos + token_length:
+                    return False
+                if position == current_pos + token_length:
+                    return True
+                current_pos += token_length
+            
+            return True
+            
+        except Exception as e:
+            print(f"境界判定エラー: {e}")
+            # フォールバック: 空白文字で判定
+            return position < len(text) and text[position].isspace()
+

package/word_processor.py

@@ -0,0 +1,392 @@
+from typing import List, Tuple, Any, Optional
+from dataclasses import dataclass
+from enum import Enum
+import os
+import math
+from .word_counter import WordCounter
+from .config import Config
+from .ai.base import BaseAI
+
+
+class WordState(Enum):
+    """単語の状態"""
+    INCOMPLETE = "incomplete"  # 未完成
+    COMPLETE = "complete"      # 完成
+    TRIGGER = "trigger"        # トリガー（次語の開始）
+
+class KList:
+    def __init__(self, num: int):
+        self.num = num
+        self.list: List[Any] = []
+
+    def check_k(self) -> None:
+        if len(self.list) >= self.num:
+            self.list.sort(key=lambda x: x.probability, reverse=True)
+            self.list = self.list[:self.num]
+        else:
+            self.list.sort(key=lambda x: x.probability, reverse=True)
+
+    def add(self, piece_word: Any) -> None:
+        # 重複チェック: 同じテキストのピースが既に存在するか確認
+        new_text = piece_word.get_full_text()
+        for existing_piece in self.list:
+            if existing_piece.get_full_text() == new_text:
+                # 既存のピースに確率を足す
+                existing_piece.probability += piece_word.probability
+                # 確率を更新したので、ソートし直す
+                self.check_k()
+                return
+        
+        # 重複がない場合は追加
+        self.list.append(piece_word)
+        self.check_k()
+
+    def pop(self) -> Any:
+        if self.list:
+            return self.list.pop(0)
+        raise IndexError("List is empty")
+
+    def empty(self) -> bool:
+        return len(self.list) == 0
+        
+@dataclass
+class WordPiece:
+    """単語のピース（部分）"""
+    text: str              # ピースのテキスト
+    probability: float     # 確率
+    next_tokens: Optional[List[Tuple[str, float]]] = None  # 次のトークン候補
+    parent: Optional['WordPiece'] = None  # 親ピース
+    children: List['WordPiece'] = None   # 子ピース
+    
+    def __post_init__(self):
+        if self.children is None:
+            self.children = []
+    
+    def get_full_text(self) -> str:
+        """ルートからこのピースまでの完全なテキストを取得"""
+        pieces = []
+        current = self
+        while current is not None:
+            if current.text:
+                pieces.append(current.text)
+            current = current.parent
+        return "".join(reversed(pieces))
+    
+    def get_full_word(self) -> str:
+        """ルートの次語からこのピースまでの完全な単語を取得"""
+        pieces = []
+        current = self
+        while current is not None:
+            if current.text:
+                pieces.append(current.text)
+            current = current.parent
+        reversed_pieces = reversed(pieces[:-1])
+        return "".join(reversed_pieces)
+
+    def add_child(self, text: str, probability: float, next_tokens: Optional[List[Tuple[str, float]]] = None) -> 'WordPiece':
+        """子ピースを追加"""
+        child = WordPiece(
+            text=text,
+            probability=probability,
+            next_tokens=next_tokens,
+            parent=self
+        )
+        self.children.append(child)
+        return child
+    
+    def is_leaf(self) -> bool:
+        """葉ノードかどうか"""
+        return len(self.children) == 0
+    
+    def get_depth(self) -> int:
+        """ルートからの深さを取得"""
+        depth = 0
+        current = self.parent
+        while current is not None:
+            depth += 1
+            current = current.parent
+        return depth
+
+
+class WordDeterminer:
+    """単語確定システム（ストリーミング向けリアルタイムアルゴリズム）"""
+    
+    def __init__(self, word_counter: WordCounter = None):
+        """
+        初期化
+        
+        Args:
+            word_counter: WordCounterインスタンス（Noneの場合はデフォルトを使用）
+        """
+        self.word_counter = word_counter or WordCounter()
+    
+    def is_boundary_char(self, char: str) -> bool:
+        """境界文字かどうかを判定（fugashi使用）"""
+        if not char:
+            return False
+        
+        # 空白文字
+        if char.isspace():
+            return True
+        
+        # 句読点
+        punctuation = ",，.．。！？!?:；;、\n\t"
+        return char in punctuation
+    
+    def is_word_boundary(self, text: str, position: int) -> bool:
+        """
+        WordCounterを使用して単語境界を判定
+        
+        Args:
+            text: テキスト
+            position: 位置（負の値で末尾から指定可能）
+            
+        Returns:
+            bool: 単語境界かどうか
+        """
+        return self.word_counter.is_word_boundary(text, position)
+    
+    def check_word_completion(self, piece: WordPiece, root_count: int, model: Any = None) -> Tuple[WordState, Optional[Any]]:
+        """
+        ストリ���ミング向けリアルタイム単語決定アルゴリズム
+        
+        Args:
+            piece: チェックするピース
+            root_count: ルートテキストの単語数
+            model: LLMモデル（BaseAIを実装したオブジェクト）
+            
+        Returns:
+            Tuple[WordState, Optional[Any]]: (状態, ペイロード)
+        """
+        full_text = piece.get_full_text()
+        
+        # next_tokensを取得
+        if not piece.next_tokens:
+            if model:
+                piece.next_tokens = self._get_next_tokens_from_model(model, full_text)
+            else:
+                return (WordState.COMPLETE, None)
+        
+        if not piece.next_tokens:
+            return (WordState.COMPLETE, None)
+        
+        # 確率順にソート（念のため）
+        sorted_tokens = sorted(piece.next_tokens, key=lambda x: x[1], reverse=True)
+        
+        # 括弧の処理
+        if piece.get_full_word() and piece.get_full_word()[-1] in ["(","「","（","【","〈","《","［","｛","｟"]:
+            return (WordState.INCOMPLETE, None)
+        if piece.get_full_word() and piece.get_full_word()[-1] in [")","]","}","》","〉","》","］","｝","｠"]:
+            return (WordState.COMPLETE, None)
+        
+        # 全トークンの挙動を確認
+        count = max(1, len(sorted_tokens))
+        tokens = sorted_tokens[:count]
+        
+        boundary_prob = 0.0  # 境界を示すトークンの確率合計
+        continuation_prob = 0.0  # 継続を示すトークンの確率合計
+        total = sum(prob for _, prob in tokens)
+        
+        for token, prob in tokens:
+            test_text = full_text + token
+            test_word_count = self._count_words(test_text)
+            
+            # 単語数がより多く増えた場合のみ境界と判定（まとまりを上げる）
+            if test_word_count > root_count + 1:
+                boundary_prob += prob
+            else:
+                continuation_prob += prob
+        
+        # 判定ロジック
+        if total > 0:
+            boundary_ratio = boundary_prob / total
+            
+            # トークンの多くが境界を示す場合 → 確定（閾値を上げてまとまりを上げる）
+            if boundary_ratio > 0.85:
+                return (WordState.COMPLETE, None)
+            
+            # トークンの多くが継続を示す場合 → 継続（閾値を下げて継続しやすく）
+            if boundary_ratio < 0.2:
+                return (WordState.INCOMPLETE, None)
+        
+        # エントロピーベース判定
+        probs = [prob for _, prob in sorted_tokens]
+        entropy = -sum(p * math.log(p + 1e-10) for p in probs if p > 0)
+        max_entropy = math.log(len(sorted_tokens)) if len(sorted_tokens) > 1 else 1.0
+        normalized_entropy = entropy / max_entropy if max_entropy > 0 else 0
+
+        return (WordState.INCOMPLETE, None)
+    
+    def _count_words(self, text: str) -> int:
+        """
+        WordCounterを使用してテキストの単語数をカウント
+        
+        Args:
+            text: カウントするテキスト
+            
+        Returns:
+            int: 単語数
+        """
+        return self.word_counter.count_words(text)
+    
+    def _get_next_tokens_from_model(self, model: Any, text: str, top_k: int = 5) -> List[Tuple[str, float]]:
+        """
+        モデルから次のトークン候補を取得（新しいBaseAIインターフェースを使用）
+        
+        Args:
+            model: BaseAIを実装したモデルオブジェクト
+            text: 入力テキスト
+            top_k: 取得する候補数
+            
+        Returns:
+            List[Tuple[str, float]]: (トークン, 確率)のリスト
+        """
+        try:
+            # BaseAIインターフェースを実装したモデルを使用
+            if isinstance(model, BaseAI):
+                return model.get_token_probabilities(text, top_k)
+            else:
+                print(f"[WORD_PROCESSOR] モデルがBaseAIインターフェースを実装していません: {type(model)}")
+                return []
+        except Exception as e:
+            print(f"[WORD_PROCESSOR] モデルからのトークン取得に失敗: {e}")
+            import traceback
+            traceback.print_exc()
+        
+        return []
+    
+    def expand_piece(self, piece: WordPiece, model: Any = None) -> List[WordPiece]:
+        """
+        ピースを展開して子ピースを生成
+        
+        Args:
+            piece: 展開するピース
+            model: LLMモデル（BaseAIを実装したオブジェクト）
+            
+        Returns:
+            List[WordPiece]: 生成された子ピースのリスト
+        """
+        children = []
+        full_text = piece.get_full_text()
+        
+        if piece.next_tokens:
+            # 既存のnext_tokensを使用
+            for token, prob in piece.next_tokens:
+                # 空文字列トークンを無視
+                if not token:
+                    continue
+                child_prob = piece.probability * prob
+                child = piece.add_child(token, child_prob)
+                children.append(child)
+        elif model:
+            # モデルから次のトークンを取得
+            next_tokens = self._get_next_tokens_from_model(model, full_text)
+            
+            if next_tokens:
+                piece.next_tokens = next_tokens
+                for token, prob in next_tokens:
+                    # 空文字列トークンを無視
+                    if not token:
+                        continue
+                    child_prob = piece.probability * prob
+                    child = piece.add_child(token, child_prob)
+                    children.append(child)
+        else:
+            print(f"[WORD_PROCESSOR] No model provided for expansion")
+        
+        return children
+    
+    def build_word_tree(self, prompt_text: str, root_text: str, model: Any, top_k: int = 5, max_depth: int = 10) -> List[WordPiece]:
+        """
+        単語ツリーを構築
+        
+        Args:
+            prompt_text: プロンプトテキスト
+            root_text: ルートテキスト
+            model: LLMモデル（BaseAIを実装したオブジェクト）
+            top_k: 取得する候補数
+            max_depth: 最大深さ
+            
+        Returns:
+            List[WordPiece]: 完成した単語ピースのリスト
+        """
+        # モデルのbuild_chat_promptメソッドを使用
+        if isinstance(model, BaseAI):
+            prompt = model.build_chat_prompt(prompt_text)
+        else:
+            # フォールバック: 従来の形式
+            prompt = self.build_chat_prompt(prompt_text)
+        
+        # ルートピースを作成
+        root = WordPiece(text=prompt + root_text, probability=1.0)
+        
+        # 優先度付きキュー（確率順）
+        candidates = KList(2 * top_k)
+        completed = []
+        iteration = 0
+        max_iterations = 1000
+        children = self.expand_piece(root, model)
+        for child in children:
+            candidates.add(child)
+        
+        while not candidates.empty() and iteration < max_iterations and len(completed) < top_k:
+            iteration += 1
+            
+            # 最も確率の高い候補を取得
+            current = candidates.pop()
+            
+            # 単語完成状態をチェック
+            root_count = self._count_words(root.get_full_text())
+            state, payload = self.check_word_completion(current, root_count, model)
+            
+            if state == WordState.COMPLETE:
+                completed.append(current)
+            elif state == WordState.INCOMPLETE:
+                # ピースを展開
+                children = self.expand_piece(current, model)
+                if len(children) == 0:
+                    # 子が生成できない場合、ピースを完成として扱う（無限ループ防止）
+                    print(f"[WORD_PROCESSOR] No children generated for '{current.get_full_text()}', marking as COMPLETE")
+                    completed.append(current)
+                else:
+                    for child in children:
+                        candidates.add(child)
+        
+        # 確率で正規化
+        total_prob = sum(p.probability for p in completed)
+        if total_prob > 0:
+            for piece in completed:
+                piece.probability = piece.probability / total_prob
+        
+        return completed[:top_k]
+        
+    def build_chat_prompt(self, user_content: str, 
+        system_content: str = "あなたは親切で役に立つAIアシスタントです。簡潔な回答をしてください") -> str:
+        """
+        チャットプロンプトを構築（後方互換性のため）
+        
+        注意: 新しいBaseAIインターフェースを使用する場合は、model.build_chat_prompt()を使用してください
+        """
+        # 既に整形済みのプロンプトが渡されている場合（複数行、ヘッダーを含む）
+        # そのまま返す
+        if "<|start_header_id|>" in user_content or "<|eot_id|>" in user_content:
+            return user_content
+        
+        # 後方互換性: 単一のuser_contentが渡された場合の従来の形式
+        prompt_text = (
+            f"<|begin_of_text|>"
+            f"<|start_header_id|>system<|end_header_id|>\n"
+            f"{system_content}\n<|eot_id|>"
+            f"<|start_header_id|>user<|end_header_id|>\n"
+            f"{user_content}\n<|eot_id|>"
+            f"<|start_header_id|>assistant<|end_header_id|>\n"
+        )
+        
+        # BOS(<|begin_of_text|>) の重複を抑止: 先頭のBOSを全て除去
+        BOS = "<|begin_of_text|>"
+        s = prompt_text.lstrip()
+        while s.startswith(BOS):
+            s = s[len(BOS):]
+        prompt_text = s
+        return prompt_text
+

requirements.txt

@@ -0,0 +1,37 @@
+# マルチモデル対応に必要なパッケージ
+
+# ============================================
+# Hugging Face Spaces用（推奨、必須）
+# ============================================
+# Gradio - Web UI
+gradio>=4.0.0
+
+# Hugging Face Spaces
+spaces
+
+# Transformers - ローカルでモデルをロード（無料、完全なトークン確率取得可能）
+transformers>=4.30.0
+torch>=2.0.0
+huggingface-hub>=0.16.0
+
+# 形態素解析
+fugashi>=1.3.0
+sudachipy>=0.6.7
+sudachidict-core>=20240125
+
+# その他
+numpy>=1.24.0
+
+# ============================================
+# 外部API用（オプション、非推奨）
+# Hugging Face Spacesでは不要です
+# ============================================
+# OpenAI API（有料、レート制限あり）
+# openai>=1.0.0
+
+# Anthropic API（有料、レート制限あり）
+# anthropic>=0.18.0
+
+# Google API（有料、レート制限あり）
+# google-generativeai>=0.3.0
+