legacy_integration:
  project: "[Project name]"
  date: "[YYYY-MM-DD]"
  
  current_state:
    systems:
      - system: "[System name]"
        type: "[Mainframe | Legacy app | etc.]"
        age: "[Years]"
        technology: "[Tech stack]"
        interfaces: ["[Available interfaces]"]
        constraints: ["[Limitations]"]
        data_format: "[Data formats]"
    
    integration_points:
      - point: "[Where AI needs to connect]"
        current_flow: "[How data/process works today]"
        ai_need: "[What AI needs from here]"
  
  target_state:
    ai_capability: "[What AI will do]"
    integration_pattern: "[Pattern selected]"
    architecture: "[High-level architecture]"
  
  integration_design:
    data_flow:
      - step: "[Step in flow]"
        from: "[Source]"
        to: "[Destination]"
        format: "[Data format]"
        frequency: "[Real-time | Batch | etc.]"
        transformation: "[Any transformation needed]"
    
    interface:
      type: "[API | File | Message | etc.]"
      protocol: "[Protocol details]"
      authentication: "[Auth method]"
      error_handling: "[How errors handled]"
    
    middleware:
      needed: [true | false]
      purpose: "[What it does]"
      options: ["[Technology options]"]
  
  risks:
    - risk: "[Risk]"
      likelihood: "[H/M/L]"
      impact: "[H/M/L]"
      mitigation: "[How to address]"
  
  phasing:
    - phase: 1
      scope: "[What's implemented]"
      dependencies: ["[What must exist]"]
      timeline: "[Duration]"
  
  success_criteria:
    - "[Criterion 1]"

api_wrapper:
  when: "Legacy has accessible database or internal APIs"
  
  architecture:
    legacy_system:
      access: "Database connection or internal API"
    
    wrapper_service:
      function: "Expose modern REST/GraphQL API"
      handles: "Authentication, transformation, caching"
    
    ai_service:
      consumes: "Wrapper API"
  
  considerations:
    - "Don't bypass business logic in legacy app"
    - "Handle legacy system availability"
    - "Consider read vs. write operations"

message_based:
  when: "Need decoupling, async is acceptable"
  
  architecture:
    legacy_system:
      publishes: "Events to message queue"
    
    message_broker:
      technology: "Kafka, RabbitMQ, etc."
      provides: "Buffering, routing, replay"
    
    ai_service:
      subscribes: "Relevant topics"
      publishes: "Results back"
  
  considerations:
    - "Define message schemas clearly"
    - "Handle message ordering if needed"
    - "Plan for replay/reprocessing"

file_based:
  when: "Mainframe batch, simple integration OK"
  
  architecture:
    legacy_system:
      exports: "Files on schedule (daily, hourly)"
      format: "CSV, fixed-width, EDI"
    
    file_processing:
      pickup: "S3, SFTP, shared drive"
      transformation: "Parse and validate"
    
    ai_service:
      input: "Transformed data"
      output: "Results file or API"
  
  considerations:
    - "File format versioning"
    - "Error handling and dead letter"
    - "Schedule coordination"

data_quality:
  from_legacy:
    issues:
      - "Inconsistent formats"
      - "Missing values"
      - "Outdated encoding"
    
    handling:
      - "Validation layer before AI"
      - "Default/fallback values"
      - "Data quality monitoring"

transformation:
  encoding: "EBCDIC → UTF-8"
  format: "Fixed-width → JSON"
  date: "YYMMDD → ISO 8601"
  nulls: "Spaces → null"
  enrichment: "Code lookups, joins"

Phase 1: Read-only integration
├── Extract data from legacy
├── AI operates on extracted data
└── Results consumed outside legacy

Phase 2: Write-back capability
├── AI results formatted for legacy
├── Feedback loop established
└── Error handling robust

Phase 3: Real-time integration
├── Lower latency integration
├── Synchronous where needed
└── Graceful degradation