Initial deployment of da-autolabel-dev

Dockerfile

@@ -0,0 +1,27 @@
+FROM openjdk:21-jdk-slim
+
+WORKDIR /app
+
+# Install required packages
+RUN apt-get update && apt-get install -y \
+    curl \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy application files
+COPY . .
+
+# Build application (if build.gradle.kts exists)
+RUN if [ -f "build.gradle.kts" ]; then \
+        ./gradlew build -x test; \
+    fi
+
+# Expose port
+EXPOSE 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8080/actuator/health || exit 1
+
+# Run application
+CMD ["java", "-jar", "build/libs/da-autolabel.jar"]

README.md

@@ -1,10 +1,38 @@
 ---
-title: Da Autolabel Dev
-emoji: ⚡
-colorFrom: purple
-colorTo: yellow
+title: da-autolabel (dev)
+emoji: 🔧
+colorFrom: blue
+colorTo: green
 sdk: docker
-pinned: false
+app_port: 8080
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# da-autolabel - dev Environment
+
+This is the da-autolabel microservice deployed in the dev environment.
+
+## Features
+
+- RESTful API endpoints
+- Health monitoring via Actuator
+- JWT authentication integration
+- PostgreSQL database connectivity
+
+## API Documentation
+
+Once deployed, API documentation will be available at:
+- Swagger UI: https://huggingface.co/spaces/dalabsai/da-autolabel-dev/swagger-ui.html
+- Health Check: https://huggingface.co/spaces/dalabsai/da-autolabel-dev/actuator/health
+
+## Environment
+
+- **Environment**: dev
+- **Port**: 8080
+- **Java Version**: 21
+- **Framework**: Spring Boot
+
+## Deployment
+
+This service is automatically deployed via the DALab CI/CD pipeline.
+
+Last updated: 2025-06-16 23:40:06

build.gradle.kts

@@ -0,0 +1,23 @@
+// da-autolabel inherits common configuration from parent build.gradle.kts
+// This build file adds autolabel-specific dependencies
+
+dependencies {
+    // DA-Protos common entities and utilities
+    implementation(project(":da-protos"))
+    
+    // LLM Integration Dependencies
+    implementation("com.theokanning.openai-gpt3-java:service:0.18.2")
+    implementation("com.google.cloud:google-cloud-aiplatform:3.34.0")
+    implementation("org.springframework.boot:spring-boot-starter-webflux")
+    implementation("org.apache.httpcomponents.client5:httpclient5:5.2.1")
+    implementation("com.fasterxml.jackson.core:jackson-databind")
+    implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")
+    
+    // Additional dependencies specific to da-autolabel
+    implementation("org.springframework.cloud:spring-cloud-starter-openfeign:4.1.1")
+}
+
+// Configure main application class
+configure<org.springframework.boot.gradle.dsl.SpringBootExtension> {
+    mainClass.set("com.dalab.autolabel.DaAutolabelApplication")
+} 

src/main/docker/Dockerfile

@@ -0,0 +1,23 @@
+# Ultra-lean container using Google Distroless
+# Expected final size: ~120-180MB (minimal base + JRE + JAR only)
+
+FROM gcr.io/distroless/java21-debian12:nonroot
+
+# Set working directory
+WORKDIR /app
+
+# Copy JAR file
+COPY build/libs/da-autolabel.jar app.jar
+
+# Expose standard Spring Boot port
+EXPOSE 8080
+
+# Run application (distroless has no shell, so use exec form)
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=75.0", \
+    "-XX:+UseG1GC", \
+    "-XX:+UseStringDeduplication", \
+    "-Djava.security.egd=file:/dev/./urandom", \
+    "-Dspring.backgroundpreinitializer.ignore=true", \
+    "-jar", "app.jar"]

src/main/docker/Dockerfile.alpine-jlink

@@ -0,0 +1,43 @@
+# Ultra-minimal Alpine + Custom JRE
+# Expected size: ~120-160MB
+
+# Stage 1: Create custom JRE with only needed modules
+FROM eclipse-temurin:21-jdk-alpine as jre-builder
+WORKDIR /app
+
+# Analyze JAR to find required modules
+COPY build/libs/*.jar app.jar
+RUN jdeps --ignore-missing-deps --print-module-deps app.jar > modules.txt
+
+# Create minimal JRE with only required modules
+RUN jlink \
+    --add-modules $(cat modules.txt),java.logging,java.xml,java.sql,java.naming,java.desktop,java.management,java.security.jgss,java.instrument \
+    --strip-debug \
+    --no-man-pages \
+    --no-header-files \
+    --compress=2 \
+    --output /custom-jre
+
+# Stage 2: Production image
+FROM alpine:3.19
+RUN apk add --no-cache tzdata && \
+    addgroup -g 1001 -S appgroup && \
+    adduser -u 1001 -S appuser -G appgroup
+
+# Copy custom JRE
+COPY --from=jre-builder /custom-jre /opt/java
+ENV JAVA_HOME=/opt/java
+ENV PATH="$JAVA_HOME/bin:$PATH"
+
+WORKDIR /app
+COPY build/libs/*.jar app.jar
+RUN chown appuser:appgroup app.jar
+
+USER appuser
+EXPOSE 8080
+
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=70.0", \
+    "-XX:+UseG1GC", \
+    "-jar", "app.jar"]

src/main/docker/Dockerfile.layered

@@ -0,0 +1,34 @@
+# Ultra-optimized layered build using Distroless
+# Expected size: ~180-220MB with better caching
+
+FROM gcr.io/distroless/java21-debian12:nonroot as base
+
+# Stage 1: Extract JAR layers for optimal caching
+FROM eclipse-temurin:21-jdk-alpine as extractor
+WORKDIR /app
+COPY build/libs/*.jar app.jar
+RUN java -Djarmode=layertools -jar app.jar extract
+
+# Stage 2: Production image with extracted layers
+FROM base
+WORKDIR /app
+
+# Copy layers in dependency order (best caching)
+COPY --from=extractor /app/dependencies/ ./
+COPY --from=extractor /app/spring-boot-loader/ ./
+COPY --from=extractor /app/snapshot-dependencies/ ./
+COPY --from=extractor /app/application/ ./
+
+EXPOSE 8080
+
+# Optimized JVM settings for micro-containers
+ENTRYPOINT ["java", \
+    "-XX:+UseContainerSupport", \
+    "-XX:MaxRAMPercentage=70.0", \
+    "-XX:+UseG1GC", \
+    "-XX:+UseStringDeduplication", \
+    "-XX:+CompactStrings", \
+    "-Xshare:on", \
+    "-Djava.security.egd=file:/dev/./urandom", \
+    "-Dspring.backgroundpreinitializer.ignore=true", \
+    "org.springframework.boot.loader.JarLauncher"]

src/main/docker/Dockerfile.native

@@ -0,0 +1,20 @@
+# GraalVM Native Image - Ultra-fast startup, tiny size
+# Expected size: ~50-80MB, startup <100ms
+# Note: Requires native compilation support in Spring Boot
+
+# Stage 1: Native compilation
+FROM ghcr.io/graalvm/graalvm-ce:ol9-java21 as native-builder
+WORKDIR /app
+
+# Install native-image
+RUN gu install native-image
+
+# Copy source and build native executable
+COPY . .
+RUN ./gradlew nativeCompile
+
+# Stage 2: Minimal runtime
+FROM scratch
+COPY --from=native-builder /app/build/native/nativeCompile/app /app
+EXPOSE 8080
+ENTRYPOINT ["/app"]

src/main/java/com/dalab/autolabel/DaAutolabelApplication.java

@@ -0,0 +1,34 @@
+package com.dalab.autolabel;
+
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import io.swagger.v3.oas.models.info.License;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
+
+@SpringBootApplication
+@EnableMethodSecurity // Enable method-level security (for @PreAuthorize)
+@EnableAsync // Enable asynchronous method execution
+public class DaAutolabelApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(DaAutolabelApplication.class, args);
+    }
+
+    @Bean
+    public OpenAPI customOpenAPI(@Value("${spring.application.name:DALab AutoLabel Service}") String appName,
+                               @Value("${spring.application.description:API for AutoLabel Service}") String appDescription,
+                               @Value("${spring.application.version:0.0.1-SNAPSHOT}") String appVersion) {
+        return new OpenAPI()
+                .info(new Info()
+                        .title(appName)
+                        .version(appVersion)
+                        .description(appDescription)
+                        .termsOfService("http://swagger.io/terms/") // Placeholder
+                        .license(new License().name("Apache 2.0").url("http://springdoc.org"))); // Placeholder
+    }
+} 

src/main/java/com/dalab/autolabel/client/dto/AssetIdentifier.java

@@ -0,0 +1,12 @@
+package com.dalab.autolabel.client.dto;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class AssetIdentifier {
+    private String assetId;
+    private String provider; // Optional: e.g., GCP, AWS, AZURE, OCI, for context
+    // Add other relevant fields that might be needed from catalog to identify/fetch asset details
+} 

src/main/java/com/dalab/autolabel/client/feign/AssetCatalogClient.java

@@ -0,0 +1,39 @@
+package com.dalab.autolabel.client.feign;
+
+import com.dalab.autolabel.client.dto.AssetIdentifier; // Assuming a DTO from da-catalog
+import com.dalab.autolabel.client.rest.dto.LabelingJobRequest;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.List;
+import java.util.Map;
+
+@FeignClient(name = "da-catalog", path = "/api/v1/catalog") // Value from da-catalog application properties
+public interface AssetCatalogClient {
+
+    // Example: Get assets by connection ID (actual endpoint TBD in da-catalog)
+    @GetMapping("/assets")
+    List<AssetIdentifier> getAssetsByConnection(@RequestParam("connectionId") String connectionId);
+
+    // Example: Get assets by criteria (actual endpoint TBD in da-catalog)
+    @PostMapping("/assets/search") // Assuming a search endpoint
+    List<AssetIdentifier> findAssetsByCriteria(@RequestBody Map<String, String> criteria);
+
+    // Example: Get minimal metadata for an asset (actual endpoint TBD in da-catalog)
+    @GetMapping("/assets/{assetId}/metadata/technical") // Or a specific slimmed down DTO endpoint
+    String getAssetTechnicalMetadata(@PathVariable("assetId") String assetId);
+
+    // Example: Add labels to an asset (actual endpoint TBD in da-catalog)
+    @PostMapping("/assets/{assetId}/labels")
+    void addLabelsToAsset(@PathVariable("assetId") String assetId, @RequestBody List<String> labels);
+
+    // Example: Remove a label from an asset (actual endpoint TBD in da-catalog)
+    @DeleteMapping("/assets/{assetId}/labels/{labelName}")
+    void removeLabelFromAsset(@PathVariable("assetId") String assetId, @PathVariable("labelName") String labelName);
+
+} 

src/main/java/com/dalab/autolabel/client/rest/dto/LabelingFeedbackRequest.java

@@ -0,0 +1,64 @@
+package com.dalab.autolabel.client.rest.dto;
+
+import java.util.List;
+import java.util.Map;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+/**
+ * Request DTO for submitting feedback on auto-suggested labels.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingFeedbackRequest {
+
+    @NotBlank(message = "Asset ID cannot be blank")
+    private String assetId;
+
+    @NotBlank(message = "Job ID that generated the suggestions cannot be blank")
+    private String labelingJobId; // ID of the job that produced these suggestions
+
+    @NotEmpty(message = "Feedback items cannot be empty")
+    private List<FeedbackItem> feedbackItems;
+
+    private String userId; // Optional: User providing the feedback
+    private Map<String, String> additionalContext; // Optional: e.g., UI version, session ID
+
+    /**
+     * Nested DTO for individual feedback items.
+     */
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Builder
+    public static class FeedbackItem {
+        @NotBlank(message = "Suggested label cannot be blank")
+        private String suggestedLabel;
+
+        private Double originalConfidence; // Optional: Confidence score from the LLM
+
+        @NotNull(message = "Feedback type cannot be null")
+        private FeedbackType type; // e.g., CONFIRMED, REJECTED, CORRECTED
+
+        private String correctedLabel; // If type is CORRECTED
+        private String userComment; // Optional comment
+    }
+
+    /**
+     * Enum for feedback type.
+     */
+    public enum FeedbackType {
+        CONFIRMED, // User agrees with the suggestion
+        REJECTED,  // User disagrees with the suggestion
+        CORRECTED, // User provides a corrected label
+        FLAGGED    // User flags for further review, without immediate correction
+    }
+} 

src/main/java/com/dalab/autolabel/client/rest/dto/LabelingFeedbackResponse.java

@@ -0,0 +1,30 @@
+package com.dalab.autolabel.client.rest.dto;
+
+import java.time.LocalDateTime;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Response DTO after submitting labeling feedback.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingFeedbackResponse {
+
+    private String feedbackId; // A unique ID for this feedback submission
+    private String assetId;
+    private String status; // e.g., "RECEIVED", "PROCESSED", "ERROR"
+    private String message;
+    private LocalDateTime receivedAt;
+    
+    /**
+     * Timestamp when the feedback was processed.
+     */
+    private LocalDateTime processedAt;
+
+} 

src/main/java/com/dalab/autolabel/client/rest/dto/LabelingJobListResponse.java

@@ -0,0 +1,47 @@
+package com.dalab.autolabel.client.rest.dto;
+
+import java.util.List;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+/**
+ * Response DTO for listing auto-labeling jobs with pagination information.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingJobListResponse {
+
+    /**
+     * List of job statuses for the current page.
+     */
+    private List<LabelingJobStatusResponse> jobs;
+
+    /**
+     * Current page number (0-indexed).
+     */
+    private int pageNumber;
+
+    /**
+     * Number of jobs per page.
+     */
+    private int pageSize;
+
+    /**
+     * Total number of jobs matching the criteria.
+     */
+    private long totalElements;
+
+    /**
+     * Total number of pages.
+     */
+    private int totalPages;
+
+    /**
+     * Indicates if this is the last page.
+     */
+    private boolean last;
+} 

src/main/java/com/dalab/autolabel/client/rest/dto/LabelingJobRequest.java

@@ -0,0 +1,82 @@
+package com.dalab.autolabel.client.rest.dto;
+
+import java.util.List;
+import java.util.Map;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+/**
+ * Request DTO to trigger an auto-labeling job.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingJobRequest {
+
+    /**
+     * A user-defined name for this labeling job for easier identification.
+     */
+    @NotNull(message = "Job name cannot be null")
+    private String jobName;
+
+    /**
+     * Specifies the scope of assets to be labeled.
+     * Only one of these should typically be provided.
+     */
+    @NotNull(message = "Labeling scope cannot be null")
+    @Valid // Enable validation for nested LabelingScope object
+    private LabelingScope scope;
+
+    /**
+     * Optional: Override ML configuration for this specific job.
+     * If not provided, the globally configured ML settings will be used.
+     */
+    @Valid // Enable validation for nested MLConfigRequest object if annotations are added there
+    private MLConfigRequest overrideMlConfig;
+
+    /**
+     * Optional: Parameters to control job execution, e.g., priority, run mode (dry-run vs apply).
+     */
+    private Map<String, String> jobParameters;
+
+    /**
+     * Nested DTO for defining the scope of the labeling job.
+     */
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Builder
+    public static class LabelingScope {
+        /**
+         * List of specific asset IDs to label.
+         */
+        private List<String> assetIds;
+
+        /**
+         * ID of a cloud connection. All assets under this connection will be considered.
+         * This implies da-autolabel might need to query da-catalog for assets based on connectionId.
+         */
+        private String cloudConnectionId;
+
+        /**
+         * Criteria for selecting assets, e.g., based on existing labels, asset types, or other metadata.
+         * This would be a more complex filter.
+         * For now, represented as a map, but could be a more structured query object.
+         */
+        private Map<String, String> assetCriteria;
+
+        /**
+         * An identifier for a pre-defined asset group or collection.
+         */
+        private String assetGroupId;
+        
+        // It would be good to add a validation ensuring at least one scope field is provided.
+        // This can be done with a custom class-level validator, or by checking in the service layer.
+    }
+} 

src/main/java/com/dalab/autolabel/client/rest/dto/LabelingJobResponse.java

@@ -0,0 +1,83 @@
+package com.dalab.autolabel.client.rest.dto;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+/**
+ * Response DTO after submitting an auto-labeling job.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingJobResponse {
+
+    /**
+     * The unique identifier for the submitted labeling job.
+     */
+    private String jobId;
+
+    /**
+     * The asset ID that was processed (for single asset jobs).
+     */
+    private String assetId;
+
+    /**
+     * The current status of the job (e.g., "SUBMITTED", "RUNNING", "COMPLETED", "FAILED").
+     */
+    private String status;
+
+    /**
+     * Timestamp when the job was submitted/created.
+     */
+    private LocalDateTime submittedAt;
+
+    /**
+     * Timestamp when the job was created.
+     */
+    private LocalDateTime createdAt;
+
+    /**
+     * Timestamp when the job was completed.
+     */
+    private LocalDateTime completedAt;
+
+    /**
+     * Processing time in milliseconds.
+     */
+    private Long processingTimeMs;
+
+    /**
+     * A brief message providing more details about the job submission.
+     */
+    private String message;
+
+    /**
+     * Error message if the job failed.
+     */
+    private String errorMessage;
+
+    /**
+     * List of label suggestions with confidence scores.
+     */
+    private List<LabelSuggestionDTO> suggestions;
+
+    /**
+     * DTO for label suggestions.
+     */
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Builder
+    public static class LabelSuggestionDTO {
+        private String labelName;
+        private Double confidence;
+        private String reasoning;
+        private String category;
+    }
+} 

src/main/java/com/dalab/autolabel/client/rest/dto/LabelingJobStatusResponse.java

@@ -0,0 +1,49 @@
+package com.dalab.autolabel.client.rest.dto;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+/**
+ * Response DTO for querying the status of an auto-labeling job.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingJobStatusResponse {
+
+    private String jobId;
+    private String jobName; // From the original request
+    private String status; // e.g., SUBMITTED, PREPARING_DATA, CALLING_LLM, APPLYING_LABELS, COMPLETED, FAILED, PARTIALLY_COMPLETED
+    private LocalDateTime submittedAt;
+    private LocalDateTime startedAt;
+    private LocalDateTime lastUpdatedAt;
+    private LocalDateTime completedAt;
+
+    private Integer totalAssetsToProcess;
+    private Integer assetsProcessed;
+    private Integer assetsSuccessfullyLabeled;
+    private Integer assetsFailed;
+
+    private String currentStageDescription; // e.g., "Fetching metadata for asset X", "Calling LLM for batch Y"
+    private Double progressPercentage; // Overall progress
+
+    private List<String> errorMessages; // List of errors if any occurred
+
+    /**
+     * Optional: Link to where detailed results or logs might be found, if applicable.
+     */
+    private String resultsLink;
+
+    /**
+     * Optional: summary of labels applied or suggested if the job is complete or partially complete.
+     * Key: Label Name, Value: Count of assets this label was applied to.
+     */
+    private Map<String, Integer> labelSummary;
+} 

src/main/java/com/dalab/autolabel/client/rest/dto/MLConfigRequest.java

@@ -0,0 +1,108 @@
+package com.dalab.autolabel.client.rest.dto;
+
+import java.util.Map;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+/**
+ * Represents the request to configure Machine Learning (ML) settings for auto-labeling.
+ * This DTO is designed to be flexible to accommodate various LLM providers and their configurations.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class MLConfigRequest {
+
+    /**
+     * Specifies the ML provider to be used.
+     * Examples: "openai", "ollama", "gemini", "azure_openai", "vertex_ai".
+     */
+    private String providerType;
+
+    /**
+     * The API key for the selected ML provider, if applicable.
+     * This should be stored securely.
+     */
+    private String apiKey;
+
+    /**
+     * The base URL for the ML provider's API.
+     * Especially relevant for self-hosted models like Ollama or enterprise Azure OpenAI endpoints.
+     */
+    private String baseUrl;
+
+    /**
+     * The specific model name to be used from the provider.
+     * Examples: "gpt-3.5-turbo", "llama2", "gemini-pro".
+     */
+    private String modelName;
+
+    /**
+     * The prompt template to be used for generating labels.
+     * This template can include placeholders for metadata fields.
+     * Example: "Based on the following metadata, suggest relevant labels: {metadata_summary}"
+     */
+    private String promptTemplate;
+    
+    /**
+     * A map for any additional provider-specific parameters.
+     * This allows for extending configuration without changing the DTO structure.
+     * Keys could be "temperature", "maxTokens", "deploymentName" (for Azure OpenAI), etc.
+     */
+    private Map<String, Object> additionalParameters;
+
+    /**
+     * Configuration for how many labels to suggest.
+     */
+    private SuggestionConfig suggestionConfig;
+
+    /**
+     * Configuration for confidence thresholds.
+     */
+    private ConfidenceConfig confidenceConfig;
+
+
+    /**
+     * Nested DTO for label suggestion configuration.
+     */
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Builder
+    public static class SuggestionConfig {
+        /**
+         * Maximum number of labels to suggest.
+         */
+        private Integer maxSuggestions;
+
+        /**
+         * Whether to include confidence scores with suggestions.
+         */
+        private Boolean includeConfidenceScores;
+    }
+
+    /**
+     * Nested DTO for confidence threshold configuration.
+     */
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Builder
+    public static class ConfidenceConfig {
+        /**
+         * Minimum confidence score for a suggestion to be considered.
+         * (Value between 0.0 and 1.0)
+         */
+        private Double minThreshold;
+
+        /**
+         * Action to take if confidence is below the minimum threshold.
+         * Examples: "REJECT", "FLAG_FOR_REVIEW"
+         */
+        private String actionBelowThreshold;
+    }
+} 

src/main/java/com/dalab/autolabel/controller/AutoLabelingController.java

@@ -0,0 +1,239 @@
+package com.dalab.autolabel.controller;
+
+import java.util.Map;
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobListResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingJobResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobStatusResponse;
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.llm.client.LLMClientFactory;
+import com.dalab.autolabel.service.AutoLabelingService;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+
+/**
+ * REST controller for auto-labeling operations using LLM providers.
+ * Provides endpoints for job management, ML configuration, and feedback processing.
+ */
+@RestController
+@RequestMapping("/api/v1/autolabel")
+@Tag(name = "Auto-Labeling", description = "LLM-powered auto-labeling operations")
+public class AutoLabelingController {
+
+    private static final Logger log = LoggerFactory.getLogger(AutoLabelingController.class);
+
+    private final AutoLabelingService autoLabelingService;
+    private final LLMClientFactory llmClientFactory;
+
+    @Autowired
+    public AutoLabelingController(AutoLabelingService autoLabelingService, LLMClientFactory llmClientFactory) {
+        this.autoLabelingService = autoLabelingService;
+        this.llmClientFactory = llmClientFactory;
+    }
+
+    @PostMapping("/labeling/jobs")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD', 'ROLE_USER')")
+    @Operation(summary = "Create a labeling job", description = "Creates a new auto-labeling job for the specified assets")
+    public ResponseEntity<LabelingJobResponse> createLabelingJob(
+            @Valid @RequestBody LabelingJobRequest request) {
+        log.info("REST request to create labeling job: {}", request.getJobName());
+        
+        try {
+            LabelingJobResponse response = autoLabelingService.createLabelingJob(request);
+            return ResponseEntity.status(HttpStatus.ACCEPTED).body(response);
+        } catch (Exception e) {
+            log.error("Failed to create labeling job: {}", e.getMessage(), e);
+            LabelingJobResponse errorResponse = LabelingJobResponse.builder()
+                    .jobId(UUID.randomUUID().toString())
+                    .status("FAILED")
+                    .message("Failed to create labeling job: " + e.getMessage())
+                    .build();
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
+        }
+    }
+
+    @GetMapping("/labeling/jobs")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD', 'ROLE_USER')")
+    @Operation(summary = "Get labeling jobs", description = "Retrieves a paginated list of labeling jobs")
+    public ResponseEntity<LabelingJobListResponse> getLabelingJobs(
+            @PageableDefault(size = 20, sort = "submittedAt") Pageable pageable,
+            @RequestParam(required = false) @Parameter(description = "Filter by job status") String status,
+            @RequestParam(required = false) @Parameter(description = "Filter by user ID") UUID userId) {
+        log.info("REST request to get labeling jobs with filters: status={}, userId={}", status, userId);
+        
+        // TODO: Implement actual job listing from database
+        LabelingJobListResponse response = LabelingJobListResponse.builder()
+                .jobs(java.util.Collections.emptyList())
+                .totalElements(0L)
+                .pageNumber(pageable.getPageNumber())
+                .pageSize(pageable.getPageSize())
+                .totalPages(0)
+                .last(true)
+                .build();
+                
+        return ResponseEntity.ok(response);
+    }
+
+    @GetMapping("/labeling/jobs/{jobId}")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD', 'ROLE_USER')")
+    @Operation(summary = "Get job status", description = "Retrieves the status and details of a specific labeling job")
+    public ResponseEntity<LabelingJobStatusResponse> getJobStatus(@PathVariable String jobId) {
+        log.info("REST request to get status for job: {}", jobId);
+        
+        try {
+            UUID jobUuid = UUID.fromString(jobId);
+            LabelingJobStatusResponse response = autoLabelingService.getJobStatus(jobUuid);
+            return ResponseEntity.ok(response);
+        } catch (IllegalArgumentException e) {
+            log.error("Invalid job ID format: {}", jobId);
+            return ResponseEntity.badRequest().build();
+        }
+    }
+
+    @PostMapping("/labeling/feedback")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD', 'ROLE_USER')")
+    @Operation(summary = "Provide labeling feedback", description = "Submits feedback for improving labeling accuracy")
+    public ResponseEntity<LabelingFeedbackResponse> provideFeedback(
+            @Valid @RequestBody LabelingFeedbackRequest feedback) {
+        log.info("REST request to provide feedback for asset: {}", feedback.getAssetId());
+        
+        try {
+            LabelingFeedbackResponse response = autoLabelingService.processFeedback(feedback);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            log.error("Failed to process feedback: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    @PutMapping("/labeling/config/ml")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD')")
+    @Operation(summary = "Update ML configuration", description = "Updates the machine learning configuration for auto-labeling")
+    public ResponseEntity<Map<String, Object>> updateMLConfiguration(
+            @Valid @RequestBody MLConfigRequest mlConfig) {
+        log.info("REST request to update ML configuration for provider: {}", mlConfig.getProviderType());
+        
+        try {
+            boolean success = autoLabelingService.updateMLConfiguration(mlConfig);
+            
+            if (success) {
+                return ResponseEntity.ok(Map.of(
+                    "status", "SUCCESS",
+                    "message", "ML configuration updated successfully",
+                    "provider", mlConfig.getProviderType()
+                ));
+            } else {
+                return ResponseEntity.badRequest().body(Map.of(
+                    "status", "ERROR",
+                    "message", "ML configuration validation failed",
+                    "provider", mlConfig.getProviderType()
+                ));
+            }
+        } catch (Exception e) {
+            log.error("Failed to update ML configuration: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of(
+                "status", "ERROR",
+                "message", "Failed to update ML configuration: " + e.getMessage()
+            ));
+        }
+    }
+
+    @PostMapping("/labeling/config/ml/test")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD')")
+    @Operation(summary = "Test ML configuration", description = "Tests the connectivity and validity of an ML configuration")
+    public ResponseEntity<Map<String, Object>> testMLConfiguration(
+            @Valid @RequestBody MLConfigRequest mlConfig) {
+        log.info("REST request to test ML configuration for provider: {}", mlConfig.getProviderType());
+        
+        try {
+            boolean connectionOk = llmClientFactory.testConnection(mlConfig);
+            boolean configValid = llmClientFactory.validateConfiguration(mlConfig);
+            
+            Map<String, Object> result = Map.of(
+                "provider", mlConfig.getProviderType(),
+                "connectionTest", connectionOk ? "PASSED" : "FAILED",
+                "configurationTest", configValid ? "VALID" : "INVALID",
+                "overallStatus", (connectionOk && configValid) ? "SUCCESS" : "FAILED"
+            );
+            
+            return ResponseEntity.ok(result);
+            
+        } catch (Exception e) {
+            log.error("Failed to test ML configuration: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of(
+                "status", "ERROR",
+                "message", "Failed to test ML configuration: " + e.getMessage()
+            ));
+        }
+    }
+
+    @GetMapping("/providers")
+    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DATA_STEWARD', 'ROLE_USER')")
+    @Operation(summary = "Get available LLM providers", description = "Retrieves information about all supported LLM providers")
+    public ResponseEntity<Map<String, Object>> getProviders() {
+        log.debug("REST request to get available LLM providers");
+        
+        try {
+            Map<String, Map<String, Object>> capabilities = autoLabelingService.getProviderCapabilities();
+            
+            Map<String, Object> response = Map.of(
+                "supportedProviders", llmClientFactory.getSupportedProviders(),
+                "providerCapabilities", capabilities
+            );
+            
+            return ResponseEntity.ok(response);
+            
+        } catch (Exception e) {
+            log.error("Failed to get providers: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    @GetMapping("/health")
+    @Operation(summary = "Service health check", description = "Checks the health status of the auto-labeling service")
+    public ResponseEntity<Map<String, Object>> healthCheck() {
+        log.debug("Health check requested");
+        
+        try {
+            Map<String, Object> health = Map.of(
+                "status", "UP",
+                "service", "da-autolabel",
+                "timestamp", java.time.LocalDateTime.now(),
+                "availableProviders", llmClientFactory.getSupportedProviders().size()
+            );
+            
+            return ResponseEntity.ok(health);
+            
+        } catch (Exception e) {
+            log.error("Health check failed: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(Map.of(
+                "status", "DOWN",
+                "error", e.getMessage()
+            ));
+        }
+    }
+} 

src/main/java/com/dalab/autolabel/controller/LabelingConfigController.java

@@ -0,0 +1,74 @@
+package com.dalab.autolabel.controller;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.service.IMLConfigService;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * REST controller for managing AutoLabel ML configurations.
+ */
+@RestController
+@RequestMapping("/api/v1/labeling")
+@RequiredArgsConstructor
+@Slf4j
+public class LabelingConfigController {
+
+    private final IMLConfigService mlConfigService;
+
+    /**
+     * Updates the Machine Learning (ML) configuration for auto-labeling.
+     * Requires ADMIN role.
+     *
+     * @param mlConfigRequest The ML configuration request.
+     * @return ResponseEntity indicating success or failure.
+     */
+    @PutMapping("/config/ml")
+    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
+    public ResponseEntity<Void> updateMlConfiguration(@RequestBody MLConfigRequest mlConfigRequest) {
+        log.info("Received request to update ML configuration: {}", mlConfigRequest);
+        try {
+            mlConfigService.updateMlConfig(mlConfigRequest);
+            return ResponseEntity.ok().build();
+        } catch (IllegalArgumentException e) {
+            log.error("Invalid ML configuration provided: {}", e.getMessage());
+            return ResponseEntity.badRequest().build(); // Or a more specific error response
+        } catch (Exception e) {
+            log.error("Error updating ML configuration: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    /**
+     * Retrieves the current Machine Learning (ML) configuration for auto-labeling.
+     * Requires ADMIN role.
+     *
+     * @return ResponseEntity with the current MLConfigRequest or not found/error.
+     */
+    @GetMapping("/config/ml")
+    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
+    public ResponseEntity<MLConfigRequest> getMlConfiguration() {
+        log.info("Received request to get ML configuration.");
+        try {
+            MLConfigRequest config = mlConfigService.getMlConfig();
+            if (config != null) {
+                return ResponseEntity.ok(config);
+            } else {
+                return ResponseEntity.notFound().build();
+            }
+        } catch (Exception e) {
+            log.error("Error retrieving ML configuration: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+} 

src/main/java/com/dalab/autolabel/controller/LabelingJobController.java

@@ -0,0 +1,116 @@
+package com.dalab.autolabel.controller;
+
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobListResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingJobResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobStatusResponse;
+import com.dalab.autolabel.exception.AutoLabelingException;
+import com.dalab.autolabel.service.ILabelingJobService;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/v1/labeling") // Changed base path to /api/v1/labeling
+@RequiredArgsConstructor
+@Slf4j
+public class LabelingJobController {
+
+    private final ILabelingJobService labelingJobService;
+
+    /**
+     * Submits a new auto-labeling job.
+     * Requires DATA_STEWARD or ADMIN role.
+     *
+     * @param jobRequest The labeling job request.
+     * @return ResponseEntity with LabelingJobResponse or an error.
+     */
+    @PostMapping("/jobs")
+    @PreAuthorize("hasAnyAuthority('ROLE_DATA_STEWARD', 'ROLE_ADMIN')")
+    public ResponseEntity<LabelingJobResponse> submitLabelingJob(@Valid @RequestBody LabelingJobRequest jobRequest) {
+        log.info("Received request to submit labeling job: {}", jobRequest.getJobName());
+        try {
+            LabelingJobResponse jobResponse = labelingJobService.submitLabelingJob(jobRequest);
+            return ResponseEntity.status(HttpStatus.ACCEPTED).body(jobResponse);
+        } catch (AutoLabelingException e) {
+            log.error("Error submitting labeling job '{}': {}", jobRequest.getJobName(), e.getMessage());
+            return ResponseEntity.badRequest().body(LabelingJobResponse.builder().message(e.getMessage()).build());
+        } catch (Exception e) {
+            log.error("Unexpected error submitting labeling job '{}': {}", jobRequest.getJobName(), e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(LabelingJobResponse.builder().message("An unexpected error occurred.").build());
+        }
+    }
+
+    /**
+     * Retrieves the status of a specific auto-labeling job.
+     * Requires DATA_STEWARD, ADMIN, or USER role.
+     *
+     * @param jobId The ID of the job.
+     * @return ResponseEntity with LabelingJobStatusResponse or an error.
+     */
+    @GetMapping("/jobs/{jobId}")
+    @PreAuthorize("hasAnyAuthority('ROLE_DATA_STEWARD', 'ROLE_ADMIN', 'ROLE_USER')")
+    public ResponseEntity<LabelingJobStatusResponse> getJobStatus(@PathVariable String jobId) {
+        log.info("Received request to get status for labeling job ID: {}", jobId);
+        LabelingJobStatusResponse statusResponse = labelingJobService.getJobStatus(jobId);
+        if (statusResponse != null) {
+            return ResponseEntity.ok(statusResponse);
+        } else {
+            log.warn("Labeling job with ID '{}' not found.", jobId);
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    /**
+     * Lists all auto-labeling jobs with pagination.
+     * Requires DATA_STEWARD, ADMIN, or USER role.
+     *
+     * @param pageable Pagination information.
+     * @return ResponseEntity with LabelingJobListResponse or an error.
+     */
+    @GetMapping("/jobs")
+    @PreAuthorize("hasAnyAuthority('ROLE_DATA_STEWARD', 'ROLE_ADMIN', 'ROLE_USER')")
+    public ResponseEntity<LabelingJobListResponse> listJobs(@PageableDefault(size = 20) Pageable pageable) {
+        log.info("Received request to list labeling jobs. Pagination: {}", pageable);
+        try {
+            LabelingJobListResponse listResponse = labelingJobService.listJobs(pageable);
+            return ResponseEntity.ok(listResponse);
+        } catch (Exception e) {
+            log.error("Error listing labeling jobs: {}", e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    /**
+     * Submits feedback for auto-suggested labels on an asset.
+     * Requires DATA_STEWARD or ADMIN role.
+     *
+     * @param feedbackRequest The labeling feedback request.
+     * @return ResponseEntity with LabelingFeedbackResponse or an error.
+     */
+    @PostMapping("/feedback")
+    @PreAuthorize("hasAnyAuthority('ROLE_DATA_STEWARD', 'ROLE_ADMIN')")
+    public ResponseEntity<LabelingFeedbackResponse> submitLabelingFeedback(@Valid @RequestBody LabelingFeedbackRequest feedbackRequest) {
+        log.info("Received labeling feedback for asset ID: {}", feedbackRequest.getAssetId());
+        try {
+            LabelingFeedbackResponse feedbackResponse = labelingJobService.processLabelingFeedback(feedbackRequest);
+            return ResponseEntity.ok(feedbackResponse);
+        } catch (AutoLabelingException e) {
+            log.error("Error processing labeling feedback for asset '{}': {}", feedbackRequest.getAssetId(), e.getMessage());
+            return ResponseEntity.badRequest().body(LabelingFeedbackResponse.builder().message(e.getMessage()).build());
+        } catch (Exception e) {
+            log.error("Unexpected error processing labeling feedback for asset '{}': {}", feedbackRequest.getAssetId(), e.getMessage(), e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(LabelingFeedbackResponse.builder().message("An unexpected error occurred while processing feedback.").build());
+        }
+    }
+} 

src/main/java/com/dalab/autolabel/entity/LabelingFeedbackEntity.java

@@ -0,0 +1,52 @@
+package com.dalab.autolabel.entity;
+
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackRequest;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * JPA Entity representing labeling feedback provided by a user.
+ */
+@Entity
+@Table(name = "dalab_autolabel_feedback")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingFeedbackEntity {
+
+    @Id
+    private String feedbackId;
+
+    @Column(nullable = false)
+    private String assetId;
+
+    @Column(nullable = false)
+    private String labelingJobId; // The job that generated the suggestions being corrected
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb", nullable = false)
+    private List<LabelingFeedbackRequest.FeedbackItem> feedbackItems;
+
+    private String userId; // User who provided the feedback
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, String> additionalContext; // e.g., UI version, session ID
+
+    @Column(nullable = false)
+    private LocalDateTime receivedAt;
+
+    private LocalDateTime processedAt; // When the feedback was fully processed (e.g., catalog updated)
+    
+    private String processingStatus; // E.g., "RECEIVED", "PROCESSING", "PROCESSED", "ERROR"
+} 

src/main/java/com/dalab/autolabel/entity/LabelingJobEntity.java

@@ -0,0 +1,72 @@
+package com.dalab.autolabel.entity;
+
+import com.dalab.autolabel.client.rest.dto.LabelingJobRequest;
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * JPA Entity representing an auto-labeling job.
+ */
+@Entity
+@Table(name = "dalab_autolabel_job")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class LabelingJobEntity {
+
+    @Id
+    private String jobId;
+
+    private String jobName;
+
+    @Enumerated(EnumType.STRING)
+    private JobStatus status;
+
+    private LocalDateTime submittedAt;
+    private LocalDateTime startedAt;
+    private LocalDateTime lastUpdatedAt;
+    private LocalDateTime completedAt;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private LabelingJobRequest.LabelingScope scope; // Store the original scope
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private MLConfigRequest effectiveMlConfig; // Store the ML config used for this job
+
+    private Integer totalAssetsToProcess;
+    private Integer assetsProcessed;
+    private Integer assetsSuccessfullyLabeled;
+    private Integer assetsFailed;
+
+    private String currentStageDescription;
+    private Double progressPercentage;
+
+    @ElementCollection(fetch = FetchType.EAGER)
+    @CollectionTable(name = "dalab_autolabel_job_errors", joinColumns = @JoinColumn(name = "job_id"))
+    @Column(name = "error_message", length = 2048) // Increased length for error messages
+    private List<String> errorMessages;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    private Map<String, Integer> labelSummary; // Key: Label Name, Value: Count
+    
+    private String triggeredByUserId; // User who triggered the job
+
+    // Enum for JobStatus (can be shared or specific to this entity's package)
+    public enum JobStatus {
+        SUBMITTED, PREPARING_DATA, CALLING_LLM, APPLYING_LABELS, COMPLETED, FAILED, PARTIALLY_COMPLETED, CANCELLED
+    }
+} 

src/main/java/com/dalab/autolabel/exception/AutoLabelingException.java

@@ -0,0 +1,17 @@
+package com.dalab.autolabel.exception;
+
+/**
+ * Custom exception for the AutoLabel service.
+ */
+public class AutoLabelingException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    public AutoLabelingException(String message) {
+        super(message);
+    }
+
+    public AutoLabelingException(String message, Throwable cause) {
+        super(message, cause);
+    }
+} 

src/main/java/com/dalab/autolabel/llm/client/ILLMClient.java

@@ -0,0 +1,75 @@
+package com.dalab.autolabel.llm.client;
+
+import java.util.List;
+import java.util.Map;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.llm.model.LLMResponse;
+import com.dalab.autolabel.llm.model.LabelSuggestion;
+
+/**
+ * Interface for a client that interacts with a Large Language Model (LLM).
+ * Provides abstraction for different LLM providers (OpenAI, Gemini, Ollama, etc.).
+ */
+public interface ILLMClient {
+
+    /**
+     * Gets the provider name for this LLM client (e.g., "OPENAI", "GEMINI", "OLLAMA").
+     *
+     * @return The provider name.
+     */
+    String getProviderName();
+
+    /**
+     * Suggests a list of labels for the given asset content/metadata using the LLM.
+     *
+     * @param assetContent A string representation of the asset content or relevant metadata.
+     * @param mlConfig The ML configuration to use, containing model details, prompt templates, etc.
+     * @return A list of suggested label strings.
+     * @throws Exception if there is an error during LLM interaction.
+     */
+    List<String> suggestLabels(String assetContent, MLConfigRequest mlConfig) throws Exception;
+
+    /**
+     * Suggests labels with confidence scores for better decision making.
+     *
+     * @param assetContent A string representation of the asset content or relevant metadata.
+     * @param mlConfig The ML configuration to use, containing model details, prompt templates, etc.
+     * @return A list of label suggestions with confidence scores.
+     * @throws Exception if there is an error during LLM interaction.
+     */
+    List<LabelSuggestion> suggestLabelsWithConfidence(String assetContent, MLConfigRequest mlConfig) throws Exception;
+
+    /**
+     * Processes multiple assets in batch for efficiency.
+     *
+     * @param assetContents List of asset content strings to process.
+     * @param mlConfig The ML configuration to use.
+     * @return List of LLM responses corresponding to each input.
+     * @throws Exception if there is an error during LLM interaction.
+     */
+    List<LLMResponse> batchSuggestLabels(List<String> assetContents, MLConfigRequest mlConfig) throws Exception;
+
+    /**
+     * Validates that the ML configuration is compatible with this LLM client.
+     *
+     * @param mlConfig The ML configuration to validate.
+     * @return true if the configuration is valid for this client, false otherwise.
+     */
+    boolean validateConfiguration(MLConfigRequest mlConfig);
+
+    /**
+     * Gets the capabilities of this LLM client.
+     *
+     * @return A map of capabilities (e.g., "maxTokens", "supportsBatch", "supportsConfidence").
+     */
+    Map<String, Object> getCapabilities();
+
+    /**
+     * Tests the connection to the LLM provider with the given configuration.
+     *
+     * @param mlConfig The ML configuration to test.
+     * @return true if the connection is successful, false otherwise.
+     */
+    boolean testConnection(MLConfigRequest mlConfig);
+} 

src/main/java/com/dalab/autolabel/llm/client/LLMClientFactory.java

@@ -0,0 +1,137 @@
+package com.dalab.autolabel.llm.client;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+
+/**
+ * Factory for creating and managing LLM clients.
+ * Handles provider selection and client lifecycle.
+ */
+@Service
+public class LLMClientFactory {
+
+    private static final Logger log = LoggerFactory.getLogger(LLMClientFactory.class);
+    
+    private final Map<String, ILLMClient> clients;
+
+    @Autowired
+    public LLMClientFactory(List<ILLMClient> llmClients) {
+        this.clients = new HashMap<>();
+        
+        // Register all available clients
+        for (ILLMClient client : llmClients) {
+            clients.put(client.getProviderName().toUpperCase(), client);
+            log.info("Registered LLM client: {}", client.getProviderName());
+        }
+    }
+
+    /**
+     * Gets the appropriate LLM client based on the ML configuration.
+     *
+     * @param mlConfig The ML configuration specifying the provider
+     * @return The LLM client for the specified provider
+     * @throws IllegalArgumentException if the provider is not supported
+     */
+    public ILLMClient getClient(MLConfigRequest mlConfig) {
+        if (mlConfig == null || mlConfig.getProviderType() == null) {
+            throw new IllegalArgumentException("ML configuration and provider type cannot be null");
+        }
+
+        String providerType = mlConfig.getProviderType().toUpperCase();
+        ILLMClient client = clients.get(providerType);
+        
+        if (client == null) {
+            throw new IllegalArgumentException("Unsupported LLM provider: " + providerType);
+        }
+
+        return client;
+    }
+
+    /**
+     * Gets all available LLM clients.
+     *
+     * @return Collection of all registered LLM clients
+     */
+    public Collection<ILLMClient> getAllClients() {
+        return clients.values();
+    }
+
+    /**
+     * Gets the names of all supported providers.
+     *
+     * @return Set of provider names
+     */
+    public Set<String> getSupportedProviders() {
+        return clients.keySet();
+    }
+
+    /**
+     * Validates if a provider is supported.
+     *
+     * @param providerType The provider type to check
+     * @return true if supported, false otherwise
+     */
+    public boolean isProviderSupported(String providerType) {
+        if (providerType == null) {
+            return false;
+        }
+        return clients.containsKey(providerType.toUpperCase());
+    }
+
+    /**
+     * Gets capabilities for all providers.
+     *
+     * @return Map of provider names to their capabilities
+     */
+    public Map<String, Map<String, Object>> getAllProviderCapabilities() {
+        Map<String, Map<String, Object>> allCapabilities = new HashMap<>();
+        
+        for (Map.Entry<String, ILLMClient> entry : clients.entrySet()) {
+            allCapabilities.put(entry.getKey(), entry.getValue().getCapabilities());
+        }
+        
+        return allCapabilities;
+    }
+
+    /**
+     * Tests connection for a specific configuration.
+     *
+     * @param mlConfig The ML configuration to test
+     * @return true if the connection test passes, false otherwise
+     */
+    public boolean testConnection(MLConfigRequest mlConfig) {
+        try {
+            ILLMClient client = getClient(mlConfig);
+            return client.testConnection(mlConfig);
+        } catch (Exception e) {
+            log.error("Connection test failed: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    /**
+     * Validates a configuration for a specific provider.
+     *
+     * @param mlConfig The ML configuration to validate
+     * @return true if the configuration is valid, false otherwise
+     */
+    public boolean validateConfiguration(MLConfigRequest mlConfig) {
+        try {
+            ILLMClient client = getClient(mlConfig);
+            return client.validateConfiguration(mlConfig);
+        } catch (Exception e) {
+            log.error("Configuration validation failed: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+} 

src/main/java/com/dalab/autolabel/llm/client/impl/MockLLMClient.java

@@ -0,0 +1,138 @@
+package com.dalab.autolabel.llm.client.impl;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import org.springframework.stereotype.Component;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.llm.client.ILLMClient;
+import com.dalab.autolabel.llm.model.LLMResponse;
+import com.dalab.autolabel.llm.model.LabelSuggestion;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Component("mockLLMClient")
+@Slf4j
+public class MockLLMClient implements ILLMClient {
+
+    private static final List<String> MOCK_LABELS = Arrays.asList(
+            "PII", "Confidential", "Public", "Sensitive", "FinancialData",
+            "HealthRecord", "SourceCode", "UserGeneratedContent", "Archive", "Temporary"
+    );
+    private final Random random = new Random();
+
+    @Override
+    public String getProviderName() {
+        return "MOCK";
+    }
+
+    @Override
+    public List<String> suggestLabels(String assetContent, MLConfigRequest mlConfig) throws Exception {
+        log.info("MockLLMClient: Received request to suggest labels for asset content (first 50 chars): '{}' with config: {}", 
+                assetContent.substring(0, Math.min(assetContent.length(), 50)), mlConfig.getModelName());
+        
+        // Simulate network delay
+        Thread.sleep(50 + random.nextInt(200)); // Simulate 50-250ms delay
+
+        int numberOfLabels = 1 + random.nextInt(3); // Suggest 1 to 3 labels
+        List<String> suggested = new java.util.ArrayList<>();
+        for (int i = 0; i < numberOfLabels; i++) {
+            suggested.add(MOCK_LABELS.get(random.nextInt(MOCK_LABELS.size())));
+        }
+
+        log.info("MockLLMClient: Suggested labels: {}", suggested);
+        return suggested;
+    }
+
+    @Override
+    public boolean validateConfiguration(MLConfigRequest mlConfig) {
+        log.info("MockLLMClient: Validating configuration for model: {}", mlConfig.getModelName());
+        // Mock validation - always return true for testing
+        return true;
+    }
+
+    @Override
+    public boolean testConnection(MLConfigRequest mlConfig) {
+        log.info("MockLLMClient: Testing connection for model: {}", mlConfig.getModelName());
+        // Mock connection test - always return true for testing
+        return true;
+    }
+
+    @Override
+    public Map<String, Object> getCapabilities() {
+        Map<String, Object> capabilities = new HashMap<>();
+        capabilities.put("maxTokens", 4096);
+        capabilities.put("supportsBatch", true);
+        capabilities.put("supportsConfidence", true);
+        capabilities.put("supportsReasoning", true);
+        capabilities.put("provider", "MOCK");
+        capabilities.put("cost", 0.0);
+        return capabilities;
+    }
+
+    @Override
+    public List<LabelSuggestion> suggestLabelsWithConfidence(String assetContent, MLConfigRequest mlConfig) throws Exception {
+        log.info("MockLLMClient: Received request to suggest labels with confidence for asset content (first 50 chars): '{}' with config: {}", 
+                assetContent.substring(0, Math.min(assetContent.length(), 50)), mlConfig.getModelName());
+
+        // Simulate processing delay
+        Thread.sleep(100 + random.nextInt(200));
+
+        // Generate mock suggestions with confidence scores
+        List<LabelSuggestion> suggestions = new ArrayList<>();
+        int numSuggestions = 2 + random.nextInt(4); // 2-5 suggestions
+        
+        for (int i = 0; i < numSuggestions; i++) {
+            String label = MOCK_LABELS.get(random.nextInt(MOCK_LABELS.size()));
+            double confidence = 0.5 + (random.nextDouble() * 0.5); // 0.5-1.0 confidence
+            
+            suggestions.add(LabelSuggestion.builder()
+                    .label(label)
+                    .confidence(confidence)
+                    .reasoning("Mock reasoning for " + label + " based on content analysis")
+                    .category("MOCK_CATEGORY")
+                    .build());
+        }
+        
+        return suggestions;
+    }
+
+    @Override
+    public List<LLMResponse> batchSuggestLabels(List<String> assetContents, MLConfigRequest mlConfig) throws Exception {
+        log.info("MockLLMClient: Processing batch of {} assets with config: {}", assetContents.size(), mlConfig.getModelName());
+        
+        List<LLMResponse> responses = new ArrayList<>();
+        
+        for (String content : assetContents) {
+            try {
+                List<LabelSuggestion> suggestions = suggestLabelsWithConfidence(content, mlConfig);
+                
+                LLMResponse response = LLMResponse.builder()
+                        .successful(true)
+                        .suggestions(suggestions)
+                        .processingTimeMs(100L + random.nextInt(200))
+                        .timestamp(LocalDateTime.now())
+                        .build();
+                        
+                responses.add(response);
+            } catch (Exception e) {
+                LLMResponse errorResponse = LLMResponse.builder()
+                        .successful(false)
+                        .errorMessage("Mock error: " + e.getMessage())
+                        .processingTimeMs(50L)
+                        .timestamp(LocalDateTime.now())
+                        .build();
+                        
+                responses.add(errorResponse);
+            }
+        }
+        
+        return responses;
+    }
+} 

src/main/java/com/dalab/autolabel/llm/client/impl/OllamaLLMClient.java

@@ -0,0 +1,355 @@
+package com.dalab.autolabel.llm.client.impl;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.apache.hc.client5.http.classic.methods.HttpPost;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.core5.http.io.entity.StringEntity;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.llm.client.ILLMClient;
+import com.dalab.autolabel.llm.model.LLMResponse;
+import com.dalab.autolabel.llm.model.LabelSuggestion;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Ollama implementation of the LLM client for local/self-hosted open-source models.
+ * Supports models like Llama2, CodeLlama, Mistral, Gemma, DeepSeek, etc.
+ */
+@Component
+public class OllamaLLMClient implements ILLMClient {
+
+    private static final Logger log = LoggerFactory.getLogger(OllamaLLMClient.class);
+    private static final String PROVIDER_NAME = "OLLAMA";
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    // Default Ollama endpoint
+    private static final String DEFAULT_BASE_URL = "http://localhost:11434";
+
+    // Default prompt template for label suggestion
+    private static final String DEFAULT_PROMPT_TEMPLATE = """
+        You are a data governance expert. Analyze the following data asset and suggest appropriate labels.
+        
+        Data Asset Information:
+        {metadata_summary}
+        
+        Based on this information, suggest up to {max_suggestions} relevant data classification labels. Focus on:
+        1. Data sensitivity levels (PII, Confidential, Internal, Public)
+        2. Business context and domain
+        3. Technical characteristics
+        4. Regulatory compliance needs
+        
+        Provide your response as a JSON array with this format:
+        [
+          {
+            "label": "label name",
+            "confidence": 0.95,
+            "reasoning": "explanation for this label",
+            "category": "PII|BUSINESS|TECHNICAL|COMPLIANCE"
+          }
+        ]
+        
+        Only return the JSON array, no additional text.
+        """;
+
+    @Override
+    public String getProviderName() {
+        return PROVIDER_NAME;
+    }
+
+    @Override
+    public List<String> suggestLabels(String assetContent, MLConfigRequest mlConfig) throws Exception {
+        List<LabelSuggestion> suggestions = suggestLabelsWithConfidence(assetContent, mlConfig);
+        return suggestions.stream()
+                .map(LabelSuggestion::getLabel)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public List<LabelSuggestion> suggestLabelsWithConfidence(String assetContent, MLConfigRequest mlConfig) throws Exception {
+        log.info("Requesting label suggestions from Ollama for content: {}", 
+                assetContent.length() > 100 ? assetContent.substring(0, 100) + "..." : assetContent);
+
+        try {
+            String baseUrl = mlConfig.getBaseUrl() != null ? mlConfig.getBaseUrl() : DEFAULT_BASE_URL;
+            String prompt = buildPrompt(assetContent, mlConfig);
+            
+            Map<String, Object> requestBody = new HashMap<>();
+            requestBody.put("model", mlConfig.getModelName() != null ? mlConfig.getModelName() : "llama2");
+            requestBody.put("prompt", prompt);
+            requestBody.put("stream", false);
+            
+            // Add optional parameters
+            Map<String, Object> options = new HashMap<>();
+            options.put("temperature", getDoubleParameter(mlConfig, "temperature", 0.7));
+            options.put("top_p", getDoubleParameter(mlConfig, "top_p", 0.9));
+            options.put("max_tokens", getIntegerParameter(mlConfig, "max_tokens", 1000));
+            requestBody.put("options", options);
+
+            String responseJson = makeHttpRequest(baseUrl + "/api/generate", requestBody);
+            return parseOllamaResponse(responseJson);
+            
+        } catch (Exception e) {
+            log.error("Error getting label suggestions from Ollama: {}", e.getMessage(), e);
+            throw new Exception("Failed to get suggestions from Ollama: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public List<LLMResponse> batchSuggestLabels(List<String> assetContents, MLConfigRequest mlConfig) throws Exception {
+        log.info("Processing batch of {} assets for label suggestions with Ollama", assetContents.size());
+        
+        List<LLMResponse> responses = new ArrayList<>();
+        long startTime = System.currentTimeMillis();
+        
+        for (String content : assetContents) {
+            long itemStartTime = System.currentTimeMillis();
+            try {
+                List<LabelSuggestion> suggestions = suggestLabelsWithConfidence(content, mlConfig);
+                long processingTime = System.currentTimeMillis() - itemStartTime;
+                
+                LLMResponse response = LLMResponse.builder()
+                        .inputContent(content)
+                        .suggestions(suggestions)
+                        .processingTimeMs(processingTime)
+                        .timestamp(LocalDateTime.now())
+                        .provider(PROVIDER_NAME)
+                        .modelName(mlConfig.getModelName())
+                        .successful(true)
+                        .overallConfidence(calculateOverallConfidence(suggestions))
+                        .estimatedCost(0.0) // Local models have no API cost
+                        .build();
+                
+                responses.add(response);
+                
+            } catch (Exception e) {
+                log.error("Error processing asset in batch: {}", e.getMessage(), e);
+                
+                LLMResponse errorResponse = LLMResponse.builder()
+                        .inputContent(content)
+                        .suggestions(new ArrayList<>())
+                        .processingTimeMs(System.currentTimeMillis() - itemStartTime)
+                        .timestamp(LocalDateTime.now())
+                        .provider(PROVIDER_NAME)
+                        .modelName(mlConfig.getModelName())
+                        .successful(false)
+                        .errorMessage(e.getMessage())
+                        .estimatedCost(0.0)
+                        .build();
+                
+                responses.add(errorResponse);
+            }
+        }
+        
+        log.info("Completed Ollama batch processing in {} ms", System.currentTimeMillis() - startTime);
+        return responses;
+    }
+
+    @Override
+    public boolean validateConfiguration(MLConfigRequest mlConfig) {
+        if (mlConfig == null) {
+            return false;
+        }
+        
+        // Check provider type
+        if (!PROVIDER_NAME.equalsIgnoreCase(mlConfig.getProviderType())) {
+            return false;
+        }
+        
+        // For Ollama, API key is not required but model name is important
+        String modelName = mlConfig.getModelName();
+        if (modelName == null || modelName.trim().isEmpty()) {
+            log.warn("Model name not specified for Ollama client");
+            return false;
+        }
+        
+        return true;
+    }
+
+    @Override
+    public Map<String, Object> getCapabilities() {
+        Map<String, Object> capabilities = new HashMap<>();
+        capabilities.put("maxTokens", 4096); // Depends on the model
+        capabilities.put("supportsBatch", true);
+        capabilities.put("supportsConfidence", true);
+        capabilities.put("supportsReasoning", true);
+        capabilities.put("supportedModels", Arrays.asList(
+                "llama2", "llama2:7b", "llama2:13b", "llama2:70b",
+                "codellama", "codellama:7b", "codellama:13b", "codellama:34b",
+                "mistral", "mistral:7b", "mistral:instruct",
+                "gemma:2b", "gemma:7b",
+                "deepseek-coder", "deepseek-coder:6.7b", "deepseek-coder:33b"
+        ));
+        capabilities.put("costPerToken", 0.0); // Local models have no API cost
+        capabilities.put("requiresLocalSetup", true);
+        return capabilities;
+    }
+
+    @Override
+    public boolean testConnection(MLConfigRequest mlConfig) {
+        try {
+            if (!validateConfiguration(mlConfig)) {
+                return false;
+            }
+            
+            String baseUrl = mlConfig.getBaseUrl() != null ? mlConfig.getBaseUrl() : DEFAULT_BASE_URL;
+            
+            // Test with a simple request
+            Map<String, Object> testRequest = new HashMap<>();
+            testRequest.put("model", mlConfig.getModelName());
+            testRequest.put("prompt", "Test connection. Respond with OK.");
+            testRequest.put("stream", false);
+            
+            Map<String, Object> options = new HashMap<>();
+            options.put("max_tokens", 10);
+            testRequest.put("options", options);
+            
+            String response = makeHttpRequest(baseUrl + "/api/generate", testRequest);
+            return response != null && !response.trim().isEmpty();
+            
+        } catch (Exception e) {
+            log.error("Connection test failed for Ollama: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    private String makeHttpRequest(String url, Map<String, Object> requestBody) throws Exception {
+        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
+            HttpPost httpPost = new HttpPost(url);
+            httpPost.setHeader("Content-Type", "application/json");
+            
+            String jsonBody = objectMapper.writeValueAsString(requestBody);
+            httpPost.setEntity(new StringEntity(jsonBody, StandardCharsets.UTF_8));
+            
+            return httpClient.execute(httpPost, response -> {
+                if (response.getCode() == 200) {
+                    return new String(response.getEntity().getContent().readAllBytes(), StandardCharsets.UTF_8);
+                } else {
+                    throw new IOException("HTTP " + response.getCode() + ": " + response.getReasonPhrase());
+                }
+            });
+            
+        } catch (Exception e) {
+            log.error("HTTP request failed: {}", e.getMessage(), e);
+            throw e;
+        }
+    }
+
+    private String buildPrompt(String assetContent, MLConfigRequest mlConfig) {
+        String template = mlConfig.getPromptTemplate() != null ? 
+                mlConfig.getPromptTemplate() : DEFAULT_PROMPT_TEMPLATE;
+        
+        Integer maxSuggestions = mlConfig.getSuggestionConfig() != null ? 
+                mlConfig.getSuggestionConfig().getMaxSuggestions() : 5;
+        
+        return template
+                .replace("{metadata_summary}", assetContent)
+                .replace("{max_suggestions}", String.valueOf(maxSuggestions));
+    }
+
+    private List<LabelSuggestion> parseOllamaResponse(String responseJson) {
+        try {
+            JsonNode responseNode = objectMapper.readTree(responseJson);
+            String responseText = responseNode.path("response").asText();
+            
+            return parseLabelsFromResponse(responseText);
+            
+        } catch (JsonProcessingException e) {
+            log.error("Failed to parse Ollama response JSON: {}", e.getMessage(), e);
+            return new ArrayList<>();
+        }
+    }
+
+    private List<LabelSuggestion> parseLabelsFromResponse(String response) {
+        List<LabelSuggestion> suggestions = new ArrayList<>();
+        
+        try {
+            // Try to parse as JSON first
+            JsonNode jsonArray = objectMapper.readTree(response);
+            if (jsonArray.isArray()) {
+                for (JsonNode item : jsonArray) {
+                    LabelSuggestion suggestion = LabelSuggestion.builder()
+                            .label(item.path("label").asText())
+                            .confidence(item.path("confidence").asDouble(0.5))
+                            .reasoning(item.path("reasoning").asText())
+                            .category(item.path("category").asText())
+                            .build();
+                    suggestions.add(suggestion);
+                }
+                return suggestions;
+            }
+        } catch (JsonProcessingException e) {
+            log.debug("Response is not valid JSON, trying text parsing: {}", e.getMessage());
+        }
+        
+        // Fallback: parse as plain text
+        return parseLabelsFromText(response);
+    }
+
+    private List<LabelSuggestion> parseLabelsFromText(String response) {
+        List<LabelSuggestion> suggestions = new ArrayList<>();
+        
+        // Look for patterns like "- Label" or "1. Label" or just lines with labels
+        Pattern labelPattern = Pattern.compile("(?:[-*]|\\d+\\.)\\s*([A-Za-z_][A-Za-z0-9_\\s]*)", Pattern.MULTILINE);
+        Matcher matcher = labelPattern.matcher(response);
+        
+        while (matcher.find()) {
+            String label = matcher.group(1).trim();
+            suggestions.add(LabelSuggestion.builder()
+                    .label(label)
+                    .confidence(0.6) // Default confidence for text parsing from local models
+                    .reasoning("Extracted from Ollama text response")
+                    .category("UNKNOWN")
+                    .build());
+        }
+        
+        return suggestions;
+    }
+
+    private double calculateOverallConfidence(List<LabelSuggestion> suggestions) {
+        if (suggestions.isEmpty()) {
+            return 0.0;
+        }
+        
+        return suggestions.stream()
+                .mapToDouble(s -> s.getConfidence() != null ? s.getConfidence() : 0.5)
+                .average()
+                .orElse(0.0);
+    }
+
+    private Double getDoubleParameter(MLConfigRequest mlConfig, String key, Double defaultValue) {
+        if (mlConfig.getAdditionalParameters() != null && mlConfig.getAdditionalParameters().containsKey(key)) {
+            Object value = mlConfig.getAdditionalParameters().get(key);
+            if (value instanceof Number) {
+                return ((Number) value).doubleValue();
+            }
+        }
+        return defaultValue;
+    }
+
+    private Integer getIntegerParameter(MLConfigRequest mlConfig, String key, Integer defaultValue) {
+        if (mlConfig.getAdditionalParameters() != null && mlConfig.getAdditionalParameters().containsKey(key)) {
+            Object value = mlConfig.getAdditionalParameters().get(key);
+            if (value instanceof Number) {
+                return ((Number) value).intValue();
+            }
+        }
+        return defaultValue;
+    }
+} 

src/main/java/com/dalab/autolabel/llm/client/impl/OpenAiLLMClient.java

@@ -0,0 +1,328 @@
+package com.dalab.autolabel.llm.client.impl;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.llm.client.ILLMClient;
+import com.dalab.autolabel.llm.model.LLMResponse;
+import com.dalab.autolabel.llm.model.LabelSuggestion;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.theokanning.openai.completion.chat.ChatCompletionRequest;
+import com.theokanning.openai.completion.chat.ChatCompletionResult;
+import com.theokanning.openai.completion.chat.ChatMessage;
+import com.theokanning.openai.completion.chat.ChatMessageRole;
+import com.theokanning.openai.service.OpenAiService;
+
+/**
+ * OpenAI GPT implementation of the LLM client.
+ * Supports GPT-3.5-turbo, GPT-4, and other OpenAI models.
+ */
+@Component
+public class OpenAiLLMClient implements ILLMClient {
+
+    private static final Logger log = LoggerFactory.getLogger(OpenAiLLMClient.class);
+    private static final String PROVIDER_NAME = "OPENAI";
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    // Default prompt template for label suggestion
+    private static final String DEFAULT_PROMPT_TEMPLATE = """
+        You are a data governance AI assistant. Based on the following asset metadata, suggest relevant data labels.
+        
+        Asset Information:
+        {metadata_summary}
+        
+        Please suggest up to {max_suggestions} relevant labels for this data asset. Focus on:
+        - Data sensitivity (PII, Confidential, Public, etc.)
+        - Business purpose and domain
+        - Technical characteristics
+        - Compliance requirements
+        
+        Respond with a JSON array of objects, each containing:
+        - "label": the suggested label text
+        - "confidence": confidence score (0.0 to 1.0)
+        - "reasoning": brief explanation for the suggestion
+        - "category": category type (PII, BUSINESS, TECHNICAL, COMPLIANCE)
+        
+        Example response:
+        [
+          {"label": "PII", "confidence": 0.95, "reasoning": "Contains personal identifiers", "category": "PII"},
+          {"label": "Customer Data", "confidence": 0.87, "reasoning": "Related to customer information", "category": "BUSINESS"}
+        ]
+        """;
+
+    @Override
+    public String getProviderName() {
+        return PROVIDER_NAME;
+    }
+
+    @Override
+    public List<String> suggestLabels(String assetContent, MLConfigRequest mlConfig) throws Exception {
+        List<LabelSuggestion> suggestions = suggestLabelsWithConfidence(assetContent, mlConfig);
+        return suggestions.stream()
+                .map(LabelSuggestion::getLabel)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public List<LabelSuggestion> suggestLabelsWithConfidence(String assetContent, MLConfigRequest mlConfig) throws Exception {
+        log.info("Requesting label suggestions from OpenAI for content: {}", 
+                assetContent.length() > 100 ? assetContent.substring(0, 100) + "..." : assetContent);
+
+        try {
+            OpenAiService service = createOpenAiService(mlConfig);
+            String prompt = buildPrompt(assetContent, mlConfig);
+            
+            ChatCompletionRequest request = ChatCompletionRequest.builder()
+                    .model(mlConfig.getModelName() != null ? mlConfig.getModelName() : "gpt-3.5-turbo")
+                    .messages(List.of(new ChatMessage(ChatMessageRole.USER.value(), prompt)))
+                    .temperature(getDoubleParameter(mlConfig, "temperature", 0.7))
+                    .maxTokens(getIntegerParameter(mlConfig, "maxTokens", 1000))
+                    .build();
+
+            ChatCompletionResult result = service.createChatCompletion(request);
+            
+            if (result.getChoices() != null && !result.getChoices().isEmpty()) {
+                String responseContent = result.getChoices().get(0).getMessage().getContent();
+                return parseLabelsFromResponse(responseContent);
+            }
+            
+            log.warn("No choices returned from OpenAI response");
+            return new ArrayList<>();
+            
+        } catch (Exception e) {
+            log.error("Error getting label suggestions from OpenAI: {}", e.getMessage(), e);
+            throw new Exception("Failed to get suggestions from OpenAI: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public List<LLMResponse> batchSuggestLabels(List<String> assetContents, MLConfigRequest mlConfig) throws Exception {
+        log.info("Processing batch of {} assets for label suggestions", assetContents.size());
+        
+        List<LLMResponse> responses = new ArrayList<>();
+        long startTime = System.currentTimeMillis();
+        
+        for (String content : assetContents) {
+            long itemStartTime = System.currentTimeMillis();
+            try {
+                List<LabelSuggestion> suggestions = suggestLabelsWithConfidence(content, mlConfig);
+                long processingTime = System.currentTimeMillis() - itemStartTime;
+                
+                LLMResponse response = LLMResponse.builder()
+                        .inputContent(content)
+                        .suggestions(suggestions)
+                        .processingTimeMs(processingTime)
+                        .timestamp(LocalDateTime.now())
+                        .provider(PROVIDER_NAME)
+                        .modelName(mlConfig.getModelName())
+                        .successful(true)
+                        .overallConfidence(calculateOverallConfidence(suggestions))
+                        .build();
+                
+                responses.add(response);
+                
+            } catch (Exception e) {
+                log.error("Error processing asset in batch: {}", e.getMessage(), e);
+                
+                LLMResponse errorResponse = LLMResponse.builder()
+                        .inputContent(content)
+                        .suggestions(new ArrayList<>())
+                        .processingTimeMs(System.currentTimeMillis() - itemStartTime)
+                        .timestamp(LocalDateTime.now())
+                        .provider(PROVIDER_NAME)
+                        .modelName(mlConfig.getModelName())
+                        .successful(false)
+                        .errorMessage(e.getMessage())
+                        .build();
+                
+                responses.add(errorResponse);
+            }
+        }
+        
+        log.info("Completed batch processing in {} ms", System.currentTimeMillis() - startTime);
+        return responses;
+    }
+
+    @Override
+    public boolean validateConfiguration(MLConfigRequest mlConfig) {
+        if (mlConfig == null) {
+            return false;
+        }
+        
+        // Check provider type
+        if (!PROVIDER_NAME.equalsIgnoreCase(mlConfig.getProviderType())) {
+            return false;
+        }
+        
+        // Check required fields
+        if (mlConfig.getApiKey() == null || mlConfig.getApiKey().trim().isEmpty()) {
+            return false;
+        }
+        
+        // Validate model name if provided
+        String modelName = mlConfig.getModelName();
+        if (modelName != null && !isValidOpenAiModel(modelName)) {
+            log.warn("Unknown OpenAI model: {}", modelName);
+            // Still return true as new models might be added
+        }
+        
+        return true;
+    }
+
+    @Override
+    public Map<String, Object> getCapabilities() {
+        Map<String, Object> capabilities = new HashMap<>();
+        capabilities.put("maxTokens", 4096);
+        capabilities.put("supportsBatch", true);
+        capabilities.put("supportsConfidence", true);
+        capabilities.put("supportsReasoning", true);
+        capabilities.put("supportedModels", Arrays.asList(
+                "gpt-3.5-turbo", "gpt-3.5-turbo-16k", "gpt-4", "gpt-4-turbo", "gpt-4o"
+        ));
+        capabilities.put("costPerToken", 0.0000015); // Approximate for GPT-3.5-turbo
+        return capabilities;
+    }
+
+    @Override
+    public boolean testConnection(MLConfigRequest mlConfig) {
+        try {
+            if (!validateConfiguration(mlConfig)) {
+                return false;
+            }
+            
+            OpenAiService service = createOpenAiService(mlConfig);
+            
+            // Simple test request
+            ChatCompletionRequest testRequest = ChatCompletionRequest.builder()
+                    .model(mlConfig.getModelName() != null ? mlConfig.getModelName() : "gpt-3.5-turbo")
+                    .messages(List.of(new ChatMessage(ChatMessageRole.USER.value(), "Test connection. Respond with 'OK'.")))
+                    .maxTokens(10)
+                    .build();
+            
+            ChatCompletionResult result = service.createChatCompletion(testRequest);
+            return result.getChoices() != null && !result.getChoices().isEmpty();
+            
+        } catch (Exception e) {
+            log.error("Connection test failed for OpenAI: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    private OpenAiService createOpenAiService(MLConfigRequest mlConfig) {
+        Duration timeout = Duration.ofSeconds(getIntegerParameter(mlConfig, "timeoutSeconds", 60));
+        return new OpenAiService(mlConfig.getApiKey(), timeout);
+    }
+
+    private String buildPrompt(String assetContent, MLConfigRequest mlConfig) {
+        String template = mlConfig.getPromptTemplate() != null ? 
+                mlConfig.getPromptTemplate() : DEFAULT_PROMPT_TEMPLATE;
+        
+        Integer maxSuggestions = mlConfig.getSuggestionConfig() != null ? 
+                mlConfig.getSuggestionConfig().getMaxSuggestions() : 5;
+        
+        return template
+                .replace("{metadata_summary}", assetContent)
+                .replace("{max_suggestions}", String.valueOf(maxSuggestions));
+    }
+
+    private List<LabelSuggestion> parseLabelsFromResponse(String response) {
+        List<LabelSuggestion> suggestions = new ArrayList<>();
+        
+        try {
+            // Try to parse as JSON first
+            JsonNode jsonArray = objectMapper.readTree(response);
+            if (jsonArray.isArray()) {
+                for (JsonNode item : jsonArray) {
+                    LabelSuggestion suggestion = LabelSuggestion.builder()
+                            .label(item.path("label").asText())
+                            .confidence(item.path("confidence").asDouble(0.5))
+                            .reasoning(item.path("reasoning").asText())
+                            .category(item.path("category").asText())
+                            .build();
+                    suggestions.add(suggestion);
+                }
+                return suggestions;
+            }
+        } catch (JsonProcessingException e) {
+            log.debug("Response is not valid JSON, trying text parsing: {}", e.getMessage());
+        }
+        
+        // Fallback: parse as plain text
+        return parseLabelsFromText(response);
+    }
+
+    private List<LabelSuggestion> parseLabelsFromText(String response) {
+        List<LabelSuggestion> suggestions = new ArrayList<>();
+        
+        // Look for patterns like "- Label" or "1. Label" or just lines with labels
+        Pattern labelPattern = Pattern.compile("(?:[-*]|\\d+\\.)\\s*([A-Za-z_][A-Za-z0-9_\\s]*)", Pattern.MULTILINE);
+        Matcher matcher = labelPattern.matcher(response);
+        
+        while (matcher.find()) {
+            String label = matcher.group(1).trim();
+            suggestions.add(LabelSuggestion.builder()
+                    .label(label)
+                    .confidence(0.7) // Default confidence for text parsing
+                    .reasoning("Extracted from text response")
+                    .category("UNKNOWN")
+                    .build());
+        }
+        
+        return suggestions;
+    }
+
+    private double calculateOverallConfidence(List<LabelSuggestion> suggestions) {
+        if (suggestions.isEmpty()) {
+            return 0.0;
+        }
+        
+        return suggestions.stream()
+                .mapToDouble(s -> s.getConfidence() != null ? s.getConfidence() : 0.5)
+                .average()
+                .orElse(0.0);
+    }
+
+    private boolean isValidOpenAiModel(String modelName) {
+        Set<String> validModels = Set.of(
+                "gpt-3.5-turbo", "gpt-3.5-turbo-16k", "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613",
+                "gpt-4", "gpt-4-0613", "gpt-4-32k", "gpt-4-32k-0613", "gpt-4-turbo", "gpt-4o"
+        );
+        return validModels.contains(modelName);
+    }
+
+    private Double getDoubleParameter(MLConfigRequest mlConfig, String key, Double defaultValue) {
+        if (mlConfig.getAdditionalParameters() != null && mlConfig.getAdditionalParameters().containsKey(key)) {
+            Object value = mlConfig.getAdditionalParameters().get(key);
+            if (value instanceof Number) {
+                return ((Number) value).doubleValue();
+            }
+        }
+        return defaultValue;
+    }
+
+    private Integer getIntegerParameter(MLConfigRequest mlConfig, String key, Integer defaultValue) {
+        if (mlConfig.getAdditionalParameters() != null && mlConfig.getAdditionalParameters().containsKey(key)) {
+            Object value = mlConfig.getAdditionalParameters().get(key);
+            if (value instanceof Number) {
+                return ((Number) value).intValue();
+            }
+        }
+        return defaultValue;
+    }
+} 

src/main/java/com/dalab/autolabel/llm/model/LLMResponse.java

@@ -0,0 +1,80 @@
+package com.dalab.autolabel.llm.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Represents a complete response from an LLM including suggestions and metadata.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class LLMResponse {
+    
+    /**
+     * The input content that was processed.
+     */
+    private String inputContent;
+    
+    /**
+     * List of label suggestions with confidence scores.
+     */
+    private List<LabelSuggestion> suggestions;
+    
+    /**
+     * Overall confidence in the response quality.
+     */
+    private Double overallConfidence;
+    
+    /**
+     * Processing time in milliseconds.
+     */
+    private Long processingTimeMs;
+    
+    /**
+     * Timestamp when the response was generated.
+     */
+    private LocalDateTime timestamp;
+    
+    /**
+     * The LLM provider used.
+     */
+    private String provider;
+    
+    /**
+     * The model name used.
+     */
+    private String modelName;
+    
+    /**
+     * Number of tokens used in the request.
+     */
+    private Integer tokensUsed;
+    
+    /**
+     * Cost of the request (if applicable).
+     */
+    private Double estimatedCost;
+    
+    /**
+     * Any additional metadata from the LLM response.
+     */
+    private Map<String, Object> metadata;
+    
+    /**
+     * Error message if the request failed.
+     */
+    private String errorMessage;
+    
+    /**
+     * Whether the response was successful.
+     */
+    private Boolean successful;
+} 

src/main/java/com/dalab/autolabel/llm/model/LabelSuggestion.java

@@ -0,0 +1,36 @@
+package com.dalab.autolabel.llm.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * Represents a label suggestion from an LLM with associated confidence score.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class LabelSuggestion {
+    
+    /**
+     * The suggested label text.
+     */
+    private String label;
+    
+    /**
+     * Confidence score for this suggestion (0.0 to 1.0).
+     */
+    private Double confidence;
+    
+    /**
+     * Optional reasoning or explanation for this suggestion.
+     */
+    private String reasoning;
+    
+    /**
+     * Category or type of this label (e.g., "PII", "BUSINESS", "TECHNICAL").
+     */
+    private String category;
+} 

src/main/java/com/dalab/autolabel/mapper/LabelingJobMapper.java

@@ -0,0 +1,38 @@
+package com.dalab.autolabel.mapper;
+
+import com.dalab.autolabel.client.rest.dto.LabelingJobStatusResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobListResponse;
+import com.dalab.autolabel.entity.LabelingJobEntity;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.factory.Mappers;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+@Mapper(componentModel = "spring")
+public interface LabelingJobMapper {
+
+    LabelingJobMapper INSTANCE = Mappers.getMapper(LabelingJobMapper.class);
+
+    @Mapping(source = "jobId", target = "jobId")
+    LabelingJobStatusResponse toStatusResponse(LabelingJobEntity entity);
+
+    List<LabelingJobStatusResponse> toStatusResponseList(List<LabelingJobEntity> entities);
+
+    default LabelingJobListResponse toJobListResponse(Page<LabelingJobEntity> page) {
+        if (page == null) {
+            return null;
+        }
+        return LabelingJobListResponse.builder()
+                .jobs(toStatusResponseList(page.getContent()))
+                .pageNumber(page.getNumber())
+                .pageSize(page.getSize())
+                .totalElements(page.getTotalElements())
+                .totalPages(page.getTotalPages())
+                .last(page.isLast())
+                .build();
+    }
+    // Add mappings from LabelingJobRequest to LabelingJobEntity if needed for creation
+    // Add mappings from LabelingFeedbackRequest to LabelingFeedbackEntity
+} 

src/main/java/com/dalab/autolabel/repository/LabelingFeedbackRepository.java

@@ -0,0 +1,19 @@
+package com.dalab.autolabel.repository;
+
+import com.dalab.autolabel.entity.LabelingFeedbackEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Spring Data JPA repository for the {@link LabelingFeedbackEntity} entity.
+ */
+@Repository
+public interface LabelingFeedbackRepository extends JpaRepository<LabelingFeedbackEntity, String> {
+
+    List<LabelingFeedbackEntity> findByAssetId(String assetId);
+    List<LabelingFeedbackEntity> findByLabelingJobId(String labelingJobId);
+    List<LabelingFeedbackEntity> findByUserId(String userId);
+
+} 

src/main/java/com/dalab/autolabel/repository/LabelingJobRepository.java

@@ -0,0 +1,13 @@
+package com.dalab.autolabel.repository;
+
+import com.dalab.autolabel.entity.LabelingJobEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data JPA repository for the {@link LabelingJobEntity} entity.
+ */
+@Repository
+public interface LabelingJobRepository extends JpaRepository<LabelingJobEntity, String> {
+    // Custom query methods can be added here if needed, e.g., findByStatus
+} 

src/main/java/com/dalab/autolabel/security/SecurityUtils.java

@@ -0,0 +1 @@
+ 

src/main/java/com/dalab/autolabel/service/AutoLabelingService.java

@@ -0,0 +1,395 @@
+package com.dalab.autolabel.service;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingJobResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobStatusResponse;
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.llm.client.ILLMClient;
+import com.dalab.autolabel.llm.client.LLMClientFactory;
+import com.dalab.autolabel.llm.model.LabelSuggestion;
+
+/**
+ * Core auto-labeling service that orchestrates the LLM-powered labeling workflow.
+ * Handles job creation, execution, feedback processing, and active learning.
+ */
+@Service
+public class AutoLabelingService {
+
+    private static final Logger log = LoggerFactory.getLogger(AutoLabelingService.class);
+
+    private final LLMClientFactory llmClientFactory;
+    // TODO: Add repositories and other services when implemented
+    // private final LabelingJobRepository labelingJobRepository;
+    // private final FeedbackRepository feedbackRepository;
+    // private final CatalogServiceClient catalogServiceClient;
+
+    // Global ML configuration (can be updated via config API)
+    private MLConfigRequest globalMlConfig;
+
+    @Autowired
+    public AutoLabelingService(LLMClientFactory llmClientFactory) {
+        this.llmClientFactory = llmClientFactory;
+    }
+
+    /**
+     * Creates and processes a labeling job for one or more assets.
+     *
+     * @param request The labeling job request containing scope and configuration
+     * @return The labeling job response with job status
+     */
+    public LabelingJobResponse createLabelingJob(LabelingJobRequest request) {
+        log.info("Creating labeling job: {}", request.getJobName());
+
+        long startTime = System.currentTimeMillis();
+        String jobId = UUID.randomUUID().toString();
+        
+        try {
+            // Validate the request
+            validateLabelingRequest(request);
+
+            // Get ML configuration (use override or global default)
+            MLConfigRequest mlConfig = request.getOverrideMlConfig() != null 
+                ? request.getOverrideMlConfig() 
+                : globalMlConfig;
+
+            if (mlConfig == null) {
+                throw new IllegalArgumentException("No ML configuration available");
+            }
+
+            // Get the appropriate LLM client
+            ILLMClient llmClient = llmClientFactory.getClient(mlConfig);
+
+            // Get assets to process based on scope
+            List<String> assetIds = getAssetsFromScope(request.getScope());
+            
+            if (assetIds.isEmpty()) {
+                return LabelingJobResponse.builder()
+                        .jobId(jobId)
+                        .status("COMPLETED")
+                        .submittedAt(LocalDateTime.now())
+                        .createdAt(LocalDateTime.now())
+                        .completedAt(LocalDateTime.now())
+                        .processingTimeMs(System.currentTimeMillis() - startTime)
+                        .message("No assets found matching the specified scope")
+                        .build();
+            }
+
+            // For single asset, process immediately
+            if (assetIds.size() == 1) {
+                String assetId = assetIds.get(0);
+                
+                // Get asset content for LLM processing
+                String assetContent = getAssetContent(assetId);
+                
+                // Get label suggestions from LLM
+                List<LabelSuggestion> suggestions = llmClient.suggestLabelsWithConfidence(assetContent, mlConfig);
+                
+                // Filter suggestions based on confidence thresholds
+                List<LabelSuggestion> filteredSuggestions = filterSuggestionsByConfidence(suggestions, mlConfig);
+                
+                return LabelingJobResponse.builder()
+                        .jobId(jobId)
+                        .assetId(assetId)
+                        .status("COMPLETED")
+                        .submittedAt(LocalDateTime.now())
+                        .createdAt(LocalDateTime.now())
+                        .completedAt(LocalDateTime.now())
+                        .processingTimeMs(System.currentTimeMillis() - startTime)
+                        .message("Labeling completed successfully")
+                        .suggestions(convertToLabelSuggestionDTOs(filteredSuggestions))
+                        .build();
+            } else {
+                // For multiple assets, return job submitted status
+                // TODO: Implement async processing for large batches
+                return LabelingJobResponse.builder()
+                        .jobId(jobId)
+                        .status("SUBMITTED")
+                        .submittedAt(LocalDateTime.now())
+                        .createdAt(LocalDateTime.now())
+                        .message("Job submitted for processing " + assetIds.size() + " assets")
+                        .build();
+            }
+
+        } catch (Exception e) {
+            log.error("Failed to create labeling job {}: {}", request.getJobName(), e.getMessage(), e);
+            
+            return LabelingJobResponse.builder()
+                    .jobId(jobId)
+                    .status("FAILED")
+                    .submittedAt(LocalDateTime.now())
+                    .createdAt(LocalDateTime.now())
+                    .completedAt(LocalDateTime.now())
+                    .processingTimeMs(System.currentTimeMillis() - startTime)
+                    .errorMessage("Failed to process labeling job: " + e.getMessage())
+                    .build();
+        }
+    }
+
+    /**
+     * Processes multiple labeling jobs in batch for efficiency.
+     *
+     * @param jobRequests List of labeling job requests
+     * @return List of labeling job responses
+     */
+    public List<LabelingJobResponse> createBatchLabelingJobs(List<LabelingJobRequest> jobRequests) {
+        log.info("Processing batch of {} labeling jobs", jobRequests.size());
+
+        List<LabelingJobResponse> allResponses = new ArrayList<>();
+
+        // Group requests by ML configuration to process efficiently
+        Map<MLConfigRequest, List<LabelingJobRequest>> configGroups = jobRequests.stream()
+                .collect(Collectors.groupingBy(request -> 
+                    request.getOverrideMlConfig() != null ? request.getOverrideMlConfig() : globalMlConfig));
+
+        for (Map.Entry<MLConfigRequest, List<LabelingJobRequest>> entry : configGroups.entrySet()) {
+            MLConfigRequest mlConfig = entry.getKey();
+            List<LabelingJobRequest> requests = entry.getValue();
+
+            try {
+                ILLMClient llmClient = llmClientFactory.getClient(mlConfig);
+
+                for (LabelingJobRequest request : requests) {
+                    try {
+                        LabelingJobResponse response = createLabelingJob(request);
+                        allResponses.add(response);
+                    } catch (Exception e) {
+                        log.error("Failed to process job {}: {}", request.getJobName(), e.getMessage(), e);
+                        
+                        LabelingJobResponse errorResponse = LabelingJobResponse.builder()
+                                .jobId(UUID.randomUUID().toString())
+                                .status("FAILED")
+                                .submittedAt(LocalDateTime.now())
+                                .createdAt(LocalDateTime.now())
+                                .completedAt(LocalDateTime.now())
+                                .errorMessage("Job processing failed: " + e.getMessage())
+                                .build();
+                        allResponses.add(errorResponse);
+                    }
+                }
+
+            } catch (Exception e) {
+                log.error("Failed to process batch with ML config {}: {}", mlConfig.getProviderType(), e.getMessage(), e);
+                
+                // Create error responses for all requests in this batch
+                for (LabelingJobRequest request : requests) {
+                    LabelingJobResponse errorResponse = LabelingJobResponse.builder()
+                            .jobId(UUID.randomUUID().toString())
+                            .status("FAILED")
+                            .submittedAt(LocalDateTime.now())
+                            .createdAt(LocalDateTime.now())
+                            .completedAt(LocalDateTime.now())
+                            .errorMessage("Batch processing failed: " + e.getMessage())
+                            .build();
+                    allResponses.add(errorResponse);
+                }
+            }
+        }
+
+        return allResponses;
+    }
+
+    /**
+     * Processes feedback for active learning and model improvement.
+     *
+     * @param feedback The feedback request containing user corrections
+     * @return The feedback response
+     */
+    public LabelingFeedbackResponse processFeedback(LabelingFeedbackRequest feedback) {
+        log.info("Processing feedback for asset: {}", feedback.getAssetId());
+
+        try {
+            // TODO: Store feedback in database for active learning
+            // feedbackRepository.save(LabelingFeedbackEntity.fromDTO(feedback));
+
+            // TODO: Update asset labels via catalog service
+            // if (feedback.getCorrectedLabels() != null) {
+            //     catalogServiceClient.updateAssetLabels(feedback.getAssetId(), feedback.getCorrectedLabels());
+            // }
+
+            // TODO: Trigger model retraining if enough feedback accumulated
+            // checkAndTriggerActivelearning();
+
+            return LabelingFeedbackResponse.builder()
+                    .feedbackId(UUID.randomUUID().toString())
+                    .assetId(feedback.getAssetId())
+                    .status("PROCESSED")
+                    .message("Feedback processed successfully")
+                    .processedAt(LocalDateTime.now())
+                    .build();
+
+        } catch (Exception e) {
+            log.error("Failed to process feedback for asset {}: {}", feedback.getAssetId(), e.getMessage(), e);
+            
+            return LabelingFeedbackResponse.builder()
+                    .feedbackId(UUID.randomUUID().toString())
+                    .assetId(feedback.getAssetId())
+                    .status("FAILED")
+                    .message("Failed to process feedback: " + e.getMessage())
+                    .processedAt(LocalDateTime.now())
+                    .build();
+        }
+    }
+
+    /**
+     * Updates ML configuration and validates it.
+     *
+     * @param mlConfig The new ML configuration
+     * @return true if configuration is valid and updated, false otherwise
+     */
+    public boolean updateMLConfiguration(MLConfigRequest mlConfig) {
+        log.info("Updating ML configuration for provider: {}", mlConfig.getProviderType());
+
+        try {
+            // Validate configuration
+            boolean isValid = llmClientFactory.validateConfiguration(mlConfig);
+            if (!isValid) {
+                log.warn("ML configuration validation failed for provider: {}", mlConfig.getProviderType());
+                return false;
+            }
+
+            // Test connection
+            boolean connectionOk = llmClientFactory.testConnection(mlConfig);
+            if (!connectionOk) {
+                log.warn("ML configuration connection test failed for provider: {}", mlConfig.getProviderType());
+                return false;
+            }
+
+            // TODO: Store configuration in database
+            // configurationRepository.save(mlConfig);
+
+            log.info("ML configuration updated successfully for provider: {}", mlConfig.getProviderType());
+            return true;
+
+        } catch (Exception e) {
+            log.error("Failed to update ML configuration: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    /**
+     * Gets the status of a labeling job.
+     *
+     * @param jobId The job ID
+     * @return The job status response
+     */
+    public LabelingJobStatusResponse getJobStatus(UUID jobId) {
+        log.debug("Getting status for job: {}", jobId);
+
+        // TODO: Implement job status tracking in database
+        // For now, return a mock response
+        return LabelingJobStatusResponse.builder()
+                .jobId(jobId.toString())
+                .status("COMPLETED")
+                .progressPercentage(100.0)
+                .startedAt(LocalDateTime.now().minusMinutes(5))
+                .completedAt(LocalDateTime.now())
+                .build();
+    }
+
+    /**
+     * Gets all available LLM providers and their capabilities.
+     *
+     * @return Map of provider capabilities
+     */
+    public Map<String, Map<String, Object>> getProviderCapabilities() {
+        return llmClientFactory.getAllProviderCapabilities();
+    }
+
+    // Private helper methods
+
+    private void validateLabelingRequest(LabelingJobRequest request) {
+        if (request == null) {
+            throw new IllegalArgumentException("Labeling request cannot be null");
+        }
+        if (request.getJobName() == null || request.getJobName().trim().isEmpty()) {
+            throw new IllegalArgumentException("Job name cannot be null or empty");
+        }
+        if (request.getScope() == null) {
+            throw new IllegalArgumentException("Labeling scope cannot be null");
+        }
+        
+        // Validate that at least one asset selection method is provided
+        if ((request.getScope().getAssetIds() == null || request.getScope().getAssetIds().isEmpty()) &&
+            request.getScope().getCloudConnectionId() == null &&
+            (request.getScope().getAssetCriteria() == null || request.getScope().getAssetCriteria().isEmpty()) &&
+            request.getScope().getAssetGroupId() == null) {
+            throw new IllegalArgumentException("At least one asset selection method must be provided in scope");
+        }
+    }
+
+    private String prepareAssetContent(LabelingJobRequest request) {
+        // This method is no longer used with the new DTO structure
+        // Asset content is now retrieved per asset ID via getAssetContent()
+        return "Asset content preparation moved to getAssetContent() method";
+    }
+
+    private List<LabelSuggestion> filterSuggestionsByConfidence(List<LabelSuggestion> suggestions, MLConfigRequest mlConfig) {
+        if (mlConfig.getConfidenceConfig() == null || mlConfig.getConfidenceConfig().getMinThreshold() == null) {
+            return suggestions; // No filtering
+        }
+
+        double minThreshold = mlConfig.getConfidenceConfig().getMinThreshold();
+        
+        return suggestions.stream()
+                .filter(suggestion -> suggestion.getConfidence() != null && suggestion.getConfidence() >= minThreshold)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Get list of asset IDs from the labeling scope.
+     */
+    private List<String> getAssetsFromScope(LabelingJobRequest.LabelingScope scope) {
+        List<String> assetIds = new ArrayList<>();
+        
+        if (scope.getAssetIds() != null && !scope.getAssetIds().isEmpty()) {
+            assetIds.addAll(scope.getAssetIds());
+        }
+        
+        // TODO: Implement other scope types
+        // if (scope.getCloudConnectionId() != null) {
+        //     assetIds.addAll(assetCatalogClient.getAssetsByConnectionId(scope.getCloudConnectionId()));
+        // }
+        // if (scope.getAssetCriteria() != null) {
+        //     assetIds.addAll(assetCatalogClient.getAssetsByCriteria(scope.getAssetCriteria()));
+        // }
+        
+        return assetIds;
+    }
+
+    /**
+     * Get asset content for LLM processing.
+     */
+    private String getAssetContent(String assetId) {
+        // TODO: Implement actual asset content retrieval
+        // For now return a placeholder
+        return "Asset content for " + assetId + " - metadata, schema, and sample data would go here";
+    }
+
+    /**
+     * Convert LLM label suggestions to DTOs.
+     */
+    private List<LabelingJobResponse.LabelSuggestionDTO> convertToLabelSuggestionDTOs(List<LabelSuggestion> suggestions) {
+        return suggestions.stream()
+                .map(suggestion -> LabelingJobResponse.LabelSuggestionDTO.builder()
+                        .labelName(suggestion.getLabel())
+                        .confidence(suggestion.getConfidence())
+                        .reasoning(suggestion.getReasoning())
+                        .category(suggestion.getCategory())
+                        .build())
+                .collect(Collectors.toList());
+    }
+} 

src/main/java/com/dalab/autolabel/service/ILLMIntegrationService.java

@@ -0,0 +1,21 @@
+package com.dalab.autolabel.service;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import java.util.List;
+
+/**
+ * Service interface for integrating with various LLM clients.
+ */
+public interface ILLMIntegrationService {
+
+    /**
+     * Suggests labels for a given asset content using the configured LLM.
+     *
+     * @param assetContent The content or metadata of the asset to label.
+     * @param mlConfig The ML configuration specifying which LLM to use and its parameters.
+     * @return A list of suggested labels.
+     * @throws Exception if there is an error during LLM interaction or if the client is not found.
+     */
+    List<String> suggestLabelsForAsset(String assetContent, MLConfigRequest mlConfig) throws Exception;
+
+} 

src/main/java/com/dalab/autolabel/service/ILabelingJobService.java

@@ -0,0 +1,52 @@
+package com.dalab.autolabel.service;
+
+import com.dalab.autolabel.client.rest.dto.LabelingJobRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingJobResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobStatusResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingJobListResponse;
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackRequest;
+import com.dalab.autolabel.client.rest.dto.LabelingFeedbackResponse;
+import com.dalab.autolabel.exception.AutoLabelingException;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * Service interface for managing auto-labeling jobs.
+ */
+public interface ILabelingJobService {
+
+    /**
+     * Submits a new auto-labeling job.
+     *
+     * @param request The labeling job request DTO.
+     * @return A response DTO containing the job ID and initial status.
+     * @throws AutoLabelingException if ML config is not found or other issues.
+     */
+    LabelingJobResponse submitLabelingJob(LabelingJobRequest request) throws AutoLabelingException;
+
+    /**
+     * Retrieves the status of a specific labeling job.
+     *
+     * @param jobId The ID of the job.
+     * @return A response DTO containing the job status, or null if not found.
+     */
+    LabelingJobStatusResponse getJobStatus(String jobId);
+
+    /**
+     * Lists all labeling jobs, with optional pagination.
+     *
+     * @param pageable Pagination information.
+     * @return A paginated list of job statuses.
+     */
+    LabelingJobListResponse listJobs(Pageable pageable);
+
+    /**
+     * Processes user feedback on suggested labels for an asset.
+     *
+     * @param request The labeling feedback request DTO.
+     * @return A response DTO indicating the result of processing the feedback.
+     * @throws AutoLabelingException if there is an issue processing the feedback.
+     */
+    LabelingFeedbackResponse processLabelingFeedback(LabelingFeedbackRequest request) throws AutoLabelingException;
+
+    // Potentially add other methods like listJobs, cancelJob, etc. in the future.
+} 

src/main/java/com/dalab/autolabel/service/IMLConfigService.java

@@ -0,0 +1,24 @@
+package com.dalab.autolabel.service;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+
+/**
+ * Service interface for managing ML configurations for auto-labeling.
+ */
+public interface IMLConfigService {
+
+    /**
+     * Updates the ML configuration.
+     *
+     * @param mlConfigRequest The ML configuration request DTO.
+     */
+    void updateMlConfig(MLConfigRequest mlConfigRequest);
+
+    /**
+     * Retrieves the current ML configuration.
+     *
+     * @return The current MLConfigRequest, or null if not configured.
+     */
+    MLConfigRequest getMlConfig();
+
+} 

src/main/java/com/dalab/autolabel/service/impl/InMemoryMLConfigService.java

@@ -0,0 +1,53 @@
+package com.dalab.autolabel.service.impl;
+
+import org.springframework.stereotype.Service;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.service.IMLConfigService;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * In-memory implementation of IMLConfigService.
+ * This is a basic implementation and should be replaced with a persistent store in a production environment.
+ */
+@Service
+@Slf4j
+public class InMemoryMLConfigService implements IMLConfigService {
+
+    private MLConfigRequest currentConfig;
+
+    /**
+     * Updates the ML configuration.
+     *
+     * @param mlConfigRequest The ML configuration request DTO.
+     * @throws IllegalArgumentException if mlConfigRequest is null
+     */
+    @Override
+    public void updateMlConfig(MLConfigRequest mlConfigRequest) {
+        if (mlConfigRequest == null) {
+            throw new IllegalArgumentException("ML configuration request cannot be null");
+        }
+        
+        log.info("Updating ML configuration: {}", mlConfigRequest);
+        // In a real application, perform validation and secure storage of API keys.
+        this.currentConfig = mlConfigRequest;
+        log.info("ML configuration updated successfully.");
+        // TODO: Persist this configuration to a database or a secure configuration management system.
+        // TODO: Implement secure handling of sensitive data like API keys (e.g., using Spring Vault).
+    }
+
+    /**
+     * Retrieves the current ML configuration.
+     *
+     * @return The current MLConfigRequest, or null if not configured.
+     */
+    @Override
+    public MLConfigRequest getMlConfig() {
+        if (this.currentConfig == null) {
+            log.warn("ML configuration has not been set up yet.");
+            // Optionally, return a default configuration or throw an exception.
+        }
+        return this.currentConfig;
+    }
+} 

src/main/java/com/dalab/autolabel/service/impl/LLMIntegrationServiceImpl.java

@@ -0,0 +1,69 @@
+package com.dalab.autolabel.service.impl;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.llm.client.ILLMClient;
+import com.dalab.autolabel.service.ILLMIntegrationService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@Service
+@Slf4j
+public class LLMIntegrationServiceImpl implements ILLMIntegrationService {
+
+    private final Map<String, ILLMClient> llmClients; // Injected map of all ILLMClient beans
+
+    @Autowired
+    public LLMIntegrationServiceImpl(Map<String, ILLMClient> llmClients) {
+        this.llmClients = llmClients;
+        log.info("Initialized LLMIntegrationService with available clients: {}", llmClients.keySet());
+    }
+
+    @Override
+    public List<String> suggestLabelsForAsset(String assetContent, MLConfigRequest mlConfig) throws Exception {
+        if (mlConfig == null || mlConfig.getProviderType() == null) {
+            log.error("MLConfig or ProviderType is null. Cannot determine LLM client.");
+            // Fallback to a default mock client if no provider type is specified or use global default
+            ILLMClient defaultClient = llmClients.get("mockLLMClient"); // Bean name of MockLLMClient
+            if (defaultClient != null) {
+                log.warn("Using default MOCK LLM client as provider type was not specified in MLConfig.");
+                return defaultClient.suggestLabels(assetContent, mlConfig != null ? mlConfig : new MLConfigRequest()); // Pass a default config if null
+            } else {
+                throw new IllegalStateException("MLConfig.providerType is null and no default MOCK LLM client is available.");
+            }
+        }
+
+        // Construct bean name based on provider type, e.g., "openaiLLMClient", "geminiLLMClient"
+        // This assumes ILLMClient beans are named like "[providerType]LLMClient"
+        String clientBeanName = mlConfig.getProviderType().toLowerCase() + "LLMClient"; 
+        ILLMClient client = llmClients.get(clientBeanName);
+
+        if (client == null) {
+            // Fallback: try finding client by provider name if naming convention isn't strict
+            Optional<ILLMClient> foundClient = llmClients.values().stream()
+                    .filter(c -> c.getProviderName().equalsIgnoreCase(mlConfig.getProviderType()))
+                    .findFirst();
+            if (foundClient.isPresent()){
+                client = foundClient.get();
+                log.warn("LLM client for provider '{}' found by provider name, not bean naming convention.", mlConfig.getProviderType());
+            } else {
+                 log.error("No LLM client found for provider type: {}. Available clients: {}. Attempted bean name: {}", 
+                        mlConfig.getProviderType(), llmClients.keySet(), clientBeanName);
+                // Fallback to mock if specific client not found but mock exists
+                ILLMClient mockClient = llmClients.get("mockLLMClient");
+                if (mockClient != null) {
+                    log.warn("Falling back to MOCK LLM client as client for '{}' was not found.", mlConfig.getProviderType());
+                    return mockClient.suggestLabels(assetContent, mlConfig);
+                }
+                throw new IllegalArgumentException("No LLM client configured for provider: " + mlConfig.getProviderType() + " and no mock fallback.");
+            }
+        }
+
+        log.info("Using LLM client: {}", client.getClass().getSimpleName());
+        return client.suggestLabels(assetContent, mlConfig);
+    }
+} 

src/main/java/com/dalab/autolabel/service/impl/LabelingJobServiceImpl.java

@@ -0,0 +1,280 @@
+package com.dalab.autolabel.service.impl;
+
+import com.dalab.autolabel.client.dto.AssetIdentifier;
+import com.dalab.autolabel.client.feign.AssetCatalogClient;
+import com.dalab.autolabel.client.rest.dto.*;
+import com.dalab.autolabel.entity.LabelingFeedbackEntity;
+import com.dalab.autolabel.entity.LabelingJobEntity;
+import com.dalab.autolabel.exception.AutoLabelingException;
+import com.dalab.autolabel.mapper.LabelingJobMapper;
+import com.dalab.autolabel.repository.LabelingFeedbackRepository;
+import com.dalab.autolabel.repository.LabelingJobRepository;
+import com.dalab.autolabel.service.IMLConfigService;
+import com.dalab.autolabel.service.ILabelingJobService;
+import com.dalab.autolabel.service.ILLMIntegrationService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class LabelingJobServiceImpl implements ILabelingJobService {
+
+    private final IMLConfigService mlConfigService;
+    private final LabelingJobRepository labelingJobRepository;
+    private final LabelingFeedbackRepository labelingFeedbackRepository;
+    private final LabelingJobMapper labelingJobMapper;
+    private final AssetCatalogClient assetCatalogClient;
+    private final ILLMIntegrationService llmIntegrationService;
+
+    @Override
+    @Transactional
+    public LabelingJobResponse submitLabelingJob(LabelingJobRequest request) throws AutoLabelingException {
+        log.info("Received request to submit labeling job: {}", request.getJobName());
+
+        MLConfigRequest currentMlConfig = request.getOverrideMlConfig() != null ?
+                request.getOverrideMlConfig() :
+                mlConfigService.getMlConfig();
+
+        if (currentMlConfig == null) {
+            log.error("ML configuration not found. Cannot submit labeling job.");
+            throw new AutoLabelingException("Auto-labeling ML configuration is not set. Please configure it via PUT /api/v1/labeling/config/ml.");
+        }
+        if (currentMlConfig.getProviderType() == null && !"MOCK".equalsIgnoreCase(currentMlConfig.getModelName())) {
+             log.warn("MLConfig.providerType is null for job '{}'. LLMIntegrationService might default to mock.", request.getJobName());
+        }
+
+        String jobId = UUID.randomUUID().toString();
+        LocalDateTime submittedAt = LocalDateTime.now();
+
+        LabelingJobEntity jobEntity = LabelingJobEntity.builder()
+                .jobId(jobId)
+                .jobName(request.getJobName())
+                .status(LabelingJobEntity.JobStatus.SUBMITTED)
+                .submittedAt(submittedAt)
+                .lastUpdatedAt(submittedAt)
+                .scope(request.getScope())
+                .effectiveMlConfig(currentMlConfig)
+                .totalAssetsToProcess(0)
+                .assetsProcessed(0)
+                .assetsSuccessfullyLabeled(0)
+                .assetsFailed(0)
+                .progressPercentage(0.0)
+                .errorMessages(new ArrayList<>())
+                .build();
+        labelingJobRepository.save(jobEntity);
+
+        log.info("Labeling job {} submitted successfully. Job ID: {}", request.getJobName(), jobId);
+        processLabelingJobAsync(jobId, request.getJobName(), request.getScope(), currentMlConfig);
+
+        return LabelingJobResponse.builder()
+                .jobId(jobId)
+                .status("SUBMITTED")
+                .submittedAt(submittedAt)
+                .message("Labeling job '" + request.getJobName() + "' submitted successfully.")
+                .build();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public LabelingJobStatusResponse getJobStatus(String jobId) {
+        log.debug("Fetching status for job ID: {}", jobId);
+        return labelingJobRepository.findById(jobId)
+                .map(labelingJobMapper::toStatusResponse)
+                .orElse(null);
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public LabelingJobListResponse listJobs(Pageable pageable) {
+        log.debug("Fetching list of jobs with pagination: {}", pageable);
+        Page<LabelingJobEntity> jobPage = labelingJobRepository.findAll(pageable);
+        return labelingJobMapper.toJobListResponse(jobPage);
+    }
+
+    @Async
+    @Transactional
+    public void processLabelingJobAsync(String jobId, String jobName, LabelingJobRequest.LabelingScope scope, MLConfigRequest mlConfig) {
+        log.info("[Job ID: {}] Starting asynchronous processing for job: {}", jobId, jobName);
+        updateJobStatus(jobId, LabelingJobEntity.JobStatus.PREPARING_DATA, "Fetching asset list...", null, null, null, null, 0.05);
+
+        List<AssetIdentifier> targetAssets;
+        try {
+            targetAssets = resolveAssetIdentifiers(scope);
+        } catch (Exception e) {
+            log.error("[Job ID: {}] Failed to resolve asset identifiers: {}", jobId, e.getMessage(), e);
+            updateJobStatus(jobId, LabelingJobEntity.JobStatus.FAILED, "Failed to resolve asset scope.", 0,0,0,0, 1.0);
+            labelingJobRepository.findById(jobId).ifPresent(job -> job.setCompletedAt(LocalDateTime.now()));
+            return;
+        }
+
+        if (targetAssets.isEmpty()) {
+            log.warn("[Job ID: {}] No assets found for the given scope.", jobId);
+            updateJobStatus(jobId, LabelingJobEntity.JobStatus.FAILED, "No assets found for the given scope.", 0, 0, 0, 0, 1.0);
+            labelingJobRepository.findById(jobId).ifPresent(job -> job.setCompletedAt(LocalDateTime.now()));
+            return;
+        }
+        updateJobStatus(jobId, null, "Identified " + targetAssets.size() + " assets for labeling.", targetAssets.size(), 0, 0, 0, 0.1);
+        labelingJobRepository.findById(jobId).ifPresent(job -> job.setStartedAt(LocalDateTime.now()));
+
+        int processed = 0;
+        int succeeded = 0;
+        int failed = 0;
+
+        for (AssetIdentifier asset : targetAssets) {
+            String assetId = asset.getAssetId();
+            try {
+                log.info("[Job ID: {}] Processing asset: {}", jobId, assetId);
+                updateJobStatus(jobId, LabelingJobEntity.JobStatus.CALLING_LLM, "Processing asset: " + assetId, null, null, null, null, 0.1 + (0.8 * ((double)processed / targetAssets.size())));
+
+                String assetTechnicalMetadata = "";
+                try {
+                    assetTechnicalMetadata = "This is a mock technical metadata for asset " + assetId + ". Contains keywords: PII, financial, sensitive data.";
+                    log.info("[Job ID: {}] Mock fetched technical metadata for asset {}: {}", jobId, assetId, assetTechnicalMetadata.substring(0, Math.min(assetTechnicalMetadata.length(), 100)));
+                } catch (Exception e) {
+                    log.warn("[Job ID: {}] Could not fetch technical metadata for asset {}. Proceeding with empty metadata. Error: {}", jobId, assetId, e.getMessage());
+                }
+
+                List<String> suggestedLabels = llmIntegrationService.suggestLabelsForAsset(assetTechnicalMetadata, mlConfig);
+                log.info("[Job ID: {}] LLM suggested labels for {}: {}", jobId, assetId, suggestedLabels);
+
+                log.info("[Job ID: {}] Mock applying labels {} for asset: {}", jobId, suggestedLabels, assetId);
+                succeeded++;
+
+            } catch (InterruptedException e) {
+                log.warn("[Job ID: {}] Processing for asset {} interrupted.", jobId, assetId);
+                Thread.currentThread().interrupt();
+                failed++;
+                addErrorMessageToJob(jobId, "Processing interrupted for asset " + assetId);
+            } catch (Exception e) {
+                log.error("[Job ID: {}] Error processing asset {}: {}", jobId, assetId, e.getMessage(), e);
+                failed++;
+                addErrorMessageToJob(jobId, "Failed to process asset " + assetId + ": " + e.getMessage());
+            }
+            processed++;
+            updateJobStatus(jobId, null, "Processed asset: " + assetId, null, processed, succeeded, failed, 0.1 + (0.8 * ((double)processed / targetAssets.size())));
+        }
+
+        LabelingJobEntity.JobStatus finalStatus = failed == 0 ? LabelingJobEntity.JobStatus.COMPLETED : (succeeded > 0 ? LabelingJobEntity.JobStatus.PARTIALLY_COMPLETED : LabelingJobEntity.JobStatus.FAILED);
+        String finalMessage = String.format("Job %s. Total: %d, Succeeded: %d, Failed: %d.",
+                finalStatus.name().toLowerCase(), targetAssets.size(), succeeded, failed);
+        updateJobStatus(jobId, finalStatus, finalMessage, null, processed, succeeded, failed, 1.0);
+        labelingJobRepository.findById(jobId).ifPresent(job -> job.setCompletedAt(LocalDateTime.now()));
+        log.info("[Job ID: {}] Labeling job processing finished with status: {}. Message: {}", jobId, finalStatus, finalMessage);
+    }
+
+    private void updateJobStatus(String jobId, LabelingJobEntity.JobStatus status, String stageDescription,
+                                 Integer totalAssets, Integer processedAssets,
+                                 Integer succeededAssets, Integer failedAssets, Double progress) {
+        labelingJobRepository.findById(jobId).ifPresent(job -> {
+            if (status != null) job.setStatus(status);
+            if (stageDescription != null) job.setCurrentStageDescription(stageDescription);
+            if (totalAssets != null) job.setTotalAssetsToProcess(totalAssets);
+            if (processedAssets != null) job.setAssetsProcessed(processedAssets);
+            if (succeededAssets != null) job.setAssetsSuccessfullyLabeled(succeededAssets);
+            if (failedAssets != null) job.setAssetsFailed(failedAssets);
+            if (progress != null) job.setProgressPercentage(progress);
+            job.setLastUpdatedAt(LocalDateTime.now());
+            labelingJobRepository.save(job);
+            log.debug("[Job ID: {}] Status updated: {}", jobId, job);
+        });
+    }
+
+    private void addErrorMessageToJob(String jobId, String errorMessage) {
+        labelingJobRepository.findById(jobId).ifPresent(job -> {
+            if(job.getErrorMessages() == null) job.setErrorMessages(new ArrayList<>());
+            job.getErrorMessages().add(errorMessage);
+            labelingJobRepository.save(job);
+        });
+    }
+
+    @Override
+    @Transactional
+    public LabelingFeedbackResponse processLabelingFeedback(LabelingFeedbackRequest request) throws AutoLabelingException {
+        log.info("Received labeling feedback for asset ID: {}, job ID: {}", request.getAssetId(), request.getLabelingJobId());
+
+        if (request.getFeedbackItems() == null || request.getFeedbackItems().isEmpty()) {
+            log.warn("Labeling feedback request for asset {} is empty.", request.getAssetId());
+            throw new AutoLabelingException("Feedback items cannot be empty.");
+        }
+
+        String feedbackId = UUID.randomUUID().toString();
+        LabelingFeedbackEntity feedbackEntity = LabelingFeedbackEntity.builder()
+                .feedbackId(feedbackId)
+                .assetId(request.getAssetId())
+                .labelingJobId(request.getLabelingJobId())
+                .feedbackItems(request.getFeedbackItems())
+                .userId(request.getUserId())
+                .additionalContext(request.getAdditionalContext())
+                .receivedAt(LocalDateTime.now())
+                .processingStatus("RECEIVED")
+                .build();
+        labelingFeedbackRepository.save(feedbackEntity);
+
+        for (LabelingFeedbackRequest.FeedbackItem item : request.getFeedbackItems()) {
+            try {
+                switch (item.getType()) {
+                    case CONFIRMED:
+                        log.info("[Feedback ID: {}] Asset: {}, Label '{}' confirmed. (Mock catalog update)", feedbackId, request.getAssetId(), item.getSuggestedLabel());
+                        break;
+                    case CORRECTED:
+                        log.info("[Feedback ID: {}] Asset: {}, Label '{}' corrected to '{}'. (Mock catalog update)",
+                                feedbackId, request.getAssetId(), item.getSuggestedLabel(), item.getCorrectedLabel());
+                        break;
+                    case REJECTED:
+                        log.info("[Feedback ID: {}] Asset: {}, Label '{}' rejected. (Mock catalog update)", feedbackId, request.getAssetId(), item.getSuggestedLabel());
+                        break;
+                    case FLAGGED:
+                        log.info("[Feedback ID: {}] Asset: {}, Label '{}' flagged for review.", feedbackId, request.getAssetId(), item.getSuggestedLabel());
+                        break;
+                }
+            } catch (Exception e) {
+                log.error("[Feedback ID: {}] Error processing feedback item for asset {}: {} - {}", feedbackId, request.getAssetId(), item, e.getMessage(), e);
+            }
+        }
+
+        feedbackEntity.setProcessingStatus("PROCESSED");
+        feedbackEntity.setProcessedAt(LocalDateTime.now());
+        labelingFeedbackRepository.save(feedbackEntity);
+
+        return LabelingFeedbackResponse.builder()
+                .feedbackId(feedbackId)
+                .assetId(request.getAssetId())
+                .status(feedbackEntity.getProcessingStatus())
+                .message("Feedback processed successfully.")
+                .receivedAt(feedbackEntity.getReceivedAt())
+                .build();
+    }
+
+    private List<AssetIdentifier> resolveAssetIdentifiers(LabelingJobRequest.LabelingScope scope) throws AutoLabelingException {
+        if (scope == null) return List.of();
+
+        List<AssetIdentifier> assets = new ArrayList<>();
+        if (scope.getAssetIds() != null && !scope.getAssetIds().isEmpty()) {
+            assets.addAll(scope.getAssetIds().stream().map(id -> AssetIdentifier.builder().assetId(id).build()).collect(Collectors.toList()));
+        }
+        
+        if (assets.isEmpty() && scope.getCloudConnectionId() != null) {
+            log.warn("Mocking asset resolution for cloudConnectionId: {}", scope.getCloudConnectionId());
+            assets.add(AssetIdentifier.builder().assetId("conn-" + scope.getCloudConnectionId() + "-asset1").provider("MOCK_CLOUD").build());
+            assets.add(AssetIdentifier.builder().assetId("conn-" + scope.getCloudConnectionId() + "-asset2").provider("MOCK_CLOUD").build());
+        }
+
+        if (assets.isEmpty()){
+            log.warn("No asset resolution strategy matched for scope, returning generic mock assets.");
+            return List.of(AssetIdentifier.builder().assetId("mock-global-asset-001").build(), AssetIdentifier.builder().assetId("mock-global-asset-002").build());
+        }
+        return assets.stream().distinct().collect(Collectors.toList());
+    }
+} 

src/main/resources/application.properties

@@ -0,0 +1,85 @@
+# =========================================
+# DALab AutoLabel Service Configuration
+# =========================================
+
+# Application
+spring.application.name=da-autolabel
+spring.application.description=DALab Smart Labeling & ML Microservice
+spring.application.version=1.0.0
+
+# Server Configuration
+server.port=8080
+server.servlet.context-path=/api/v1/autolabel
+management.server.port=8380
+
+# Database Configuration
+# Primary database for da-autolabel service
+spring.datasource.url=jdbc:postgresql://localhost:5432/da_autolabel
+spring.datasource.username=da_autolabel_user
+spring.datasource.password=da_autolabel_pass
+spring.datasource.driver-class-name=org.postgresql.Driver
+
+# Additional database for common entities (read-only)
+spring.datasource.common.url=jdbc:postgresql://localhost:5432/da_protos
+spring.datasource.common.username=da_common_user
+spring.datasource.common.password=da_common_pass
+spring.datasource.common.driver-class-name=org.postgresql.Driver
+
+# JPA Configuration
+spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=false
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
+spring.jpa.properties.hibernate.format_sql=true
+spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true
+
+# Kafka Configuration
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=da-autolabel-consumer-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.springframework.kafka.support.serializer.JsonDeserializer
+spring.kafka.consumer.properties.spring.json.trusted.packages=*
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer
+
+# Kafka Topics
+app.kafka.topic.asset-change-event=dalab.assets.changes
+app.kafka.topic.labeling-result=dalab.labeling.results
+
+# Security Configuration - Keycloak JWT
+spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8180/realms/dalab
+spring.security.oauth2.resourceserver.jwt.jwk-set-uri=http://localhost:8180/realms/dalab/protocol/openid-connect/certs
+
+# LLM Configuration (placeholders - update with real credentials)
+llm.openai.api-key=${OPENAI_API_KEY:sk-your-openai-api-key}
+llm.openai.model=${OPENAI_MODEL:gpt-3.5-turbo}
+llm.openai.max-tokens=${OPENAI_MAX_TOKENS:1000}
+llm.openai.temperature=${OPENAI_TEMPERATURE:0.3}
+
+# Ollama Configuration (for local LLMs)
+llm.ollama.base-url=${OLLAMA_BASE_URL:http://localhost:11434}
+llm.ollama.model=${OLLAMA_MODEL:llama2}
+llm.ollama.timeout=${OLLAMA_TIMEOUT:30000}
+
+# Google Gemini Configuration (placeholder)
+llm.gemini.api-key=${GEMINI_API_KEY:your-gemini-api-key}
+llm.gemini.project-id=${GEMINI_PROJECT_ID:your-gcp-project-id}
+llm.gemini.location=${GEMINI_LOCATION:us-central1}
+
+# Management Endpoints
+management.endpoints.web.exposure.include=health,info,metrics,prometheus
+management.endpoint.health.show-details=always
+management.health.defaults.enabled=true
+management.health.diskspace.enabled=true
+
+# Logging
+logging.level.com.dalab.autolabel=DEBUG
+logging.level.org.springframework.kafka=WARN
+logging.level.org.springframework.security=WARN
+logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n
+logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
+
+# OpenAPI Documentation
+springdoc.api-docs.path=/v3/api-docs
+springdoc.swagger-ui.path=/swagger-ui.html
+springdoc.swagger-ui.enabled=true 

src/test/java/com/dalab/autolabel/controller/LabelingConfigControllerTest.java

@@ -0,0 +1,94 @@
+package com.dalab.autolabel.controller;
+
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+import com.dalab.autolabel.service.IMLConfigService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@WebMvcTest(LabelingConfigController.class)
+class LabelingConfigControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private IMLConfigService mlConfigService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private MLConfigRequest mlConfigRequest;
+
+    @BeforeEach
+    void setUp() {
+        mlConfigRequest = MLConfigRequest.builder()
+                .providerType("TEST_PROVIDER")
+                .modelName("test-model")
+                .baseUrl("http://localhost/test")
+                .apiKey("test-key")
+                .build();
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void updateMlConfiguration_AdminRole_ShouldSucceed() throws Exception {
+        doNothing().when(mlConfigService).updateMlConfig(any(MLConfigRequest.class));
+
+        mockMvc.perform(put("/api/v1/labeling/config/ml")
+                        .with(csrf()) // Add CSRF token for PUT requests if CSRF is enabled
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(mlConfigRequest)))
+                .andExpect(status().isOk());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_USER") // Non-admin role
+    void updateMlConfiguration_UserRole_ShouldBeForbidden() throws Exception {
+        mockMvc.perform(put("/api/v1/labeling/config/ml")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(mlConfigRequest)))
+                .andExpect(status().isForbidden());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void getMlConfiguration_AdminRole_ShouldReturnConfig() throws Exception {
+        when(mlConfigService.getMlConfig()).thenReturn(mlConfigRequest);
+
+        mockMvc.perform(get("/api/v1/labeling/config/ml"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.providerType").value("TEST_PROVIDER"))
+                .andExpect(jsonPath("$.modelName").value("test-model"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_ADMIN")
+    void getMlConfiguration_AdminRole_NoConfigFound_ShouldReturnNotFound() throws Exception {
+        when(mlConfigService.getMlConfig()).thenReturn(null);
+
+        mockMvc.perform(get("/api/v1/labeling/config/ml"))
+                .andExpect(status().isNotFound());
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_USER") // Non-admin role
+    void getMlConfiguration_UserRole_ShouldBeForbidden() throws Exception {
+        mockMvc.perform(get("/api/v1/labeling/config/ml"))
+                .andExpect(status().isForbidden());
+    }
+} 

src/test/java/com/dalab/autolabel/controller/LabelingJobControllerTest.java

@@ -0,0 +1,173 @@
+package com.dalab.autolabel.controller;
+
+import com.dalab.autolabel.client.rest.dto.*;
+import com.dalab.autolabel.exception.AutoLabelingException;
+import com.dalab.autolabel.service.ILabelingJobService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@WebMvcTest(LabelingJobController.class)
+class LabelingJobControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private ILabelingJobService labelingJobService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private LabelingJobRequest labelingJobRequest;
+    private LabelingJobResponse labelingJobResponse;
+    private LabelingJobStatusResponse labelingJobStatusResponse;
+    private LabelingFeedbackRequest labelingFeedbackRequest;
+    private LabelingFeedbackResponse labelingFeedbackResponse;
+
+    @BeforeEach
+    void setUp() {
+        String jobId = UUID.randomUUID().toString();
+        labelingJobRequest = LabelingJobRequest.builder().jobName("Test Job").build();
+        labelingJobResponse = LabelingJobResponse.builder()
+                .jobId(jobId)
+                .status("SUBMITTED")
+                .submittedAt(LocalDateTime.now())
+                .message("Job submitted")
+                .build();
+        labelingJobStatusResponse = LabelingJobStatusResponse.builder()
+                .jobId(jobId).jobName("Test Job").status("RUNNING").build();
+
+        labelingFeedbackRequest = LabelingFeedbackRequest.builder()
+                .assetId("asset-123")
+                .labelingJobId(jobId)
+                .feedbackItems(List.of(LabelingFeedbackRequest.FeedbackItem.builder()
+                        .suggestedLabel("PII")
+                        .type(LabelingFeedbackRequest.FeedbackType.CONFIRMED)
+                        .build()))
+                .build();
+        labelingFeedbackResponse = LabelingFeedbackResponse.builder()
+                .feedbackId(UUID.randomUUID().toString())
+                .assetId("asset-123")
+                .status("RECEIVED")
+                .build();
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void submitLabelingJob_ValidRequest_ShouldSucceed() throws Exception {
+        when(labelingJobService.submitLabelingJob(any(LabelingJobRequest.class))).thenReturn(labelingJobResponse);
+
+        mockMvc.perform(post("/api/v1/labeling/jobs")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(labelingJobRequest)))
+                .andExpect(status().isAccepted())
+                .andExpect(jsonPath("$.jobId").value(labelingJobResponse.getJobId()));
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_USER") // Insufficient role
+    void submitLabelingJob_UserRole_ShouldBeForbidden() throws Exception {
+        mockMvc.perform(post("/api/v1/labeling/jobs")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(labelingJobRequest)))
+                .andExpect(status().isForbidden());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void getJobStatus_ExistingJob_ShouldReturnStatus() throws Exception {
+        when(labelingJobService.getJobStatus(eq(labelingJobStatusResponse.getJobId()))).thenReturn(labelingJobStatusResponse);
+
+        mockMvc.perform(get("/api/v1/labeling/jobs/{jobId}", labelingJobStatusResponse.getJobId()))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.jobId").value(labelingJobStatusResponse.getJobId()))
+                .andExpect(jsonPath("$.status").value("RUNNING"));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void getJobStatus_NonExistingJob_ShouldReturnNotFound() throws Exception {
+        String nonExistentJobId = UUID.randomUUID().toString();
+        when(labelingJobService.getJobStatus(eq(nonExistentJobId))).thenReturn(null);
+
+        mockMvc.perform(get("/api/v1/labeling/jobs/{jobId}", nonExistentJobId))
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_USER")
+    void listJobs_ShouldReturnJobList() throws Exception {
+        LabelingJobListResponse listResponse = LabelingJobListResponse.builder()
+                .jobs(Collections.singletonList(labelingJobStatusResponse))
+                .pageNumber(0).pageSize(20).totalElements(1L).totalPages(1).last(true)
+                .build();
+        when(labelingJobService.listJobs(any(Pageable.class))).thenReturn(listResponse);
+
+        mockMvc.perform(get("/api/v1/labeling/jobs").param("page", "0").param("size", "20"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.jobs[0].jobId").value(labelingJobStatusResponse.getJobId()));
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void submitLabelingFeedback_ValidRequest_ShouldSucceed() throws Exception {
+        when(labelingJobService.processLabelingFeedback(any(LabelingFeedbackRequest.class))).thenReturn(labelingFeedbackResponse);
+
+        mockMvc.perform(post("/api/v1/labeling/feedback")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(labelingFeedbackRequest)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.feedbackId").value(labelingFeedbackResponse.getFeedbackId()));
+    }
+    
+    @Test
+    @WithMockUser(authorities = "ROLE_USER") // Insufficient role
+    void submitLabelingFeedback_UserRole_ShouldBeForbidden() throws Exception {
+         mockMvc.perform(post("/api/v1/labeling/feedback")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(labelingFeedbackRequest)))
+                .andExpect(status().isForbidden());
+    }
+
+    @Test
+    @WithMockUser(authorities = "ROLE_DATA_STEWARD")
+    void submitLabelingJob_ServiceThrowsAutoLabelingException_ShouldReturnBadRequest() throws Exception {
+        when(labelingJobService.submitLabelingJob(any(LabelingJobRequest.class)))
+            .thenThrow(new AutoLabelingException("Test ML config error"));
+
+        mockMvc.perform(post("/api/v1/labeling/jobs")
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(labelingJobRequest)))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.message").value("Test ML config error"));
+    }
+} 

src/test/java/com/dalab/autolabel/service/impl/InMemoryMLConfigServiceTest.java

@@ -0,0 +1,59 @@
+package com.dalab.autolabel.service.impl;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.dalab.autolabel.client.rest.dto.MLConfigRequest;
+
+class InMemoryMLConfigServiceTest {
+
+    private InMemoryMLConfigService mlConfigService;
+
+    @BeforeEach
+    void setUp() {
+        mlConfigService = new InMemoryMLConfigService();
+    }
+
+    @Test
+    void getMlConfig_Initial_ShouldBeNull() {
+        assertNull(mlConfigService.getMlConfig(), "Initial config should be null");
+    }
+
+    @Test
+    void updateMlConfig_AndGetMlConfig_ShouldReturnUpdatedConfig() {
+        MLConfigRequest newConfig = MLConfigRequest.builder()
+                .providerType("OPENAI")
+                .modelName("gpt-4")
+                .apiKey("sk-123")
+                .build();
+
+        mlConfigService.updateMlConfig(newConfig);
+        MLConfigRequest fetchedConfig = mlConfigService.getMlConfig();
+
+        assertNotNull(fetchedConfig, "Fetched config should not be null after update");
+        assertEquals("OPENAI", fetchedConfig.getProviderType());
+        assertEquals("gpt-4", fetchedConfig.getModelName());
+        assertEquals("sk-123", fetchedConfig.getApiKey());
+    }
+
+    @Test
+    void updateMlConfig_WithNull_ShouldThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> {
+            mlConfigService.updateMlConfig(null);
+        }, "Updating with null config should throw IllegalArgumentException");
+    }
+    
+    @Test
+    void updateMlConfig_MultipleUpdates_ShouldReflectLatest() {
+        MLConfigRequest config1 = MLConfigRequest.builder().modelName("model1").build();
+        MLConfigRequest config2 = MLConfigRequest.builder().modelName("model2").build();
+
+        mlConfigService.updateMlConfig(config1);
+        assertEquals("model1", mlConfigService.getMlConfig().getModelName());
+
+        mlConfigService.updateMlConfig(config2);
+        assertEquals("model2", mlConfigService.getMlConfig().getModelName());
+    }
+} 

src/test/java/com/dalab/autolabel/service/impl/LabelingJobServiceImplTest.java

@@ -0,0 +1,179 @@
+package com.dalab.autolabel.service.impl;
+
+import com.dalab.autolabel.client.dto.AssetIdentifier;
+import com.dalab.autolabel.client.feign.AssetCatalogClient;
+import com.dalab.autolabel.client.rest.dto.*;
+import com.dalab.autolabel.entity.LabelingFeedbackEntity;
+import com.dalab.autolabel.entity.LabelingJobEntity;
+import com.dalab.autolabel.exception.AutoLabelingException;
+import com.dalab.autolabel.mapper.LabelingJobMapper;
+import com.dalab.autolabel.repository.LabelingFeedbackRepository;
+import com.dalab.autolabel.repository.LabelingJobRepository;
+import com.dalab.autolabel.service.IMLConfigService;
+import com.dalab.autolabel.service.ILLMIntegrationService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class LabelingJobServiceImplTest {
+
+    @Mock
+    private IMLConfigService mlConfigService;
+    @Mock
+    private LabelingJobRepository labelingJobRepository;
+    @Mock
+    private LabelingFeedbackRepository labelingFeedbackRepository;
+    @Mock
+    private LabelingJobMapper labelingJobMapper;
+    @Mock
+    private AssetCatalogClient assetCatalogClient; // Mocked, not used in these specific tests yet
+    @Mock
+    private ILLMIntegrationService llmIntegrationService; // Mocked for async part
+
+    @InjectMocks
+    private LabelingJobServiceImpl labelingJobService;
+
+    private MLConfigRequest mlConfigRequest;
+    private LabelingJobRequest labelingJobRequest;
+    private LabelingJobEntity labelingJobEntity;
+    private LabelingJobStatusResponse labelingJobStatusResponse;
+
+    @BeforeEach
+    void setUp() {
+        mlConfigRequest = MLConfigRequest.builder().providerType("MOCK").modelName("mock-model").build();
+        labelingJobRequest = LabelingJobRequest.builder()
+                .jobName("Test Job")
+                .scope(LabelingJobRequest.LabelingScope.builder().assetIds(List.of("asset1")).build())
+                .build();
+        
+        String jobId = UUID.randomUUID().toString();
+        labelingJobEntity = LabelingJobEntity.builder()
+                .jobId(jobId)
+                .jobName("Test Job")
+                .status(LabelingJobEntity.JobStatus.SUBMITTED)
+                .submittedAt(LocalDateTime.now())
+                .build();
+        labelingJobStatusResponse = LabelingJobStatusResponse.builder()
+                .jobId(jobId)
+                .jobName("Test Job")
+                .status("SUBMITTED")
+                .build();
+    }
+
+    @Test
+    void submitLabelingJob_ValidRequest_ShouldSaveJobAndReturnResponse() throws AutoLabelingException {
+        when(mlConfigService.getMlConfig()).thenReturn(mlConfigRequest);
+        when(labelingJobRepository.save(any(LabelingJobEntity.class))).thenReturn(labelingJobEntity);
+        // Mocking async method to avoid its execution. We are testing the synchronous part here.
+        // A more robust way might involve a TestExecutionListener or checking side effects.
+        LabelingJobServiceImpl spyService = spy(labelingJobService);
+        doNothing().when(spyService).processLabelingJobAsync(anyString(), anyString(), any(LabelingJobRequest.LabelingScope.class), any(MLConfigRequest.class));
+
+        LabelingJobResponse response = spyService.submitLabelingJob(labelingJobRequest);
+
+        assertNotNull(response);
+        assertEquals("SUBMITTED", response.getStatus());
+        assertNotNull(response.getJobId());
+        verify(labelingJobRepository).save(any(LabelingJobEntity.class));
+        verify(spyService).processLabelingJobAsync(eq(response.getJobId()), eq(labelingJobRequest.getJobName()), eq(labelingJobRequest.getScope()), eq(mlConfigRequest));
+    }
+
+    @Test
+    void submitLabelingJob_NoMlConfig_ShouldThrowAutoLabelingException() {
+        when(mlConfigService.getMlConfig()).thenReturn(null);
+        assertThrows(AutoLabelingException.class, () -> {
+            labelingJobService.submitLabelingJob(labelingJobRequest);
+        });
+        verify(labelingJobRepository, never()).save(any(LabelingJobEntity.class));
+    }
+
+    @Test
+    void getJobStatus_ExistingJob_ShouldReturnStatusResponse() {
+        when(labelingJobRepository.findById(anyString())).thenReturn(Optional.of(labelingJobEntity));
+        when(labelingJobMapper.toStatusResponse(any(LabelingJobEntity.class))).thenReturn(labelingJobStatusResponse);
+
+        LabelingJobStatusResponse response = labelingJobService.getJobStatus("some-job-id");
+
+        assertNotNull(response);
+        assertEquals(labelingJobEntity.getJobId(), response.getJobId());
+        verify(labelingJobRepository).findById(eq("some-job-id"));
+    }
+
+    @Test
+    void getJobStatus_NonExistingJob_ShouldReturnNull() {
+        when(labelingJobRepository.findById(anyString())).thenReturn(Optional.empty());
+        LabelingJobStatusResponse response = labelingJobService.getJobStatus("non-existent-id");
+        assertNull(response);
+        verify(labelingJobMapper, never()).toStatusResponse(any());
+    }
+
+    @Test
+    void listJobs_ShouldReturnPaginatedResponse() {
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<LabelingJobEntity> page = new PageImpl<>(Collections.singletonList(labelingJobEntity), pageable, 1);
+        LabelingJobListResponse expectedResponse = LabelingJobListResponse.builder().jobs(List.of(labelingJobStatusResponse)).build(); 
+        // Mapper is complex, so we trust its unit tests and mock its output directly for listJobs
+
+        when(labelingJobRepository.findAll(any(Pageable.class))).thenReturn(page);
+        when(labelingJobMapper.toJobListResponse(page)).thenReturn(expectedResponse);
+
+        LabelingJobListResponse actualResponse = labelingJobService.listJobs(pageable);
+
+        assertNotNull(actualResponse);
+        assertEquals(expectedResponse.getJobs().size(), actualResponse.getJobs().size());
+        verify(labelingJobRepository).findAll(pageable);
+        verify(labelingJobMapper).toJobListResponse(page);
+    }
+
+    @Test
+    void processLabelingFeedback_ValidRequest_ShouldSaveFeedback() throws AutoLabelingException {
+        LabelingFeedbackRequest feedbackRequest = LabelingFeedbackRequest.builder()
+                .assetId("asset-1")
+                .labelingJobId("job-1")
+                .feedbackItems(List.of(LabelingFeedbackRequest.FeedbackItem.builder().suggestedLabel("Old").correctedLabel("New").type(LabelingFeedbackRequest.FeedbackType.CORRECTED).build()))
+                .build();
+        
+        ArgumentCaptor<LabelingFeedbackEntity> feedbackEntityCaptor = ArgumentCaptor.forClass(LabelingFeedbackEntity.class);
+        when(labelingFeedbackRepository.save(any(LabelingFeedbackEntity.class))).thenAnswer(invocation -> invocation.getArgument(0));
+
+        LabelingFeedbackResponse response = labelingJobService.processLabelingFeedback(feedbackRequest);
+
+        assertNotNull(response);
+        assertEquals("PROCESSED", response.getStatus());
+        assertNotNull(response.getFeedbackId());
+        verify(labelingFeedbackRepository, times(2)).save(feedbackEntityCaptor.capture()); // Saved once for RECEIVED, once for PROCESSED
+        
+        LabelingFeedbackEntity savedEntity = feedbackEntityCaptor.getValue();
+        assertEquals(feedbackRequest.getAssetId(), savedEntity.getAssetId());
+        assertEquals("PROCESSED", savedEntity.getProcessingStatus());
+    }
+
+    @Test
+    void processLabelingFeedback_EmptyItems_ShouldThrowException() {
+        LabelingFeedbackRequest feedbackRequest = LabelingFeedbackRequest.builder().feedbackItems(Collections.emptyList()).build();
+        assertThrows(AutoLabelingException.class, () -> {
+            labelingJobService.processLabelingFeedback(feedbackRequest);
+        });
+        verify(labelingFeedbackRepository, never()).save(any());
+    }
+}