MCP サーバーの接続が不安定な時の対処法：ネットワーク問題の診断と解決

2025年6月9日

MCP サーバー

MCP サーバーとクライアント間の接続が不安定になることは、実際の運用において避けられない課題です。接続の断続的な切断、レスポンスの遅延、予期しない通信エラーなど、これらの問題は開発者にとって頭の痛い問題となります。しかし、適切なネットワーク診断技術を身につけることで、これらの問題を体系的に解決できます。

この記事では、MCP サーバーの接続不安定問題に対する技術的なアプローチを詳しく解説いたします。従来のエラーハンドリングとは異なり、ネットワーク層での問題発生メカニズムから、WebSocket 接続特有の診断手法、そして実用的な監視システムの構築まで、技術者が現場で即座に活用できる知識とツールをご紹介します。特に、ping や traceroute といった基本的な診断コマンドから、専用の WebSocket 診断ツール、さらにはパケットレベルでの詳細解析まで、段階的な診断アプローチを通じて、接続問題の根本原因を特定し、効果的な解決策を実装する方法を学んでいただけます。

背景

MCP 接続における不安定要因の分析

MCP（Model Context Protocol）の接続不安定問題は、従来の HTTP ベースの API とは根本的に異なる特性を持っています。WebSocket を基盤とする双方向通信の性質上、ネットワークの状態変化に対してより敏感に反応します。

接続不安定化の主要因子

MCP 接続の不安定化は、以下の要因が複合的に作用することで発生します。

#	要因カテゴリ	発生頻度	影響度	典型的な症状
1	ネットワーク遅延	高	中	レスポンス時間の増加
2	パケット損失	中	高	断続的な接続切断
3	帯域幅制限	中	中	大容量データ転送の失敗
4	ファイアウォール	低	高	完全な接続ブロック
5	プロキシ干渉	低	高	WebSocket ハンドシェイク失敗
6	DNS 解決問題	低	高	初期接続の失敗
7	負荷分散器の設定	低	中	セッション継続性の問題
8	ISP レベルの制限	低	中	特定時間帯の性能劣化

これらの要因を理解することで、効果的な診断戦略を立案できます。

ネットワーク層での問題発生メカニズム

ネットワーク通信における問題は、OSI モデルの各層で異なる形で現れます。MCP 接続の場合、特に重要なのは以下の層での問題です。

typescript// ネットワーク層別の問題分析
interface NetworkLayerAnalysis {
  // 物理層・データリンク層（Layer 1-2）
  physical: {
    symptoms: ['完全な接続不能', 'ハードウェア依存の問題'];
    diagnostics: [
      'ケーブル接続確認',
      'ネットワークアダプタ状態'
    ];
    solutions: ['物理的な接続確認', 'ハードウェア交換'];
  };

  // ネットワーク層（Layer 3）
  network: {
    symptoms: ['IP アドレス解決不能', 'ルーティング問題'];
    diagnostics: ['ping テスト', 'traceroute 解析'];
    solutions: ['ルーティングテーブル修正', 'DNS 設定調整'];
  };

  // トランスポート層（Layer 4）
  transport: {
    symptoms: ['TCP 接続タイムアウト', 'ポート到達不能'];
    diagnostics: ['netstat 確認', 'ポートスキャン'];
    solutions: ['ファイアウォール設定', 'プロキシ設定調整'];
  };

  // アプリケーション層（Layer 7）
  application: {
    symptoms: [
      'WebSocket ハンドシェイク失敗',
      'プロトコルエラー'
    ];
    diagnostics: [
      'WebSocket フレーム解析',
      'JSON-RPC メッセージ検証'
    ];
    solutions: [
      'プロトコル実装修正',
      'メッセージフォーマット調整'
    ];
  };
}

WebSocket 接続特有の不安定性要因

WebSocket 接続は、従来の HTTP リクエスト・レスポンスモデルとは異なる持続的な接続を維持するため、特有の問題が発生します。

WebSocket 固有の課題

typescript// WebSocket 接続の状態管理
class WebSocketConnectionAnalyzer {
  // 接続状態の詳細監視
  analyzeConnectionState(
    ws: WebSocket
  ): ConnectionStateAnalysis {
    return {
      readyState: this.getReadyStateDescription(
        ws.readyState
      ),
      bufferedAmount: ws.bufferedAmount,
      protocol: ws.protocol,
      url: ws.url,
      extensions: ws.extensions,

      // WebSocket 固有の診断項目
      healthMetrics: {
        lastPingTime: this.getLastPingTime(ws),
        roundTripTime: this.calculateRTT(ws),
        messageQueueSize: this.getQueueSize(ws),
        errorHistory: this.getRecentErrors(ws),
      },

      // 不安定性の指標
      stabilityIndicators: {
        reconnectionCount: this.getReconnectionCount(ws),
        averageConnectionDuration:
          this.getAverageConnectionDuration(ws),
        errorRate: this.calculateErrorRate(ws),
        latencyVariation:
          this.calculateLatencyVariation(ws),
      },
    };
  }

  private getReadyStateDescription(state: number): string {
    const states = {
      0: 'CONNECTING - 接続確立中',
      1: 'OPEN - 接続確立済み、通信可能',
      2: 'CLOSING - 接続終了処理中',
      3: 'CLOSED - 接続終了済み',
    };
    return states[state] || 'UNKNOWN';
  }

  // 接続品質の総合評価
  assessConnectionQuality(
    ws: WebSocket
  ): QualityAssessment {
    const metrics = this.analyzeConnectionState(ws);

    let score = 100;
    let issues: string[] = [];

    // RTT によるペナルティ
    if (metrics.healthMetrics.roundTripTime > 1000) {
      score -= 30;
      issues.push('高レイテンシ（RTT > 1000ms）');
    } else if (metrics.healthMetrics.roundTripTime > 500) {
      score -= 15;
      issues.push('中程度のレイテンシ（RTT > 500ms）');
    }

    // エラー率によるペナルティ
    if (metrics.stabilityIndicators.errorRate > 0.05) {
      score -= 40;
      issues.push('高エラー率（> 5%）');
    } else if (
      metrics.stabilityIndicators.errorRate > 0.01
    ) {
      score -= 20;
      issues.push('中程度のエラー率（> 1%）');
    }

    // 再接続頻度によるペナルティ
    if (metrics.stabilityIndicators.reconnectionCount > 5) {
      score -= 25;
      issues.push('頻繁な再接続');
    }

    return {
      score: Math.max(0, score),
      grade: this.getQualityGrade(score),
      issues,
      recommendations: this.generateRecommendations(issues),
    };
  }
}

課題

断続的な接続切断の原因特定の困難さ

断続的な接続切断は、MCP サーバー運用において最も診断が困難な問題の一つです。問題が間欠的に発生するため、再現性の確保と原因の特定に時間がかかります。

問題の複雑性

typescript// 断続的接続切断の分析フレームワーク
class IntermittentDisconnectionAnalyzer {
  private disconnectionEvents: DisconnectionEvent[] = [];
  private connectionMetrics = new Map<
    string,
    ConnectionMetric[]
  >();

  // 切断パターンの分析
  analyzeDisconnectionPattern(): DisconnectionPattern {
    const events = this.disconnectionEvents;

    // 時間的パターンの検出
    const timePattern = this.detectTimePattern(events);

    // 頻度パターンの分析
    const frequencyPattern = this.analyzeFrequency(events);

    // 外部要因との相関分析
    const correlationAnalysis =
      this.analyzeCorrelations(events);

    return {
      timePattern,
      frequencyPattern,
      correlationAnalysis,
      predictiveModel: this.buildPredictiveModel(events),
      recommendations: this.generateActionItems(events),
    };
  }

  private detectTimePattern(
    events: DisconnectionEvent[]
  ): TimePattern {
    const hourlyDistribution = new Array(24).fill(0);
    const dailyDistribution = new Array(7).fill(0);

    events.forEach((event) => {
      const date = new Date(event.timestamp);
      hourlyDistribution[date.getHours()]++;
      dailyDistribution[date.getDay()]++;
    });

    return {
      hourlyPeaks: this.findPeaks(hourlyDistribution),
      dailyPeaks: this.findPeaks(dailyDistribution),
      isRandom: this.testRandomness(events),
      cyclicalPattern: this.detectCycles(events),
    };
  }

  // 相関要因の分析
  private analyzeCorrelations(
    events: DisconnectionEvent[]
  ): CorrelationAnalysis {
    return {
      systemLoad: this.correlateWithSystemLoad(events),
      networkTraffic:
        this.correlateWithNetworkTraffic(events),
      externalServices:
        this.correlateWithExternalServices(events),
      userActivity: this.correlateWithUserActivity(events),
      environmentalFactors:
        this.correlateWithEnvironment(events),
    };
  }
}

レイテンシ変動による性能劣化

ネットワークレイテンシの変動は、MCP プロトコルの双方向通信において深刻な性能問題を引き起こします。

レイテンシ影響の定量化

typescript// レイテンシ変動の監視と分析
class LatencyVariationMonitor {
  private latencyHistory: LatencyMeasurement[] = [];
  private alertThresholds = {
    warning: 500, // 500ms
    critical: 1000, // 1000ms
    variation: 0.3, // 30% 変動
  };

  // リアルタイムレイテンシ測定
  async measureLatency(
    connection: WebSocket
  ): Promise<LatencyMeasurement> {
    const startTime = performance.now();
    const pingId = this.generatePingId();

    return new Promise((resolve, reject) => {
      const timeout = setTimeout(() => {
        reject(new Error('Ping timeout'));
      }, 5000);

      const handler = (event: MessageEvent) => {
        const data = JSON.parse(event.data);
        if (data.type === 'pong' && data.id === pingId) {
          clearTimeout(timeout);
          connection.removeEventListener(
            'message',
            handler
          );

          const endTime = performance.now();
          const latency = endTime - startTime;

          const measurement: LatencyMeasurement = {
            timestamp: Date.now(),
            latency,
            pingId,
            connectionId: this.getConnectionId(connection),
          };

          this.latencyHistory.push(measurement);
          this.trimHistory();

          resolve(measurement);
        }
      };

      connection.addEventListener('message', handler);
      connection.send(
        JSON.stringify({
          type: 'ping',
          id: pingId,
          timestamp: startTime,
        })
      );
    });
  }

  // レイテンシ統計の算出
  calculateLatencyStatistics(
    windowSize: number = 100
  ): LatencyStatistics {
    const recentMeasurements = this.latencyHistory
      .slice(-windowSize)
      .map((m) => m.latency);

    if (recentMeasurements.length === 0) {
      return { available: false };
    }

    const sorted = recentMeasurements.sort((a, b) => a - b);
    const sum = recentMeasurements.reduce(
      (a, b) => a + b,
      0
    );

    return {
      available: true,
      count: recentMeasurements.length,
      average: sum / recentMeasurements.length,
      median: sorted[Math.floor(sorted.length / 2)],
      min: sorted[0],
      max: sorted[sorted.length - 1],
      standardDeviation: this.calculateStandardDeviation(
        recentMeasurements
      ),
      percentile95:
        sorted[Math.floor(sorted.length * 0.95)],
      percentile99:
        sorted[Math.floor(sorted.length * 0.99)],
      variation: this.calculateVariationCoefficient(
        recentMeasurements
      ),
    };
  }

  // 異常検知
  detectLatencyAnomalies(): LatencyAnomaly[] {
    const stats = this.calculateLatencyStatistics();
    const anomalies: LatencyAnomaly[] = [];

    if (!stats.available) return anomalies;

    // 高レイテンシの検出
    if (stats.average > this.alertThresholds.critical) {
      anomalies.push({
        type: 'HIGH_LATENCY_CRITICAL',
        severity: 'critical',
        value: stats.average,
        threshold: this.alertThresholds.critical,
        message: `平均レイテンシが臨界値を超過: ${stats.average.toFixed(
          2
        )}ms`,
      });
    } else if (
      stats.average > this.alertThresholds.warning
    ) {
      anomalies.push({
        type: 'HIGH_LATENCY_WARNING',
        severity: 'warning',
        value: stats.average,
        threshold: this.alertThresholds.warning,
        message: `平均レイテンシが警告値を超過: ${stats.average.toFixed(
          2
        )}ms`,
      });
    }

    // レイテンシ変動の検出
    if (stats.variation > this.alertThresholds.variation) {
      anomalies.push({
        type: 'HIGH_LATENCY_VARIATION',
        severity: 'warning',
        value: stats.variation,
        threshold: this.alertThresholds.variation,
        message: `レイテンシ変動が大きすぎます: ${(
          stats.variation * 100
        ).toFixed(1)}%`,
      });
    }

    return anomalies;
  }
}

複数要因が重なる複合的な問題

実際の運用環境では、単一の原因ではなく複数の要因が複合的に作用して接続問題が発生します。これらの相互作用を理解し、体系的に診断する手法が必要です。

複合問題の診断アプローチ

typescript// 複合問題の分析システム
class CompositeIssueAnalyzer {
  private factors: Map<string, IssueFactor> = new Map();
  private interactions: FactorInteraction[] = [];

  // 複合問題の分析
  analyzeCompositeIssue(
    symptoms: Symptom[]
  ): CompositeAnalysis {
    // 1. 各症状から疑われる要因を抽出
    const suspectedFactors = this.identifyFactors(symptoms);

    // 2. 要因間の相互作用を分析
    const interactions = this.analyzeInteractions(
      suspectedFactors
    );

    // 3. 主要な要因を特定
    const primaryFactors = this.identifyPrimaryFactors(
      suspectedFactors,
      interactions
    );

    // 4. 解決策の優先順位付け
    const prioritizedSolutions = this.prioritizeSolutions(
      primaryFactors,
      interactions
    );

    return {
      symptoms,
      suspectedFactors,
      interactions,
      primaryFactors,
      prioritizedSolutions,
      confidence: this.calculateConfidence(
        suspectedFactors,
        interactions
      ),
    };
  }

  private identifyFactors(
    symptoms: Symptom[]
  ): IssueFactor[] {
    const factors: IssueFactor[] = [];

    // 症状と要因のマッピング
    const symptomFactorMap = {
      intermittent_disconnection: [
        { name: 'network_instability', weight: 0.8 },
        { name: 'server_overload', weight: 0.6 },
        { name: 'client_timeout', weight: 0.4 },
      ],
      high_latency: [
        { name: 'network_congestion', weight: 0.9 },
        { name: 'geographic_distance', weight: 0.7 },
        { name: 'processing_delay', weight: 0.5 },
      ],
      packet_loss: [
        { name: 'network_congestion', weight: 0.9 },
        { name: 'hardware_failure', weight: 0.8 },
        { name: 'configuration_error', weight: 0.3 },
      ],
    };

    symptoms.forEach((symptom) => {
      const mappedFactors =
        symptomFactorMap[symptom.type] || [];
      mappedFactors.forEach((factor) => {
        const existingFactor = factors.find(
          (f) => f.name === factor.name
        );
        if (existingFactor) {
          existingFactor.confidence = Math.max(
            existingFactor.confidence,
            factor.weight * symptom.severity
          );
        } else {
          factors.push({
            name: factor.name,
            confidence: factor.weight * symptom.severity,
            evidences: [symptom],
            category: this.getFactorCategory(factor.name),
          });
        }
      });
    });

    return factors.sort(
      (a, b) => b.confidence - a.confidence
    );
  }
}

解決策

ネットワーク診断ツールの活用

効果的な診断を行うためには、適切なツールを段階的に使用することが重要です。基本的なネットワークコマンドから専用ツールまで、体系的なアプローチをご紹介します。

ping/traceroute/netstat による基本診断

typescript// 基本ネットワーク診断ツール
class BasicNetworkDiagnostics {
  // ping診断の実行と解析
  async runPingDiagnosis(
    target: string,
    count: number = 10
  ): Promise<PingResult> {
    const { exec } = require('child_process');
    const { promisify } = require('util');
    const execAsync = promisify(exec);

    try {
      const { stdout } = await execAsync(
        `ping -c ${count} ${target}`
      );
      return this.parsePingOutput(stdout);
    } catch (error) {
      return {
        success: false,
        error: error.message,
        reachable: false,
      };
    }
  }

  private parsePingOutput(output: string): PingResult {
    const lines = output.split('\n');
    const statistics = lines.find((line) =>
      line.includes('packet loss')
    );
    const timing = lines.find((line) =>
      line.includes('min/avg/max')
    );

    if (!statistics || !timing) {
      return { success: false, error: 'Parse error' };
    }

    const packetLossMatch = statistics.match(
      /(\d+(?:\.\d+)?)% packet loss/
    );
    const timingMatch = timing.match(
      /min\/avg\/max\/stddev = ([\d.]+)\/([\d.]+)\/([\d.]+)\/([\d.]+)/
    );

    return {
      success: true,
      reachable: true,
      packetLoss: packetLossMatch
        ? parseFloat(packetLossMatch[1])
        : 0,
      timing: timingMatch
        ? {
            min: parseFloat(timingMatch[1]),
            avg: parseFloat(timingMatch[2]),
            max: parseFloat(timingMatch[3]),
            stddev: parseFloat(timingMatch[4]),
          }
        : null,
    };
  }

  // traceroute診断
  async runTracerouteDiagnosis(
    target: string
  ): Promise<TracerouteResult> {
    const { exec } = require('child_process');
    const { promisify } = require('util');
    const execAsync = promisify(exec);

    try {
      const { stdout } = await execAsync(
        `traceroute ${target}`
      );
      return this.parseTracerouteOutput(stdout);
    } catch (error) {
      return {
        success: false,
        error: error.message,
        hops: [],
      };
    }
  }

  // netstat診断
  async checkPortConnectivity(
    host: string,
    port: number
  ): Promise<PortCheckResult> {
    const net = require('net');

    return new Promise((resolve) => {
      const socket = new net.Socket();
      const timeout = 5000;

      socket.setTimeout(timeout);
      socket.on('connect', () => {
        socket.destroy();
        resolve({
          host,
          port,
          open: true,
          responseTime: Date.now() - startTime,
        });
      });

      socket.on('timeout', () => {
        socket.destroy();
        resolve({
          host,
          port,
          open: false,
          error: 'Connection timeout',
        });
      });

      socket.on('error', (error) => {
        resolve({
          host,
          port,
          open: false,
          error: error.message,
        });
      });

      const startTime = Date.now();
      socket.connect(port, host);
    });
  }
}

WebSocket 専用診断ツールの実装

WebSocket 接続特有の問題を診断するための専用ツールを実装します。

typescript// WebSocket専用診断ツール
class WebSocketDiagnostics {
  // WebSocket接続テスト
  async testWebSocketConnection(
    url: string
  ): Promise<WebSocketTestResult> {
    return new Promise((resolve) => {
      const startTime = Date.now();
      const ws = new WebSocket(url);
      let handshakeTime: number;

      const timeout = setTimeout(() => {
        ws.close();
        resolve({
          success: false,
          error: 'Connection timeout',
          duration: Date.now() - startTime,
        });
      }, 10000);

      ws.on('open', () => {
        handshakeTime = Date.now() - startTime;
        // Echo テスト
        const testMessage = JSON.stringify({
          test: true,
          timestamp: Date.now(),
        });
        ws.send(testMessage);
      });

      ws.on('message', (data) => {
        clearTimeout(timeout);
        const responseTime = Date.now() - startTime;
        ws.close();

        resolve({
          success: true,
          handshakeTime,
          responseTime,
          protocol: ws.protocol,
          extensions: ws.extensions,
        });
      });

      ws.on('error', (error) => {
        clearTimeout(timeout);
        resolve({
          success: false,
          error: error.message,
          duration: Date.now() - startTime,
        });
      });
    });
  }

  // WebSocketフレーム解析
  analyzeWebSocketFrames(ws: WebSocket): FrameAnalysis {
    const frames: FrameInfo[] = [];

    // フレーム情報の収集
    const originalSend = ws.send.bind(ws);
    ws.send = (data: any) => {
      frames.push({
        direction: 'outbound',
        timestamp: Date.now(),
        size: this.calculateFrameSize(data),
        type: this.getFrameType(data),
        payload: data,
      });
      return originalSend(data);
    };

    // 受信フレーム監視
    ws.addEventListener('message', (event) => {
      frames.push({
        direction: 'inbound',
        timestamp: Date.now(),
        size: this.calculateFrameSize(event.data),
        type: this.getFrameType(event.data),
        payload: event.data,
      });
    });

    return {
      frames,
      statistics: () =>
        this.calculateFrameStatistics(frames),
    };
  }
}

パケットキャプチャによる詳細解析

ネットワークレベルでの詳細な解析を行うためのパケットキャプチャツールの実装です。

typescript// パケット解析システム
class PacketAnalyzer {
  // tcpdump/wiresharkデータの解析
  async analyzePacketCapture(
    pcapFile: string
  ): Promise<PacketAnalysis> {
    const packets = await this.readPcapFile(pcapFile);

    return {
      totalPackets: packets.length,
      protocols: this.analyzeProtocols(packets),
      timing: this.analyzePacketTiming(packets),
      errors: this.detectPacketErrors(packets),
      websocketHandshake:
        this.analyzeWebSocketHandshake(packets),
      dataTransfer: this.analyzeDataTransfer(packets),
    };
  }

  private analyzeWebSocketHandshake(
    packets: Packet[]
  ): HandshakeAnalysis {
    const handshakePackets = packets.filter(
      (p) =>
        p.payload.includes('Upgrade: websocket') ||
        p.payload.includes('Sec-WebSocket-Key') ||
        p.payload.includes('Sec-WebSocket-Accept')
    );

    if (handshakePackets.length === 0) {
      return {
        success: false,
        error: 'No WebSocket handshake found',
      };
    }

    // ハンドシェイクシーケンスの分析
    const request = handshakePackets.find((p) =>
      p.payload.includes('Sec-WebSocket-Key')
    );
    const response = handshakePackets.find((p) =>
      p.payload.includes('Sec-WebSocket-Accept')
    );

    if (!request || !response) {
      return {
        success: false,
        error: 'Incomplete handshake sequence',
        packets: handshakePackets.length,
      };
    }

    return {
      success: true,
      duration: response.timestamp - request.timestamp,
      requestHeaders: this.parseHttpHeaders(
        request.payload
      ),
      responseHeaders: this.parseHttpHeaders(
        response.payload
      ),
      keyExchange: this.validateKeyExchange(
        request.payload,
        response.payload
      ),
    };
  }
}

接続品質監視システム

継続的な監視により、問題を早期に発見し対処するシステムを構築します。

リアルタイム接続状態監視

typescript// リアルタイム監視システム
class RealTimeConnectionMonitor {
  private connections = new Map<string, ConnectionState>();
  private metrics = new Map<string, MetricHistory>();
  private alerts: Alert[] = [];

  // 接続監視の開始
  startMonitoring(
    connectionId: string,
    ws: WebSocket
  ): void {
    const monitor = {
      connectionId,
      websocket: ws,
      startTime: Date.now(),
      lastActivity: Date.now(),
      metrics: {
        messagesReceived: 0,
        messagesSent: 0,
        errors: 0,
        reconnections: 0,
      },
    };

    this.connections.set(connectionId, monitor);
    this.setupEventListeners(connectionId, ws);
    this.startPeriodicChecks(connectionId);
  }

  private setupEventListeners(
    connectionId: string,
    ws: WebSocket
  ): void {
    ws.on('message', () => {
      this.updateMetric(
        connectionId,
        'messagesReceived',
        1
      );
      this.updateActivity(connectionId);
    });

    ws.on('error', (error) => {
      this.updateMetric(connectionId, 'errors', 1);
      this.handleConnectionError(connectionId, error);
    });

    ws.on('close', () => {
      this.handleConnectionClose(connectionId);
    });
  }

  // 定期的なヘルスチェック
  private async startPeriodicChecks(
    connectionId: string
  ): Promise<void> {
    const checkInterval = setInterval(async () => {
      const connection = this.connections.get(connectionId);
      if (!connection) {
        clearInterval(checkInterval);
        return;
      }

      await this.performHealthCheck(connectionId);
    }, 30000); // 30秒間隔
  }

  private async performHealthCheck(
    connectionId: string
  ): Promise<void> {
    const connection = this.connections.get(connectionId);
    if (
      !connection ||
      connection.websocket.readyState !== WebSocket.OPEN
    ) {
      return;
    }

    // ping/pongテスト
    const pingStart = Date.now();
    try {
      await this.sendPing(connection.websocket);
      const pingTime = Date.now() - pingStart;

      this.recordMetric(connectionId, 'ping', pingTime);

      // アラート判定
      if (pingTime > 1000) {
        this.raiseAlert({
          type: 'HIGH_LATENCY',
          connectionId,
          value: pingTime,
          severity: 'warning',
        });
      }
    } catch (error) {
      this.raiseAlert({
        type: 'PING_FAILED',
        connectionId,
        error: error.message,
        severity: 'error',
      });
    }
  }
}

統計データ収集と分析

typescript// 統計データ分析システム
class ConnectionStatisticsAnalyzer {
  private dataStore: Map<string, StatisticsData> =
    new Map();

  // 統計データの収集
  collectStatistics(
    connectionId: string
  ): ConnectionStatistics {
    const rawData = this.dataStore.get(connectionId);
    if (!rawData) {
      return { available: false };
    }

    return {
      available: true,
      uptime: this.calculateUptime(rawData),
      reliability: this.calculateReliability(rawData),
      performance: this.calculatePerformance(rawData),
      trends: this.analyzeTrends(rawData),
      predictions: this.generatePredictions(rawData),
    };
  }

  // 信頼性メトリクスの計算
  private calculateReliability(
    data: StatisticsData
  ): ReliabilityMetrics {
    const totalTime = Date.now() - data.startTime;
    const downtime = data.disconnectionEvents.reduce(
      (sum, event) => sum + (event.duration || 0),
      0
    );

    return {
      availability:
        ((totalTime - downtime) / totalTime) * 100,
      mtbf: totalTime / data.disconnectionEvents.length, // Mean Time Between Failures
      mttr: downtime / data.disconnectionEvents.length, // Mean Time To Repair
      errorRate: data.errorCount / data.totalMessages,
      stabilityScore: this.calculateStabilityScore(data),
    };
  }

  // パフォーマンスメトリクスの計算
  private calculatePerformance(
    data: StatisticsData
  ): PerformanceMetrics {
    return {
      averageLatency: this.calculateAverageLatency(
        data.latencyHistory
      ),
      throughput: this.calculateThroughput(data),
      efficiency: this.calculateEfficiency(data),
      resourceUtilization:
        this.calculateResourceUtilization(data),
    };
  }
}

異常検知アルゴリズム

typescript// 異常検知システム
class AnomalyDetectionSystem {
  private models = new Map<string, AnomalyModel>();
  private thresholds: AnomalyThresholds;

  // 異常検知モデルの訓練
  trainAnomalyModel(
    connectionId: string,
    historicalData: MetricHistory[]
  ): void {
    const model =
      this.buildStatisticalModel(historicalData);
    this.models.set(connectionId, model);
  }

  // リアルタイム異常検知
  detectAnomalies(
    connectionId: string,
    currentMetrics: CurrentMetrics
  ): AnomalyDetection {
    const model = this.models.get(connectionId);
    if (!model) {
      return {
        anomaliesDetected: false,
        reason: 'No trained model',
      };
    }

    const anomalies: Anomaly[] = [];

    // 統計的異常検知
    const statisticalAnomaly =
      this.detectStatisticalAnomaly(model, currentMetrics);
    if (statisticalAnomaly) {
      anomalies.push(statisticalAnomaly);
    }

    // パターンベース異常検知
    const patternAnomaly = this.detectPatternAnomaly(
      model,
      currentMetrics
    );
    if (patternAnomaly) {
      anomalies.push(patternAnomaly);
    }

    // 閾値ベース異常検知
    const thresholdAnomalies =
      this.detectThresholdAnomalies(currentMetrics);
    anomalies.push(...thresholdAnomalies);

    return {
      anomaliesDetected: anomalies.length > 0,
      anomalies,
      confidence: this.calculateConfidence(anomalies),
      recommendations:
        this.generateRecommendations(anomalies),
    };
  }

  private detectStatisticalAnomaly(
    model: AnomalyModel,
    metrics: CurrentMetrics
  ): Anomaly | null {
    // Z-scoreによる異常検知
    const zScore =
      (metrics.latency - model.latencyMean) /
      model.latencyStdDev;

    if (Math.abs(zScore) > 2.5) {
      // 2.5σを超える場合
      return {
        type: 'STATISTICAL_ANOMALY',
        metric: 'latency',
        value: metrics.latency,
        expected: model.latencyMean,
        severity:
          Math.abs(zScore) > 3 ? 'critical' : 'warning',
        zScore,
      };
    }

    return null;
  }
}

具体例

診断ツールの実装コード例

実際の運用で使用できる診断ツールの完全な実装例をご紹介します。

typescript// 包括的な診断ツール
class MCPConnectionDiagnosticTool {
  private results: DiagnosticResult[] = [];

  // 完全診断の実行
  async runCompleteDiagnosis(
    mcpServerUrl: string
  ): Promise<DiagnosticReport> {
    console.log('MCP接続診断を開始します...');

    const report: DiagnosticReport = {
      timestamp: new Date().toISOString(),
      serverUrl: mcpServerUrl,
      tests: [],
      summary: null,
    };

    try {
      // 1. 基本ネットワーク診断
      const networkTest = await this.runNetworkDiagnosis(
        mcpServerUrl
      );
      report.tests.push(networkTest);

      // 2. WebSocket接続テスト
      const wsTest = await this.runWebSocketDiagnosis(
        mcpServerUrl
      );
      report.tests.push(wsTest);

      // 3. MCP プロトコルテスト
      const mcpTest = await this.runMCPProtocolTest(
        mcpServerUrl
      );
      report.tests.push(mcpTest);

      // 4. 負荷テスト
      const loadTest = await this.runLoadTest(mcpServerUrl);
      report.tests.push(loadTest);

      // 5. 長期安定性テスト
      const stabilityTest = await this.runStabilityTest(
        mcpServerUrl
      );
      report.tests.push(stabilityTest);

      // サマリーの生成
      report.summary = this.generateSummary(report.tests);
    } catch (error) {
      report.error = error.message;
    }

    return report;
  }

  private async runNetworkDiagnosis(
    url: string
  ): Promise<TestResult> {
    const urlObj = new URL(url);
    const hostname = urlObj.hostname;
    const port =
      parseInt(urlObj.port) ||
      (url.startsWith('wss:') ? 443 : 80);

    const diagnostics = new BasicNetworkDiagnostics();

    // ping テスト
    const pingResult = await diagnostics.runPingDiagnosis(
      hostname
    );

    // port接続テスト
    const portResult =
      await diagnostics.checkPortConnectivity(
        hostname,
        port
      );

    // traceroute
    const tracerouteResult =
      await diagnostics.runTracerouteDiagnosis(hostname);

    return {
      name: 'Network Diagnosis',
      success: pingResult.success && portResult.open,
      details: {
        ping: pingResult,
        port: portResult,
        traceroute: tracerouteResult,
      },
      recommendations: this.generateNetworkRecommendations(
        pingResult,
        portResult,
        tracerouteResult
      ),
    };
  }

  private async runWebSocketDiagnosis(
    url: string
  ): Promise<TestResult> {
    const wsDiagnostics = new WebSocketDiagnostics();

    // 基本接続テスト
    const connectionTest =
      await wsDiagnostics.testWebSocketConnection(url);

    if (connectionTest.success) {
      // 詳細テストの実行
      const ws = new WebSocket(url);
      const frameAnalysis =
        wsDiagnostics.analyzeWebSocketFrames(ws);

      // 接続品質テスト
      const qualityTest = await this.testConnectionQuality(
        ws
      );

      ws.close();

      return {
        name: 'WebSocket Diagnosis',
        success: true,
        details: {
          connection: connectionTest,
          frameAnalysis: frameAnalysis.statistics(),
          quality: qualityTest,
        },
      };
    } else {
      return {
        name: 'WebSocket Diagnosis',
        success: false,
        error: connectionTest.error,
        recommendations: [
          'WebSocket接続の確立に失敗しました。ネットワーク設定を確認してください。',
        ],
      };
    }
  }

  private async testConnectionQuality(
    ws: WebSocket
  ): Promise<QualityTestResult> {
    const tests = [];

    // レイテンシテスト
    const latencyTest = await this.measureLatency(ws, 10);
    tests.push({ name: 'Latency', result: latencyTest });

    // スループットテスト
    const throughputTest = await this.measureThroughput(ws);
    tests.push({
      name: 'Throughput',
      result: throughputTest,
    });

    // 安定性テスト
    const stabilityTest = await this.testStability(ws, 60); // 60秒間
    tests.push({
      name: 'Stability',
      result: stabilityTest,
    });

    return {
      tests,
      overallScore: this.calculateOverallScore(tests),
    };
  }
}

監視ダッシュボードの構築

リアルタイム監視ダッシュボードの実装例です。

typescript// 監視ダッシュボード
class MonitoringDashboard {
  private express = require('express');
  private app = this.express();
  private server: any;
  private io: any;
  private monitoringData = new Map<string, any>();

  constructor(port: number = 3001) {
    this.setupExpress();
    this.setupSocketIO();
    this.setupRoutes();
    this.server = this.app.listen(port, () => {
      console.log(
        `監視ダッシュボードが起動しました: http://localhost:${port}`
      );
    });
  }

  private setupRoutes(): void {
    // ダッシュボードのHTML
    this.app.get('/', (req, res) => {
      res.send(this.generateDashboardHTML());
    });

    // 監視データのAPI
    this.app.get('/api/connections', (req, res) => {
      const connections = Array.from(
        this.monitoringData.entries()
      ).map(([id, data]) => ({
        id,
        ...data.latest,
      }));
      res.json(connections);
    });

    // 詳細データのAPI
    this.app.get(
      '/api/connections/:id/details',
      (req, res) => {
        const data = this.monitoringData.get(req.params.id);
        res.json(data || { error: 'Connection not found' });
      }
    );
  }

  // リアルタイムデータ更新
  updateConnectionData(
    connectionId: string,
    data: any
  ): void {
    if (!this.monitoringData.has(connectionId)) {
      this.monitoringData.set(connectionId, {
        history: [],
        latest: null,
        alerts: [],
      });
    }

    const connectionData =
      this.monitoringData.get(connectionId);
    connectionData.latest = data;
    connectionData.history.push({
      timestamp: Date.now(),
      data,
    });

    // 履歴サイズ制限
    if (connectionData.history.length > 1000) {
      connectionData.history =
        connectionData.history.slice(-1000);
    }

    // WebSocketで更新通知
    this.io.emit('connectionUpdate', {
      connectionId,
      data,
    });
  }

  private generateDashboardHTML(): string {
    return `
<!DOCTYPE html>
<html>
<head>
    <title>MCP Connection Monitor</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .connection-card { 
            border: 1px solid #ddd; 
            padding: 15px; 
            margin: 10px 0; 
            border-radius: 5px; 
        }
        .status-good { background-color: #d4edda; }
        .status-warning { background-color: #fff3cd; }
        .status-error { background-color: #f8d7da; }
        .metrics { display: flex; gap: 20px; margin: 10px 0; }
        .metric { text-align: center; }
        .metric-value { font-size: 2em; font-weight: bold; }
        .metric-label { font-size: 0.9em; color: #666; }
    </style>
    <script src="/socket.io/socket.io.js"></script>
</head>
<body>
    <h1>MCP Connection Monitor</h1>
    <div id="connections"></div>
    
    <script>
        const socket = io();
        
        socket.on('connectionUpdate', (update) => {
            updateConnectionDisplay(update.connectionId, update.data);
        });
        
        function updateConnectionDisplay(connectionId, data) {
            // 接続表示の更新ロジック
            const container = document.getElementById('connections');
            let card = document.getElementById('conn-' + connectionId);
            
            if (!card) {
                card = document.createElement('div');
                card.id = 'conn-' + connectionId;
                card.className = 'connection-card';
                container.appendChild(card);
            }
            
            const status = data.status || 'unknown';
            card.className = 'connection-card status-' + status;
            
            card.innerHTML = \`
                <h3>Connection: \${connectionId}</h3>
                <div class="metrics">
                    <div class="metric">
                        <div class="metric-value">\${data.latency || 'N/A'}</div>
                        <div class="metric-label">Latency (ms)</div>
                    </div>
                    <div class="metric">
                        <div class="metric-value">\${data.uptime || 'N/A'}</div>
                        <div class="metric-label">Uptime</div>
                    </div>
                    <div class="metric">
                        <div class="metric-value">\${data.errorRate || '0'}</div>
                        <div class="metric-label">Error Rate (%)</div>
                    </div>
                </div>
                <div>Status: \${status}</div>
                <div>Last Update: \${new Date().toLocaleTimeString()}</div>
            \`;
        }
        
        // 初期データの読み込み
        fetch('/api/connections')
            .then(response => response.json())
            .then(connections => {
                connections.forEach(conn => {
                    updateConnectionDisplay(conn.id, conn);
                });
            });
    </script>
</body>
</html>`;
  }
}

自動診断レポートシステム

定期的な診断と自動レポート生成システムの実装です。

typescript// 自動診断レポートシステム
class AutomaticDiagnosticReporter {
  private diagnosticTool: MCPConnectionDiagnosticTool;
  private scheduler: NodeJS.Timer | null = null;
  private reports: DiagnosticReport[] = [];

  constructor(private config: ReportConfig) {
    this.diagnosticTool = new MCPConnectionDiagnosticTool();
  }

  // 定期診断の開始
  startPeriodicDiagnosis(): void {
    console.log('定期診断を開始します...');

    this.scheduler = setInterval(async () => {
      await this.runDiagnosisAndReport();
    }, this.config.intervalMs);

    // 初回実行
    this.runDiagnosisAndReport();
  }

  private async runDiagnosisAndReport(): Promise<void> {
    try {
      console.log('診断を実行中...');
      const report =
        await this.diagnosticTool.runCompleteDiagnosis(
          this.config.mcpServerUrl
        );

      this.reports.push(report);

      // レポート数の制限
      if (this.reports.length > this.config.maxReports) {
        this.reports = this.reports.slice(
          -this.config.maxReports
        );
      }

      // 問題が検出された場合の通知
      if (this.hasIssues(report)) {
        await this.sendAlert(report);
      }

      // レポートの保存
      await this.saveReport(report);

      console.log(
        '診断完了:',
        report.summary?.overallStatus
      );
    } catch (error) {
      console.error(
        '診断実行中にエラーが発生しました:',
        error
      );
    }
  }

  private hasIssues(report: DiagnosticReport): boolean {
    return (
      report.tests.some((test) => !test.success) ||
      report.summary?.overallStatus === 'error'
    );
  }

  private async sendAlert(
    report: DiagnosticReport
  ): Promise<void> {
    const alert = {
      timestamp: new Date().toISOString(),
      severity: this.calculateSeverity(report),
      summary: report.summary,
      failedTests: report.tests.filter(
        (test) => !test.success
      ),
      serverUrl: report.serverUrl,
    };

    // 複数の通知チャネル
    if (this.config.notifications.email) {
      await this.sendEmailAlert(alert);
    }

    if (this.config.notifications.webhook) {
      await this.sendWebhookAlert(alert);
    }

    if (this.config.notifications.slack) {
      await this.sendSlackAlert(alert);
    }
  }

  // トレンド分析
  analyzeTrends(): TrendAnalysis {
    if (this.reports.length < 2) {
      return { available: false };
    }

    const recentReports = this.reports.slice(-10); // 最新10件

    return {
      available: true,
      period: {
        start: recentReports[0].timestamp,
        end: recentReports[recentReports.length - 1]
          .timestamp,
      },
      reliability:
        this.calculateReliabilityTrend(recentReports),
      performance:
        this.calculatePerformanceTrend(recentReports),
      issues: this.identifyRecurringIssues(recentReports),
      recommendations:
        this.generateTrendRecommendations(recentReports),
    };
  }

  // HTML レポートの生成
  generateHTMLReport(report: DiagnosticReport): string {
    return `
<!DOCTYPE html>
<html>
<head>
    <title>MCP診断レポート - ${new Date(
      report.timestamp
    ).toLocaleString()}</title>
    <style>
        body { font-family: Arial, sans-serif; max-width: 1200px; margin: 0 auto; padding: 20px; }
        .header { background: #f8f9fa; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
        .test-result { border: 1px solid #ddd; margin: 10px 0; padding: 15px; border-radius: 5px; }
        .success { background-color: #d4edda; border-color: #c3e6cb; }
        .failure { background-color: #f8d7da; border-color: #f5c6cb; }
        .details { margin-top: 10px; font-size: 0.9em; }
        .recommendations { background: #fff3cd; padding: 10px; border-radius: 5px; margin-top: 10px; }
        pre { background: #f8f9fa; padding: 10px; border-radius: 3px; overflow-x: auto; }
    </style>
</head>
<body>
    <div class="header">
        <h1>MCP接続診断レポート</h1>
        <p><strong>サーバーURL:</strong> ${
          report.serverUrl
        }</p>
        <p><strong>診断日時:</strong> ${new Date(
          report.timestamp
        ).toLocaleString()}</p>
        <p><strong>総合ステータス:</strong> ${
          report.summary?.overallStatus || 'Unknown'
        }</p>
    </div>
    
    ${report.tests
      .map(
        (test) => `
        <div class="test-result ${
          test.success ? 'success' : 'failure'
        }">
            <h3>${test.name} ${
          test.success ? '✅' : '❌'
        }</h3>
            ${
              test.error
                ? `<p><strong>エラー:</strong> ${test.error}</p>`
                : ''
            }
            ${
              test.details
                ? `
                <div class="details">
                    <strong>詳細:</strong>
                    <pre>${JSON.stringify(
                      test.details,
                      null,
                      2
                    )}</pre>
                </div>
            `
                : ''
            }
            ${
              test.recommendations
                ? `
                <div class="recommendations">
                    <strong>推奨事項:</strong>
                    <ul>
                        ${test.recommendations
                          .map((rec) => `<li>${rec}</li>`)
                          .join('')}
                    </ul>
                </div>
            `
                : ''
            }
        </div>
    `
      )
      .join('')}
    
    ${
      report.summary
        ? `
        <div class="header">
            <h2>サマリー</h2>
            <pre>${JSON.stringify(
              report.summary,
              null,
              2
            )}</pre>
        </div>
    `
        : ''
    }
</body>
</html>`;
  }
}