Upload folder using huggingface_hub

auto_training.py

@@ -0,0 +1,403 @@
+"""
+NullAI Auto-Training Manager
+
+自動学習システムの核となるモジュール。
+データ量や時間ベースのトリガーで自動的にファインチューニングを実行する。
+"""
+import asyncio
+import json
+import logging
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass, asdict
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AutoTrainingState:
+    """自動学習システムの状態"""
+    enabled: bool = True
+    last_check_time: Optional[str] = None
+    last_training_time: Optional[str] = None
+    last_training_success: bool = True
+    last_training_examples_count: int = 0
+    next_scheduled_training: Optional[str] = None
+    total_auto_trainings: int = 0
+    consecutive_failures: int = 0
+    is_training: bool = False
+    last_error: Optional[str] = None
+
+
+class AutoTrainingManager:
+    """
+    自動学習マネージャー
+
+    設定に基づいて、トレーニングデータを監視し、
+    条件を満たした場合に自動的にファインチューニングを実行する。
+    """
+
+    def __init__(self, config: Dict[str, Any], training_manager):
+        """
+        Args:
+            config: null_ai_config.json の auto_training セクション
+            training_manager: FineTuningManager インスタンス
+        """
+        self.config = config
+        self.training_manager = training_manager
+        self.state = AutoTrainingState()
+        self.state_file = Path("training_data/auto_training_state.json")
+
+        # 設定の読み込み
+        self.enabled = config.get("enabled", True)
+        self.trigger_mode = config.get("trigger_mode", "hybrid")
+        self.min_examples = config.get("min_examples", 100)
+        self.min_days = config.get("min_days_since_last_training", 7)
+        self.max_days = config.get("max_days_since_last_training", 30)
+        self.quality_threshold = config.get("quality_threshold", 0.8)
+        self.check_interval_minutes = config.get("check_interval_minutes", 60)
+        self.preferred_hour = config.get("preferred_training_hour", 2)
+        self.allow_manual_override = config.get("allow_manual_override", True)
+
+        # トレーニングパラメータ
+        self.training_method = config.get("training_method", "peft")
+        self.training_params = config.get("training_params", {})
+
+        # 状態の復元
+        self._load_state()
+
+        logger.info(f"AutoTrainingManager initialized: enabled={self.enabled}, trigger_mode={self.trigger_mode}")
+
+    def _load_state(self):
+        """永続化された状態を読み込む"""
+        try:
+            if self.state_file.exists():
+                with open(self.state_file, 'r') as f:
+                    state_dict = json.load(f)
+                    self.state = AutoTrainingState(**state_dict)
+                logger.info(f"Loaded auto-training state from {self.state_file}")
+        except Exception as e:
+            logger.warning(f"Failed to load auto-training state: {e}")
+
+    def _save_state(self):
+        """状態を永続化する"""
+        try:
+            self.state_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.state_file, 'w') as f:
+                json.dump(asdict(self.state), f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save auto-training state: {e}")
+
+    def get_training_data_stats(self, domain_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        トレーニングデータの統計を取得
+
+        Returns:
+            {
+                "total_examples": int,
+                "examples_by_domain": Dict[str, int],
+                "high_quality_count": int,
+                "oldest_timestamp": str,
+                "newest_timestamp": str
+            }
+        """
+        training_data_dir = Path("training_data/master_outputs")
+        if not training_data_dir.exists():
+            return {
+                "total_examples": 0,
+                "examples_by_domain": {},
+                "high_quality_count": 0,
+                "oldest_timestamp": None,
+                "newest_timestamp": None
+            }
+
+        stats = {
+            "total_examples": 0,
+            "examples_by_domain": {},
+            "high_quality_count": 0,
+            "oldest_timestamp": None,
+            "newest_timestamp": None
+        }
+
+        # JSONLファイルを走査
+        jsonl_files = []
+        if domain_id:
+            jsonl_files = [training_data_dir / f"master_outputs_{domain_id}.jsonl"]
+        else:
+            jsonl_files = list(training_data_dir.glob("master_outputs_*.jsonl"))
+
+        for jsonl_file in jsonl_files:
+            if not jsonl_file.exists():
+                continue
+
+            domain = jsonl_file.stem.replace("master_outputs_", "")
+            domain_count = 0
+
+            with open(jsonl_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    try:
+                        example = json.loads(line.strip())
+                        stats["total_examples"] += 1
+                        domain_count += 1
+
+                        # 高品質データのカウント
+                        confidence = example.get("metadata", {}).get("confidence", 0)
+                        if confidence >= self.quality_threshold:
+                            stats["high_quality_count"] += 1
+
+                        # タイムスタンプの追跡
+                        timestamp = example.get("metadata", {}).get("timestamp")
+                        if timestamp:
+                            if stats["oldest_timestamp"] is None or timestamp < stats["oldest_timestamp"]:
+                                stats["oldest_timestamp"] = timestamp
+                            if stats["newest_timestamp"] is None or timestamp > stats["newest_timestamp"]:
+                                stats["newest_timestamp"] = timestamp
+
+                    except json.JSONDecodeError:
+                        continue
+
+            if domain_count > 0:
+                stats["examples_by_domain"][domain] = domain_count
+
+        return stats
+
+    def check_training_trigger(self, domain_id: Optional[str] = None) -> tuple[bool, str]:
+        """
+        トレーニングをトリガーすべきかチェックする
+
+        Returns:
+            (should_trigger: bool, reason: str)
+        """
+        if not self.enabled:
+            return False, "Auto-training is disabled"
+
+        if self.state.is_training:
+            return False, "Training is already in progress"
+
+        # データ統計を取得
+        stats = self.get_training_data_stats(domain_id)
+
+        if stats["total_examples"] == 0:
+            return False, "No training data available"
+
+        # 最終トレーニングからの経過時間を計算
+        days_since_last = None
+        if self.state.last_training_time:
+            try:
+                last_training = datetime.fromisoformat(self.state.last_training_time)
+                days_since_last = (datetime.utcnow() - last_training).days
+            except ValueError:
+                pass
+
+        # トリガーモードに応じた判定
+        if self.trigger_mode == "data_count":
+            # データ量ベースのみ
+            if stats["high_quality_count"] >= self.min_examples:
+                return True, f"Sufficient training data ({stats['high_quality_count']} examples >= {self.min_examples})"
+            return False, f"Insufficient training data ({stats['high_quality_count']} < {self.min_examples})"
+
+        elif self.trigger_mode == "time_based":
+            # 時間ベースのみ
+            if days_since_last is None:
+                return True, "First auto-training"
+            if days_since_last >= self.min_days:
+                return True, f"Time threshold met ({days_since_last} days >= {self.min_days} days)"
+            return False, f"Too soon since last training ({days_since_last} < {self.min_days} days)"
+
+        elif self.trigger_mode == "hybrid":
+            # ハイブリッド（データ量 AND 時間）
+            if stats["high_quality_count"] < self.min_examples:
+                return False, f"Insufficient training data ({stats['high_quality_count']} < {self.min_examples})"
+
+            if days_since_last is None:
+                return True, f"First auto-training with {stats['high_quality_count']} examples"
+
+            if days_since_last >= self.min_days:
+                return True, f"Both conditions met: {stats['high_quality_count']} examples, {days_since_last} days since last training"
+
+            return False, f"Time condition not met ({days_since_last} < {self.min_days} days)"
+
+        elif self.trigger_mode == "max_interval":
+            # 最大間隔強制モード
+            if days_since_last is not None and days_since_last >= self.max_days:
+                return True, f"Maximum interval reached ({days_since_last} >= {self.max_days} days)"
+
+            # 通常のハイブリッド判定
+            if stats["high_quality_count"] >= self.min_examples and (days_since_last is None or days_since_last >= self.min_days):
+                return True, f"Standard conditions met: {stats['high_quality_count']} examples"
+
+            return False, "Conditions not met"
+
+        return False, f"Unknown trigger mode: {self.trigger_mode}"
+
+    def should_train_now(self) -> bool:
+        """
+        現在がトレーニングに適した時間帯かチェック
+
+        preferred_training_hour の前後1時間をトレーニング推奨時間とする
+        """
+        current_hour = datetime.utcnow().hour
+
+        # 推奨時間の前後1時間
+        target_hours = [
+            (self.preferred_hour - 1) % 24,
+            self.preferred_hour,
+            (self.preferred_hour + 1) % 24
+        ]
+
+        return current_hour in target_hours
+
+    async def trigger_auto_training(self, domain_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        自動トレーニングを実行
+
+        Returns:
+            トレーニング結果の辞書
+        """
+        logger.info(f"Starting auto-training for domain: {domain_id or 'all'}")
+
+        # 状態を更新
+        self.state.is_training = True
+        self.state.last_check_time = datetime.utcnow().isoformat()
+        self._save_state()
+
+        try:
+            # データ統計を取得
+            stats = self.get_training_data_stats(domain_id)
+
+            # ファインチューニングを実行
+            # 注: training_manager の実装に合わせて適切なメソッドを呼び出す
+            result = await self._execute_training(domain_id, stats)
+
+            # 成功時の状態更新
+            self.state.last_training_time = datetime.utcnow().isoformat()
+            self.state.last_training_success = result.get("success", False)
+            self.state.last_training_examples_count = stats["high_quality_count"]
+            self.state.total_auto_trainings += 1
+            self.state.consecutive_failures = 0
+            self.state.last_error = None
+
+            logger.info(f"Auto-training completed successfully: {result}")
+
+            return {
+                "success": True,
+                "result": result,
+                "stats": stats,
+                "timestamp": self.state.last_training_time
+            }
+
+        except Exception as e:
+            logger.error(f"Auto-training failed: {e}", exc_info=True)
+
+            # 失敗時の状態更新
+            self.state.last_training_success = False
+            self.state.consecutive_failures += 1
+            self.state.last_error = str(e)
+
+            return {
+                "success": False,
+                "error": str(e),
+                "consecutive_failures": self.state.consecutive_failures
+            }
+
+        finally:
+            self.state.is_training = False
+            self._save_state()
+
+    async def _execute_training(self, domain_id: Optional[str], stats: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        実際のトレーニングを実行（内部メソッド）
+        """
+        # トレーニングパラメータを準備
+        training_params = {
+            "apprentice_model_name": None,  # 既存の弟子モデルを使用
+            "domain_id": domain_id,
+            "method": self.training_method,
+            "epochs": self.training_params.get("epochs", 3),
+            "learning_rate": self.training_params.get("learning_rate", 2e-4),
+            "batch_size": self.training_params.get("batch_size", 4),
+            "lora_r": self.training_params.get("lora_r", 8),
+            "lora_alpha": self.training_params.get("lora_alpha", 16),
+            "output_name": f"auto_training_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}"
+        }
+
+        logger.info(f"Executing training with params: {training_params}")
+
+        # FineTuningManagerを使ってトレーニングを実行
+        # 注: この部分は実際のトレーニングAPIに合わせて実装する必要があります
+        # 今はプレースホルダーとして簡単な構造を返します
+
+        # TODO: 実際のトレーニング実行コードをここに実装
+        result = {
+            "success": True,
+            "output_dir": f"training_data/checkpoints/{training_params['output_name']}",
+            "model_name": training_params['output_name'],
+            "train_loss": 0.5,  # プレースホルダー
+            "method": self.training_method,
+            "examples_used": stats["high_quality_count"]
+        }
+
+        return result
+
+    def get_status(self) -> Dict[str, Any]:
+        """
+        自動学習システムの現在の状態を取得
+        """
+        should_trigger, reason = self.check_training_trigger()
+        stats = self.get_training_data_stats()
+
+        return {
+            "enabled": self.enabled,
+            "is_training": self.state.is_training,
+            "trigger_mode": self.trigger_mode,
+            "should_trigger": should_trigger,
+            "trigger_reason": reason,
+            "config": {
+                "min_examples": self.min_examples,
+                "min_days": self.min_days,
+                "max_days": self.max_days,
+                "quality_threshold": self.quality_threshold,
+                "check_interval_minutes": self.check_interval_minutes,
+                "preferred_hour": self.preferred_hour
+            },
+            "state": {
+                "last_check_time": self.state.last_check_time,
+                "last_training_time": self.state.last_training_time,
+                "last_training_success": self.state.last_training_success,
+                "last_training_examples_count": self.state.last_training_examples_count,
+                "total_auto_trainings": self.state.total_auto_trainings,
+                "consecutive_failures": self.state.consecutive_failures,
+                "last_error": self.state.last_error
+            },
+            "data_stats": stats,
+            "should_train_now": self.should_train_now()
+        }
+
+    def enable(self):
+        """自動学習を有効化"""
+        self.enabled = True
+        self.state.enabled = True
+        self._save_state()
+        logger.info("Auto-training enabled")
+
+    def disable(self):
+        """自動学習を無効化"""
+        self.enabled = False
+        self.state.enabled = False
+        self._save_state()
+        logger.info("Auto-training disabled")
+
+    def update_config(self, new_config: Dict[str, Any]):
+        """設定を更新"""
+        self.config.update(new_config)
+
+        # 設定値を再読み込み
+        self.trigger_mode = self.config.get("trigger_mode", self.trigger_mode)
+        self.min_examples = self.config.get("min_examples", self.min_examples)
+        self.min_days = self.config.get("min_days_since_last_training", self.min_days)
+        self.max_days = self.config.get("max_days_since_last_training", self.max_days)
+        self.quality_threshold = self.config.get("quality_threshold", self.quality_threshold)
+
+        logger.info(f"Auto-training config updated: {new_config}")
+        self._save_state()

coordinate_estimator.py

@@ -0,0 +1,359 @@
+# null_ai/coordinate_estimator.py
+"""
+Coordinate Auto-Estimation Module
+
+AIを使って知識タイルの6次元座標を自動推定します。
+座標: [x, y, z, c, g, v]
+- medical_space [x, y, z]: ドメイン固有の3次元空間
+- meta_space [c, g, v]: Certainty, Granularity, Verification
+"""
+
+import logging
+import json
+from typing import List, Dict, Any, Optional
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+
+class CoordinateEstimator:
+    """
+    LLMを使って6次元座標を自動推定するクラス
+    """
+
+    def __init__(self):
+        self.domain_schemas = self._load_domain_schemas()
+
+    def _load_domain_schemas(self) -> Dict[str, Dict[str, str]]:
+        """
+        各ドメインの座標軸の定義を返す
+
+        将来的には設定ファイルから読み込む
+        """
+        return {
+            "medical": {
+                "x": "Anatomical location (0.0=nervous system, 0.5=cardiovascular, 1.0=digestive)",
+                "y": "Pathological classification (0.0=infectious, 0.5=metabolic, 1.0=trauma)",
+                "z": "Treatment level (0.0=prevention, 0.5=diagnosis, 1.0=treatment)"
+            },
+            "general": {
+                "x": "Knowledge category (0.0=science, 0.5=technology, 1.0=humanities)",
+                "y": "Complexity level (0.0=basic, 0.5=intermediate, 1.0=advanced)",
+                "z": "Application scope (0.0=theoretical, 0.5=practical, 1.0=applied)"
+            },
+            "legal": {
+                "x": "Legal field (0.0=civil, 0.5=criminal, 1.0=commercial)",
+                "y": "Court level (0.0=district, 0.5=high, 1.0=supreme)",
+                "z": "Era (0.0=classical, 0.5=modern, 1.0=contemporary)"
+            },
+            "technology": {
+                "x": "Technology domain (0.0=hardware, 0.5=software, 1.0=network)",
+                "y": "Maturity (0.0=emerging, 0.5=established, 1.0=legacy)",
+                "z": "Scale (0.0=personal, 0.5=enterprise, 1.0=global)"
+            }
+        }
+
+    async def estimate_coordinates(
+        self,
+        prompt: str,
+        response: str,
+        domain_id: str,
+        llm_inference_func,
+        use_reasoning: bool = True
+    ) -> Dict[str, Any]:
+        """
+        6次元座標を推定
+
+        Args:
+            prompt: ユーザーの質問
+            response: AIの回答
+            domain_id: ドメインID
+            llm_inference_func: LLM推論関数（async）
+            use_reasoning: 推論過程を含めるか
+
+        Returns:
+            {
+                "coordinates": [x, y, z, c, g, v],
+                "reasoning": "推定の理由",
+                "confidence": 0.85
+            }
+        """
+        # ドメインスキーマ取得
+        domain_schema = self.domain_schemas.get(
+            domain_id,
+            self.domain_schemas["general"]  # フォールバック
+        )
+
+        # プロンプト構築
+        estimation_prompt = self._build_estimation_prompt(
+            prompt, response, domain_id, domain_schema, use_reasoning
+        )
+
+        # LLMに座標推定を依頼
+        try:
+            llm_response = await llm_inference_func(estimation_prompt)
+
+            # レスポンスから座標を抽出
+            result = self._parse_llm_response(llm_response)
+
+            # バリデーション
+            if self._validate_coordinates(result["coordinates"]):
+                logger.info(f"Estimated coordinates for domain '{domain_id}': {result['coordinates']}")
+                return result
+            else:
+                logger.error(f"Invalid coordinates: {result['coordinates']}")
+                return self._get_default_coordinates(domain_id)
+
+        except Exception as e:
+            logger.error(f"Coordinate estimation failed: {e}")
+            return self._get_default_coordinates(domain_id)
+
+    def _build_estimation_prompt(
+        self,
+        prompt: str,
+        response: str,
+        domain_id: str,
+        domain_schema: Dict[str, str],
+        use_reasoning: bool
+    ) -> str:
+        """
+        座標推定用のプロンプトを構築
+        """
+        base_prompt = f"""You are an expert in knowledge space mapping and coordinate estimation.
+
+Your task is to estimate the 6-dimensional coordinates that best represent the following knowledge in the domain of "{domain_id}".
+
+**Coordinate System:**
+
+1. **Domain-specific space [x, y, z]** (each 0.0-1.0):
+   - x-axis: {domain_schema['x']}
+   - y-axis: {domain_schema['y']}
+   - z-axis: {domain_schema['z']}
+
+2. **Meta-information space [c, g, v]** (each 0.0-1.0):
+   - c (Certainty): How certain/verified is this knowledge?
+     * 0.0 = hypothesis, speculation
+     * 0.5 = established theory, widely accepted
+     * 1.0 = proven fact, empirically verified
+
+   - g (Granularity): How detailed/specific is this knowledge?
+     * 0.0 = high-level overview, general concept
+     * 0.5 = detailed explanation
+     * 1.0 = highly specialized, expert-level detail
+
+   - v (Verification): What is the verification status?
+     * 0.0 = unverified, no sources
+     * 0.5 = expert-reviewed, single source
+     * 1.0 = peer-reviewed, multiple sources confirmed
+
+**Knowledge to estimate:**
+
+Question: {prompt}
+
+Answer: {response}
+
+**Instructions:**
+"""
+
+        if use_reasoning:
+            base_prompt += """
+1. First, analyze the knowledge and explain your reasoning for each coordinate.
+2. Then, output the final coordinates.
+
+Format your response as JSON:
+{
+  "reasoning": "Your detailed reasoning here...",
+  "coordinates": [x, y, z, c, g, v],
+  "confidence": 0.85
+}
+"""
+        else:
+            base_prompt += """
+Output ONLY the coordinates as a JSON object:
+{
+  "coordinates": [x, y, z, c, g, v],
+  "confidence": 0.85
+}
+"""
+
+        base_prompt += """
+**Important:**
+- All coordinates must be between 0.0 and 1.0
+- Use 2 decimal places (e.g., 0.75)
+- confidence should reflect how confident you are in this estimation (0.0-1.0)
+"""
+
+        return base_prompt
+
+    def _parse_llm_response(self, llm_response: str) -> Dict[str, Any]:
+        """
+        LLMのレスポンスから座標を抽出
+        """
+        try:
+            # JSONブロックを探す
+            # LLMはしばしば ```json ... ``` で囲む
+            if "```json" in llm_response:
+                json_start = llm_response.find("```json") + 7
+                json_end = llm_response.find("```", json_start)
+                json_str = llm_response[json_start:json_end].strip()
+            elif "```" in llm_response:
+                json_start = llm_response.find("```") + 3
+                json_end = llm_response.find("```", json_start)
+                json_str = llm_response[json_start:json_end].strip()
+            else:
+                # JSON全体を探す
+                json_str = llm_response.strip()
+
+            # JSONパース
+            result = json.loads(json_str)
+
+            # 必須フィールドチェック
+            if "coordinates" not in result:
+                raise ValueError("Missing 'coordinates' field")
+
+            # デフォルト値設定
+            if "reasoning" not in result:
+                result["reasoning"] = "No reasoning provided"
+            if "confidence" not in result:
+                result["confidence"] = 0.5
+
+            return result
+
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON parse error: {e}")
+            logger.debug(f"LLM response: {llm_response}")
+
+            # フォールバック: 数値のリストを直接探す
+            return self._fallback_parse(llm_response)
+
+    def _fallback_parse(self, llm_response: str) -> Dict[str, Any]:
+        """
+        JSONパースに失敗した場合のフォールバック
+        """
+        import re
+
+        # [0.1, 0.2, 0.3, 0.4, 0.5, 0.6] のようなパターンを探す
+        pattern = r'\[[\s]*([0-9.]+)[\s]*,[\s]*([0-9.]+)[\s]*,[\s]*([0-9.]+)[\s]*,[\s]*([0-9.]+)[\s]*,[\s]*([0-9.]+)[\s]*,[\s]*([0-9.]+)[\s]*\]'
+        match = re.search(pattern, llm_response)
+
+        if match:
+            coords = [float(match.group(i)) for i in range(1, 7)]
+            return {
+                "coordinates": coords,
+                "reasoning": "Parsed from array notation",
+                "confidence": 0.5
+            }
+
+        # パースに完全に失敗
+        raise ValueError("Could not parse coordinates from LLM response")
+
+    def _validate_coordinates(self, coordinates: List[float]) -> bool:
+        """
+        座標の妥当性をチェック
+        """
+        if not isinstance(coordinates, list):
+            return False
+
+        if len(coordinates) != 6:
+            logger.error(f"Expected 6 coordinates, got {len(coordinates)}")
+            return False
+
+        for i, coord in enumerate(coordinates):
+            if not isinstance(coord, (int, float)):
+                logger.error(f"Coordinate {i} is not a number: {coord}")
+                return False
+
+            if not (0.0 <= coord <= 1.0):
+                logger.error(f"Coordinate {i} out of range [0.0, 1.0]: {coord}")
+                return False
+
+        return True
+
+    def _get_default_coordinates(self, domain_id: str) -> Dict[str, Any]:
+        """
+        推定に失敗した場合のデフォルト座標
+        """
+        logger.warning(f"Using default coordinates for domain '{domain_id}'")
+
+        # ドメイン中心の座標
+        return {
+            "coordinates": [0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
+            "reasoning": "Default coordinates (estimation failed)",
+            "confidence": 0.3
+        }
+
+    async def estimate_batch(
+        self,
+        knowledge_items: List[Dict[str, str]],
+        llm_inference_func,
+        max_concurrent: int = 3
+    ) -> List[Dict[str, Any]]:
+        """
+        複数の知識アイテムの座標を一括推定
+
+        Args:
+            knowledge_items: [{"prompt": "...", "response": "...", "domain_id": "..."}, ...]
+            llm_inference_func: LLM推論関数
+            max_concurrent: 同時実行数
+
+        Returns:
+            推定結果のリスト
+        """
+        semaphore = asyncio.Semaphore(max_concurrent)
+
+        async def estimate_with_semaphore(item):
+            async with semaphore:
+                return await self.estimate_coordinates(
+                    prompt=item["prompt"],
+                    response=item["response"],
+                    domain_id=item.get("domain_id", "general"),
+                    llm_inference_func=llm_inference_func
+                )
+
+        tasks = [estimate_with_semaphore(item) for item in knowledge_items]
+        results = await asyncio.gather(*tasks)
+
+        return results
+
+    def get_domain_schema(self, domain_id: str) -> Dict[str, str]:
+        """
+        ドメインスキーマを取得（UI表示用）
+        """
+        return self.domain_schemas.get(domain_id, self.domain_schemas["general"])
+
+    def add_domain_schema(self, domain_id: str, schema: Dict[str, str]):
+        """
+        新しいドメインスキーマを追加
+        """
+        if not all(key in schema for key in ["x", "y", "z"]):
+            raise ValueError("Schema must contain 'x', 'y', 'z' definitions")
+
+        self.domain_schemas[domain_id] = schema
+        logger.info(f"Added domain schema for '{domain_id}'")
+
+    def interpolate_coordinates(
+        self,
+        coord1: List[float],
+        coord2: List[float],
+        weight: float = 0.5
+    ) -> List[float]:
+        """
+        2つの座標の間を補間（類似知識の座標推定に使用）
+
+        Args:
+            coord1: 座標1
+            coord2: 座標2
+            weight: 補間ウェイト (0.0=coord1, 1.0=coord2)
+
+        Returns:
+            補間された座標
+        """
+        if len(coord1) != 6 or len(coord2) != 6:
+            raise ValueError("Both coordinates must be 6-dimensional")
+
+        interpolated = [
+            coord1[i] * (1 - weight) + coord2[i] * weight
+            for i in range(6)
+        ]
+
+        return interpolated

db_enrichment.py

@@ -0,0 +1,523 @@
+# null_ai/db_enrichment.py
+"""
+Database Enrichment Module
+
+AIを使って自動的に知識ベースを拡充するモジュール。
+DeepSeekが質問を生成 → 師匠モデルが回答 → .iathに保存
+"""
+
+import logging
+import asyncio
+from typing import List, Dict, Any, Optional, Callable
+from datetime import datetime
+import uuid
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class AIEnrichmentEngine:
+    """
+    AI駆動の知識ベース拡充エンジン
+
+    動作フロー:
+    1. DeepSeek（永久指導者）が拡充用の質問を生成
+    2. 師匠モデルが質問に回答
+    3. 座標を自動推定
+    4. .iathに保存
+    """
+
+    def __init__(
+        self,
+        prompt_generator_func,  # プロンプト生成用LLM関数
+        answer_generator_func,  # 回答生成用LLM関数
+        coordinate_estimator,   # CoordinateEstimator
+        iath_writer            # IathWriter
+    ):
+        """
+        Args:
+            prompt_generator_func: async def(prompt) -> str (DeepSeek使用)
+            answer_generator_func: async def(prompt) -> dict (師匠モデル使用)
+            coordinate_estimator: CoordinateEstimatorインスタンス
+            iath_writer: IathWriterインスタンス
+        """
+        self.prompt_generator = prompt_generator_func
+        self.answer_generator = answer_generator_func
+        self.coordinate_estimator = coordinate_estimator
+        self.iath_writer = iath_writer
+
+        self.enrichment_state = {
+            "is_running": False,
+            "progress": 0.0,
+            "current_question": 0,
+            "total_questions": 0,
+            "generated_tiles": 0,
+            "start_time": None,
+            "domain_id": None
+        }
+
+    async def generate_enrichment_questions(
+        self,
+        domain_id: str,
+        num_questions: int = 10,
+        focus_areas: Optional[List[str]] = None
+    ) -> List[str]:
+        """
+        DeepSeekを使って拡充用の質問を生成
+
+        Args:
+            domain_id: ドメインID
+            num_questions: 生成する質問数
+            focus_areas: 重点領域（例: ["基礎理論", "応用例", "最新研究"]）
+
+        Returns:
+            生成された質問のリスト
+        """
+        logger.info(f"Generating {num_questions} enrichment questions for domain '{domain_id}'")
+
+        # 重点領域の文字列化
+        focus_text = ""
+        if focus_areas:
+            focus_text = f"\nFocus on these specific areas: {', '.join(focus_areas)}"
+
+        # プロンプト構築
+        generation_prompt = f"""You are an expert knowledge curator in the domain of {domain_id}.
+
+Your task is to generate {num_questions} diverse, high-quality questions that would enrich a knowledge base in this domain.
+
+Guidelines:
+1. Cover a wide range of topics within the domain
+2. Include questions at different complexity levels (basic, intermediate, advanced)
+3. Focus on practical applications and edge cases
+4. Avoid overly broad or trivial questions
+5. Each question should elicit detailed, informative answers{focus_text}
+
+Output format:
+Return ONLY a JSON array of questions, like this:
+["Question 1?", "Question 2?", ...]
+
+Domain: {domain_id}
+Number of questions: {num_questions}
+
+Generate the questions now:"""
+
+        try:
+            # DeepSeekでプロンプト生成
+            logger.info(f"Calling prompt generator with prompt length: {len(generation_prompt)}")
+            response = await self.prompt_generator(generation_prompt)
+
+            # 応答の長さをログ出力
+            logger.info(f"Received response from LLM, length: {len(response) if response else 0}")
+            if not response:
+                logger.error("LLM returned empty response!")
+                return []
+
+            logger.debug(f"Response preview (first 200 chars): {response[:200]}")
+
+            # JSON抽出
+            questions = self._extract_questions_from_response(response)
+
+            # 重複除去
+            questions = list(dict.fromkeys(questions))  # 順序を保持しつつ重複除去
+
+            logger.info(f"Generated {len(questions)} unique questions")
+            return questions[:num_questions]
+
+        except Exception as e:
+            logger.error(f"Failed to generate enrichment questions: {e}", exc_info=True)
+            return []
+
+    def _extract_questions_from_response(self, response: str) -> List[str]:
+        """
+        LLMのレスポンスから質問リストを抽出
+        """
+        # 空の応答チェック
+        if not response or not response.strip():
+            logger.error(f"Empty response from LLM. Response: '{response}'")
+            return []
+
+        try:
+            # JSONブロックを探す
+            json_str = ""
+            if "```json" in response:
+                json_start = response.find("```json") + 7
+                json_end = response.find("```", json_start)
+                json_str = response[json_start:json_end].strip()
+            elif "```" in response:
+                json_start = response.find("```") + 3
+                json_end = response.find("```", json_start)
+                json_str = response[json_start:json_end].strip()
+            elif "[" in response and "]" in response:
+                # JSON配列を直接探す
+                json_start = response.find("[")
+                json_end = response.rfind("]") + 1
+                json_str = response[json_start:json_end]
+            else:
+                json_str = response.strip()
+
+            # 空のjson_strチェック
+            if not json_str:
+                logger.error(f"Could not extract JSON from response. Full response: '{response[:500]}'")
+                return self._fallback_parse(response)
+
+            # JSONパース
+            questions = json.loads(json_str)
+
+            if isinstance(questions, list):
+                # 文字列のリストかチェック
+                return [q for q in questions if isinstance(q, str)]
+            else:
+                logger.error(f"Expected list, got {type(questions)}")
+                return []
+
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON parse error: {e}. Attempted to parse: '{json_str[:200]}'")
+            logger.error(f"Full response (first 500 chars): '{response[:500]}'")
+            return self._fallback_parse(response)
+
+    def _fallback_parse(self, response: str) -> List[str]:
+        """
+        JSONパースに失敗した場合のフォールバック処理
+        改行区切りのテキストとして質問を抽出
+        """
+        logger.info("Attempting fallback parsing of response...")
+        lines = response.split('\n')
+        questions = []
+        for line in lines:
+            line = line.strip()
+            # 数字付きリストのフォーマットを除去 (1. Question -> Question)
+            if line and len(line) > 5:  # 最低5文字以上
+                if line[0].isdigit() or line.startswith('-') or line.startswith('*'):
+                    # "1. " や "- " を除去
+                    cleaned = line.lstrip('0123456789.-* ').strip()
+                    if cleaned and '?' in cleaned:
+                        questions.append(cleaned)
+                elif '?' in line:
+                    # 疑問符がある行をそのまま質問として扱う
+                    questions.append(line)
+
+        logger.info(f"Fallback parsing extracted {len(questions)} questions")
+        return questions
+
+    async def enrich_with_ai(
+        self,
+        domain_id: str,
+        num_questions: int = 10,
+        focus_areas: Optional[List[str]] = None,
+        progress_callback: Optional[Callable] = None
+    ) -> Dict[str, Any]:
+        """
+        AIを使って知識ベースを拡充
+
+        Args:
+            domain_id: ドメインID
+            num_questions: 生成する質問数
+            focus_areas: 重点領域
+            progress_callback: 進捗コールバック async def(state)
+
+        Returns:
+            拡充結果
+        """
+        self.enrichment_state.update({
+            "is_running": True,
+            "progress": 0.0,
+            "current_question": 0,
+            "total_questions": num_questions,
+            "generated_tiles": 0,
+            "start_time": datetime.utcnow().isoformat(),
+            "domain_id": domain_id
+        })
+
+        try:
+            # Step 1: 質問生成
+            logger.info(f"Step 1: Generating {num_questions} questions...")
+            questions = await self.generate_enrichment_questions(
+                domain_id, num_questions, focus_areas
+            )
+
+            if not questions:
+                return {
+                    "success": False,
+                    "error": "Failed to generate questions"
+                }
+
+            self.enrichment_state["total_questions"] = len(questions)
+
+            # Step 2: 各質問に対して回答生成 + 保存
+            tiles_created = 0
+
+            for i, question in enumerate(questions):
+                logger.info(f"Processing question {i+1}/{len(questions)}: {question[:50]}...")
+
+                self.enrichment_state["current_question"] = i + 1
+                self.enrichment_state["progress"] = (i / len(questions)) * 100
+
+                if progress_callback:
+                    await progress_callback(self.enrichment_state)
+
+                try:
+                    # 師匠モデルで回答生成
+                    answer_result = await self.answer_generator(question)
+
+                    if not answer_result or "response" not in answer_result:
+                        logger.warning(f"No response for question: {question}")
+                        continue
+
+                    response = answer_result["response"]
+                    confidence = answer_result.get("confidence", 0.7)
+
+                    # 座標推定用の推論関数を作成
+                    async def coord_inference(coord_prompt):
+                        result = await self.prompt_generator(coord_prompt)
+                        return result
+
+                    # 座標推定
+                    coord_result = await self.coordinate_estimator.estimate_coordinates(
+                        prompt=question,
+                        response=response,
+                        domain_id=domain_id,
+                        llm_inference_func=coord_inference,
+                        use_reasoning=False
+                    )
+
+                    # .iath Tileオブジェクト作成
+                    from null_ai.iath_writer import create_tile_from_ai_output
+
+                    tile = create_tile_from_ai_output(
+                        knowledge_id=f"ai_enrich_{uuid.uuid4().hex}",
+                        topic=question[:100],
+                        prompt=question,
+                        response=response,
+                        coordinates=coord_result["coordinates"],
+                        confidence=confidence,
+                        domain_id=domain_id,
+                        source="ai_enrichment"
+                    )
+
+                    # .iathに保存
+                    success = self.iath_writer.append_tile(tile)
+
+                    if success:
+                        tiles_created += 1
+                        self.enrichment_state["generated_tiles"] = tiles_created
+                        logger.info(f"Saved enrichment tile {tiles_created}: {question[:50]}...")
+                    else:
+                        logger.warning(f"Failed to save tile for: {question}")
+
+                except Exception as e:
+                    logger.error(f"Error processing question '{question}': {e}")
+                    continue
+
+            # 完了
+            self.enrichment_state.update({
+                "is_running": False,
+                "progress": 100.0,
+                "current_question": len(questions)
+            })
+
+            if progress_callback:
+                await progress_callback(self.enrichment_state)
+
+            return {
+                "success": True,
+                "questions_generated": len(questions),
+                "tiles_created": tiles_created,
+                "domain_id": domain_id
+            }
+
+        except Exception as e:
+            logger.error(f"AI enrichment failed: {e}")
+            self.enrichment_state["is_running"] = False
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    def get_enrichment_status(self) -> Dict[str, Any]:
+        """現在の拡充ステータスを取得"""
+        return self.enrichment_state.copy()
+
+    def stop_enrichment(self):
+        """拡充処理を停止（実装は簡易版）"""
+        self.enrichment_state["is_running"] = False
+        logger.info("Enrichment stop requested")
+
+
+class WebEnrichmentEngine:
+    """
+    Web検索による知識ベース拡充エンジン
+
+    動作フロー:
+    1. Web検索（Brave Search / Google Custom Search）
+    2. ページから知識を抽出
+    3. Knowledge Tile形式に変換
+    4. .iathに保存
+    """
+
+    def __init__(
+        self,
+        search_api_key: Optional[str] = None,
+        search_engine: str = "brave",  # "brave" or "google"
+        coordinate_estimator=None,
+        iath_writer=None
+    ):
+        """
+        Args:
+            search_api_key: 検索APIキー
+            search_engine: 使用する検索エンジン
+            coordinate_estimator: CoordinateEstimatorインスタンス
+            iath_writer: IathWriterインスタンス
+        """
+        self.api_key = search_api_key
+        self.search_engine = search_engine
+        self.coordinate_estimator = coordinate_estimator
+        self.iath_writer = iath_writer
+
+    async def search_web(self, query: str, max_results: int = 5) -> List[Dict[str, str]]:
+        """
+        Web検索を実行
+
+        Args:
+            query: 検索クエリ
+            max_results: 最大結果数
+
+        Returns:
+            [{"title": "...", "url": "...", "snippet": "..."}, ...]
+        """
+        if self.search_engine == "brave":
+            return await self._search_brave(query, max_results)
+        elif self.search_engine == "google":
+            return await self._search_google(query, max_results)
+        else:
+            raise ValueError(f"Unknown search engine: {self.search_engine}")
+
+    async def _search_brave(self, query: str, max_results: int) -> List[Dict[str, str]]:
+        """Brave Search APIで検索"""
+        try:
+            import aiohttp
+
+            if not self.api_key:
+                logger.error("Brave Search API key not configured")
+                return []
+
+            url = "https://api.search.brave.com/res/v1/web/search"
+            headers = {
+                "Accept": "application/json",
+                "X-Subscription-Token": self.api_key
+            }
+            params = {
+                "q": query,
+                "count": max_results
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers, params=params) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        results = []
+
+                        for item in data.get("web", {}).get("results", []):
+                            results.append({
+                                "title": item.get("title", ""),
+                                "url": item.get("url", ""),
+                                "snippet": item.get("description", "")
+                            })
+
+                        return results
+                    else:
+                        logger.error(f"Brave Search API error: {response.status}")
+                        return []
+
+        except Exception as e:
+            logger.error(f"Brave Search failed: {e}")
+            return []
+
+    async def _search_google(self, query: str, max_results: int) -> List[Dict[str, str]]:
+        """Google Custom Search APIで検索"""
+        # TODO: Google Custom Search API実装
+        logger.warning("Google Custom Search not implemented yet")
+        return []
+
+    async def enrich_from_web(
+        self,
+        query: str,
+        domain_id: str,
+        max_results: int = 5
+    ) -> Dict[str, Any]:
+        """
+        Web検索結果から知識ベースを拡充
+
+        Args:
+            query: 検索クエリ
+            domain_id: ドメインID
+            max_results: 最大結果数
+
+        Returns:
+            拡充結果
+        """
+        try:
+            # Web検索
+            search_results = await self.search_web(query, max_results)
+
+            if not search_results:
+                return {
+                    "success": False,
+                    "error": "No search results found"
+                }
+
+            # 各結果をKnowledge Tileに変換
+            tiles_created = 0
+
+            for result in search_results:
+                try:
+                    # Knowledge Tile作成（Web検索結果版）
+                    tile_content = f"""Title: {result['title']}
+
+Source: {result['url']}
+
+Summary:
+{result['snippet']}
+"""
+
+                    # 座標推定（簡易版: デフォルト座標）
+                    # TODO: より高度な座標推定
+                    coordinates = [0.5, 0.5, 0.5, 0.6, 0.5, 0.7]
+
+                    from null_ai.iath_writer import create_tile_from_ai_output
+
+                    tile = create_tile_from_ai_output(
+                        knowledge_id=f"web_{uuid.uuid4().hex}",
+                        topic=result['title'],
+                        prompt=query,
+                        response=tile_content,
+                        coordinates=coordinates,
+                        confidence=0.6,  # Web検索結果は中程度の信頼度
+                        domain_id=domain_id,
+                        source="web_search"
+                    )
+
+                    # .iathに保存
+                    success = self.iath_writer.append_tile(tile)
+
+                    if success:
+                        tiles_created += 1
+                        logger.info(f"Saved web tile: {result['title']}")
+
+                except Exception as e:
+                    logger.error(f"Error creating tile from search result: {e}")
+                    continue
+
+            return {
+                "success": True,
+                "search_results": len(search_results),
+                "tiles_created": tiles_created,
+                "query": query,
+                "domain_id": domain_id
+            }
+
+        except Exception as e:
+            logger.error(f"Web enrichment failed: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }

fine_tuning.py

@@ -0,0 +1,627 @@
+# null_ai/fine_tuning.py
+"""
+NullAI Fine-tuning Module
+Implements apprentice model fine-tuning using master outputs (Alpaca format)
+"""
+
+import os
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Callable
+from datetime import datetime
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+
+class FineTuningManager:
+    """
+    Manages fine-tuning of apprentice models using master outputs.
+    Supports multiple backends: HuggingFace (PEFT/LoRA), Unsloth, MLX
+    """
+
+    def __init__(self, training_data_dir: str = "training_data/master_outputs"):
+        self.training_data_dir = Path(training_data_dir)
+        self.checkpoints_dir = Path("training_data/checkpoints")
+        self.checkpoints_dir.mkdir(parents=True, exist_ok=True)
+
+        self.current_training_state = {
+            "is_training": False,
+            "progress": 0.0,
+            "current_epoch": 0,
+            "total_epochs": 0,
+            "loss": 0.0,
+            "model_id": None,
+            "start_time": None
+        }
+
+    # ===== Training Data Loading =====
+
+    def load_training_data(self, domain_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Load training data from Alpaca-format JSONL files.
+
+        Args:
+            domain_id: Specific domain to load. If None, loads all domains.
+
+        Returns:
+            List of training examples in Alpaca format
+        """
+        training_examples = []
+
+        if not self.training_data_dir.exists():
+            logger.warning(f"Training data directory not found: {self.training_data_dir}")
+            return training_examples
+
+        # Determine which files to load
+        if domain_id:
+            jsonl_files = [self.training_data_dir / f"master_outputs_{domain_id}.jsonl"]
+        else:
+            jsonl_files = list(self.training_data_dir.glob("master_outputs_*.jsonl"))
+
+        for jsonl_file in jsonl_files:
+            if not jsonl_file.exists():
+                logger.warning(f"Training data file not found: {jsonl_file}")
+                continue
+
+            logger.info(f"Loading training data from: {jsonl_file}")
+            with open(jsonl_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    try:
+                        example = json.loads(line.strip())
+                        training_examples.append(example)
+                    except json.JSONDecodeError as e:
+                        logger.error(f"Failed to parse JSON line in {jsonl_file}: {e}")
+                        continue
+
+        logger.info(f"Loaded {len(training_examples)} training examples")
+        return training_examples
+
+    def format_training_examples_for_model(
+        self,
+        training_examples: List[Dict[str, Any]],
+        template: str = "alpaca"
+    ) -> List[str]:
+        """
+        Format training examples into model-ready prompts.
+
+        Args:
+            training_examples: Raw Alpaca-format examples
+            template: Prompt template format ("alpaca", "chatml", "llama3")
+
+        Returns:
+            List of formatted prompt strings
+        """
+        formatted_prompts = []
+
+        for example in training_examples:
+            instruction = example.get("instruction", "")
+            input_text = example.get("input", "")
+            output_text = example.get("output", "")
+
+            if template == "alpaca":
+                if input_text:
+                    prompt = f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+### Instruction:
+{instruction}
+
+### Input:
+{input_text}
+
+### Response:
+{output_text}"""
+                else:
+                    prompt = f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+
+### Instruction:
+{instruction}
+
+### Response:
+{output_text}"""
+
+            elif template == "chatml":
+                prompt = f"""<|im_start|>system
+{instruction}<|im_end|>
+<|im_start|>user
+{input_text}<|im_end|>
+<|im_start|>assistant
+{output_text}<|im_end|>"""
+
+            elif template == "llama3":
+                prompt = f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+{instruction}<|eot_id|><|start_header_id|>user<|end_header_id|>
+{input_text}<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+{output_text}<|eot_id|>"""
+
+            else:
+                raise ValueError(f"Unknown template format: {template}")
+
+            formatted_prompts.append(prompt)
+
+        return formatted_prompts
+
+    # ===== Fine-tuning Backends =====
+
+    async def fine_tune_with_huggingface_peft(
+        self,
+        model_name: str,
+        training_examples: List[Dict[str, Any]],
+        output_dir: str,
+        epochs: int = 3,
+        learning_rate: float = 2e-4,
+        batch_size: int = 4,
+        gradient_accumulation_steps: int = 4,
+        lora_r: int = 8,
+        lora_alpha: int = 16,
+        lora_dropout: float = 0.05,
+        max_seq_length: int = 512,
+        progress_callback: Optional[Callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Fine-tune model using HuggingFace Transformers + PEFT (LoRA).
+
+        This is the recommended method for most models.
+        Uses QLoRA (4-bit quantization) for memory efficiency.
+        """
+        try:
+            import torch
+            from transformers import (
+                AutoModelForCausalLM,
+                AutoTokenizer,
+                TrainingArguments,
+                Trainer,
+                DataCollatorForLanguageModeling
+            )
+            from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+            from datasets import Dataset
+
+        except ImportError as e:
+            logger.error(f"Required libraries not installed: {e}")
+            logger.error("Please install: pip install transformers peft datasets bitsandbytes accelerate")
+            raise
+
+        logger.info(f"Starting PEFT fine-tuning for model: {model_name}")
+        self.current_training_state.update({
+            "is_training": True,
+            "progress": 0.0,
+            "current_epoch": 0,
+            "total_epochs": epochs,
+            "model_id": model_name,
+            "start_time": datetime.utcnow().isoformat()
+        })
+
+        # 1. Load tokenizer
+        logger.info("Loading tokenizer...")
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        # 2. Load model with 4-bit quantization (QLoRA)
+        logger.info("Loading model with 4-bit quantization...")
+        try:
+            from transformers import BitsAndBytesConfig
+
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_use_double_quant=True
+            )
+
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                quantization_config=bnb_config,
+                device_map="auto",
+                trust_remote_code=True
+            )
+        except Exception as e:
+            logger.warning(f"4-bit quantization failed, falling back to float16: {e}")
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16,
+                device_map="auto",
+                trust_remote_code=True
+            )
+
+        # 3. Prepare model for training
+        model = prepare_model_for_kbit_training(model)
+
+        # 4. Configure LoRA
+        logger.info("Configuring LoRA...")
+        lora_config = LoraConfig(
+            r=lora_r,
+            lora_alpha=lora_alpha,
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+            lora_dropout=lora_dropout,
+            bias="none",
+            task_type="CAUSAL_LM"
+        )
+
+        model = get_peft_model(model, lora_config)
+        model.print_trainable_parameters()
+
+        # 5. Format training data
+        logger.info("Formatting training data...")
+        formatted_texts = self.format_training_examples_for_model(training_examples, template="alpaca")
+
+        # 6. Tokenize dataset
+        def tokenize_function(examples):
+            return tokenizer(
+                examples["text"],
+                truncation=True,
+                max_length=max_seq_length,
+                padding="max_length"
+            )
+
+        dataset = Dataset.from_dict({"text": formatted_texts})
+        tokenized_dataset = dataset.map(
+            tokenize_function,
+            batched=True,
+            remove_columns=dataset.column_names
+        )
+
+        # 7. Training arguments
+        training_args = TrainingArguments(
+            output_dir=output_dir,
+            num_train_epochs=epochs,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=gradient_accumulation_steps,
+            learning_rate=learning_rate,
+            fp16=True,
+            logging_steps=10,
+            save_steps=100,
+            save_total_limit=3,
+            warmup_steps=50,
+            optim="paged_adamw_8bit",
+            report_to="none"  # Disable wandb/tensorboard for now
+        )
+
+        # 8. Data collator
+        data_collator = DataCollatorForLanguageModeling(
+            tokenizer=tokenizer,
+            mlm=False
+        )
+
+        # 9. Create trainer with progress callback
+        class ProgressCallback:
+            def __init__(self, manager, total_epochs, callback):
+                self.manager = manager
+                self.total_epochs = total_epochs
+                self.callback = callback
+
+            def on_epoch_end(self, args, state, control, **kwargs):
+                epoch = state.epoch
+                loss = state.log_history[-1].get("loss", 0.0) if state.log_history else 0.0
+
+                self.manager.current_training_state.update({
+                    "current_epoch": int(epoch),
+                    "progress": (epoch / self.total_epochs) * 100,
+                    "loss": loss
+                })
+
+                if self.callback:
+                    asyncio.create_task(self.callback(self.manager.current_training_state))
+
+        from transformers import TrainerCallback
+
+        class CustomCallback(TrainerCallback):
+            def __init__(self, progress_cb):
+                self.progress_cb = progress_cb
+
+            def on_epoch_end(self, args, state, control, **kwargs):
+                self.progress_cb.on_epoch_end(args, state, control, **kwargs)
+
+        progress_cb = ProgressCallback(self, epochs, progress_callback)
+
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=tokenized_dataset,
+            data_collator=data_collator,
+            callbacks=[CustomCallback(progress_cb)]
+        )
+
+        # 10. Train!
+        logger.info("Starting training...")
+        train_result = trainer.train()
+
+        # 11. Save final model
+        logger.info(f"Saving model to: {output_dir}")
+        trainer.save_model(output_dir)
+        tokenizer.save_pretrained(output_dir)
+
+        # 12. Update state
+        self.current_training_state.update({
+            "is_training": False,
+            "progress": 100.0,
+            "current_epoch": epochs
+        })
+
+        return {
+            "success": True,
+            "output_dir": output_dir,
+            "train_loss": train_result.training_loss,
+            "metrics": train_result.metrics,
+            "model_name": model_name,
+            "lora_config": {
+                "r": lora_r,
+                "alpha": lora_alpha,
+                "dropout": lora_dropout
+            }
+        }
+
+    async def fine_tune_with_unsloth(
+        self,
+        model_name: str,
+        training_examples: List[Dict[str, Any]],
+        output_dir: str,
+        epochs: int = 3,
+        learning_rate: float = 2e-4,
+        batch_size: int = 4,
+        lora_r: int = 16,
+        progress_callback: Optional[Callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Fine-tune model using Unsloth (fastest method, 2x faster than PEFT).
+
+        Unsloth is optimized for speed and memory efficiency.
+        Recommended for: Llama, Mistral, Qwen models
+        """
+        try:
+            from unsloth import FastLanguageModel
+            from trl import SFTTrainer
+            from transformers import TrainingArguments
+            from datasets import Dataset
+        except ImportError as e:
+            logger.error(f"Unsloth not installed: {e}")
+            logger.error("Please install: pip install unsloth")
+            raise
+
+        logger.info(f"Starting Unsloth fine-tuning for model: {model_name}")
+        self.current_training_state.update({
+            "is_training": True,
+            "progress": 0.0,
+            "current_epoch": 0,
+            "total_epochs": epochs,
+            "model_id": model_name,
+            "start_time": datetime.utcnow().isoformat()
+        })
+
+        # 1. Load model with Unsloth
+        logger.info("Loading model with Unsloth...")
+        model, tokenizer = FastLanguageModel.from_pretrained(
+            model_name=model_name,
+            max_seq_length=2048,
+            dtype=None,  # Auto-detect
+            load_in_4bit=True
+        )
+
+        # 2. Add LoRA adapters
+        model = FastLanguageModel.get_peft_model(
+            model,
+            r=lora_r,
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+            lora_alpha=16,
+            lora_dropout=0,
+            bias="none",
+            use_gradient_checkpointing=True,
+            random_state=42
+        )
+
+        # 3. Format training data
+        formatted_texts = self.format_training_examples_for_model(training_examples, template="alpaca")
+        dataset = Dataset.from_dict({"text": formatted_texts})
+
+        # 4. Training arguments
+        training_args = TrainingArguments(
+            output_dir=output_dir,
+            num_train_epochs=epochs,
+            per_device_train_batch_size=batch_size,
+            learning_rate=learning_rate,
+            fp16=True,
+            logging_steps=10,
+            save_steps=100,
+            warmup_steps=50
+        )
+
+        # 5. Create SFT trainer
+        trainer = SFTTrainer(
+            model=model,
+            tokenizer=tokenizer,
+            train_dataset=dataset,
+            dataset_text_field="text",
+            max_seq_length=2048,
+            args=training_args
+        )
+
+        # 6. Train
+        logger.info("Starting training with Unsloth...")
+        trainer.train()
+
+        # 7. Save
+        logger.info(f"Saving model to: {output_dir}")
+        model.save_pretrained(output_dir)
+        tokenizer.save_pretrained(output_dir)
+
+        self.current_training_state.update({
+            "is_training": False,
+            "progress": 100.0
+        })
+
+        return {
+            "success": True,
+            "output_dir": output_dir,
+            "model_name": model_name,
+            "method": "unsloth"
+        }
+
+    async def fine_tune_with_mlx(
+        self,
+        model_name: str,
+        training_examples: List[Dict[str, Any]],
+        output_dir: str,
+        epochs: int = 3,
+        learning_rate: float = 1e-5,
+        batch_size: int = 4,
+        lora_r: int = 8,
+        progress_callback: Optional[Callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Fine-tune model using MLX (Apple Silicon only, ultra-fast).
+
+        Optimized for M1/M2/M3 Macs.
+        Uses unified memory for maximum efficiency.
+        """
+        try:
+            import mlx.core as mx
+            from mlx_lm import load, generate
+            import mlx.optimizers as optim
+            import mlx.nn as nn
+        except ImportError as e:
+            logger.error(f"MLX not installed: {e}")
+            logger.error("Please install: pip install mlx mlx-lm")
+            raise
+
+        logger.info(f"Starting MLX fine-tuning for model: {model_name}")
+        self.current_training_state.update({
+            "is_training": True,
+            "progress": 0.0,
+            "current_epoch": 0,
+            "total_epochs": epochs,
+            "model_id": model_name,
+            "start_time": datetime.utcnow().isoformat()
+        })
+
+        # Note: MLX fine-tuning is still experimental
+        # For now, return a placeholder
+        logger.warning("MLX fine-tuning is not fully implemented yet")
+
+        self.current_training_state["is_training"] = False
+
+        return {
+            "success": False,
+            "error": "MLX fine-tuning not yet implemented",
+            "model_name": model_name
+        }
+
+    # ===== Main Training Interface =====
+
+    async def start_training(
+        self,
+        apprentice_model_name: str,
+        domain_id: Optional[str] = None,
+        method: str = "peft",  # "peft", "unsloth", "mlx"
+        epochs: int = 3,
+        learning_rate: float = 2e-4,
+        batch_size: int = 4,
+        output_name: Optional[str] = None,
+        progress_callback: Optional[Callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Main entry point for fine-tuning an apprentice model.
+
+        Args:
+            apprentice_model_name: HuggingFace model name or path
+            domain_id: Domain to train on (None = all domains)
+            method: Training method ("peft", "unsloth", "mlx")
+            epochs: Number of training epochs
+            learning_rate: Learning rate
+            batch_size: Batch size per device
+            output_name: Custom name for output directory
+            progress_callback: Async callback for progress updates
+
+        Returns:
+            Training result dictionary
+        """
+        # 1. Load training data
+        training_examples = self.load_training_data(domain_id)
+
+        if not training_examples:
+            return {
+                "success": False,
+                "error": "No training data found"
+            }
+
+        # 2. Prepare output directory
+        if output_name is None:
+            timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+            output_name = f"apprentice_{domain_id or 'all'}_{timestamp}"
+
+        output_dir = self.checkpoints_dir / output_name
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # 3. Select training method
+        if method == "peft":
+            result = await self.fine_tune_with_huggingface_peft(
+                model_name=apprentice_model_name,
+                training_examples=training_examples,
+                output_dir=str(output_dir),
+                epochs=epochs,
+                learning_rate=learning_rate,
+                batch_size=batch_size,
+                progress_callback=progress_callback
+            )
+
+        elif method == "unsloth":
+            result = await self.fine_tune_with_unsloth(
+                model_name=apprentice_model_name,
+                training_examples=training_examples,
+                output_dir=str(output_dir),
+                epochs=epochs,
+                learning_rate=learning_rate,
+                batch_size=batch_size,
+                progress_callback=progress_callback
+            )
+
+        elif method == "mlx":
+            result = await self.fine_tune_with_mlx(
+                model_name=apprentice_model_name,
+                training_examples=training_examples,
+                output_dir=str(output_dir),
+                epochs=epochs,
+                learning_rate=learning_rate,
+                batch_size=batch_size,
+                progress_callback=progress_callback
+            )
+
+        else:
+            return {
+                "success": False,
+                "error": f"Unknown training method: {method}"
+            }
+
+        return result
+
+    def get_training_status(self) -> Dict[str, Any]:
+        """Get current training status."""
+        return self.current_training_state.copy()
+
+    def stop_training(self):
+        """Stop current training (if possible)."""
+        # TODO: Implement graceful training interruption
+        logger.warning("Training interruption not yet implemented")
+        self.current_training_state["is_training"] = False
+
+    def get_training_metrics(self, checkpoint_dir: str) -> Dict[str, Any]:
+        """
+        Load training metrics from a checkpoint.
+        """
+        checkpoint_path = Path(checkpoint_dir)
+
+        if not checkpoint_path.exists():
+            return {"error": "Checkpoint not found"}
+
+        # Look for trainer_state.json
+        trainer_state_file = checkpoint_path / "trainer_state.json"
+        if trainer_state_file.exists():
+            with open(trainer_state_file, 'r') as f:
+                trainer_state = json.load(f)
+                return {
+                    "log_history": trainer_state.get("log_history", []),
+                    "best_metric": trainer_state.get("best_metric"),
+                    "best_model_checkpoint": trainer_state.get("best_model_checkpoint")
+                }
+
+        return {"error": "No metrics found"}

iath_memory.py

@@ -0,0 +1,370 @@
+"""
+NullAI - .iath Memory System
+樹木型空間記憶（Dendritic Memory Space）の実装
+
+.iathファイル形式との完全互換性を持つ知識検索システム
+6次元座標系による空間的RAG（Retrieval-Augmented Generation）
+"""
+
+import struct
+import zstandard as zstd
+import json
+import logging
+import numpy as np
+from typing import List, Dict, Any, Optional, Tuple
+from pathlib import Path
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class IathDecoder:
+    """
+    .iathファイル形式のデコーダー
+    dendritic-memory-editorとの互換性を保持
+    """
+
+    def __init__(self, iath_file_path: str):
+        """
+        Args:
+            iath_file_path: .iathファイルのパス
+        """
+        self.file_path = Path(iath_file_path)
+        self.header = None
+        self.index = []
+        self.data_section_offset = 0
+
+        if self.file_path.exists():
+            self._load_header_and_index()
+        else:
+            logger.warning(f".iath file not found: {iath_file_path}")
+
+    def _load_header_and_index(self):
+        """ヘッダーとインデックスセクションを読み込む"""
+        try:
+            with open(self.file_path, 'rb') as f:
+                # ヘッダー読み込み (64 bytes)
+                header_data = f.read(64)
+                magic, version, domain_code, compression_type, checksum, index_offset, data_offset = struct.unpack(
+                    "<4sIBB32sQQ6x", header_data
+                )
+
+                self.header = {
+                    "magic": magic.decode('ascii'),
+                    "version": version,
+                    "domain_code": domain_code,
+                    "compression_type": compression_type,
+                    "index_offset": index_offset,
+                    "data_offset": data_offset
+                }
+
+                logger.info(f"Loaded .iath header: magic={self.header['magic']}, domain={domain_code}")
+
+                # インデックス読み込み
+                f.seek(index_offset)
+                index_binary = f.read(data_offset - index_offset)
+                self.index = json.loads(index_binary.decode('utf-8'))
+
+                self.data_section_offset = data_offset
+                logger.info(f"Loaded {len(self.index)} tiles from index")
+
+        except Exception as e:
+            logger.error(f"Error loading .iath file: {e}")
+            raise
+
+    def _decode_string(self, data: bytes, offset: int) -> Tuple[str, int]:
+        """NULL終端文字列をデコード"""
+        end = data.find(b'\0', offset)
+        if end == -1:
+            return data[offset:].decode('utf-8'), len(data)
+        return data[offset:end].decode('utf-8'), end + 1
+
+    def _decode_tile_data(self, compressed_data: bytes) -> dict:
+        """圧縮されたタイルデータをデコード"""
+        # zstd解凍
+        dctx = zstd.ZstdDecompressor()
+        uncompressed = dctx.decompress(compressed_data)
+
+        offset = 0
+
+        # メタデータ
+        metadata_len = struct.unpack("<I", uncompressed[offset:offset+4])[0]
+        offset += 4
+        metadata_bin = uncompressed[offset:offset+metadata_len]
+        offset += metadata_len
+
+        # メタデータ内の文字列をパース
+        meta_offset = 0
+        knowledge_id, meta_offset = self._decode_string(metadata_bin, meta_offset)
+        topic, meta_offset = self._decode_string(metadata_bin, meta_offset)
+        created_at = metadata_bin[meta_offset:meta_offset+27].decode('ascii').strip('\0')
+
+        metadata = {
+            "knowledge_id": knowledge_id,
+            "topic": topic,
+            "created_at": created_at
+        }
+
+        # 座標
+        coord_len = struct.unpack("<I", uncompressed[offset:offset+4])[0]
+        offset += 4
+        coord_data = uncompressed[offset:offset+coord_len]
+        offset += coord_len
+
+        x, y, z, c, g, v = struct.unpack("<ffffff", coord_data)
+        coordinates = {
+            "medical_space": [x, y, z],
+            "meta_space": [c, g, v]
+        }
+
+        # コンテンツ
+        content_len = struct.unpack("<I", uncompressed[offset:offset+4])[0]
+        offset += 4
+        content_data = uncompressed[offset:offset+content_len]
+        offset += content_len
+
+        # thinking_process
+        thinking_len = struct.unpack("<I", content_data[0:4])[0]
+        thinking = content_data[4:4+thinking_len].decode('utf-8')
+
+        # final_response
+        response_offset = 4 + thinking_len
+        response_len = struct.unpack("<I", content_data[response_offset:response_offset+4])[0]
+        response = content_data[response_offset+4:response_offset+4+response_len].decode('utf-8')
+
+        content = {
+            "thinking_process": thinking,
+            "final_response": response
+        }
+
+        # 検証（簡易実装）
+        verification_len = struct.unpack("<I", uncompressed[offset:offset+4])[0]
+        offset += 4
+        verification_data = uncompressed[offset:offset+verification_len]
+
+        status_code, initial_certainty, reviewer_count = struct.unpack("<BBI", verification_data[:6])
+        status_map = {0: "pending_review", 1: "partial_verified", 2: "verified", 3: "expert_confirmed"}
+
+        verification = {
+            "status": status_map.get(status_code, "pending_review"),
+            "initial_certainty": initial_certainty / 100.0,
+            "reviewers": []  # 詳細は省略
+        }
+
+        return {
+            "metadata": metadata,
+            "coordinates": coordinates,
+            "content": content,
+            "verification": verification
+        }
+
+    def get_tile_by_id(self, knowledge_id: str) -> Optional[dict]:
+        """IDで特定のタイルを取得"""
+        try:
+            # インデックスから検索
+            index_entry = next((entry for entry in self.index if entry["id"] == knowledge_id), None)
+            if not index_entry:
+                return None
+
+            # データセクションから読み込み
+            with open(self.file_path, 'rb') as f:
+                f.seek(self.data_section_offset + index_entry["offset"])
+                compressed_data = f.read(index_entry["length"])
+                return self._decode_tile_data(compressed_data)
+
+        except Exception as e:
+            logger.error(f"Error loading tile {knowledge_id}: {e}")
+            return None
+
+    def get_all_tiles(self) -> List[dict]:
+        """全タイルを取得（メモリに注意）"""
+        tiles = []
+        for entry in self.index:
+            tile = self.get_tile_by_id(entry["id"])
+            if tile:
+                tiles.append(tile)
+        return tiles
+
+
+class DendriticMemorySpace:
+    """
+    樹木型空間記憶システム
+
+    6次元座標系による知識の空間配置と検索：
+    - medical_space [x, y, z]: ドメイン固有の3次元空間
+    - meta_space [c, g, v]: Certainty, Granularity, Verification
+    """
+
+    def __init__(self, iath_file_path: str):
+        """
+        Args:
+            iath_file_path: .iathファイルのパス
+        """
+        self.decoder = IathDecoder(iath_file_path)
+        self.tiles_cache = []  # 全タイルをメモリにキャッシュ（最適化可能）
+        self._build_spatial_index()
+
+    def _build_spatial_index(self):
+        """空間インデックスを構築"""
+        logger.info("Building spatial index from .iath file...")
+        self.tiles_cache = self.decoder.get_all_tiles()
+
+        # 座標行列を構築（高速検索用）
+        if self.tiles_cache:
+            self.coordinates_matrix = np.array([
+                tile["coordinates"]["medical_space"] + tile["coordinates"]["meta_space"]
+                for tile in self.tiles_cache
+            ])
+            logger.info(f"Spatial index built: {len(self.tiles_cache)} tiles")
+        else:
+            self.coordinates_matrix = np.array([])
+            logger.warning("No tiles found in .iath file")
+
+    def search_by_coordinates(self, query_coords: List[float], top_k: int = 5, distance_threshold: float = None) -> List[dict]:
+        """
+        座標ベースの空間検索（樹木型空間記憶の核心機能）
+
+        Args:
+            query_coords: クエリ座標 [x, y, z, c, g, v]
+            top_k: 返却する上位K件
+            distance_threshold: 距離閾値（Noneなら無制限）
+
+        Returns:
+            関連するタイルのリスト（距離の近い順）
+        """
+        if len(self.tiles_cache) == 0:
+            return []
+
+        query_vector = np.array(query_coords)
+
+        # ユークリッド距離を計算
+        distances = np.linalg.norm(self.coordinates_matrix - query_vector, axis=1)
+
+        # 距離でソート
+        sorted_indices = np.argsort(distances)
+
+        # top_k件を取得
+        results = []
+        for idx in sorted_indices[:top_k]:
+            distance = distances[idx]
+            if distance_threshold is not None and distance > distance_threshold:
+                break
+
+            tile = self.tiles_cache[idx].copy()
+            tile["spatial_distance"] = float(distance)
+            results.append(tile)
+
+        return results
+
+    def search_by_text(self, query_text: str, top_k: int = 5) -> List[dict]:
+        """
+        テキスト検索（簡易実装：キーワードマッチング）
+
+        Args:
+            query_text: 検索クエリテキスト
+            top_k: 返却する上位K件
+
+        Returns:
+            関連するタイルのリスト
+        """
+        query_lower = query_text.lower()
+        matches = []
+
+        for tile in self.tiles_cache:
+            topic = tile["metadata"]["topic"].lower()
+            content = tile["content"]["final_response"].lower()
+
+            # シンプルなスコアリング（含まれる回数）
+            score = topic.count(query_lower) * 2 + content.count(query_lower)
+
+            if score > 0:
+                tile_copy = tile.copy()
+                tile_copy["text_match_score"] = score
+                matches.append(tile_copy)
+
+        # スコアでソート
+        matches.sort(key=lambda x: x["text_match_score"], reverse=True)
+
+        return matches[:top_k]
+
+    def hybrid_search(self, query_text: str, query_coords: Optional[List[float]] = None, top_k: int = 5) -> List[dict]:
+        """
+        ハイブリッド検索：テキスト + 空間座標
+
+        Args:
+            query_text: 検索クエリテキスト
+            query_coords: クエリ座標（オプション）
+            top_k: 返却する上位K件
+
+        Returns:
+            関連するタイルのリスト
+        """
+        # テキスト検索
+        text_results = self.search_by_text(query_text, top_k=top_k*2)
+
+        # 座標検索が指定されている場合
+        if query_coords:
+            spatial_results = self.search_by_coordinates(query_coords, top_k=top_k*2)
+
+            # 両方に出現するタイルを優先的にスコアリング
+            combined_scores = {}
+
+            for tile in text_results:
+                tile_id = tile["metadata"]["knowledge_id"]
+                combined_scores[tile_id] = {
+                    "tile": tile,
+                    "text_score": tile.get("text_match_score", 0),
+                    "spatial_score": 0
+                }
+
+            for tile in spatial_results:
+                tile_id = tile["metadata"]["knowledge_id"]
+                if tile_id in combined_scores:
+                    combined_scores[tile_id]["spatial_score"] = 1.0 / (1.0 + tile.get("spatial_distance", 10))
+                else:
+                    combined_scores[tile_id] = {
+                        "tile": tile,
+                        "text_score": 0,
+                        "spatial_score": 1.0 / (1.0 + tile.get("spatial_distance", 10))
+                    }
+
+            # 複合スコアで並び替え
+            ranked = sorted(
+                combined_scores.values(),
+                key=lambda x: x["text_score"] * 0.6 + x["spatial_score"] * 0.4,
+                reverse=True
+            )
+
+            return [item["tile"] for item in ranked[:top_k]]
+
+        else:
+            # テキスト検索のみ
+            return text_results[:top_k]
+
+    def get_statistics(self) -> dict:
+        """メモリ空間の統計情報を取得"""
+        if len(self.tiles_cache) == 0:
+            return {"total_tiles": 0}
+
+        coords = self.coordinates_matrix
+
+        return {
+            "total_tiles": len(self.tiles_cache),
+            "coordinate_ranges": {
+                "medical_x": {"min": float(coords[:, 0].min()), "max": float(coords[:, 0].max())},
+                "medical_y": {"min": float(coords[:, 1].min()), "max": float(coords[:, 1].max())},
+                "medical_z": {"min": float(coords[:, 2].min()), "max": float(coords[:, 2].max())},
+                "certainty": {"min": float(coords[:, 3].min()), "max": float(coords[:, 3].max())},
+                "granularity": {"min": float(coords[:, 4].min()), "max": float(coords[:, 4].max())},
+                "verification": {"min": float(coords[:, 5].min()), "max": float(coords[:, 5].max())}
+            },
+            "verification_status_distribution": self._get_verification_distribution()
+        }
+
+    def _get_verification_distribution(self) -> dict:
+        """検証ステータスの分布を取得"""
+        distribution = {}
+        for tile in self.tiles_cache:
+            status = tile["verification"]["status"]
+            distribution[status] = distribution.get(status, 0) + 1
+        return distribution

iath_writer.py

@@ -0,0 +1,453 @@
+# null_ai/iath_writer.py
+"""
+.iath File Writer Module
+
+AI生成知識を.iath形式で保存するためのモジュール。
+dendritic-memory-editor完全互換。
+"""
+
+import struct
+import zstandard as zstd
+from datetime import datetime
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+import uuid
+
+from null_ai.iath_memory import IathDecoder
+
+logger = logging.getLogger(__name__)
+
+
+class IathWriter:
+    """
+    .iathファイルへの書き込みを管理するクラス
+    """
+
+    def __init__(self, iath_file_path: str):
+        self.file_path = Path(iath_file_path)
+        self.encoder = IathTileEncoder()
+
+    def append_tile(self, tile: Dict[str, Any]) -> bool:
+        """
+        既存の.iathファイルに新しいタイルを追記
+
+        Args:
+            tile: Knowledge Tile オブジェクト
+
+        Returns:
+            成功したかどうか
+        """
+        try:
+            # 既存ファイルが存在するか確認
+            if not self.file_path.exists():
+                # 新規ファイル作成
+                return self._create_new_iath_file([tile])
+
+            # 既存ファイルの読み込み
+            decoder = IathDecoder(str(self.file_path))
+            existing_tiles = decoder.get_all_tiles()
+
+            # 新しいタイルを追加
+            existing_tiles.append(tile)
+
+            # ファイルを再構築
+            return self._rebuild_iath_file(existing_tiles)
+
+        except Exception as e:
+            logger.error(f"Failed to append tile to .iath: {e}")
+            return False
+
+    def append_tiles_batch(self, tiles: List[Dict[str, Any]]) -> bool:
+        """
+        複数のタイルを一括追記
+
+        Args:
+            tiles: Knowledge Tile のリスト
+
+        Returns:
+            成功したかどうか
+        """
+        try:
+            if not self.file_path.exists():
+                return self._create_new_iath_file(tiles)
+
+            decoder = IathDecoder(str(self.file_path))
+            existing_tiles = decoder.get_all_tiles()
+
+            # 新しいタイルを追加
+            existing_tiles.extend(tiles)
+
+            # ファイルを再構築
+            return self._rebuild_iath_file(existing_tiles)
+
+        except Exception as e:
+            logger.error(f"Failed to append tiles batch to .iath: {e}")
+            return False
+
+    def _create_new_iath_file(self, tiles: List[Dict[str, Any]]) -> bool:
+        """
+        新規.iathファイルを作成
+        """
+        try:
+            with open(self.file_path, 'wb') as f:
+                # Header作成
+                header = self._create_header(len(tiles))
+                f.write(header)
+
+                # Index作成
+                index_data, tiles_data = self._create_index_and_data(tiles)
+                index_json = json.dumps(index_data, ensure_ascii=False).encode('utf-8')
+
+                # Indexサイズを書き込み
+                f.write(struct.pack('<I', len(index_json)))
+                f.write(index_json)
+
+                # Dataセクション書き込み
+                f.write(tiles_data)
+
+            logger.info(f"Created new .iath file: {self.file_path}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to create new .iath file: {e}")
+            return False
+
+    def _rebuild_iath_file(self, tiles: List[Dict[str, Any]]) -> bool:
+        """
+        .iathファイルを再構築
+        """
+        # 一時ファイルに書き込み
+        temp_path = self.file_path.with_suffix('.iath.tmp')
+
+        try:
+            with open(temp_path, 'wb') as f:
+                # Header作成
+                header = self._create_header(len(tiles))
+                f.write(header)
+
+                # Index作成
+                index_data, tiles_data = self._create_index_and_data(tiles)
+                index_json = json.dumps(index_data, ensure_ascii=False).encode('utf-8')
+
+                # Indexサイズを書き込み
+                f.write(struct.pack('<I', len(index_json)))
+                f.write(index_json)
+
+                # Dataセクション書き込み
+                f.write(tiles_data)
+
+            # 一時ファイルを本ファイルに置き換え
+            temp_path.replace(self.file_path)
+
+            logger.info(f"Rebuilt .iath file with {len(tiles)} tiles: {self.file_path}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to rebuild .iath file: {e}")
+            if temp_path.exists():
+                temp_path.unlink()
+            return False
+
+    def _create_header(self, tile_count: int) -> bytes:
+        """
+        .iathヘッダーを作成（64バイト）
+        """
+        # マジックナンバー: "IATH" (4 bytes)
+        magic = b'IATH'
+
+        # バージョン: 1.0 (2 bytes)
+        version_major = 1
+        version_minor = 0
+
+        # タイル数 (4 bytes)
+        # 作成日時 (8 bytes, Unix timestamp)
+        created_at = int(datetime.now().timestamp())
+
+        # 予約領域 (46 bytes)
+        reserved = b'\x00' * 46
+
+        header = struct.pack(
+            '<4s 2B I Q 46s',
+            magic,
+            version_major,
+            version_minor,
+            tile_count,
+            created_at,
+            reserved
+        )
+
+        assert len(header) == 64, f"Header size must be 64 bytes, got {len(header)}"
+        return header
+
+    def _create_index_and_data(self, tiles: List[Dict[str, Any]]) -> tuple:
+        """
+        インデックスとデータセクションを作成
+
+        Returns:
+            (index_dict, data_bytes)
+        """
+        index = {"tiles": []}
+        data_buffer = bytearray()
+
+        current_offset = 0
+
+        for tile in tiles:
+            # タイルをエンコード
+            tile_bytes = self.encoder.encode_tile(tile)
+
+            # インデックスエントリ作成
+            index["tiles"].append({
+                "id": tile["metadata"]["knowledge_id"],
+                "offset": current_offset,
+                "size": len(tile_bytes)
+            })
+
+            # データバッファに追加
+            data_buffer.extend(tile_bytes)
+            current_offset += len(tile_bytes)
+
+        return index, bytes(data_buffer)
+
+
+class IathTileEncoder:
+    """
+    Knowledge Tileを.iath互換のバイナリ形式にエンコード
+
+    dendritic-memory-editorのIathEncoderと互換性あり
+    """
+
+    def encode_tile(self, tile: Dict[str, Any]) -> bytes:
+        """
+        単一のKnowledge Tileをエンコードし、zstdで圧縮
+
+        Args:
+            tile: Knowledge Tile オブジェクト
+
+        Returns:
+            圧縮されたバイナリデータ
+        """
+        # 各セクションをエンコード
+        metadata_bin = self._encode_metadata(tile["metadata"])
+        coord_bin = self._encode_coordinates(tile["coordinates"])
+        content_bin = self._encode_content(tile["content"])
+        verification_bin = self._encode_verification(tile["verification"])
+
+        # 長さプレフィックスを付けて連結
+        uncompressed = b"".join([
+            struct.pack("<I", len(metadata_bin)), metadata_bin,
+            struct.pack("<I", len(coord_bin)), coord_bin,
+            struct.pack("<I", len(content_bin)), content_bin,
+            struct.pack("<I", len(verification_bin)), verification_bin,
+        ])
+
+        # zstdで圧縮（レベル19 = 最高圧縮率）
+        cctx = zstd.ZstdCompressor(level=19)
+        compressed = cctx.compress(uncompressed)
+
+        return compressed
+
+    def _encode_metadata(self, metadata: Dict[str, Any]) -> bytes:
+        """メタデータをバイナリ化"""
+        kid = self._encode_string(metadata["knowledge_id"])
+        topic = self._encode_string(metadata["topic"])
+
+        # 作成日時（ISO形式）
+        created_at_iso = metadata.get("created_at", datetime.now().isoformat())
+        created_at = created_at_iso.encode('ascii')[:27]  # ISO format with Z
+
+        return kid + topic + created_at
+
+    def _encode_coordinates(self, coordinates: Dict[str, Any]) -> bytes:
+        """
+        座標をバイナリ化（6つの浮動小数点数）
+
+        座標は以下のいずれかの形式を受け付ける:
+        1. {"medical_space": [x, y, z], "meta_space": [c, g, v]}
+        2. [x, y, z, c, g, v]
+        """
+        if isinstance(coordinates, dict):
+            medical_space = coordinates["medical_space"]
+            meta_space = coordinates["meta_space"]
+
+            return struct.pack(
+                "<ffffff",
+                float(medical_space[0]), float(medical_space[1]), float(medical_space[2]),
+                float(meta_space[0]), float(meta_space[1]), float(meta_space[2])
+            )
+        elif isinstance(coordinates, list) and len(coordinates) == 6:
+            # フラットな配列形式
+            return struct.pack(
+                "<ffffff",
+                float(coordinates[0]), float(coordinates[1]), float(coordinates[2]),
+                float(coordinates[3]), float(coordinates[4]), float(coordinates[5])
+            )
+        else:
+            raise ValueError(f"Invalid coordinates format: {coordinates}")
+
+    def _encode_content(self, content: Dict[str, Any]) -> bytes:
+        """コンテンツ（テキスト）をバイナリ化"""
+        thinking = content.get("thinking_process", "").encode('utf-8')
+        response = content.get("final_response", "").encode('utf-8')
+
+        # 各パートの長さを前に付けて連結
+        result = struct.pack("<I", len(thinking)) + thinking
+        result += struct.pack("<I", len(response)) + response
+
+        return result
+
+    def _encode_verification(self, verification: Dict[str, Any]) -> bytes:
+        """検証履歴をバイナリ化"""
+        status_map = {
+            "pending_review": 0,
+            "partial_verified": 1,
+            "verified": 2,
+            "expert_confirmed": 3
+        }
+        status_code = status_map.get(verification.get("status", "pending_review"), 0)
+
+        initial_certainty = int(verification.get("initial_certainty", 0) * 100)  # 0-100に変換
+        reviewer_count = len(verification.get("reviewers", []))
+
+        result = struct.pack("<BBI", status_code, initial_certainty, reviewer_count)
+
+        # レビュアー情報
+        for reviewer in verification.get("reviewers", []):
+            result += self._encode_reviewer_reference(reviewer)
+
+        return result
+
+    def _encode_reviewer_reference(self, reviewer: Dict[str, Any]) -> bytes:
+        """レビュアー情報をエンコード"""
+        reviewer_id = reviewer.get("reviewer_id", "unknown").encode('utf-8')
+        return struct.pack("<36s", reviewer_id[:36])  # UUID string length
+
+    def _encode_string(self, s: str) -> bytes:
+        """NULL終端のUTF-8文字列をエンコード"""
+        return s.encode('utf-8') + b'\0'
+
+
+def create_tile_from_ai_output(
+    knowledge_id: str,
+    topic: str,
+    prompt: str,
+    response: str,
+    coordinates: List[float],
+    confidence: float,
+    domain_id: str,
+    source: str = "ai_generated"
+) -> Dict[str, Any]:
+    """
+    AI出力からKnowledge Tileオブジェクトを作成
+
+    Args:
+        knowledge_id: 知識ID（UUID推奨）
+        topic: トピック
+        prompt: ユーザーの質問
+        response: AIの回答
+        coordinates: 6次元座標 [x, y, z, c, g, v]
+        confidence: 信頼度 (0.0-1.0)
+        domain_id: ドメインID
+        source: ソース（"ai_generated", "human_verified", etc.）
+
+    Returns:
+        Knowledge Tile オブジェクト
+    """
+    if len(coordinates) != 6:
+        raise ValueError(f"Coordinates must be 6-dimensional, got {len(coordinates)}")
+
+    # 検証ステータスの決定
+    if confidence >= 0.9:
+        status = "expert_confirmed"
+    elif confidence >= 0.8:
+        status = "verified"
+    elif confidence >= 0.7:
+        status = "partial_verified"
+    else:
+        status = "pending_review"
+
+    tile = {
+        "metadata": {
+            "knowledge_id": knowledge_id,
+            "topic": topic,
+            "created_at": datetime.now().isoformat(),
+            "domain_id": domain_id,
+            "source": source
+        },
+        "coordinates": {
+            "medical_space": coordinates[:3],
+            "meta_space": coordinates[3:]
+        },
+        "content": {
+            "thinking_process": f"Question: {prompt}",
+            "final_response": response
+        },
+        "verification": {
+            "status": status,
+            "initial_certainty": confidence,
+            "reviewers": []
+        }
+    }
+
+    return tile
+
+
+def merge_jsonl_to_iath(
+    jsonl_path: str,
+    iath_path: str,
+    coordinate_estimator,
+    llm_inference_func
+) -> int:
+    """
+    JSONLファイルの訓練データを.iath形式に変換して追記
+
+    Args:
+        jsonl_path: Alpaca形式のJSONLファイルパス
+        iath_path: 出力先.iathファイルパス
+        coordinate_estimator: CoordinateEstimatorインスタンス
+        llm_inference_func: LLM推論関数
+
+    Returns:
+        変換したタイル数
+    """
+    import asyncio
+
+    writer = IathWriter(iath_path)
+    tiles_created = 0
+
+    with open(jsonl_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            try:
+                example = json.loads(line.strip())
+
+                # 座標推定
+                coord_result = asyncio.run(coordinate_estimator.estimate_coordinates(
+                    prompt=example["input"],
+                    response=example["output"],
+                    domain_id=example["metadata"]["domain_id"],
+                    llm_inference_func=llm_inference_func
+                ))
+
+                # Tileオブジェクト作成
+                tile = create_tile_from_ai_output(
+                    knowledge_id=str(uuid.uuid4()),
+                    topic=example["input"][:100],  # 最初の100文字をトピックに
+                    prompt=example["input"],
+                    response=example["output"],
+                    coordinates=coord_result["coordinates"],
+                    confidence=example["metadata"]["confidence"],
+                    domain_id=example["metadata"]["domain_id"],
+                    source="master_output"
+                )
+
+                # .iathに追記
+                writer.append_tile(tile)
+                tiles_created += 1
+
+            except Exception as e:
+                logger.error(f"Failed to convert line to tile: {e}")
+                continue
+
+    logger.info(f"Merged {tiles_created} tiles from {jsonl_path} to {iath_path}")
+    return tiles_created

llm_providers.py

@@ -0,0 +1,434 @@
+# null_ai/llm_providers.py
+import logging
+import asyncio
+import time
+import threading # For TextIteratorStreamer
+from typing import Dict, Any, AsyncGenerator, Optional
+
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+import torch
+
+from backend.app.config import ModelConfig, ModelProvider # ModelConfigを使用
+
+logger = logging.getLogger(__name__)
+
+# --- HuggingFace Transformers Provider ---
+class HuggingFaceProvider:
+    """
+    HuggingFace Transformersモデルとのインタラクションを管理するクラス。
+    """
+    _loaded_models: Dict[str, Any] = {} # {model_name: {"model": model, "tokenizer": tokenizer}}
+
+    async def _load_model_and_tokenizer(self, model_name: str) -> Dict[str, Any]:
+        """
+        HuggingFaceモデルとトークナイザーをロード（キャッシュ）する。
+        """
+        if model_name in self._loaded_models:
+            return self._loaded_models[model_name]
+
+        logger.info(f"Loading HuggingFace model: {model_name}...")
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+            model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16, # 高速化のためfloat16を使用
+                device_map="auto",         # 利用可能なデバイスに自動マップ
+                trust_remote_code=True
+            )
+            self._loaded_models[model_name] = {"model": model, "tokenizer": tokenizer}
+            logger.info(f"HuggingFace model '{model_name}' loaded successfully.")
+            return self._loaded_models[model_name]
+        except Exception as e:
+            logger.error(f"Failed to load HuggingFace model '{model_name}': {e}")
+            raise
+
+    async def infer(self, model_config: ModelConfig, prompt: str, temperature: float) -> Dict[str, Any]:
+        """
+        HuggingFaceモデルで非ストリーミング推論を実行する。
+        """
+        model_data = await self._load_model_and_tokenizer(model_config.model_name)
+        model = model_data["model"]
+        tokenizer = model_data["tokenizer"]
+
+        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+        
+        start_time = time.perf_counter()
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=model_config.max_tokens,
+            temperature=temperature,
+            do_sample=temperature > 0,
+            pad_token_id=tokenizer.eos_token_id # ストリーミングでない場合は必須ではないが、安全のため
+        )
+        end_time = time.perf_counter()
+        
+        response_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        latency_ms = (end_time - start_time) * 1000
+
+        # ここでは推論チェーンの抽出や確信度計算は行わない (ModelRouterの役割)
+        return {
+            "response": response_text,
+            "thinking": f"Inferred by {model_config.display_name} (HuggingFace).",
+            "confidence": 0.8, # 仮の値
+            "latency_ms": latency_ms
+        }
+
+    async def infer_streaming(self, model_config: ModelConfig, prompt: str, temperature: float) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        HuggingFaceモデルでストリーミング推論を実行する。
+        """
+        model_data = await self._load_model_and_tokenizer(model_config.model_name)
+        model = model_data["model"]
+        tokenizer = model_data["tokenizer"]
+
+        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+        
+        # TextIteratorStreamerを使用
+        streamer = TextIteratorStreamer(
+            tokenizer,
+            skip_prompt=True,
+            skip_special_tokens=True
+        )
+
+        generation_kwargs = {
+            **inputs,
+            "max_new_tokens": model_config.max_tokens,
+            "temperature": temperature,
+            "do_sample": temperature > 0,
+            "streamer": streamer,
+            "pad_token_id": tokenizer.eos_token_id
+        }
+
+        # 別スレッドで生成を実行
+        # Streamerはスレッドセーフではないため、生成は別スレッドで行う
+        # そしてメインスレッドからStreamerをポーリングする
+        thread = threading.Thread(target=model.generate, kwargs=generation_kwargs)
+        thread.start()
+
+        generated_text = ""
+        start_time = time.perf_counter()
+
+        yield {"type": "thinking", "content": f"Loading model: {model_config.display_name}..."}
+        
+        for new_token in streamer:
+            generated_text += new_token
+            yield {"type": "token", "content": new_token}
+            
+        thread.join() # 生成が完了するのを待つ
+        end_time = time.perf_counter()
+
+        latency_ms = (end_time - start_time) * 1000
+
+        yield {"type": "complete", "content": generated_text}
+        yield {"type": "meta", 
+               "confidence": 0.8, # 仮の値
+               "thinking": f"Inferred by {model_config.display_name} (HuggingFace).",
+               "latency_ms": latency_ms
+            }
+
+# --- Ollama Provider ---
+class OllamaProvider:
+    _ollama_client: Any = None # ollamaクライアントは遅延ロード
+    _loaded_models: Dict[str, bool] = {} # {model_name: is_loaded}
+
+    async def _get_ollama_client(self, api_url: Optional[str]) -> Any:
+        try:
+            from ollama import AsyncClient
+            if api_url and api_url != "http://localhost:11434": # デフォルト以外
+                return AsyncClient(host=api_url)
+            return AsyncClient() # デフォルトクライアント
+        except ImportError:
+            logger.error("Ollama library not installed. Please `pip install ollama`.")
+            raise
+
+    async def _ensure_model_available(self, model_name: str, api_url: Optional[str]):
+        if self._loaded_models.get(model_name):
+            return
+
+        client = await self._get_ollama_client(api_url)
+        logger.info(f"Checking Ollama model: {model_name}...")
+        try:
+            models = await client.list()
+            if not any(m['name'] == model_name for m in models['models']):
+                logger.info(f"Ollama model '{model_name}' not found locally. Pulling...")
+                await client.pull(model_name)
+            self._loaded_models[model_name] = True
+            logger.info(f"Ollama model '{model_name}' is available.")
+        except Exception as e:
+            logger.error(f"Failed to ensure Ollama model '{model_name}' availability: {e}")
+            raise
+
+    async def infer(self, model_config: ModelConfig, prompt: str, temperature: float) -> Dict[str, Any]:
+        """
+        Ollamaモデルで非ストリーミング推論を実行する。
+        """
+        await self._ensure_model_available(model_config.model_name, model_config.api_url)
+        client = await self._get_ollama_client(model_config.api_url)
+
+        start_time = time.perf_counter()
+        response = await client.generate(
+            model=model_config.model_name,
+            prompt=prompt,
+            temperature=temperature,
+            options={'num_predict': model_config.max_tokens}
+        )
+        end_time = time.perf_counter()
+
+        response_text = response.get('response', '').strip()
+        
+        # If the model returns an empty string for a question generation prompt,
+        # default to an empty JSON array to prevent parsing errors downstream.
+        if not response_text and "Return ONLY a JSON array of questions" in prompt:
+            logger.warning("Ollama model returned an empty response for question generation. Defaulting to an empty list.")
+            response_text = "[]"
+            
+        latency_ms = (end_time - start_time) * 1000
+
+        return {
+            "response": response_text,
+            "thinking": f"Inferred by {model_config.display_name} (Ollama).",
+            "confidence": 0.85, # 仮の値
+            "latency_ms": latency_ms
+        }
+
+    async def infer_streaming(self, model_config: ModelConfig, prompt: str, temperature: float) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Ollamaモデルでストリーミング推論を実行する。
+        """
+        await self._ensure_model_available(model_config.model_name, model_config.api_url)
+        client = await self._get_ollama_client(model_config.api_url)
+
+        start_time = time.perf_counter()
+        generated_text = ""
+
+        yield {"type": "thinking", "content": f"Ensuring Ollama model '{model_config.model_name}' is available..."}
+        
+        async for chunk in await client.generate(
+            model=model_config.model_name,
+            prompt=prompt,
+            temperature=temperature,
+            options={'num_predict': model_config.max_tokens},
+            stream=True
+        ):
+            if 'response' in chunk:
+                generated_text += chunk['response']
+                yield {"type": "token", "content": chunk['response']}
+        
+        end_time = time.perf_counter()
+        latency_ms = (end_time - start_time) * 1000
+
+        yield {"type": "complete", "content": generated_text}
+        yield {"type": "meta", 
+               "confidence": 0.85, # 仮の値
+               "thinking": f"Inferred by {model_config.display_name} (Ollama).",
+               "latency_ms": latency_ms
+            }
+
+# --- MLX Provider (Apple Silicon) ---
+class MLXProvider:
+    _loaded_models: Dict[str, Any] = {}
+
+    async def _load_model_and_tokenizer(self, model_name: str) -> Dict[str, Any]:
+        """
+        MLXモデルとトークナイザーをロード（キャッシュ）する。
+        """
+        if model_name in self._loaded_models:
+            return self._loaded_models[model_name]
+        
+        try:
+            import mlx.core as mx
+            from mlx_lm import load, generate
+
+            # MLXはデバイスを自動的に使用
+            logger.info(f"Loading MLX model: {model_name}...")
+            model, tokenizer = load(model_name)
+            self._loaded_models[model_name] = {"model": model, "tokenizer": tokenizer}
+            logger.info(f"MLX model '{model_name}' loaded successfully.")
+            return self._loaded_models[model_name]
+        except ImportError:
+            logger.error("MLX library not installed. Please `pip install mlx-lm mlx`.")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to load MLX model '{model_name}': {e}")
+            raise
+
+    async def infer(self, model_config: ModelConfig, prompt: str, temperature: float) -> Dict[str, Any]:
+        """
+        MLXモデルで非ストリーミング推論を実行する。
+        """
+        model_data = await self._load_model_and_tokenizer(model_config.model_name)
+        model = model_data["model"]
+        tokenizer = model_data["tokenizer"]
+        
+        start_time = time.perf_counter()
+        # MLX-LMのgenerateはストリーミングではない
+        response_text = await asyncio.to_thread(
+            lambda: generate(
+                model, tokenizer, prompt=prompt, max_tokens=model_config.max_tokens, temp=temperature
+            )
+        )
+        end_time = time.perf_counter()
+
+        latency_ms = (end_time - start_time) * 1000
+
+        return {
+            "response": response_text,
+            "thinking": f"Inferred by {model_config.display_name} (MLX).",
+            "confidence": 0.9, # 仮の値
+            "latency_ms": latency_ms
+        }
+
+    async def infer_streaming(self, model_config: ModelConfig, prompt: str, temperature: float) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        MLXモデルでストリーミング推論を実行する。
+        mlx-lmは直接ストリーミングをサポートしていないため、非ストリーミングの結果をチャンクに分割してストリーミングを模倣する。
+        """
+        yield {"type": "thinking", "content": f"Loading MLX model: {model_config.display_name}..."}
+        response_data = await self.infer(model_config, prompt, temperature)
+        response_text = response_data["response"]
+        
+        # 結果をワード単位でストリーミングとして模倣
+        for word in response_text.split():
+            yield {"type": "token", "content": word + " "}
+            await asyncio.sleep(0.05) # ダミーのストリーミング遅延
+
+        yield {"type": "complete", "content": response_text}
+        yield {"type": "meta",
+               "confidence": response_data["confidence"],
+               "thinking": response_data["thinking"],
+               "latency_ms": response_data["latency_ms"]
+            }
+
+# --- GGUF Provider (llama-cpp-python) ---
+class GGUFProvider:
+    _loaded_models: Dict[str, Any] = {} # {file_path: Llama object}
+
+    async def _load_model(self, model_file_path: str) -> Any:
+        """
+        GGUFモデルをロード（キャッシュ）する。
+        """
+        if model_file_path in self._loaded_models:
+            return self._loaded_models[model_file_path]
+        
+        try:
+            from llama_cpp import Llama
+            logger.info(f"Loading GGUF model from: {model_file_path}...")
+            # n_gpu_layers=-1 はGPUが利用可能な場合に全レイヤーをGPUにオフロードする
+            # n_ctxはコンテキストサイズ
+            llm = Llama(model_path=model_file_path, n_gpu_layers=-1, n_ctx=4096)
+            self._loaded_models[model_file_path] = llm
+            logger.info(f"GGUF model '{model_file_path}' loaded successfully.")
+            return llm
+        except ImportError:
+            logger.error("llama-cpp-python not installed. Please `pip install llama-cpp-python`.")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to load GGUF model '{model_file_path}': {e}")
+            raise
+
+    async def infer(self, model_config: ModelConfig, prompt: str, temperature: float) -> Dict[str, Any]:
+        """
+        GGUFモデルで非ストリーミング推論を実行する。
+        """
+        if not model_config.model_name or not model_config.model_name.endswith('.gguf'):
+            raise ValueError(f"GGUF provider requires 'model_name' to be a valid .gguf file path, but got '{model_config.model_name}'")
+
+        llm = await self._load_model(model_config.model_name) # model_nameがファイルパス
+
+        # Format prompt with Phi-4 chat template
+        formatted_prompt = f"""<|im_start|>system
+You are a helpful AI assistant.<|im_end|>
+<|im_start|>user
+{prompt}<|im_end|>
+<|im_start|>assistant
+"""
+
+        start_time = time.perf_counter()
+        logger.info(f"Calling GGUF model with prompt length: {len(prompt)} (formatted: {len(formatted_prompt)})")
+        logger.debug(f"Formatted prompt preview: {formatted_prompt[:300]}...")
+
+        output = llm(
+            formatted_prompt,
+            max_tokens=model_config.max_tokens,
+            temperature=temperature,
+            stop=["<|im_end|>", "<|endoftext|>"],  # Phi-4 stop tokens
+            echo=False
+        )
+        end_time = time.perf_counter()
+
+        logger.debug(f"GGUF model output structure: {list(output.keys()) if isinstance(output, dict) else type(output)}")
+
+        response_text = ""
+        if "choices" in output and len(output["choices"]) > 0:
+            choice = output["choices"][0]
+            logger.debug(f"Choice structure: {list(choice.keys()) if isinstance(choice, dict) else type(choice)}")
+            if "text" in choice:
+                response_text = choice["text"].strip()
+                logger.info(f"Extracted response text length: {len(response_text)}")
+        else:
+            logger.warning(f"No choices in output or choices is empty. Output: {output}")
+
+        # If the model returns an empty string for a question generation prompt,
+        # default to an empty JSON array to prevent parsing errors downstream.
+        if not response_text and "Return ONLY a JSON array of questions" in prompt:
+            logger.warning("GGUF model returned an empty response for question generation. Defaulting to an empty list.")
+            response_text = "[]"
+        elif not response_text:
+            logger.error(f"GGUF model returned empty response. Prompt preview: {prompt[:200]}")
+            
+        latency_ms = (end_time - start_time) * 1000
+
+        return {
+            "response": response_text,
+            "thinking": f"Inferred by {model_config.display_name} (GGUF via llama-cpp-python).",
+            "confidence": 0.92, # 仮の値
+            "latency_ms": latency_ms
+        }
+
+    async def infer_streaming(self, model_config: ModelConfig, prompt: str, temperature: float) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        GGUFモデルでストリーミング推論を実行する。
+        """
+        if not model_config.model_name or not model_config.model_name.endswith('.gguf'):
+            raise ValueError(f"GGUF provider requires 'model_name' to be a valid .gguf file path, but got '{model_config.model_name}'")
+
+        llm = await self._load_model(model_config.model_name)
+
+        # Format prompt with Phi-4 chat template
+        formatted_prompt = f"""<|im_start|>system
+You are a helpful AI assistant.<|im_end|>
+<|im_start|>user
+{prompt}<|im_end|>
+<|im_start|>assistant
+"""
+
+        start_time = time.perf_counter()
+        generated_text = ""
+
+        yield {"type": "thinking", "content": f"Loading GGUF model: {model_config.display_name}..."}
+
+        # llama_cppのcreate_completionはストリーミング可能
+        for chunk in llm(
+            formatted_prompt,
+            max_tokens=model_config.max_tokens,
+            temperature=temperature,
+            stop=["<|im_end|>", "<|endoftext|>"],  # Phi-4 stop tokens
+            echo=False,
+            stream=True
+        ):
+            token = chunk["choices"][0]["text"]
+            if token:
+                generated_text += token
+                yield {"type": "token", "content": token}
+        
+        end_time = time.perf_counter()
+        latency_ms = (end_time - start_time) * 1000
+
+        yield {"type": "complete", "content": generated_text}
+        yield {"type": "meta", 
+               "confidence": 0.92, # 仮の値
+               "thinking": f"Inferred by {model_config.display_name} (GGUF via llama-cpp-python).",
+               "latency_ms": latency_ms
+            }
+
+    # TODO: OllamaProvider, MLXProvider, GGUFProvider を実装

model_router.py

@@ -0,0 +1,828 @@
+import logging
+from typing import Optional, Dict, Any, AsyncGenerator, List
+import asyncio
+import time
+import threading # For TextIteratorStreamer
+import uuid # For generating unique IDs
+import os
+
+from backend.app.config import ConfigManager, ModelConfig, ModelProvider
+# SessionLocal は循環インポートを避けるため遅延インポート
+from backend.app.services.knowledge_service import KnowledgeService, get_knowledge_service
+from null_ai.llm_providers import HuggingFaceProvider, OllamaProvider, MLXProvider, GGUFProvider # Import all providers
+from null_ai.iath_memory import DendriticMemorySpace  # 樹木型空間記憶
+from null_ai.coordinate_estimator import CoordinateEstimator  # 座標自動推定
+from null_ai.iath_writer import IathWriter, create_tile_from_ai_output  # .iath保存
+
+logger = logging.getLogger(__name__)
+
+class ModelRouter:
+    """
+    推論エンジン間でモデルのルーティングと切り替えを管理するクラス。
+    師匠（Master）モデルと弟子（Apprentice）モデルの状態を保持する。
+    """
+    _instance: Optional['ModelRouter'] = None
+    _initialized = False
+
+    def __new__(cls, config_manager: ConfigManager):
+        if cls._instance == None:
+            cls._instance = super(ModelRouter, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_manager: ConfigManager):
+        if self._initialized:
+            return
+
+        self.config_manager = config_manager
+        self.knowledge_service = get_knowledge_service() # Instantiate KnowledgeService internally
+        self.master_model: Optional[ModelConfig] = None
+        self.apprentice_model: Optional[ModelConfig] = None
+        self.active_domain_id: Optional[str] = None # Active domain managed by ConfigManager
+        self.managed_engines: Dict[str, Dict[str, Any]] = {} # Tracks all engines and their status
+
+        # 樹木型空間記憶（.iathファイル）の初期化
+        self.dendritic_memory: Optional[DendriticMemorySpace] = None
+        self._load_dendritic_memory()
+
+        # 座標自動推定器の初期化
+        self.coordinate_estimator = CoordinateEstimator()
+
+        # .iathライターの初期化
+        iath_file_path = os.getenv("IATH_DB_PATH", "knowledge_base.iath")
+        self.iath_writer = IathWriter(iath_file_path)
+
+        # LLMプロバイダーを初期化
+        self.providers: Dict[ModelProvider, Any] = {
+            ModelProvider.HUGGINGFACE: HuggingFaceProvider(),
+            ModelProvider.OLLAMA: OllamaProvider(),
+            ModelProvider.MLX: MLXProvider(),
+            ModelProvider.GGUF: GGUFProvider(),
+        }
+
+        # 初期ロード時にデフォルトモデルを設定
+        self._load_all_engines() # Load all configured models into managed_engines
+        self._load_default_models() # This will now also try to load active master/apprentice from config
+
+        self._initialized = True
+        logger.info("ModelRouter initialized.")
+
+    def _load_dendritic_memory(self):
+        """樹木型空間記憶（.iathファイル）をロードする"""
+        try:
+            # TODO: ドメインごとに異なる.iathファイルを使用する
+            # 現在はデフォルトのパスを使用
+            import os
+            iath_file_path = os.getenv("IATH_DB_PATH", "knowledge_base.iath")
+
+            if os.path.exists(iath_file_path):
+                self.dendritic_memory = DendriticMemorySpace(iath_file_path)
+                stats = self.dendritic_memory.get_statistics()
+                logger.info(f"Dendritic memory loaded: {stats['total_tiles']} tiles from {iath_file_path}")
+            else:
+                logger.warning(f".iath file not found: {iath_file_path}. Starting with empty memory.")
+                self.dendritic_memory = None
+        except Exception as e:
+            logger.error(f"Failed to load dendritic memory: {e}")
+            self.dendritic_memory = None
+
+    def _get_any_available_model(self) -> Optional[ModelConfig]:
+        """
+        利用可能なモデルを1つ取得する（座標推定などで使用）
+
+        優先順位:
+        1. 師匠モデル
+        2. 設定された最初のモデル
+
+        Returns:
+            ModelConfig or None
+        """
+        if self.master_model:
+            return self.master_model
+
+        # 設定から最初のモデルを取得
+        for model_id, model_config in self.config_manager.models.items():
+            return model_config
+
+        return None
+
+    def _load_all_engines(self):
+        """設定ファイルから全てのモデルをロードし、managed_enginesを初期化する"""
+        self.managed_engines = {}
+        for model_id, model_config in self.config_manager.models.items():
+            self.managed_engines[model_id] = {
+                "config": model_config.dict(),
+                "status": "available", # Default status
+                "unique_id": None # Only for apprentices
+            }
+        logger.info(f"Loaded {len(self.managed_engines)} engines into management.")
+
+    def _update_engine_status(self, model_id: str, status: str, unique_id: Optional[str] = None):
+        """managed_engines内のエンジンのステータスを更新するヘルパー"""
+        if model_id in self.managed_engines:
+            self.managed_engines[model_id]["status"] = status
+            self.managed_engines[model_id]["unique_id"] = unique_id
+        else:
+            logger.warning(f"Attempted to update status for unknown engine: {model_id}")
+
+    def _load_default_models(self):
+        """設定からデフォルトの師匠モデルと弟子モデルをロードする"""
+        self.active_domain_id = self.config_manager.get_active_domain_id()
+
+        # ConfigManagerから永続化されたアクティブな師匠・弟子モデルIDをロード
+        persisted_master_id = self.config_manager.get_null_ai_setting("active_master_id")
+        persisted_apprentice_id = self.config_manager.get_null_ai_setting("active_apprentice_id")
+
+        # 師匠モデルの設定
+        if persisted_master_id:
+            master_config = self.config_manager.get_model_config(persisted_master_id)
+            if master_config:
+                self.master_model = master_config
+                self._update_engine_status(self.master_model.model_id, "master")
+                logger.info(f"Persisted master model loaded: {self.master_model.display_name}")
+            else:
+                logger.warning(f"Persisted master model '{persisted_master_id}' not found in configuration. Attempting to set default.")
+                self._set_initial_master_from_config() # 永続化されたモデルが見つからない場合はデフォルトを設定
+        else:
+            self._set_initial_master_from_config() # 永続化されたマスターIDがない場合はデフォルトを設定
+
+        # 弟子モデルの設定
+        if persisted_apprentice_id:
+            apprentice_config = self.config_manager.get_model_config(persisted_apprentice_id)
+            if apprentice_config:
+                self.apprentice_model = apprentice_config
+                # unique_idもconfigからロードする
+                apprentice_unique_id = self.config_manager.get_null_ai_setting(f"apprentice_unique_id_{persisted_apprentice_id}")
+                self._update_engine_status(self.apprentice_model.model_id, "apprentice", apprentice_unique_id)
+                logger.info(f"Persisted apprentice model loaded: {self.apprentice_model.display_name}")
+            else:
+                logger.warning(f"Persisted apprentice model '{persisted_apprentice_id}' not found in configuration. Clearing active apprentice.")
+                self.apprentice_model = None
+                self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+        else:
+            self.apprentice_model = None
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+
+    def _set_initial_master_from_config(self):
+        """設定からデフォルトの師匠モデルをロード（persistedがない場合や見つからない場合）"""
+        default_master_config = self.config_manager.get_default_model_config(domain_id=self.active_domain_id)
+        if default_master_config:
+            self.master_model = default_master_config
+            self._update_engine_status(self.master_model.model_id, "master")
+            self.config_manager.set_null_ai_setting("active_master_id", self.master_model.model_id)
+            logger.info(f"Default master model loaded for domain '{self.active_domain_id}': {self.master_model.display_name}")
+        else:
+            logger.warning(f"No default master model found for domain '{self.active_domain_id}' in configuration. Master model remains unset.")
+            self.master_model = None
+            self.config_manager.set_null_ai_setting("active_master_id", None)
+
+    def set_active_domain_id(self, domain_id: str):
+        """アクティブなドメインIDを設定し、それに応じてモデルを再ロードする"""
+        if self.active_domain_id != domain_id:
+            self.active_domain_id = domain_id
+            self._load_default_models() # アクティブドメイン変更時は師匠・弟子モデルも再設定
+            logger.info(f"ModelRouter active domain set to {domain_id} and models reloaded.")
+
+    def set_master_model(self, model_id: str) -> bool:
+        """師匠モデルを設定する"""
+        model = self.config_manager.get_model_config(model_id)
+        if model:
+            # 古い師匠を'retired'に戻す (ただし、それがまさに今昇格している弟子ではない場合)
+            if self.master_model and self.master_model.model_id != model_id:
+                # 昇格の場合、古い師匠はretiredにする
+                self._update_engine_status(self.master_model.model_id, "retired")
+                logger.info(f"Old master model '{self.master_model.display_name}' set to 'retired'.")
+            
+            self.master_model = model
+            self._update_engine_status(model_id, "master")
+            self.config_manager.set_null_ai_setting("active_master_id", model_id)
+            logger.info(f"Master model set to: {model.display_name}")
+            return True
+        logger.error(f"Model with ID '{model_id}' not found for master setting.")
+        return False
+
+    def set_apprentice_model(self, model_id: Optional[str]) -> bool:
+        """弟子モデルを設定する (Noneでクリア)"""
+        # 古い弟子を'available'に戻す
+        if self.apprentice_model:
+            self._update_engine_status(self.apprentice_model.model_id, "available")
+        
+        if model_id is None or model_id == 'none':
+            self.apprentice_model = None
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+            logger.info("Apprentice model cleared.")
+            return True
+        
+        model = self.config_manager.get_model_config(model_id)
+        if model:
+            self.apprentice_model = model
+            # For apprentices, we need to ensure unique_id is tracked if this is a named apprentice
+            apprentice_unique_id = self.managed_engines[model_id].get("unique_id") # Get existing unique_id
+            self._update_engine_status(model_id, "apprentice", apprentice_unique_id)
+            self.config_manager.set_null_ai_setting("active_apprentice_id", model_id)
+            logger.info(f"Apprentice model set to: {model.display_name}")
+            return True
+        logger.error(f"Model with ID '{model_id}' not found for apprentice setting.")
+        return False
+
+    def get_all_managed_engines(self) -> List[Dict[str, Any]]:
+        """管理している全てのエンジンとそのステータス、ユニークIDを含むリストを返す"""
+        return list(self.managed_engines.values())
+
+    def get_master_model(self) -> Optional[ModelConfig]:
+        """現在の師匠モデルを取得する"""
+        return self.master_model
+
+    def get_apprentice_model(self) -> Optional[ModelConfig]:
+        """現在の弟子モデルを取得する"""
+        return self.apprentice_model
+
+    def get_model_config(self, model_id: str) -> Optional[ModelConfig]:
+        """指定されたmodel_idのモデル設定を取得する"""
+        return self.config_manager.models.get(model_id)
+
+    def swap_engines(self, apprentice_model_id: str) -> bool:
+        """師匠と指定した弟子を入れ替える"""
+        if not self.master_model:
+            logger.error("Cannot swap: No master model is currently set.")
+            return False
+        
+        apprentice_candidate = self.config_manager.get_model_config(apprentice_model_id)
+        if not apprentice_candidate:
+            logger.error(f"Cannot swap: Apprentice model '{apprentice_model_id}' not found.")
+            return False
+        
+        # 現在の師匠と弟子の情報を取得
+        old_master_model = self.master_model
+        
+        # 新しい師匠は指定された弟子
+        new_master_model = apprentice_candidate
+        
+        # 新しい弟子は古い師匠 (ただし、古い師匠が現在のアプレンティス候補でなければ)
+        new_apprentice_model = old_master_model if old_master_model.model_id != apprentice_model_id else None
+
+        # ロールを入れ替える
+        self.master_model = new_master_model
+        self.apprentice_model = new_apprentice_model
+
+        # ステータスと永続化を更新
+        self._update_engine_status(new_master_model.model_id, "master", self.managed_engines[new_master_model.model_id].get("unique_id"))
+        self.config_manager.set_null_ai_setting("active_master_id", new_master_model.model_id)
+        
+        if new_apprentice_model:
+            self._update_engine_status(new_apprentice_model.model_id, "apprentice", self.managed_engines[new_apprentice_model.model_id].get("unique_id"))
+            self.config_manager.set_null_ai_setting("active_apprentice_id", new_apprentice_model.model_id)
+        else:
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+        
+        # 古いアプレンティスが指定されたアプレンティスとは異なる場合、そのステータスをavailableに戻す
+        if old_master_model and old_master_model.model_id != new_master_model.model_id:
+             self._update_engine_status(old_master_model.model_id, "available") # Old master becomes available if not the new apprentice
+
+        logger.info(f"Engines swapped: New Master is {new_master_model.display_name}, New Apprentice is {new_apprentice_model.display_name if new_apprentice_model else 'None'}")
+        return True
+
+    def promote_apprentice(self, apprentice_model_id: str) -> bool:
+        """指定した弟子を師匠に昇格させ、現在の師匠を引退させる"""
+        apprentice_to_promote = self.config_manager.get_model_config(apprentice_model_id)
+        if not apprentice_to_promote:
+            logger.error(f"Cannot promote: Apprentice model '{apprentice_model_id}' not found.")
+            return False
+        
+        # 現在の師匠を引退させる
+        if self.master_model:
+            self._update_engine_status(self.master_model.model_id, "retired")
+            logger.info(f"Current master model '{self.master_model.display_name}' retired.")
+        
+        # 弟子を師匠に昇格させる
+        self.master_model = apprentice_to_promote
+        self._update_engine_status(apprentice_to_promote.model_id, "master", self.managed_engines[apprentice_to_promote.model_id].get("unique_id"))
+        self.config_manager.set_null_ai_setting("active_master_id", apprentice_to_promote.model_id)
+        
+        # 弟子モデルのロールをクリア (昇格したため)
+        if self.apprentice_model and self.apprentice_model.model_id == apprentice_model_id:
+            self.apprentice_model = None
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+            logger.info(f"Apprentice model '{apprentice_to_promote.display_name}' promoted to master and apprentice role cleared.")
+        else:
+             logger.warning(f"Apprentice '{apprentice_model_id}' was promoted, but was not the currently active apprentice.")
+
+        logger.info(f"Apprentice '{apprentice_to_promote.display_name}' promoted to Master.")
+        return True
+
+    def create_new_apprentice(self) -> Optional[Dict[str, Any]]:
+        """新しい「空っぽの弟子」推論エンジンを生成し、登録する"""
+        new_apprentice_unique_id = str(uuid.uuid4())
+        new_apprentice_model_id = f"apprentice-{new_apprentice_unique_id[:8]}"
+        new_apprentice_display_name = f"Apprentice ({new_apprentice_unique_id[:4]})"
+
+        # ユーザーは「文字通り学習データがないもの」と指定。
+        # ここでは、汎用的なベースモデルを想定するか、あるいは特定のプロバイダー/モデル名を指定する。
+        # 仮に、Ollamaの何らかの軽量モデルをテンプレートとして利用する。
+        # または、単にモデル設定のみを生成し、実際のモデルファイルは後で学習時にロードする。
+        
+        # NOTE: この "empty" モデルが具体的に何を指すかは、
+        # 後続のファインチューニングのロジックによって具体化される必要がある。
+        # ここでは、設定上の一エントリとして追加する。
+        
+        # TODO: ベースとなる「空っぽ」モデルの設定をnull_ai_config.jsonなどから取得できるようにする
+        base_apprentice_provider = ModelProvider.OLLAMA # 仮のデフォルトプロバイダー
+        base_apprentice_model_name = "mistral:latest" # 仮のデフォルトモデル名
+        
+        # Configuration for the new apprentice
+        new_model_config_data = {
+            "model_id": new_apprentice_model_id,
+            "display_name": new_apprentice_display_name,
+            "provider": base_apprentice_provider.value,
+            "model_name": base_apprentice_model_name,
+            "max_tokens": 4096,
+            "temperature": 0.7,
+            "timeout": 120,
+            "is_default": False,
+            "supported_domains": ["general"], # New apprentices start with general knowledge
+            "description": f"Newly generated empty apprentice model with unique ID {new_apprentice_unique_id}."
+        }
+
+        try:
+            new_model = self.config_manager.add_model(new_model_config_data)
+            if not new_model:
+                raise Exception("Failed to add new model via config_manager.")
+            
+            self.managed_engines[new_model.model_id] = {
+                "config": new_model.dict(),
+                "status": "available",
+                "unique_id": new_apprentice_unique_id
+            }
+            # unique_idも永続化しておく
+            self.config_manager.set_null_ai_setting(f"apprentice_unique_id_{new_model.model_id}", new_apprentice_unique_id)
+
+            logger.info(f"New empty apprentice '{new_apprentice_display_name}' created with ID: {new_apprentice_model_id}")
+            return self.managed_engines[new_model.model_id]
+        except Exception as e:
+            logger.error(f"Failed to create new apprentice: {e}")
+            return None
+
+    def get_active_model(self, for_inference: bool = True) -> Optional[ModelConfig]:
+        """
+        推論に使用するアクティブなモデルを取得する。
+        for_inferenceがTrueの場合、師匠モデルを返す。
+        倒木システムにおける「学習」などの用途で弟子モデルが必要な場合は、
+        直接get_apprentice_modelを使用する。
+        """
+        if for_inference:
+            return self.master_model
+        # 将来的に「成長した」弟子モデルへの自動切り替えロジックが入る可能性
+        return self.master_model # デフォルトでは師匠モデルを使用
+
+    async def infer(self, prompt: str, domain_id: str, model_config: ModelConfig, temperature: Optional[float] = None, save_to_memory: bool = False, rag_mode: str = "rag") -> Dict[str, Any]:
+        """
+        指定されたモデルで推論を実行する。
+        RAG: DBに知識があればそれを使用、なければAI内部知識で推論してDBに蓄積。
+        rag_modeに応じて動作を切り替える。
+        """
+        # rag_mode == 'direct' の場合の処理
+        if rag_mode == "direct":
+            relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=1)
+            if relevant_knowledge:
+                # DBから直接回答を返す
+                best_match = relevant_knowledge[0]
+                logger.info(f"Direct mode: DB knowledge found. Returning direct answer from tile {best_match['id']}.")
+                return {
+                    "response": best_match['content'],
+                    "thinking": f"Directly retrieved from knowledge base. Tile ID: {best_match['id']}.",
+                    "confidence": best_match['confidence_score'],
+                    "model_used": "database_direct",
+                    "latency_ms": 50, # DB検索なので高速
+                    "source_type": "db_direct"
+                }
+            else:
+                # DBに情報がない場合は「わかりません」と返す
+                logger.info("Direct mode: No DB knowledge found. Returning 'Not found'.")
+                return {
+                    "response": "ご指定の情報はナレッジベース内に見つかりませんでした。",
+                    "thinking": "Directly searched knowledge base, but no relevant information was found.",
+                    "confidence": 0.9, # 「見つからない」という回答には高い信頼度を与える
+                    "model_used": "database_direct",
+                    "latency_ms": 50,
+                    "source_type": "db_direct"
+                }
+
+        # rag_mode == 'rag' の場合の処理 (既存のロジック)
+        has_db_knowledge = self._check_db_knowledge(domain_id, prompt)
+        source_type = "db_augmented" if has_db_knowledge else "ai_internal_weights"
+        thinking_process = ""
+        augmented_prompt = prompt
+
+        if has_db_knowledge:
+            # DBから関連知識を取得
+            relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=3)
+            logger.info(f"RAG mode: DB knowledge found for domain '{domain_id}'. Retrieved {len(relevant_knowledge)} relevant tiles.")
+
+            # RAG: プロンプトに知識を統合
+            knowledge_context = "\n\n".join([
+                f"[Knowledge {i+1} - {tile['verification_type']} verification, confidence: {tile['confidence_score']}]\n"
+                f"Topic: {tile['topic']}\n"
+                f"Content: {tile['content']}"
+                for i, tile in enumerate(relevant_knowledge)
+            ])
+
+            augmented_prompt = f"""Based on the following verified knowledge from the database:
+
+{knowledge_context}
+
+Now, please answer the following question accurately:
+{prompt}"""
+
+            response = await self._perform_llm_inference(model_config, augmented_prompt, temperature or model_config.temperature)
+            thinking_process = f"Accessed knowledge base. Retrieved {len(relevant_knowledge)} relevant knowledge tiles. " + response.get("thinking", "")
+        else:
+            # DBに知識がない場合、AI内部知識で推論
+            logger.info(f"RAG mode: No DB knowledge found for domain '{domain_id}'. Using AI internal weights.")
+            response = await self._perform_llm_inference(model_config, prompt, temperature or model_config.temperature)
+            thinking_process = "No specific DB knowledge found. Inferred from AI internal weights. " + response.get("thinking", "")
+
+            # 自己拡充: 推論結果をDBに保存
+            if save_to_memory and response.get("confidence", 0) >= 0.7:
+                await self._save_inference_to_db(
+                    domain_id=domain_id,
+                    prompt=prompt,
+                    response=response.get("response", ""),
+                    confidence=response.get("confidence", 0.7),
+                    source_type="ai",
+                    model_id=model_config.model_id
+                )
+
+        # 倒木システム: 師匠の出力を教師データとして保存
+        is_master = (self.master_model and model_config.model_id == self.master_model.model_id)
+        logger.info(f"[Training Data Check] master_model={self.master_model.model_id if self.master_model else None}, "
+                   f"current_model={model_config.model_id}, is_master={is_master}, "
+                   f"confidence={response.get('confidence', 0)}, save_to_memory={save_to_memory}")
+        if is_master and response.get("confidence", 0) >= 0.8:
+            logger.info(f"[Training Data] Saving master output for domain '{domain_id}'...")
+            await self._save_master_output_as_training_data(
+                prompt=prompt,
+                master_response=response.get("response", ""),
+                domain_id=domain_id,
+                confidence=response.get("confidence", 0.8)
+            )
+        else:
+            logger.info(f"[Training Data] NOT saving: is_master={is_master}, confidence={response.get('confidence', 0)}")
+
+        return {
+            "response": response.get("response", ""),
+            "thinking": thinking_process,
+            "confidence": response.get("confidence", 0.7),
+            "model_used": model_config.model_id,
+            "latency_ms": response.get("latency_ms", 0),
+            "source_type": source_type
+        }
+
+    async def infer_streaming(self, prompt: str, domain_id: str, model_config: ModelConfig, temperature: Optional[float] = None, save_to_memory: bool = False, rag_mode: str = "rag") -> AsyncGenerator[Dict[str, Any], None]:
+        print(f"DEBUG: infer_streaming called - model={model_config.model_id if model_config else 'None'}")
+        logger.error(f"[CRITICAL DEBUG] infer_streaming ENTRY POINT - model={model_config.model_id if model_config else 'None'}, save_to_memory={save_to_memory}")
+        """
+        指定されたモデルで推論をストリーミングで実行する。
+        RAG: DBに知識があればそれを使用、なければAI内部知識で推論してDBに蓄積。
+        rag_modeに応じて動作を切り替える。
+        """
+        logger.info(f"[INFER_STREAMING] Called with model={model_config.model_id}, domain={domain_id}, save_to_memory={save_to_memory}")
+
+        # 師匠の応答を蓄積するための変数（finallyブロックで使用）
+        generated_response = ""
+
+        try:
+            # rag_mode == 'direct' の場合の処理
+            if rag_mode == "direct":
+                relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=1)
+                if relevant_knowledge:
+                    best_match = relevant_knowledge[0]
+                    logger.info(f"Direct mode (streaming): DB knowledge found. Yielding direct answer from tile {best_match['id']}.")
+                    yield {"type": "token", "content": best_match['content']}
+                    yield {"type": "meta", "source_type": "db_direct", "thinking": f"Directly retrieved from knowledge base. Tile ID: {best_match['id']}.", "confidence": best_match['confidence_score'], "model_used": "database_direct"}
+                    yield {"type": "complete", "content": best_match['content']}
+                    return
+                else:
+                    logger.info("Direct mode (streaming): No DB knowledge found. Yielding 'Not found'.")
+                    response_text = "ご指定の情報はナレッジベース内に見つかりませんでした。"
+                    yield {"type": "token", "content": response_text}
+                    yield {"type": "meta", "source_type": "db_direct", "thinking": "Directly searched knowledge base, but no relevant information was found.", "confidence": 0.9, "model_used": "database_direct"}
+                    yield {"type": "complete", "content": response_text}
+                    return
+
+            # rag_mode == 'rag' の場合の処理 (既存のロジック)
+            has_db_knowledge = self._check_db_knowledge(domain_id, prompt)
+            source_type = "db_augmented" if has_db_knowledge else "ai_internal_weights"
+            augmented_prompt = prompt
+
+            yield {"type": "thinking", "content": f"Checking DB knowledge for domain '{domain_id}'..."}
+            await asyncio.sleep(0.1)
+
+            if has_db_knowledge:
+                # DBから関連知識を取得
+                relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=3)
+                yield {"type": "thinking", "content": f"Relevant DB knowledge found. Retrieved {len(relevant_knowledge)} tiles. Augmenting prompt..."}
+
+                # RAG: プロンプトに知識を統合
+                knowledge_context = "\n\n".join([
+                    f"[Knowledge {i+1} - {tile['verification_type']} verification, confidence: {tile['confidence_score']}]\n"
+                    f"Topic: {tile['topic']}\n"
+                    f"Content: {tile['content']}"
+                    for i, tile in enumerate(relevant_knowledge)
+                ])
+
+                augmented_prompt = f"""Based on the following verified knowledge from the database:
+
+{knowledge_context}
+
+Now, please answer the following question accurately:
+{prompt}"""
+
+                # ストリーミング推論実行
+                async for chunk in self._perform_llm_streaming_inference(model_config, augmented_prompt, temperature or model_config.temperature):
+                    if chunk.get("type") == "token":
+                        generated_response += chunk.get("content", "")
+                    yield chunk
+
+                yield {"type": "meta", "source_type": source_type, "thinking": f"Accessed knowledge base. Retrieved {len(relevant_knowledge)} relevant knowledge tiles."}
+
+                # 倒木システム: 師匠の出力を教師データとして保存 (DB知識使用時も保存)
+                logger.error(f"[CRITICAL DEBUG] Reached training data save section (with DB knowledge)! generated_response length={len(generated_response)}")
+                is_master = (self.master_model and model_config.model_id == self.master_model.model_id)
+                logger.info(f"[Training Data Check - DB Augmented] master_model={self.master_model.model_id if self.master_model else None}, "
+                           f"current_model={model_config.model_id}, is_master={is_master}, "
+                           f"response_length={len(generated_response)}, save_to_memory={save_to_memory}")
+                if is_master and len(generated_response) > 0:
+                    logger.info(f"[Training Data - DB Augmented] Saving master output for domain '{domain_id}'...")
+                    await self._save_master_output_as_training_data(
+                        prompt=prompt,
+                        master_response=generated_response,
+                        domain_id=domain_id,
+                        confidence=0.8
+                    )
+                else:
+                    logger.info(f"[Training Data - DB Augmented] NOT saving: is_master={is_master}, response_length={len(generated_response)}")
+
+            else:
+                yield {"type": "thinking", "content": "No specific DB knowledge found. Using AI internal weights."}
+
+                # ストリーミング推論実行
+                async for chunk in self._perform_llm_streaming_inference(model_config, prompt, temperature or model_config.temperature):
+                    if chunk.get("type") == "token":
+                        generated_response += chunk.get("content", "")
+                    yield chunk
+
+                yield {"type": "meta", "source_type": source_type, "thinking": "Inferred from AI internal weights."}
+
+                # 倒木システム: 師匠の出力を教師データとして保存
+                logger.error(f"[CRITICAL DEBUG] Reached training data save section! generated_response length={len(generated_response)}")
+                is_master = (self.master_model and model_config.model_id == self.master_model.model_id)
+                logger.info(f"[Training Data Check - Streaming] master_model={self.master_model.model_id if self.master_model else None}, "
+                           f"current_model={model_config.model_id}, is_master={is_master}, "
+                           f"response_length={len(generated_response)}, save_to_memory={save_to_memory}")
+                if is_master and len(generated_response) > 0:
+                    logger.info(f"[Training Data - Streaming] Saving master output for domain '{domain_id}'...")
+                    await self._save_master_output_as_training_data(
+                        prompt=prompt,
+                        master_response=generated_response,
+                        domain_id=domain_id,
+                        confidence=0.8
+                    )
+                else:
+                    logger.info(f"[Training Data - Streaming] NOT saving: is_master={is_master}, response_length={len(generated_response)}")
+
+                # 自己拡充: 推論結果をDBに保存（信頼度が十分な場合）
+                if save_to_memory and len(generated_response) > 0:
+                    await self._save_inference_to_db(
+                        domain_id=domain_id,
+                        prompt=prompt,
+                        response=generated_response,
+                        confidence=0.75,  # ストリーミングなので固定値
+                        source_type="ai",
+                        model_id=model_config.model_id
+                    )
+
+        except Exception as e:
+            logger.error(f"Error during streaming inference: {e}")
+            yield {"type": "error", "content": str(e)}
+
+    def _check_db_knowledge(self, domain_id: str, prompt: str) -> bool:
+        """
+        指定されたドメインとプロンプトに関連する知識があるかチェックする。
+        樹木型空間記憶（.iath）を使用。
+        """
+        try:
+            if self.dendritic_memory is None:
+                return False
+
+            # テキスト検索でマッチがあるかチェック
+            results = self.dendritic_memory.search_by_text(prompt[:200], top_k=1)
+            return len(results) > 0
+
+        except Exception as e:
+            logger.error(f"Error checking dendritic memory: {e}")
+            return False
+
+    def _retrieve_relevant_knowledge(self, domain_id: str, prompt: str, top_k: int = 3) -> list:
+        """
+        指定されたドメインとプロンプトに関連する知識を取得する。
+        樹木型空間記憶（.iath）のハイブリッド検索を使用。
+        """
+        try:
+            if self.dendritic_memory is None:
+                return []
+
+            # ハイブリッド検索（テキスト + 空間座標）
+            # TODO: プロンプトから空間座標を推定する機能を追加
+            results = self.dendritic_memory.hybrid_search(prompt, query_coords=None, top_k=top_k)
+
+            # 統一フォーマットに変換
+            return [
+                {
+                    "id": tile["metadata"]["knowledge_id"],
+                    "topic": tile["metadata"]["topic"],
+                    "content": tile["content"]["final_response"],
+                    "thinking_process": tile["content"]["thinking_process"],
+                    "confidence_score": tile["verification"]["initial_certainty"],
+                    "verification_type": tile["verification"]["status"],
+                    "coordinates": tile["coordinates"],
+                    "text_match_score": tile.get("text_match_score", 0),
+                    "spatial_distance": tile.get("spatial_distance", None)
+                }
+                for tile in results
+            ]
+
+        except Exception as e:
+            logger.error(f"Error retrieving relevant knowledge from dendritic memory: {e}")
+            return []
+
+    async def _perform_llm_inference(self, model_config: ModelConfig, prompt: str, temperature: float) -> Dict[str, Any]:
+        """
+        指定されたモデル設定でLLM推論を実行する。
+        各プロバイダーの実装を使用。
+        """
+        provider_type = model_config.provider
+
+        if provider_type not in self.providers:
+            raise ValueError(f"Unsupported provider: {provider_type}")
+
+        provider = self.providers[provider_type]
+
+        try:
+            result = await provider.infer(model_config, prompt, temperature)
+            return result
+        except Exception as e:
+            logger.error(f"Error during LLM inference with provider '{provider_type}': {e}")
+            raise
+
+    async def _perform_llm_streaming_inference(self, model_config: ModelConfig, prompt: str, temperature: float) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        指定されたモデル設定でLLMストリーミング推論を実行する。
+        各プロバイダーの実装を使用。
+        """
+        provider_type = model_config.provider
+
+        if provider_type not in self.providers:
+            raise ValueError(f"Unsupported provider: {provider_type}")
+
+        provider = self.providers[provider_type]
+
+        try:
+            async for chunk in provider.infer_streaming(model_config, prompt, temperature):
+                yield chunk
+        except Exception as e:
+            logger.error(f"Error during LLM streaming inference with provider '{provider_type}': {e}")
+            yield {"type": "error", "content": str(e)}
+
+    async def _save_inference_to_db(self, domain_id: str, prompt: str, response: str, confidence: float, source_type: str, model_id: str) -> bool:
+        """
+        推論結果をKnowledge TileとしてDBに保存する（自己拡充）。
+
+        Priority 2実装: 座標自動推定 + .iath保存
+        """
+        try:
+            from backend.app.database.models import KnowledgeTile
+            from backend.app.database.session import SessionLocal  # 遅延インポート
+
+            db = SessionLocal()
+            tile_id = f"ai_ktile_{uuid.uuid4().hex}"
+
+            # AI生成の知識タイルを作成（SQLite）
+            new_tile = KnowledgeTile(
+                id=tile_id,
+                workspace_id="default_workspace",  # ローカル版なのでデフォルトワークスペース
+                domain_id=domain_id,
+                topic=prompt[:200],  # プロンプトをトピックとして使用
+                content=response,
+                confidence_score=confidence,
+                verification_type="ai",  # AI生成を示す
+                verification_count=1,
+                contributor_id=None,  # AIなのでcontributorなし
+                last_verified_by_id=None
+            )
+
+            db.add(new_tile)
+            db.commit()
+            db.close()
+
+            logger.info(f"Saved AI inference to SQLite: {new_tile.id}")
+
+            # Priority 2: 座標自動推定 + .iath保存
+            try:
+                # 座標推定用のLLM推論関数を作成
+                async def llm_inference_for_coords(coord_prompt):
+                    # 師匠モデル（またはDeepSeek）を使って座標推定
+                    estimation_model = self.master_model if self.master_model else self._get_any_available_model()
+
+                    if estimation_model:
+                        result = await self._perform_llm_inference(
+                            estimation_model,
+                            coord_prompt,
+                            temperature=0.3  # 低温度で一貫性を保つ
+                        )
+                        return result.get("response", "")
+                    return "{\"coordinates\": [0.5, 0.5, 0.5, 0.5, 0.5, 0.5], \"confidence\": 0.3}"
+
+                # 座標を推定
+                coord_result = await self.coordinate_estimator.estimate_coordinates(
+                    prompt=prompt,
+                    response=response,
+                    domain_id=domain_id,
+                    llm_inference_func=llm_inference_for_coords,
+                    use_reasoning=False  # 高速化のため推論過程は省略
+                )
+
+                # .iath Tileオブジェクトを作成
+                iath_tile = create_tile_from_ai_output(
+                    knowledge_id=tile_id,
+                    topic=prompt[:100],
+                    prompt=prompt,
+                    response=response,
+                    coordinates=coord_result["coordinates"],
+                    confidence=confidence,
+                    domain_id=domain_id,
+                    source="ai_generated"
+                )
+
+                # .iathファイルに保存
+                success = self.iath_writer.append_tile(iath_tile)
+
+                if success:
+                    logger.info(f"Saved AI inference to .iath with coordinates: {coord_result['coordinates']}")
+
+                    # メモリをリロード（新しいタイルを検索可能にする）
+                    self._load_dendritic_memory()
+                else:
+                    logger.warning(f"Failed to save to .iath, but SQLite save succeeded")
+
+            except Exception as iath_error:
+                logger.error(f"Error saving to .iath (SQLite save succeeded): {iath_error}")
+                # .iath保存失敗してもSQLite保存は成功しているのでTrueを返す
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Error saving inference to DB: {e}")
+            return False
+
+    async def _save_master_output_as_training_data(self, prompt: str, master_response: str, domain_id: str, confidence: float) -> bool:
+        """
+        師匠の出力を弟子のファインチューニング用教師データとして保存する。
+        倒木システムの核心機能。
+        """
+        try:
+            import json
+            import os
+            from datetime import datetime
+
+            logger.info(f"[Save Training Data] Starting to save master output (domain={domain_id}, confidence={confidence})")
+
+            # トレーニングデータ保存ディレクトリ
+            training_data_dir = "training_data/master_outputs"
+            logger.info(f"[Save Training Data] Creating directory: {training_data_dir}")
+            os.makedirs(training_data_dir, exist_ok=True)
+
+            # Alpaca形式で保存
+            training_example = {
+                "instruction": f"You are an expert in {domain_id}. Provide accurate information based on verified knowledge.",
+                "input": prompt,
+                "output": master_response,
+                "metadata": {
+                    "domain_id": domain_id,
+                    "confidence": confidence,
+                    "master_model_id": self.master_model.model_id if self.master_model else "unknown",
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "source": "master_output"
+                }
+            }
+
+            # JSONLファイルに追記
+            output_file = os.path.join(training_data_dir, f"master_outputs_{domain_id}.jsonl")
+            logger.info(f"[Save Training Data] Writing to file: {output_file}")
+            with open(output_file, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(training_example, ensure_ascii=False) + '\n')
+
+            logger.info(f"✓ Successfully saved master output as training data: {output_file}")
+            return True
+
+        except Exception as e:
+            logger.error(f"✗ Error saving master output as training data: {e}", exc_info=True)
+            return False

model_router.py.backup

@@ -0,0 +1,803 @@
+import logging
+from typing import Optional, Dict, Any, AsyncGenerator, List
+import asyncio
+import time
+import threading # For TextIteratorStreamer
+import uuid # For generating unique IDs
+import os
+
+from backend.app.config import ConfigManager, ModelConfig, ModelProvider
+# SessionLocal は循環インポートを避けるため遅延インポート
+from backend.app.services.knowledge_service import KnowledgeService, get_knowledge_service
+from null_ai.llm_providers import HuggingFaceProvider, OllamaProvider, MLXProvider, GGUFProvider # Import all providers
+from null_ai.iath_memory import DendriticMemorySpace  # 樹木型空間記憶
+from null_ai.coordinate_estimator import CoordinateEstimator  # 座標自動推定
+from null_ai.iath_writer import IathWriter, create_tile_from_ai_output  # .iath保存
+
+logger = logging.getLogger(__name__)
+
+class ModelRouter:
+    """
+    推論エンジン間でモデルのルーティングと切り替えを管理するクラス。
+    師匠（Master）モデルと弟子（Apprentice）モデルの状態を保持する。
+    """
+    _instance: Optional['ModelRouter'] = None
+    _initialized = False
+
+    def __new__(cls, config_manager: ConfigManager):
+        if cls._instance == None:
+            cls._instance = super(ModelRouter, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_manager: ConfigManager):
+        if self._initialized:
+            return
+
+        self.config_manager = config_manager
+        self.knowledge_service = get_knowledge_service() # Instantiate KnowledgeService internally
+        self.master_model: Optional[ModelConfig] = None
+        self.apprentice_model: Optional[ModelConfig] = None
+        self.active_domain_id: Optional[str] = None # Active domain managed by ConfigManager
+        self.managed_engines: Dict[str, Dict[str, Any]] = {} # Tracks all engines and their status
+
+        # 樹木型空間記憶（.iathファイル）の初期化
+        self.dendritic_memory: Optional[DendriticMemorySpace] = None
+        self._load_dendritic_memory()
+
+        # 座標自動推定器の初期化
+        self.coordinate_estimator = CoordinateEstimator()
+
+        # .iathライターの初期化
+        iath_file_path = os.getenv("IATH_DB_PATH", "knowledge_base.iath")
+        self.iath_writer = IathWriter(iath_file_path)
+
+        # LLMプロバイダーを初期化
+        self.providers: Dict[ModelProvider, Any] = {
+            ModelProvider.HUGGINGFACE: HuggingFaceProvider(),
+            ModelProvider.OLLAMA: OllamaProvider(),
+            ModelProvider.MLX: MLXProvider(),
+            ModelProvider.GGUF: GGUFProvider(),
+        }
+
+        # 初期ロード時にデフォルトモデルを設定
+        self._load_all_engines() # Load all configured models into managed_engines
+        self._load_default_models() # This will now also try to load active master/apprentice from config
+
+        self._initialized = True
+        logger.info("ModelRouter initialized.")
+
+    def _load_dendritic_memory(self):
+        """樹木型空間記憶（.iathファイル）をロードする"""
+        try:
+            # TODO: ドメインごとに異なる.iathファイルを使用する
+            # 現在はデフォルトのパスを使用
+            import os
+            iath_file_path = os.getenv("IATH_DB_PATH", "knowledge_base.iath")
+
+            if os.path.exists(iath_file_path):
+                self.dendritic_memory = DendriticMemorySpace(iath_file_path)
+                stats = self.dendritic_memory.get_statistics()
+                logger.info(f"Dendritic memory loaded: {stats['total_tiles']} tiles from {iath_file_path}")
+            else:
+                logger.warning(f".iath file not found: {iath_file_path}. Starting with empty memory.")
+                self.dendritic_memory = None
+        except Exception as e:
+            logger.error(f"Failed to load dendritic memory: {e}")
+            self.dendritic_memory = None
+
+    def _get_any_available_model(self) -> Optional[ModelConfig]:
+        """
+        利用可能なモデルを1つ取得する（座標推定などで使用）
+
+        優先順位:
+        1. 師匠モデル
+        2. 設定された最初のモデル
+
+        Returns:
+            ModelConfig or None
+        """
+        if self.master_model:
+            return self.master_model
+
+        # 設定から最初のモデルを取得
+        for model_id, model_config in self.config_manager.models.items():
+            return model_config
+
+        return None
+
+    def _load_all_engines(self):
+        """設定ファイルから全てのモデルをロードし、managed_enginesを初期化する"""
+        self.managed_engines = {}
+        for model_id, model_config in self.config_manager.models.items():
+            self.managed_engines[model_id] = {
+                "config": model_config.dict(),
+                "status": "available", # Default status
+                "unique_id": None # Only for apprentices
+            }
+        logger.info(f"Loaded {len(self.managed_engines)} engines into management.")
+
+    def _update_engine_status(self, model_id: str, status: str, unique_id: Optional[str] = None):
+        """managed_engines内のエンジンのステータスを更新するヘルパー"""
+        if model_id in self.managed_engines:
+            self.managed_engines[model_id]["status"] = status
+            self.managed_engines[model_id]["unique_id"] = unique_id
+        else:
+            logger.warning(f"Attempted to update status for unknown engine: {model_id}")
+
+    def _load_default_models(self):
+        """設定からデフォルトの師匠モデルと弟子モデルをロードする"""
+        self.active_domain_id = self.config_manager.get_active_domain_id()
+
+        # ConfigManagerから永続化されたアクティブな師匠・弟子モデルIDをロード
+        persisted_master_id = self.config_manager.get_null_ai_setting("active_master_id")
+        persisted_apprentice_id = self.config_manager.get_null_ai_setting("active_apprentice_id")
+
+        # 師匠モデルの設定
+        if persisted_master_id:
+            master_config = self.config_manager.get_model_config(persisted_master_id)
+            if master_config:
+                self.master_model = master_config
+                self._update_engine_status(self.master_model.model_id, "master")
+                logger.info(f"Persisted master model loaded: {self.master_model.display_name}")
+            else:
+                logger.warning(f"Persisted master model '{persisted_master_id}' not found in configuration. Attempting to set default.")
+                self._set_initial_master_from_config() # 永続化されたモデルが見つからない場合はデフォルトを設定
+        else:
+            self._set_initial_master_from_config() # 永続化されたマスターIDがない場合はデフォルトを設定
+
+        # 弟子モデルの設定
+        if persisted_apprentice_id:
+            apprentice_config = self.config_manager.get_model_config(persisted_apprentice_id)
+            if apprentice_config:
+                self.apprentice_model = apprentice_config
+                # unique_idもconfigからロードする
+                apprentice_unique_id = self.config_manager.get_null_ai_setting(f"apprentice_unique_id_{persisted_apprentice_id}")
+                self._update_engine_status(self.apprentice_model.model_id, "apprentice", apprentice_unique_id)
+                logger.info(f"Persisted apprentice model loaded: {self.apprentice_model.display_name}")
+            else:
+                logger.warning(f"Persisted apprentice model '{persisted_apprentice_id}' not found in configuration. Clearing active apprentice.")
+                self.apprentice_model = None
+                self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+        else:
+            self.apprentice_model = None
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+
+    def _set_initial_master_from_config(self):
+        """設定からデフォルトの師匠モデルをロード（persistedがない場合や見つからない場合）"""
+        default_master_config = self.config_manager.get_default_model_config(domain_id=self.active_domain_id)
+        if default_master_config:
+            self.master_model = default_master_config
+            self._update_engine_status(self.master_model.model_id, "master")
+            self.config_manager.set_null_ai_setting("active_master_id", self.master_model.model_id)
+            logger.info(f"Default master model loaded for domain '{self.active_domain_id}': {self.master_model.display_name}")
+        else:
+            logger.warning(f"No default master model found for domain '{self.active_domain_id}' in configuration. Master model remains unset.")
+            self.master_model = None
+            self.config_manager.set_null_ai_setting("active_master_id", None)
+
+    def set_active_domain_id(self, domain_id: str):
+        """アクティブなドメインIDを設定し、それに応じてモデルを再ロードする"""
+        if self.active_domain_id != domain_id:
+            self.active_domain_id = domain_id
+            self._load_default_models() # アクティブドメイン変更時は師匠・弟子モデルも再設定
+            logger.info(f"ModelRouter active domain set to {domain_id} and models reloaded.")
+
+    def set_master_model(self, model_id: str) -> bool:
+        """師匠モデルを設定する"""
+        model = self.config_manager.get_model_config(model_id)
+        if model:
+            # 古い師匠を'retired'に戻す (ただし、それがまさに今昇格している弟子ではない場合)
+            if self.master_model and self.master_model.model_id != model_id:
+                # 昇格の場合、古い師匠はretiredにする
+                self._update_engine_status(self.master_model.model_id, "retired")
+                logger.info(f"Old master model '{self.master_model.display_name}' set to 'retired'.")
+            
+            self.master_model = model
+            self._update_engine_status(model_id, "master")
+            self.config_manager.set_null_ai_setting("active_master_id", model_id)
+            logger.info(f"Master model set to: {model.display_name}")
+            return True
+        logger.error(f"Model with ID '{model_id}' not found for master setting.")
+        return False
+
+    def set_apprentice_model(self, model_id: Optional[str]) -> bool:
+        """弟子モデルを設定する (Noneでクリア)"""
+        # 古い弟子を'available'に戻す
+        if self.apprentice_model:
+            self._update_engine_status(self.apprentice_model.model_id, "available")
+        
+        if model_id is None or model_id == 'none':
+            self.apprentice_model = None
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+            logger.info("Apprentice model cleared.")
+            return True
+        
+        model = self.config_manager.get_model_config(model_id)
+        if model:
+            self.apprentice_model = model
+            # For apprentices, we need to ensure unique_id is tracked if this is a named apprentice
+            apprentice_unique_id = self.managed_engines[model_id].get("unique_id") # Get existing unique_id
+            self._update_engine_status(model_id, "apprentice", apprentice_unique_id)
+            self.config_manager.set_null_ai_setting("active_apprentice_id", model_id)
+            logger.info(f"Apprentice model set to: {model.display_name}")
+            return True
+        logger.error(f"Model with ID '{model_id}' not found for apprentice setting.")
+        return False
+
+    def get_all_managed_engines(self) -> List[Dict[str, Any]]:
+        """管理している全てのエンジンとそのステータス、ユニークIDを含むリストを返す"""
+        return list(self.managed_engines.values())
+
+    def get_master_model(self) -> Optional[ModelConfig]:
+        """現在の師匠モデルを取得する"""
+        return self.master_model
+
+    def get_apprentice_model(self) -> Optional[ModelConfig]:
+        """現在の弟子モデルを取得する"""
+        return self.apprentice_model
+
+    def swap_engines(self, apprentice_model_id: str) -> bool:
+        """師匠と指定した弟子を入れ替える"""
+        if not self.master_model:
+            logger.error("Cannot swap: No master model is currently set.")
+            return False
+        
+        apprentice_candidate = self.config_manager.get_model_config(apprentice_model_id)
+        if not apprentice_candidate:
+            logger.error(f"Cannot swap: Apprentice model '{apprentice_model_id}' not found.")
+            return False
+        
+        # 現在の師匠と弟子の情報を取得
+        old_master_model = self.master_model
+        
+        # 新しい師匠は指定された弟子
+        new_master_model = apprentice_candidate
+        
+        # 新しい弟子は古い師匠 (ただし、古い師匠が現在のアプレンティス候補でなければ)
+        new_apprentice_model = old_master_model if old_master_model.model_id != apprentice_model_id else None
+
+        # ロールを入れ替える
+        self.master_model = new_master_model
+        self.apprentice_model = new_apprentice_model
+
+        # ステータスと永続化を更新
+        self._update_engine_status(new_master_model.model_id, "master", self.managed_engines[new_master_model.model_id].get("unique_id"))
+        self.config_manager.set_null_ai_setting("active_master_id", new_master_model.model_id)
+        
+        if new_apprentice_model:
+            self._update_engine_status(new_apprentice_model.model_id, "apprentice", self.managed_engines[new_apprentice_model.model_id].get("unique_id"))
+            self.config_manager.set_null_ai_setting("active_apprentice_id", new_apprentice_model.model_id)
+        else:
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+        
+        # 古いアプレンティスが指定されたアプレンティスとは異なる場合、そのステータスをavailableに戻す
+        if old_master_model and old_master_model.model_id != new_master_model.model_id:
+             self._update_engine_status(old_master_model.model_id, "available") # Old master becomes available if not the new apprentice
+
+        logger.info(f"Engines swapped: New Master is {new_master_model.display_name}, New Apprentice is {new_apprentice_model.display_name if new_apprentice_model else 'None'}")
+        return True
+
+    def promote_apprentice(self, apprentice_model_id: str) -> bool:
+        """指定した弟子を師匠に昇格させ、現在の師匠を引退させる"""
+        apprentice_to_promote = self.config_manager.get_model_config(apprentice_model_id)
+        if not apprentice_to_promote:
+            logger.error(f"Cannot promote: Apprentice model '{apprentice_model_id}' not found.")
+            return False
+        
+        # 現在の師匠を引��させる
+        if self.master_model:
+            self._update_engine_status(self.master_model.model_id, "retired")
+            logger.info(f"Current master model '{self.master_model.display_name}' retired.")
+        
+        # 弟子を師匠に昇格させる
+        self.master_model = apprentice_to_promote
+        self._update_engine_status(apprentice_to_promote.model_id, "master", self.managed_engines[apprentice_to_promote.model_id].get("unique_id"))
+        self.config_manager.set_null_ai_setting("active_master_id", apprentice_to_promote.model_id)
+        
+        # 弟子モデルのロールをクリア (昇格したため)
+        if self.apprentice_model and self.apprentice_model.model_id == apprentice_model_id:
+            self.apprentice_model = None
+            self.config_manager.set_null_ai_setting("active_apprentice_id", None)
+            logger.info(f"Apprentice model '{apprentice_to_promote.display_name}' promoted to master and apprentice role cleared.")
+        else:
+             logger.warning(f"Apprentice '{apprentice_model_id}' was promoted, but was not the currently active apprentice.")
+
+        logger.info(f"Apprentice '{apprentice_to_promote.display_name}' promoted to Master.")
+        return True
+
+    def create_new_apprentice(self) -> Optional[Dict[str, Any]]:
+        """新しい「空っぽの弟子」推論エンジンを生成し、登録する"""
+        new_apprentice_unique_id = str(uuid.uuid4())
+        new_apprentice_model_id = f"apprentice-{new_apprentice_unique_id[:8]}"
+        new_apprentice_display_name = f"Apprentice ({new_apprentice_unique_id[:4]})"
+
+        # ユーザーは「文字通り学習データがないもの」と指定。
+        # ここでは、汎用的なベースモデルを想定するか、あるいは特定のプロバイダー/モデル名を指定する。
+        # 仮に、Ollamaの何らかの軽量モデルをテンプレートとして利用する。
+        # または、単にモデル設定のみを生成し、実際のモデルファイルは後で学習時にロードする。
+        
+        # NOTE: この "empty" モデルが具体的に何を指すかは、
+        # 後続のファインチューニングのロジックによって具体化される必要がある。
+        # ここでは、設定上の一エントリとして追加する。
+        
+        # TODO: ベースとなる「空っぽ」モデルの設定をnull_ai_config.jsonなどから取得できるようにする
+        base_apprentice_provider = ModelProvider.OLLAMA # 仮のデフォルトプロバイダー
+        base_apprentice_model_name = "mistral:latest" # 仮のデフォルトモデル名
+        
+        # Configuration for the new apprentice
+        new_model_config_data = {
+            "model_id": new_apprentice_model_id,
+            "display_name": new_apprentice_display_name,
+            "provider": base_apprentice_provider.value,
+            "model_name": base_apprentice_model_name,
+            "max_tokens": 4096,
+            "temperature": 0.7,
+            "timeout": 120,
+            "is_default": False,
+            "supported_domains": ["general"], # New apprentices start with general knowledge
+            "description": f"Newly generated empty apprentice model with unique ID {new_apprentice_unique_id}."
+        }
+
+        try:
+            new_model = self.config_manager.add_model(new_model_config_data)
+            if not new_model:
+                raise Exception("Failed to add new model via config_manager.")
+            
+            self.managed_engines[new_model.model_id] = {
+                "config": new_model.dict(),
+                "status": "available",
+                "unique_id": new_apprentice_unique_id
+            }
+            # unique_idも永続化しておく
+            self.config_manager.set_null_ai_setting(f"apprentice_unique_id_{new_model.model_id}", new_apprentice_unique_id)
+
+            logger.info(f"New empty apprentice '{new_apprentice_display_name}' created with ID: {new_apprentice_model_id}")
+            return self.managed_engines[new_model.model_id]
+        except Exception as e:
+            logger.error(f"Failed to create new apprentice: {e}")
+            return None
+
+    def get_active_model(self, for_inference: bool = True) -> Optional[ModelConfig]:
+        """
+        推論に使用するアクティブなモデルを取得する。
+        for_inferenceがTrueの場合、師匠モデルを返す。
+        倒木システムにおける「学習」などの用途で弟子モデルが必要な場合は、
+        直接get_apprentice_modelを使用する。
+        """
+        if for_inference:
+            return self.master_model
+        # 将来的に「成長した」弟子モデルへの自動切り替えロジックが入る可能性
+        return self.master_model # デフォルトでは師匠モデルを使用
+
+    async def infer(self, prompt: str, domain_id: str, model_config: ModelConfig, temperature: Optional[float] = None, save_to_memory: bool = False, rag_mode: str = "rag") -> Dict[str, Any]:
+        """
+        指定されたモデルで推論を実行する。
+        RAG: DBに知識があればそれを使用、なければAI内部知識で推論してDBに蓄積。
+        rag_modeに応じて動作を切り替える。
+        """
+        # rag_mode == 'direct' の場合の処理
+        if rag_mode == "direct":
+            relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=1)
+            if relevant_knowledge:
+                # DBから直接回答を返す
+                best_match = relevant_knowledge[0]
+                logger.info(f"Direct mode: DB knowledge found. Returning direct answer from tile {best_match['id']}.")
+                return {
+                    "response": best_match['content'],
+                    "thinking": f"Directly retrieved from knowledge base. Tile ID: {best_match['id']}.",
+                    "confidence": best_match['confidence_score'],
+                    "model_used": "database_direct",
+                    "latency_ms": 50, # DB検索なので高速
+                    "source_type": "db_direct"
+                }
+            else:
+                # DBに情報がない場合は「わかりません」と返す
+                logger.info("Direct mode: No DB knowledge found. Returning 'Not found'.")
+                return {
+                    "response": "ご指定の情報はナレッジベース内に見つかりませんでした。",
+                    "thinking": "Directly searched knowledge base, but no relevant information was found.",
+                    "confidence": 0.9, # 「見つからない」という回答には高い信頼度を与える
+                    "model_used": "database_direct",
+                    "latency_ms": 50,
+                    "source_type": "db_direct"
+                }
+
+        # rag_mode == 'rag' の場合の処理 (既存のロジック)
+        has_db_knowledge = self._check_db_knowledge(domain_id, prompt)
+        source_type = "db_augmented" if has_db_knowledge else "ai_internal_weights"
+        thinking_process = ""
+        augmented_prompt = prompt
+
+        if has_db_knowledge:
+            # DBから関連知識を取得
+            relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=3)
+            logger.info(f"RAG mode: DB knowledge found for domain '{domain_id}'. Retrieved {len(relevant_knowledge)} relevant tiles.")
+
+            # RAG: プロンプトに知識を統合
+            knowledge_context = "\n\n".join([
+                f"[Knowledge {i+1} - {tile['verification_type']} verification, confidence: {tile['confidence_score']}]\n"
+                f"Topic: {tile['topic']}\n"
+                f"Content: {tile['content']}"
+                for i, tile in enumerate(relevant_knowledge)
+            ])
+
+            augmented_prompt = f"""Based on the following verified knowledge from the database:
+
+{knowledge_context}
+
+Now, please answer the following question accurately:
+{prompt}"""
+
+            response = await self._perform_llm_inference(model_config, augmented_prompt, temperature or model_config.temperature)
+            thinking_process = f"Accessed knowledge base. Retrieved {len(relevant_knowledge)} relevant knowledge tiles. " + response.get("thinking", "")
+        else:
+            # DBに知識がない場合、AI内部知識で推論
+            logger.info(f"RAG mode: No DB knowledge found for domain '{domain_id}'. Using AI internal weights.")
+            response = await self._perform_llm_inference(model_config, prompt, temperature or model_config.temperature)
+            thinking_process = "No specific DB knowledge found. Inferred from AI internal weights. " + response.get("thinking", "")
+
+            # 自己拡充: 推論結果をDBに保存
+            if save_to_memory and response.get("confidence", 0) >= 0.7:
+                await self._save_inference_to_db(
+                    domain_id=domain_id,
+                    prompt=prompt,
+                    response=response.get("response", ""),
+                    confidence=response.get("confidence", 0.7),
+                    source_type="ai",
+                    model_id=model_config.model_id
+                )
+
+        # 倒木システム: 師匠の出力を教師データとして保存
+        is_master = (self.master_model and model_config.model_id == self.master_model.model_id)
+        logger.info(f"[Training Data Check] master_model={self.master_model.model_id if self.master_model else None}, "
+                   f"current_model={model_config.model_id}, is_master={is_master}, "
+                   f"confidence={response.get('confidence', 0)}, save_to_memory={save_to_memory}")
+        if is_master and response.get("confidence", 0) >= 0.8:
+            logger.info(f"[Training Data] Saving master output for domain '{domain_id}'...")
+            await self._save_master_output_as_training_data(
+                prompt=prompt,
+                master_response=response.get("response", ""),
+                domain_id=domain_id,
+                confidence=response.get("confidence", 0.8)
+            )
+        else:
+            logger.info(f"[Training Data] NOT saving: is_master={is_master}, confidence={response.get('confidence', 0)}")
+
+        return {
+            "response": response.get("response", ""),
+            "thinking": thinking_process,
+            "confidence": response.get("confidence", 0.7),
+            "model_used": model_config.model_id,
+            "latency_ms": response.get("latency_ms", 0),
+            "source_type": source_type
+        }
+
+    async def infer_streaming(self, prompt: str, domain_id: str, model_config: ModelConfig, temperature: Optional[float] = None, save_to_memory: bool = False, rag_mode: str = "rag") -> AsyncGenerator[Dict[str, Any], None]:
+        print(f"DEBUG: infer_streaming called - model={model_config.model_id if model_config else 'None'}")
+        logger.error(f"[CRITICAL DEBUG] infer_streaming ENTRY POINT - model={model_config.model_id if model_config else 'None'}, save_to_memory={save_to_memory}")
+        """
+        指定されたモデルで推論をストリーミングで実行する。
+        RAG: DBに知識があればそれを使用、なければAI内部知識で推論してDBに蓄積。
+        rag_modeに応じて動作を切り替える。
+        """
+        logger.info(f"[INFER_STREAMING] Called with model={model_config.model_id}, domain={domain_id}, save_to_memory={save_to_memory}")
+
+        # 師匠の応答を蓄積するための変数（finallyブロックで使用）
+        generated_response = ""
+
+        try:
+            # rag_mode == 'direct' の場合の処理
+            if rag_mode == "direct":
+                relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=1)
+                if relevant_knowledge:
+                    best_match = relevant_knowledge[0]
+                    logger.info(f"Direct mode (streaming): DB knowledge found. Yielding direct answer from tile {best_match['id']}.")
+                    yield {"type": "token", "content": best_match['content']}
+                    yield {"type": "meta", "source_type": "db_direct", "thinking": f"Directly retrieved from knowledge base. Tile ID: {best_match['id']}.", "confidence": best_match['confidence_score'], "model_used": "database_direct"}
+                    yield {"type": "complete", "content": best_match['content']}
+                    return
+                else:
+                    logger.info("Direct mode (streaming): No DB knowledge found. Yielding 'Not found'.")
+                    response_text = "ご指定の情報はナレッジベース内に見つかりませんでした。"
+                    yield {"type": "token", "content": response_text}
+                    yield {"type": "meta", "source_type": "db_direct", "thinking": "Directly searched knowledge base, but no relevant information was found.", "confidence": 0.9, "model_used": "database_direct"}
+                    yield {"type": "complete", "content": response_text}
+                    return
+
+            # rag_mode == 'rag' の場合の処理 (既存のロジック)
+            has_db_knowledge = self._check_db_knowledge(domain_id, prompt)
+            source_type = "db_augmented" if has_db_knowledge else "ai_internal_weights"
+            augmented_prompt = prompt
+
+            yield {"type": "thinking", "content": f"Checking DB knowledge for domain '{domain_id}'..."}
+            await asyncio.sleep(0.1)
+
+            if has_db_knowledge:
+            # DBから関連知識を取得
+            relevant_knowledge = self._retrieve_relevant_knowledge(domain_id, prompt, top_k=3)
+            yield {"type": "thinking", "content": f"Relevant DB knowledge found. Retrieved {len(relevant_knowledge)} tiles. Augmenting prompt..."}
+
+            # RAG: プロンプトに知識を統合
+            knowledge_context = "\n\n".join([
+                f"[Knowledge {i+1} - {tile['verification_type']} verification, confidence: {tile['confidence_score']}]\n"
+                f"Topic: {tile['topic']}\n"
+                f"Content: {tile['content']}"
+                for i, tile in enumerate(relevant_knowledge)
+            ])
+
+            augmented_prompt = f"""Based on the following verified knowledge from the database:
+
+{knowledge_context}
+
+Now, please answer the following question accurately:
+{prompt}"""
+
+            # ストリーミング推論実行
+            async for chunk in self._perform_llm_streaming_inference(model_config, augmented_prompt, temperature or model_config.temperature):
+                if chunk.get("type") == "token":
+                    generated_response += chunk.get("content", "")
+                yield chunk
+
+            yield {"type": "meta", "source_type": source_type, "thinking": f"Accessed knowledge base. Retrieved {len(relevant_knowledge)} relevant knowledge tiles."}
+
+        else:
+            yield {"type": "thinking", "content": "No specific DB knowledge found. Using AI internal weights."}
+
+            # ストリーミング推論実行
+            async for chunk in self._perform_llm_streaming_inference(model_config, prompt, temperature or model_config.temperature):
+                if chunk.get("type") == "token":
+                    generated_response += chunk.get("content", "")
+                yield chunk
+
+            yield {"type": "meta", "source_type": source_type, "thinking": "Inferred from AI internal weights."}
+
+            # 自己拡充: 推論結果をDBに保存（信頼度が十分な場合）
+            if save_to_memory and len(generated_response) > 0:
+                await self._save_inference_to_db(
+                    domain_id=domain_id,
+                    prompt=prompt,
+                    response=generated_response,
+                    confidence=0.75,  # ストリーミングなので固定値
+                    source_type="ai",
+                    model_id=model_config.model_id
+                )
+
+        # 倒木システム: 師匠の出力を教師データとして保存
+        logger.error(f"[CRITICAL DEBUG] Reached training data save section! generated_response length={len(generated_response)}")
+        is_master = (self.master_model and model_config.model_id == self.master_model.model_id)
+        logger.info(f"[Training Data Check - Streaming] master_model={self.master_model.model_id if self.master_model else None}, "
+                   f"current_model={model_config.model_id}, is_master={is_master}, "
+                   f"response_length={len(generated_response)}, save_to_memory={save_to_memory}")
+        if is_master and len(generated_response) > 0:
+            logger.info(f"[Training Data - Streaming] Saving master output for domain '{domain_id}'...")
+            await self._save_master_output_as_training_data(
+                prompt=prompt,
+                master_response=generated_response,
+                domain_id=domain_id,
+                confidence=0.8
+            )
+        else:
+            logger.info(f"[Training Data - Streaming] NOT saving: is_master={is_master}, response_length={len(generated_response)}")
+
+    def _check_db_knowledge(self, domain_id: str, prompt: str) -> bool:
+        """
+        指定されたドメインとプロンプトに関連する知識があるかチェックする。
+        樹木型空間記憶（.iath）を使用。
+        """
+        try:
+            if self.dendritic_memory is None:
+                return False
+
+            # テキスト検索でマッチがあるかチェック
+            results = self.dendritic_memory.search_by_text(prompt[:200], top_k=1)
+            return len(results) > 0
+
+        except Exception as e:
+            logger.error(f"Error checking dendritic memory: {e}")
+            return False
+
+    def _retrieve_relevant_knowledge(self, domain_id: str, prompt: str, top_k: int = 3) -> list:
+        """
+        指定されたドメインとプロンプトに関連する知識を取得する。
+        樹木型空間記憶（.iath）のハイブリッド検索を使用。
+        """
+        try:
+            if self.dendritic_memory is None:
+                return []
+
+            # ハイブリッド検索（テキスト + 空間座標）
+            # TODO: プロンプトから空間座標を推定する機能を追加
+            results = self.dendritic_memory.hybrid_search(prompt, query_coords=None, top_k=top_k)
+
+            # 統一フォーマットに変換
+            return [
+                {
+                    "id": tile["metadata"]["knowledge_id"],
+                    "topic": tile["metadata"]["topic"],
+                    "content": tile["content"]["final_response"],
+                    "thinking_process": tile["content"]["thinking_process"],
+                    "confidence_score": tile["verification"]["initial_certainty"],
+                    "verification_type": tile["verification"]["status"],
+                    "coordinates": tile["coordinates"],
+                    "text_match_score": tile.get("text_match_score", 0),
+                    "spatial_distance": tile.get("spatial_distance", None)
+                }
+                for tile in results
+            ]
+
+        except Exception as e:
+            logger.error(f"Error retrieving relevant knowledge from dendritic memory: {e}")
+            return []
+
+    async def _perform_llm_inference(self, model_config: ModelConfig, prompt: str, temperature: float) -> Dict[str, Any]:
+        """
+        指定されたモデル設定でLLM推論を実行する。
+        各プロバイダーの実装を使用。
+        """
+        provider_type = model_config.provider
+
+        if provider_type not in self.providers:
+            raise ValueError(f"Unsupported provider: {provider_type}")
+
+        provider = self.providers[provider_type]
+
+        try:
+            result = await provider.infer(model_config, prompt, temperature)
+            return result
+        except Exception as e:
+            logger.error(f"Error during LLM inference with provider '{provider_type}': {e}")
+            raise
+
+    async def _perform_llm_streaming_inference(self, model_config: ModelConfig, prompt: str, temperature: float) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        指定されたモデル設定でLLMストリーミング推論を実行する。
+        各プロバイダーの実装を使用。
+        """
+        provider_type = model_config.provider
+
+        if provider_type not in self.providers:
+            raise ValueError(f"Unsupported provider: {provider_type}")
+
+        provider = self.providers[provider_type]
+
+        try:
+            async for chunk in provider.infer_streaming(model_config, prompt, temperature):
+                yield chunk
+        except Exception as e:
+            logger.error(f"Error during LLM streaming inference with provider '{provider_type}': {e}")
+            yield {"type": "error", "content": str(e)}
+
+    async def _save_inference_to_db(self, domain_id: str, prompt: str, response: str, confidence: float, source_type: str, model_id: str) -> bool:
+        """
+        推論結果をKnowledge TileとしてDBに保存する（自己拡充）。
+
+        Priority 2実装: 座標自動推定 + .iath保存
+        """
+        try:
+            from backend.app.database.models import KnowledgeTile
+            from backend.app.database.session import SessionLocal  # 遅延インポート
+
+            db = SessionLocal()
+            tile_id = f"ai_ktile_{uuid.uuid4().hex}"
+
+            # AI生成の知識タイルを作成（SQLite）
+            new_tile = KnowledgeTile(
+                id=tile_id,
+                workspace_id="default_workspace",  # ローカル版なのでデフォルトワークスペース
+                domain_id=domain_id,
+                topic=prompt[:200],  # プロンプトをトピックとして使用
+                content=response,
+                confidence_score=confidence,
+                verification_type="ai",  # AI生成を示す
+                verification_count=1,
+                contributor_id=None,  # AIなのでcontributorなし
+                last_verified_by_id=None
+            )
+
+            db.add(new_tile)
+            db.commit()
+            db.close()
+
+            logger.info(f"Saved AI inference to SQLite: {new_tile.id}")
+
+            # Priority 2: 座標自動推定 + .iath保存
+            try:
+                # 座標推定用のLLM推論関数を作成
+                async def llm_inference_for_coords(coord_prompt):
+                    # 師匠モデル（またはDeepSeek）を使って座標推定
+                    estimation_model = self.master_model if self.master_model else self._get_any_available_model()
+
+                    if estimation_model:
+                        result = await self._perform_llm_inference(
+                            estimation_model,
+                            coord_prompt,
+                            temperature=0.3  # 低温度で一貫性を保つ
+                        )
+                        return result.get("response", "")
+                    return "{\"coordinates\": [0.5, 0.5, 0.5, 0.5, 0.5, 0.5], \"confidence\": 0.3}"
+
+                # 座標を推定
+                coord_result = await self.coordinate_estimator.estimate_coordinates(
+                    prompt=prompt,
+                    response=response,
+                    domain_id=domain_id,
+                    llm_inference_func=llm_inference_for_coords,
+                    use_reasoning=False  # 高速化のため推論過程は省略
+                )
+
+                # .iath Tileオブジェクトを作成
+                iath_tile = create_tile_from_ai_output(
+                    knowledge_id=tile_id,
+                    topic=prompt[:100],
+                    prompt=prompt,
+                    response=response,
+                    coordinates=coord_result["coordinates"],
+                    confidence=confidence,
+                    domain_id=domain_id,
+                    source="ai_generated"
+                )
+
+                # .iathファイルに保存
+                success = self.iath_writer.append_tile(iath_tile)
+
+                if success:
+                    logger.info(f"Saved AI inference to .iath with coordinates: {coord_result['coordinates']}")
+
+                    # メモリをリロード（新しいタイルを検索可能にする）
+                    self._load_dendritic_memory()
+                else:
+                    logger.warning(f"Failed to save to .iath, but SQLite save succeeded")
+
+            except Exception as iath_error:
+                logger.error(f"Error saving to .iath (SQLite save succeeded): {iath_error}")
+                # .iath保存失敗してもSQLite保存は成功しているのでTrueを返す
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Error saving inference to DB: {e}")
+            return False
+
+    async def _save_master_output_as_training_data(self, prompt: str, master_response: str, domain_id: str, confidence: float) -> bool:
+        """
+        師匠の出力を弟子のファインチューニング用教師データとして保存する。
+        倒木システムの核心機能。
+        """
+        try:
+            import json
+            import os
+            from datetime import datetime
+
+            logger.info(f"[Save Training Data] Starting to save master output (domain={domain_id}, confidence={confidence})")
+
+            # トレーニングデータ保存ディレクトリ
+            training_data_dir = "training_data/master_outputs"
+            logger.info(f"[Save Training Data] Creating directory: {training_data_dir}")
+            os.makedirs(training_data_dir, exist_ok=True)
+
+            # Alpaca形式で保存
+            training_example = {
+                "instruction": f"You are an expert in {domain_id}. Provide accurate information based on verified knowledge.",
+                "input": prompt,
+                "output": master_response,
+                "metadata": {
+                    "domain_id": domain_id,
+                    "confidence": confidence,
+                    "master_model_id": self.master_model.model_id if self.master_model else "unknown",
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "source": "master_output"
+                }
+            }
+
+            # JSONLファイルに追記
+            output_file = os.path.join(training_data_dir, f"master_outputs_{domain_id}.jsonl")
+            logger.info(f"[Save Training Data] Writing to file: {output_file}")
+            with open(output_file, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(training_example, ensure_ascii=False) + '\n')
+
+            logger.info(f"✓ Successfully saved master output as training data: {output_file}")
+            return True
+
+        except Exception as e:
+            logger.error(f"✗ Error saving master output as training data: {e}", exc_info=True)
+            return False