Technical Architecture AstraPath AI v2.0

// User Management
model User {
  id            String   @id @default(cuid())
  email         String   @unique
  passwordHash  String
  profile       Profile?
  subscriptions Subscription[]
  sessions      Session[]
  createdAt     DateTime @default(now())
  updatedAt     DateTime @updatedAt
  @@map("users")
}

model Profile {
  id          String @id @default(cuid())
  userId      String @unique
  firstName   String
  lastName    String
  jobTitle    String?
  company     String?
  skills      Skill[]
  goals       Goal[]
  user        User   @relation(fields: [userId], references: [id])
  @@map("profiles")
}

// Learning System
model LearningPath {
  id          String @id @default(cuid())
  title       String
  description String
  modules     Module[]
  difficulty  Difficulty
  estimatedHours Int
  tags        Tag[]
  createdAt   DateTime @default(now())
  @@map("learning_paths")
}

// AI Models & Processing
model AiModel {
  id          String @id @default(cuid())
  name        String
  version     String
  apiEndpoint String
  parameters  Json
  isActive    Boolean @default(true)
  @@map("ai_models")
}

// Authentication & User Management
POST   /api/auth/register
POST   /api/auth/login
POST   /api/auth/refresh
DELETE /api/auth/logout

// Career Tools API
GET    /api/tools
POST   /api/tools/:toolId/execute
GET    /api/tools/:toolId/history

// Learning Paths API
GET    /api/learning/paths
POST   /api/learning/paths/:pathId/enroll
GET    /api/learning/progress/:userId
PUT    /api/learning/modules/:moduleId/complete

// AI Processing API
POST   /api/ai/multimodal/analyze
POST   /api/ai/text/generate
GET    /api/ai/jobs/:jobId/status
POST   /api/ai/models/configure

// Analytics & Metrics
GET    /api/analytics/user/:userId
POST   /api/analytics/events
GET    /api/analytics/team/:teamId
GET    /api/metrics/performance

type User {
  id: ID!
  email: String!
  profile: Profile
  learningPaths: [LearningPath!]!
  analytics: UserAnalytics
}

type LearningPath {
  id: ID!
  title: String!
  description: String!
  modules: [Module!]!
  progress(userId: ID!): Progress
  difficulty: Difficulty!
}

type Query {
  user(id: ID!): User
  learningPaths(
    filter: LearningPathFilter
    sort: SortInput
    pagination: PaginationInput
  ): [LearningPath!]!
  
  aiTools: [AiTool!]!
  analytics(userId: ID!): UserAnalytics
}

type Mutation {
  executeAiTool(
    toolId: ID!
    input: AiToolInput!
  ): AiToolResult!
  
  enrollInLearningPath(
    pathId: ID!
    userId: ID!
  ): EnrollmentResult!
}

# Kubernetes HPA Configuration
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: astrapath-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: astrapath-api
  minReplicas: 3
  maxReplicas: 50
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

---
# Vertical Pod Autoscaler
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: astrapath-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: astrapath-ai-service
  updatePolicy:
    updateMode: "Auto"

# Terraform AWS Infrastructure
resource "aws_eks_cluster" "astrapath" {
  name     = "astrapath-cluster"
  role_arn = aws_iam_role.cluster.arn
  version  = "1.28"

  vpc_config {
    subnet_ids = aws_subnet.private[*].id
    endpoint_config {
      private_access = true
      public_access  = true
    }
  }

  enabled_cluster_log_types = [
    "api", "audit", "authenticator", 
    "controllerManager", "scheduler"
  ]
}

resource "aws_eks_node_group" "main" {
  cluster_name    = aws_eks_cluster.astrapath.name
  node_group_name = "main-nodes"
  node_role_arn   = aws_iam_role.node.arn
  subnet_ids      = aws_subnet.private[*].id

  instance_types = ["c5.xlarge", "c5.2xlarge"]
  capacity_type  = "SPOT"

  scaling_config {
    desired_size = 3
    max_size     = 20
    min_size     = 1
  }
}

// K6 Load Testing Script
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate } from 'k6/metrics';

const errorRate = new Rate('errors');

export let options = {
  stages: [
    { duration: '5m', target: 100 },   // Ramp-up
    { duration: '10m', target: 500 },  // Normal load
    { duration: '5m', target: 1000 },  // Peak load
    { duration: '10m', target: 1000 }, // Sustained peak
    { duration: '5m', target: 0 },     // Ramp-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.1'],
    errors: ['rate<0.1'],
  },
};

export default function () {
  // Test API endpoints
  const response = http.get('https://api.astrapath.ai/health');
  check(response, {
    'status is 200': (r) => r.status === 200,
    'response time OK': (r) => r.timings.duration < 200,
  });

  // Test AI endpoint with authentication
  const aiResponse = http.post(
    'https://api.astrapath.ai/ai/tools/execute',
    JSON.stringify({
      toolId: 'interview_coach',
      input: { question: 'Tell me about yourself' }
    }),
    {
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${__ENV.API_TOKEN}`
      }
    }
  );
  
  check(aiResponse, {
    'AI response success': (r) => r.status === 200,
    'AI response time': (r) => r.timings.duration < 5000,
  });

  errorRate.add(response.status !== 200);
  sleep(Math.random() * 3);
}