❌ A2A通信なしの場合
User → Single Coordinator → Agent A（個別処理）
                        → Agent B（個別処理）  
                        → Agent C（個別処理）
                        ↓
                   個別結果をマニュアル統合
                        ↓
                   品質の低い最終結果

✅ A2A通信ありの場合  
User → Coordinator → Agent A ←→ Agent B ←→ Agent C
                        ↓         ↓         ↓
                   リアルタイム情報共有・協調処理
                        ↓
                   統合された高品質結果

🔴 データアクセスの複雑性（MCP導入前）

Agent A → API接続A → Database A
Agent B → API接続B → Database B  
Agent C → API接続C → External Service C
        ↓
・各エージェントが個別のデータソースアクセス実装
・データ形式の不統一による変換処理の複雑化  
・セキュリティ・認証の重複実装
・データ整合性の管理困難

✅ 統一データアクセス層（MCP導入後）

Agent A ↘
Agent B → MCP Protocol → Unified Data Layer → すべてのデータソース
Agent C ↗
        ↓
・統一インターフェースによるシンプルなデータアクセス
・データ形式の自動変換と標準化
・セキュリティ・認証の一元管理  
・データ整合性とトランザクション管理の自動化

🌟 マルチエージェント + A2A + MCP = 次世代AIシステム

┌─────────────────────────────────────────┐
│ マルチエージェントシステム（設計思想）      │
│  ┌─────────────────────────────────┐    │
│  │ A2A通信（協調制御）              │    │  
│  │  ┌─────────────────────────┐    │    │
│  │  │ MCP（データアクセス）     │    │    │
│  │  │                         │    │    │
│  │  │ • 統一インターフェース   │    │    │
│  │  │ • リアルタイムデータ同期 │    │    │
│  │  │ • セキュリティ管理       │    │    │
│  │  └─────────────────────────┘    │    │
│  │                                 │    │
│  │ • 動的エージェント選択           │    │
│  │ • 適応的ワークフロー制御         │    │
│  │ • リアルタイム協調処理           │    │
│  └─────────────────────────────────┘    │
│                                         │
│ • 専門エージェントの協調による高度な問題解決 │
│ • 障害耐性とスケーラビリティ              │
│ • 継続的学習と自動改善                  │
└─────────────────────────────────────────┘

Backend:    Python + FastAPI
Protocol:   Model Context Protocol (MCP)
Communication: WebSocket + Agent-to-Agent messaging
Cloud:      Azure Container Apps
AI:         Azure Cognitive Services
Development: Docker + Hot Reload

❌ 従来の単一AIシステム
User: "交通渋滞で配送遅延、顧客クレーム対応を"
→ Single AI: 交通情報 OR 顧客対応のどちらかが浅い処理になる
→ 結果: 表面的な回答、根本解決に至らない

❌ 従来のシステム
User: "緊急事態が発生しました"
→ 事前定義されたワークフローに従うのみ
→ 状況に応じた最適処理パスの選択ができない

❌ 従来の実装
複数データソースへの問い合わせ
→ 順次処理によるレスポンス遅延
→ 情報鮮度の劣化
→ 統合時の整合性問題

✅ A2A システム
User: "交通渋滞で配送遅延、顧客クレーム対応を"

並行実行:
├─ Smart City Agent: リアルタイム交通分析 + 迂回ルート最適化
├─ Customer Support Agent: 顧客心理分析 + サービス回復戦略  
└─ Enterprise Agent: 配送リソース再配置 + 影響範囲算出

→ 各専門領域での最深度分析が同時実行可能
→ 3分で包括的解決策を生成

# ✅ インテリジェントコーディネーション
# User Query → LLM分析による動的エージェント選択
#           → 状況に応じた最適協調パターン決定
#           → リアルタイム優先度調整
#           → 品質評価による自動再実行

# 実装例:
if emergency_level == "critical":
    coordination_pattern = "sequential_cascade"  # 緊急時連鎖処理
elif complexity == "high": 
    coordination_pattern = "hierarchical"       # 段階的詳細化
else:
    coordination_pattern = "parallel"           # 並列最適化

# 品質評価による適応制御
quality_score = await evaluate_result_quality(result)
if quality_score < 0.8:
    print("🔄 品質不足のため前段階を修正して再実行")
    corrected_input = await correct_previous_step(result)
    result = await re_execute_with_corrections(corrected_input)

✅ MCP統合による統一データアクセス
複数エージェント → MCP Protocol → 統一データレイヤー
                                 ↓
                    リアルタイム整合性保証されたデータ
                                 ↓
                    各エージェントが最新情報で推論実行

# 以前: 不可能（事前定義ルートのみ）
# 現在: 可能
async def analyze_query_with_llm(self, query: str) -> Dict[str, Any]:
    # LLMがクエリを解析して最適エージェントを動的選択
    prompt = f"クエリ: {query}\n最適なエージェント組み合わせを選択せよ"
    analysis = await self.openai_client.chat.completions.create(...)
    return json.loads(analysis.choices[0].message.content)

# 以前: 不可能（品質評価と自動再実行）
# 現在: 可能
async def execute_with_quality_control(self, query, agents):
    max_retries = 3
    for attempt in range(max_retries):
        result = await self.execute_task(query, agents)
        quality_score = await self.evaluate_quality(result)
        
        if quality_score >= 0.8:
            return result
        else:
            # 品質不足時の自動改善
            print(f"🔄 品質不足 ({quality_score:.2f})、改善して再実行")
            agents = await self.optimize_agent_selection(query, result)
            
    return await self.fallback_response(query)

# 以前: 不可能（ワークフロー巻き戻し）
# 現在: 可能
async def execute_adaptive_workflow(self, workflow_steps):
    current_step = 0
    step_results = []
    
    while current_step < len(workflow_steps):
        step_result = await self.execute_step(workflow_steps[current_step])
        
        # 結果評価と動的制御
        evaluation = await self.evaluate_step_result(step_result)
        
        if evaluation["action"] == "continue":
            step_results.append(step_result)
            current_step += 1
        elif evaluation["action"] == "retry_previous":
            # 前段階に戻って修正
            print("🔙 前段階を修正して再実行")
            steps_back = evaluation["steps_back"]
            current_step = max(0, current_step - steps_back)
            step_results = step_results[:-steps_back]  # 結果も巻き戻し
        elif evaluation["action"] == "add_parallel_task":
            # 新しい並列タスクを動的追加
            new_tasks = evaluation["additional_tasks"]
            workflow_steps.extend(new_tasks)
    
    return await self.synthesize_workflow_results(step_results)

# 以前: 不可能（データ整合性問題）
# 現在: 可能
async def sync_agent_states(self, workflow_id):
    # 全エージェント間でリアルタイム状態同期
    current_states = await asyncio.gather(*[
        agent.get_current_state(workflow_id) 
        for agent in self.active_agents
    ])
    await self.broadcast_state_update(workflow_id, current_states)

# src/agents/coordinator/intelligent_coordinator.py
async def analyze_query_with_llm(self, query: str, query_type: str = "general") -> Dict[str, Any]:
    """ユーザークエリをLLMで分析して最適エージェントを自動選択"""
    
    if not self.openai_client:
        # フォールバック: ルールベース分析
        return await self.fallback_query_analysis(query, query_type)
    
    try:
        # エージェント能力情報をLLM用に整理
        agents_info = "\n".join([
            f"- {cap.agent_id}: {cap.description}\n  専門分野: {', '.join(cap.specialty_areas)}\n  キーワード: {', '.join(cap.keywords[:5])}"
            for cap in self.agent_capabilities.values()
        ])
        
        # LLMプロンプト構築
        prompt = f"""
ユーザークエリ: "{query}"

利用可能エージェント:
{agents_info}

タスク:
1. クエリ内容を分析
2. 必要なエージェントを選択
3. 理由を説明

レスポンス形式 (JSON):
{{
  "selected_agents": ["エージェントID一覧"],
  "reasoning": "選択理由",
  "coordination_type": "parallel|sequential|hierarchical",
  "priority": "high|medium|low"
}}
        """
        
        # LLMでエージェント選択実行
        response = await self.openai_client.chat.completions.create(
            model=os.getenv("REASONING_MODEL", "gpt-4o"),
            messages=[
                {"role": "system", "content": "あなたはマルチエージェントシステムの知的コーディネーターです。ユーザーのクエリを分析し、最適なエージェントを選択してください。"},
                {"role": "user", "content": prompt}
            ],
            temperature=0.2,
            response_format={"type": "json_object"}
        )
        
        result = json.loads(response.choices[0].message.content)
        return {
            "selected_agents": result.get("selected_agents", []),
            "reasoning": result.get("reasoning", "LLMによる自動分析"),
            "coordination_type": result.get("coordination_type", "parallel"),
            "priority": result.get("priority", "medium")
        }
        
    except Exception as e:
        print(f"⚠️  LLM分析エラー: {e}")
        return await self.fallback_query_analysis(query, query_type)

async def fallback_query_analysis(self, query: str, query_type: str) -> Dict[str, Any]:
    """フォールバック: ルールベースのエージェント選択"""
    required_agents = []
    query_lower = query.lower()
    
    # カスタマーサポート関連キーワード検出
    if any(word in query_lower for word in ["顧客", "お客様", "問い合わせ", "苦情", "返品"]):
        required_agents.append("customer_support_agent")
    
    # スマートシティ関連キーワード検出
    if any(word in query_lower for word in ["交通", "渋滞", "事故", "電力", "緒急事態"]):
        required_agents.append("smart_city_agent")
    
    # 企業業務関連キーワード検出
    if any(word in query_lower for word in ["従業員", "給与", "人事", "財務", "プロジェクト", "配送"]):
        required_agents.append("enterprise_agent")
    
    return {
        "selected_agents": list(set(required_agents)),
        "reasoning": f"キーワードベース分析: {', '.join(required_agents)}",
        "coordination_type": "parallel",
        "priority": "medium"
    }

入力: "顧客からの苦情を処理したいのですが"
→ 自動判断: customer_support_agent のみ選択

入力: "交通事故により配送が遅れています。影響を受けた顧客への対応をお願いします"
→ 自動判断: smart_city_agent + customer_support_agent + enterprise_agent

         ┌→ Customer Agent ┐
Query ──→┤                 ├→ 統合結果
         └→ City Agent    ┘

Query → Agent A → Agent B → Agent C → Final Response

Query → Coordinator → Specialist Agents → Sub-specialists → Result

# src/agents/coordinator/intelligent_coordinator.py 
async def orchestrate_agents(self, query: str, query_type: str = "general") -> Dict[str, Any]:
    """エージェント間協調処理の実行"""
    try:
        # Step 1: LLMベース自動エージェント選択
        analysis_result = await self.analyze_query_with_llm(query, query_type)
        selected_agents = analysis_result.get("selected_agents", [])
        coordination_type = analysis_result.get("coordination_type", "parallel")
        
        if not selected_agents:
            return {
                "status": "error",
                "message": "対応可能なエージェントが見つかりません"
            }
        
        # Step 2: 協調タイプに応じた処理
        if coordination_type == "parallel":
            return await self.execute_parallel_coordination(query, selected_agents)
        elif coordination_type == "sequential":
            return await self.execute_sequential_coordination(query, selected_agents) 
        elif coordination_type == "hierarchical":
            return await self.execute_hierarchical_coordination(query, selected_agents)
        else:
            # デフォルト: 並列処理
            return await self.execute_parallel_coordination(query, selected_agents)
            
    except Exception as e:
        return {
            "status": "error",
            "message": f"協調処理エラー: {str(e)}"
        }

async def execute_parallel_coordination(self, query: str, selected_agents: List[str]) -> Dict[str, Any]:
    """並列型協調処理"""
    # Step 1: 複数エージェントに同時にタスク分散
    tasks = []
    for agent_id in selected_agents:
        if agent_id == "customer_support_agent":
            task = self.customer_support_agent.handle_query(query)
        elif agent_id == "smart_city_agent":
            task = self.smart_city_agent.handle_query(query)
        elif agent_id == "enterprise_agent":
            task = self.enterprise_agent.handle_query(query)
        tasks.append(task)
    
    # Step 2: 各エージェントが並列で専門処理を実行
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    # Step 3: 調整エージェントが全結果を統合して最終回答生成
    return await self.synthesize_results(query, selected_agents, results)

async def execute_sequential_coordination(self, query: str, selected_agents: List[str]) -> Dict[str, Any]:
    """順次連携型協調処理"""
    current_result = {"query": query}
    
    for agent_id in selected_agents:
        # 前のエージェントの結果を基に次のエージェントが処理
        if agent_id == "smart_city_agent":
            current_result = await self.smart_city_agent.handle_query_with_context(query, current_result)
        elif agent_id == "enterprise_agent":
            current_result = await self.enterprise_agent.handle_query_with_context(query, current_result)
        elif agent_id == "customer_support_agent":
            current_result = await self.customer_support_agent.handle_query_with_context(query, current_result)
    
    return current_result

{
  "workflow_id": "WF-COMPLEX-001",
  "participating_agents": ["smart_city_agent", "customer_support_agent", "enterprise_agent"],
  "analysis": {
    "traffic_situation": "主要道路で事故により30分遅延",
    "customer_impact": "12件のクレーム、うち3件が重要顧客",
    "business_risk": "配送遅延による信頼失墜リスク"
  },
  "coordinated_response": {
    "immediate_actions": [
      "重要顧客への個別連絡・謝罪",
      "代替ルートでの緊急配送手配",
      "配送料全額返金オファー"
    ],
    "preventive_measures": [
      "リアルタイム交通情報システム導入",
      "配送ルート複数化",
      "顧客通知システム自動化"
    ]
  },
  "estimated_resolution": "2時間以内",
  "customer_satisfaction_recovery": "95%以上"
}

🔴 MCP導入前のマルチエージェントシステム

Agent A (顧客サポート) ─┐
                    ├─ 個別DB接続とAPI実装
Agent B (スマートシティ) ─┤    ↓
                    ├─ データ形式変換処理
Agent C (企業業務)    ─┤    ↓  
                    └─ セキュリティ・認証の重複実装
                         ↓
                    メンテナンスコスト増大
                         ↓
                    データ不整合リスク

🟢 MCP導入後のマルチエージェントシステム

Agent A (顧客サポート) ─┐
                     ├─ MCP統一インターフェース
Agent B (スマートシティ) ─┤         ↓
                     ├─ 自動データ変換・検証
Agent C (企業業務)    ─┤         ↓
                     └─ 統一セキュリティ・認証
                              ↓
                         データアクセス層
                              ↓
                    すべての外部データソース

# 従来の方法：各エージェントが個別にデータアクセス
class CustomerAgent:
    def get_customer_info(self, customer_id):
        # 個別のデータベース接続
        db_connection = create_db_connection(
            host="localhost", user="app_user", password="secret"
        )
        try:
            result = db_connection.execute(
                "SELECT * FROM customers WHERE id = %s", (customer_id,)
            )
            return result.fetchone()
        except Exception as e:
            logging.error(f"Database error: {e}")
            return None
        finally:
            db_connection.close()
        
class CityAgent:
    def get_traffic_data(self, location):
        # 別のAPI接続と認証処理
        headers = {"Authorization": f"Bearer {self.api_token}"}
        try:
            response = requests.get(
                f"https://city-api.example.com/traffic/{location}",
                headers=headers, timeout=30
            )
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            logging.error(f"API error: {e}")
            return None

# MCP使用：統一されたデータアクセス
class MCPClient:
    async def query_data_source(self, source: str, query: dict):
        """MCPプロトコルを使用した統一データアクセス"""
        try:
            # MCPメッセージの構成
            mcp_message = {
                "method": "resources/read",
                "params": {
                    "uri": f"mcp://{source}",
                    "query": query
                }
            }
            # 統一されたエラーハンドリング
            response = await self.send_mcp_request(mcp_message)
            return response.get("result", {})
        except Exception as e:
            logging.error(f"MCP query error for {source}: {e}")
            raise MCPError(f"データソース {source} へのアクセスに失敗しました")

# エージェントは統一インターフェースを使用
class CustomerAgent(BaseAgent):
    def __init__(self, agent_id: str, name: str):
        super().__init__(agent_id, name)
        # MCPクライアントを登録
        self.register_mcp_client("customer_db", MCPClient())
        
    async def get_customer_info(self, customer_id: str):
        """MCPを使用した統一顧客情報取得"""
        try:
            return await self.mcp_clients["customer_db"].query_data_source(
                "customer_database", 
                {"action": "get_customer", "customer_id": customer_id}
            )
        except Exception as e:
            return {"error": f"顧客情報の取得に失敗しました: {e}"}
        
    async def get_customer_info(self, customer_id: str) -> Dict[str, Any]:
        """顧客情報をMCP経由で取得"""
        if "customer_db" in self.mcp_clients:
            return await self.mcp_clients["customer_db"].query_data_source(
                "customer_database", 
                {"action": "get_customer", "customer_id": customer_id}
            )
        else:
            # フォールバック処理
            return {"error": "MCP client not available"}

自然言語クエリ
    ↓
┌─────────────────────────┐
│   Coordinator Agent     │ ←─ クエリ分析・エージェント選択
│   (LLM-based Analysis)  │
└─────────┬───────────────┘
          │
    ┌─────┴─────┐
    │ 自動判断   │
    └─────┬─────┘
          ↓
┌─────────────────────────────────────┐
│  Selected Agent(s) 協調実行         │
├─────────────────────────────────────┤
│ Customer │  City  │ Enterprise      │
│ Support  │ Management │ Agent       │
└─────┬────────┬─────────┬────────────┘
      │        │         │
      └────────┼─────────┘
               ↓
    ┌─────────────────┐
    │ 結果統合・最終回答 │
    └─────────────────┘

┌─────────────────┐    ┌──────────────────────┐
│   Web Client    │◄──►│    FastAPI Server    │
└─────────────────┘    └──────────┬───────────┘
                                  │
                         ┌────────▼────────┐
                         │  Smart Router   │ ←─ 自動エージェント選択
                         │ (Query Analysis)│
                         └────────┬────────┘
                                  │
            ┌─────────────────────┼─────────────────────┐
            │                     │                     │
    ┌───────▼────────┐   ┌────────▼────────┐   ┌───────▼────────┐
    │ Customer Agent │   │  City Agent     │   │ Enterprise     │
    │     Support    │   │   Management    │   │   Agent        │
    └────────┬───────┘   └────────┬────────┘   └───────┬────────┘
             │                    │                    │
             └────────┬───────────┬────────────────────┘
                      │           │
              ┌───────▼───────────▼──────┐
              │   Coordinator Agent      │ ←─ 協調制御・結果統合
              └─────────┬────────────────┘
                        │
        ┌───────────────┼───────────────┐
        │               │               │
┌───────▼──────┐ ┌──────▼──────┐ ┌──────▼──────┐
│ Customer MCP │ │  City MCP   │ │Enterprise   │
│   Server     │ │   Server    │ │ MCP Server  │
└──────────────┘ └─────────────┘ └─────────────┘

# APIコール例
curl -X POST "http://localhost:8000/coordinator/orchestrate" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "顧客ID12345の注文状況を確認して、配送状況と返金処理を検討してください",
    "query_type": "customer_service"
  }'

# 1. クエリ分析（調整エージェント内部処理）
analyzed_keywords = ["顧客", "注文状況", "配送", "返金"]
required_capabilities = ["customer_management", "order_tracking", "payment_processing"]

# 2. 自動エージェント選択結果
selected_agents = [
    "customer_support_agent",  # 顧客情報・返金処理
    "enterprise_agent"         # 注文・配送状況確認
]

{
  "status": "success",
  "result": {
    "customer_info": "プレミアム会員（3年継続）",
    "order_status": "配送遅延（台風影響）",
    "recommended_actions": [
      "配送状況の詳細説明",
      "代替商品の提案",
      "配送料返金の手続き"
    ],
    "estimated_resolution": "24時間以内"
  }
}

# 自然言語での緊急事態報告
curl -X POST "http://localhost:8000/coordinator/orchestrate" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "新宿区西新宿で高層ビル火災が発生しました。近隣企業への影響を評価し、顧客へも適切に対応してください。",
    "query_type": "emergency"
  }'

# クエリ分析結果
detected_keywords = {
    "emergency": ["火災", "緊急"],           # → smart_city_agent
    "business": ["企業", "影響"],            # → enterprise_agent  
    "customer": ["顧客", "対応"]             # → customer_support_agent
}

# 自動選択結果: 全エージェント協調が必要
selected_agents = ["smart_city_agent", "enterprise_agent", "customer_support_agent"]
coordination_type = "sequential_cascade"  # 連鎖型協調処理

# Stage 1: 緊急事態初期対応
stage1 = await smart_city_agent.handle_emergency({
    "type": "fire", "location": "新宿区西新宿", "severity": "high"
})

# Stage 2: Stage1の結果を基に企業影響評価  
stage2 = await enterprise_agent.assess_business_impact({
    "emergency_data": stage1,
    "affected_area": stage1["impact_radius"],
    "business_operations": "all_sectors"
})

# Stage 3: Stage1+2の統合結果で顧客対応策立案
stage3 = await customer_support_agent.create_customer_response({
    "emergency_info": stage1,
    "business_impact": stage2,
    "affected_customers": stage2["customer_list"]
})

# Final: 全ステージ結果の統合
final_response = coordinator.synthesize_emergency_response([stage1, stage2, stage3])

{
  "emergency_coordination": {
    "incident_id": "FIRE-2024-0001",
    "coordinated_response_time": "3分30秒",
    "participating_agents": ["smart_city_agent", "enterprise_agent", "customer_support_agent"],
    
    "city_response": {
      "emergency_units_dispatched": ["消防車3台", "救急車2台"],
      "traffic_control": "半径1km通行止め実施",
      "estimated_containment": "45分以内"
    },
    
    "business_impact_assessment": {
      "affected_companies": 28,
      "evacuated_employees": 1247,
      "suspended_services": ["配送", "コールセンター"],
      "bcp_activation": "Level-2 発動"
    },
    
    "customer_response_plan": {
      "affected_customers": 3891,
      "auto_notifications_sent": 3891,
      "service_alternatives": "代替拠点での受付開始",
      "compensation_offered": "サービス中断による割引"
    }
  }
}

# 自然言語での包括的業務指示
curl -X POST "http://localhost:8000/reasoning/orchestrate" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "新入社員の田中さんを開発部に配属します。給与設定、プロジェクト割り当て、顧客対応体制の準備をお願いします。",
    "query_type": "general"
  }'

# 自動検出されたマルチドメイン要求
domain_analysis = {
    "hr_requirements": ["新入社員", "配属"],        # → enterprise_agent
    "finance_requirements": ["給与設定"],           # → enterprise_agent  
    "project_requirements": ["プロジェクト割り当て"],  # → enterprise_agent
    "customer_requirements": ["顧客対応体制"]        # → customer_support_agent
}

# 自動協調スケジューリング
coordination_plan = {
    "phase1": "基本情報セットアップ（enterprise_agent）",
    "phase2": "顧客対応体制構築（customer_support_agent）", 
    "phase3": "統合確認・最終調整（coordinator）"
}

# 複数のエンドポイントを手動で呼び出し
curl /customer-support/create-ticket
curl /enterprise/check-inventory  
curl /city/traffic-status
# 結果を手動で統合...

# 1回のAPI呼び出しで自動協調完了
curl -X POST "/coordinator/orchestrate" \
  -d '{"query": "交通渋滞で配送遅延、顧客対応してください"}'

"台風で配送に影響が出ています"
→ 自動選択: smart_city_agent (気象情報) + enterprise_agent (配送調整) + customer_support_agent (顧客通知)

"年末の繁忙期対応をお願いします"  
→ 自動選択: enterprise_agent (人員配置) + customer_support_agent (サポート体制強化)

# エージェント選択精度の継続改善
class SelectionLearner:
    def learn_from_feedback(self, query, selected_agents, user_satisfaction):
        # 選択精度を向上させる学習ロジック
        if user_satisfaction > 0.9:
            self.reinforce_selection_pattern(query, selected_agents)
        else:
            self.adjust_selection_criteria(query, selected_agents)

# リポジトリクローン
git clone https://github.com/RyoutaTakaoka/MCP_A2A_RAG.git
cd MCP_A2A_RAG

# 環境設定
cp .env.template .env
# .env ファイルに実際のAPIキーを設定

# ローカル開発環境起動
./dev-start.sh

# または手動で起動
python3 src/main.py

# カスタマーサポート専用クエリ
curl -X POST "http://localhost:8000/coordinator/orchestrate" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "顧客からの苦情を処理したいです",
    "query_type": "general"
  }'

# 期待される自動選択: customer_support_agent のみ

# 複合的な問題への対応
curl -X POST "http://localhost:8000/coordinator/orchestrate" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "交通渋滞により配送が遅れ、お客様からクレームが来ています",
    "query_type": "general"
  }'

# 期待される自動選択: smart_city_agent + customer_support_agent + enterprise_agent

# 全エージェント状態確認
curl -X POST "http://localhost:8000/coordinator/orchestrate" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "システム全体の稼働状況を報告してください",
    "query_type": "system_status"
  }'

# 期待される自動選択: 全エージェント（customer_support_agent + smart_city_agent + enterprise_agent）

# 緊急時の自動エージェント協調
curl -X POST "http://localhost:8000/coordinator/orchestrate" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "火災が発生しました。企業への影響と顧客対応を至急お願いします",
    "query_type": "emergency"
  }'

# 期待される自動選択: smart_city_agent → enterprise_agent → customer_support_agent (連鎖協調)

{
  "workflow_id": "WF-AUTO-001",
  "query": "交通渋滞により配送が遅れ...",
  "participating_agents": [
    "smart_city_agent",
    "customer_support_agent", 
    "enterprise_agent"
  ],
  "selection_reasoning": "交通(smart_city) + 顧客(customer_support) + 配送(enterprise)の複合課題を検出",
  "processing_time": 1.247
}

# 現在のGPT-4o：即答型処理
def gpt4o_processing(query):
    response = model.generate(query)  # 即座に回答生成
    return response  # 推論プロセスは見えない

# GPT-5.1：推論ステップ可視化型
def gpt51_reasoning(query):
    reasoning_steps = model.reason_step_by_step(query)
    # [思考1] → [思考2] → [検証] → [結論]
    for step in reasoning_steps:
        print(f"Reasoning: {step.thought}")
        if step.needs_verification:
            step.verify()
    
    return step.final_conclusion  # 検証済み結論

# 現在：各エージェントの判断プロセスが不透明
customer_agent.analyze(issue)  # → 結果のみ返却
city_agent.analyze(issue)     # → 推論過程不明
enterprise_agent.analyze(issue)  # → なぜその判断？

# 推論ステップを他エージェントと共有
def reasoning_aware_coordination():
    # エージェントAの推論過程
    customer_reasoning = customer_agent.reason_with_steps(issue)
    # [思考] "VIP顧客なので優先対応が必要"
    # [根拠] "過去の購入履歴から高価値顧客と判定"
    # [検証] "同類ケースでの対応実績を確認"
    
    # エージェントBが推論過程を理解して連携
    city_agent.build_on_reasoning(
        previous_reasoning=customer_reasoning,
        new_context="都市インフラ影響も考慮"
    )
    # [思考] "顧客対応に加えて配送ルート最適化が必要"
    # [連携] "customer_agentの優先判定を活用"
    
    return collaborative_solution

class ReasoningQualityAgent:
    """GPT-5.1の推論機能を活用した品質管理"""
    
    async def validate_agent_reasoning(self, agent_response):
        # 推論ステップを解析
        reasoning_chain = self.extract_reasoning_steps(agent_response)
        
        # 各ステップの論理性を検証
        for step in reasoning_chain:
            logic_validation = await self.verify_logic(step)
            if not logic_validation.is_valid:
                # 自動的に推論を修正
                corrected_step = await self.correct_reasoning(step)
                reasoning_chain.update(step, corrected_step)
        
        return self.synthesize_verified_conclusion(reasoning_chain)

def intelligent_agent_selection(complex_query):
    # GPT-5.1が推論ステップを分析
    reasoning_analysis = gpt51_coordinator.analyze_query_reasoning(complex_query)
    
    # 推論: "この問題は3段階の分析が必要"
    # 1. 顧客感情分析 → customer_agent適任
    # 2. 技術的解決策 → enterprise_agent適任  
    # 3. 実装可能性検証 → city_agent適任
    
    # 推論に基づく最適なエージェント組み合わせを選択
    optimal_team = reasoning_analysis.recommend_agent_team()
    
    # 各エージェントに推論コンテキストを共有
    for agent in optimal_team:
        agent.receive_reasoning_context(reasoning_analysis)
    
    return coordinate_with_shared_reasoning(optimal_team)

# 推論機能はコンピュート集約的
class ReasoningCostManager:
    def should_use_full_reasoning(self, query_complexity):
        if query_complexity.is_simple():
            return False  # GPT-4o高速処理で十分
        elif query_complexity.requires_collaboration():
            return True   # 推論機能で品質向上