ユースケース：医療 — 電子カルテ連携 AI 診断支援システム

# app/services/fhir_client.rb
class FhirClient
  BASE_HEADERS = {
    "Content-Type" => "application/fhir+json",
    "Accept" => "application/fhir+json"
  }.freeze
 
  def initialize(endpoint:, auth_token:)
    @endpoint = endpoint
    @auth_token = auth_token
    @conn = Faraday.new(url: endpoint) do |f|
      f.request :json
      f.response :json
      f.adapter Faraday.default_adapter
    end
  end
 
  # 患者リソースを FHIR R4 形式で取得
  def fetch_patient(patient_id)
    response = @conn.get("Patient/#{patient_id}") do |req|
      req.headers = authorized_headers
    end
 
    raise FhirError, response.body unless response.success?
 
    FhirPatientMapper.from_resource(response.body)
  end
 
  # 画像検査(ImagingStudy)を検索
  def search_imaging_studies(patient_id:, modality: nil)
    params = { patient: patient_id }
    params[:modality] = modality if modality # CT, MRI, CR など
 
    response = @conn.get("ImagingStudy", params) do |req|
      req.headers = authorized_headers
    end
 
    bundle = response.body
    bundle.dig("entry")&.map { |e| e["resource"] } || []
  end
 
  private
 
  def authorized_headers
    BASE_HEADERS.merge("Authorization" => "Bearer #{@auth_token}")
  end
end

# app/services/anonymization_pipeline.rb
class AnonymizationPipeline
  # 仮名加工情報の基準に準拠した匿名化処理
  DIRECT_IDENTIFIERS = %i[
    name address phone_number email
    insurance_number my_number
  ].freeze
 
  QUASI_IDENTIFIERS = %i[
    birth_date zip_code occupation
  ].freeze
 
  def initialize(key_store:)
    @key_store = key_store # 仮名化キーの安全な保管
  end
 
  def anonymize(patient_record)
    anonymized = patient_record.deep_dup
 
    # 直接識別子を仮名化（不可逆ハッシュ + ソルト）
    DIRECT_IDENTIFIERS.each do |field|
      next unless anonymized.respond_to?(field)
 
      original = anonymized.public_send(field)
      next if original.blank?
 
      pseudonym = generate_pseudonym(patient_record.id, field)
      anonymized.public_send(:"#{field}=", pseudonym)
    end
 
    # 準識別子を一般化（k-匿名性の確保）
    generalize_quasi_identifiers!(anonymized)
 
    # 匿名化ログを監査証跡として記録
    AuditLog.create!(
      action: "anonymize",
      target_type: "PatientRecord",
      target_id: patient_record.id,
      performed_at: Time.current,
      details: { fields_processed: DIRECT_IDENTIFIERS + QUASI_IDENTIFIERS }
    )
 
    anonymized
  end
 
  private
 
  def generate_pseudonym(record_id, field)
    salt = @key_store.fetch_salt(record_id)
    Digest::SHA256.hexdigest("#{record_id}:#{field}:#{salt}")[0..15]
  end
 
  def generalize_quasi_identifiers!(record)
    # 生年月日 → 年齢帯に変換（例: 1985-03-15 → "35-39"）
    if record.respond_to?(:birth_date) && record.birth_date.present?
      age = ((Time.current - record.birth_date.to_time) / 1.year).floor
      age_band = "#{(age / 5) * 5}-#{(age / 5) * 5 + 4}"
      record.birth_date = nil
      record.age_band = age_band
    end
 
    # 郵便番号 → 上3桁に丸める（例: 160-0023 → "160-XXXX"）
    if record.respond_to?(:zip_code) && record.zip_code.present?
      record.zip_code = record.zip_code[0..2] + "-XXXX"
    end
  end
end

# app/services/diagnosis_assistant.rb
class DiagnosisAssistant
  CONFIDENCE_THRESHOLD = 0.85 # この閾値以上で医師に通知
  CRITICAL_FINDINGS = %w[
    nodule mass hemorrhage pneumothorax fracture
  ].freeze
 
  def initialize(ai_client:, fhir_client:)
    @ai_client = ai_client
    @fhir_client = fhir_client
  end
 
  # 画像を解析し、所見候補を返す（診断ではなく "注意喚起"）
  def analyze_imaging_study(study_id:, physician_id:)
    study = @fhir_client.fetch_imaging_study(study_id)
    anonymized_images = prepare_images(study)
 
    # AI モデルによる解析
    ai_result = @ai_client.analyze(
      images: anonymized_images,
      modality: study[:modality],
      body_region: study[:body_site]
    )
 
    # 所見候補をフィルタリング
    findings = ai_result[:findings].select do |finding|
      finding[:confidence] >= CONFIDENCE_THRESHOLD
    end
 
    # 結果を「支援情報」として構造化
    AssistantReport.create!(
      imaging_study_id: study_id,
      physician_id: physician_id,
      findings: findings.map { |f| format_finding(f) },
      ai_model_version: ai_result[:model_version],
      processing_time_ms: ai_result[:elapsed_ms],
      status: :pending_review, # 医師の確認待ち
      disclaimer: build_disclaimer
    )
  end
 
  private
 
  def format_finding(finding)
    {
      region: finding[:location],
      description: finding[:description],
      confidence: finding[:confidence],
      severity: classify_severity(finding),
      suggested_action: suggest_action(finding),
      # 医師が必ず確認すべきことを明示
      review_note: "この所見は AI による候補です。臨床判断は担当医が行ってください。"
    }
  end
 
  def classify_severity(finding)
    if CRITICAL_FINDINGS.any? { |cf| finding[:description].downcase.include?(cf) }
      :critical
    elsif finding[:confidence] >= 0.95
      :high
    else
      :moderate
    end
  end
 
  def build_disclaimer
    "本レポートは AI による支援情報であり、医学的診断ではありません。" \
    "すべての臨床判断は担当医師の責任において行われます。"
  end
end

# config/initializers/aws_healthcare.rb
Rails.application.config.aws_healthcare = {
  vpc: {
    cidr: "10.100.0.0/16",
    private_subnets: %w[10.100.1.0/24 10.100.2.0/24],
    no_internet_gateway: true        # インターネット直結禁止
  },
  rds: {
    engine: "aurora-postgresql",
    encryption_at_rest: true,        # AES-256 / KMS管理鍵
    backup_retention_days: 35,
    audit_logging: true              # 全クエリの監査ログ
  },
  s3: {
    bucket: "seiryoku-medical-images",
    encryption: "aws:kms",
    block_public_access: true,       # パブリックアクセス完全ブロック
    lifecycle: { transition_to_glacier: 365 }
  },
  cloudtrail: {
    include_data_events: true        # S3 オブジェクトレベルの操作も記録
  }
}

# app/models/concerns/pseudonymizable.rb
module Pseudonymizable
  extend ActiveSupport::Concern
 
  ALLOWED_PURPOSES = %w[ai_training quality_improvement clinical_research].freeze
 
  included do
    def to_pseudonymous(purpose:)
      raise ArgumentError, "不正な利用目的: #{purpose}" unless ALLOWED_PURPOSES.include?(purpose.to_s)
 
      pseudonymous_record = self.class.new(
        age_band: calculate_age_band,      # 医療上必要な属性は保持
        sex: sex,
        medical_history: medical_history,
        pseudonym_id: SecureRandom.uuid,    # 個人識別情報は仮名化
        original_id_hash: Digest::SHA256.hexdigest("#{id}:#{Rails.application.secret_key_base}")
      )
 
      # 利用目的の記録（法的要件）
      PseudonymizationLog.create!(
        original_record_type: self.class.name,
        pseudonym_id: pseudonymous_record.pseudonym_id,
        purpose:,
        processed_at: Time.current
      )
 
      pseudonymous_record
    end
  end
end

# app/services/rollout_manager.rb
class RolloutManager
  PHASES = {
    phase_1: {
      departments: ["放射線科"],
      modalities: %w[CT MRI],
      duration_months: 3,
      success_criteria: {
        physician_adoption_rate: 0.80,   # 読影医の80%が利用
        false_positive_rate: 0.10,        # 偽陽性率10%以下
        physician_satisfaction: 3.5       # 5段階評価で3.5以上
      }
    },
    phase_2: {
      departments: ["放射線科", "呼吸器内科", "消化器外科", "整形外科"],
      modalities: %w[CT MRI CR],
      duration_months: 3,
      success_criteria: {
        physician_adoption_rate: 0.70,
        false_positive_rate: 0.10,
        physician_satisfaction: 3.5
      }
    },
    phase_3: {
      departments: :all,
      modalities: :all,
      duration_months: 6,
      success_criteria: {
        physician_adoption_rate: 0.60,
        false_positive_rate: 0.08,
        physician_satisfaction: 4.0
      }
    }
  }.freeze
 
  def evaluate_phase(phase_key)
    phase = PHASES[phase_key]
    metrics = collect_metrics(phase)
 
    phase[:success_criteria].all? do |criterion, threshold|
      metrics[criterion] >= threshold
    end
  end
end