diff --git a/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/controller/RuleBuilderController.java b/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/controller/RuleBuilderController.java
index 30aeadc6..7d0957b9 100644
--- a/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/controller/RuleBuilderController.java
+++ b/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/controller/RuleBuilderController.java
@@ -62,7 +62,6 @@ public class RuleBuilderController implements RuleBuilderResource {
             throw new AssertionError("There was an error when merging the user rule update into the rule file");
         }
         try {
-            log.info("result"+mergingResult.getMergedRules());
             var droolsValidation = droolsValidationService.testRules(new RuleValidationModel(RuleFileType.ENTITY.name(), mergingResult.getMergedRules()));
             log.info("result of validation: " + droolsValidation);
             droolsValidationResponse = DroolsValidationResponse.builder()
diff --git a/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/rulesmanagement/models/RuleFileBluePrint.java b/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/rulesmanagement/models/RuleFileBluePrint.java
index 533492e1..196e7f85 100644
--- a/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/rulesmanagement/models/RuleFileBluePrint.java
+++ b/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/rulesmanagement/models/RuleFileBluePrint.java
@@ -1,6 +1,7 @@
 package com.iqser.red.service.redaction.v1.server.rulesmanagement.models;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedList;
@@ -34,6 +35,9 @@ public class RuleFileBluePrint {
     List<BasicDeclaration> declarations;
     List<BasicFunction> functions;
 
+    private static final String IMPORT_PREFIX = "import ";
+    private static final String PACKAGE_PREFIX = "package ";
+
 
     public boolean removeRule(RuleIdentifier ruleIdentifier) {
 
@@ -54,6 +58,60 @@ public class RuleFileBluePrint {
     }
 
 
+    public void addImport(String importStatement) {
+
+        if (importStatement == null || importStatement.trim().isEmpty()) {
+            return;
+        }
+
+        String cleanImport = importStatement.trim();
+        if (!cleanImport.startsWith(IMPORT_PREFIX)) {
+            cleanImport = IMPORT_PREFIX + cleanImport;
+        }
+
+        if (imports == null) {
+            imports = PACKAGE_PREFIX + "drools\n\n";
+        }
+
+        if (!imports.contains(cleanImport)) {
+            imports = imports.trim() + "\n" + cleanImport;
+        }
+    }
+
+
+    public void mergeImports(RuleFileBluePrint other) {
+
+        if (other == null || other.getImports() == null) {
+            return;
+        }
+
+        addImports(other.getImports());
+    }
+
+
+    public String getImports() {
+
+        if (imports == null || imports.trim().isEmpty()) {
+            return PACKAGE_PREFIX + "drools\n\n";
+        }
+        return imports;
+    }
+
+
+    public void addImports(String importStatements) {
+
+        if (importStatements == null || importStatements.trim().isEmpty()) {
+            return;
+        }
+
+        Arrays.stream(importStatements.split("\n"))
+                .map(String::trim)
+                .filter(line -> !line.isEmpty())
+                .filter(line -> !line.startsWith(PACKAGE_PREFIX))
+                .forEach(this::addImport);
+    }
+
+
     public boolean removeRuleClassByRuleIdentifier(RuleIdentifier ruleIdentifier) {
 
         AtomicBoolean wasRemoved = new AtomicBoolean(false);
diff --git a/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/service/RuleBuilderService.java b/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/service/RuleBuilderService.java
index d3a7352e..5c215c2c 100644
--- a/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/service/RuleBuilderService.java
+++ b/redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/service/RuleBuilderService.java
@@ -51,10 +51,10 @@ public class RuleBuilderService {
 
     public RuleMergingResult mergeUserRulesAndSystemRules(String existingRules, String userUpdatedRules) {
 
-        RuleFileBluePrint ruleFileBluePrintExisting = RuleFileParser.buildBluePrintFromRulesString(existingRules);
-        RuleFileBluePrint mergedRuleFileBlueprint = RuleFileParser.buildBluePrintFromRulesString(userUpdatedRules, false);
+        RuleFileBluePrint mergedRuleFileBluePrint = RuleFileParser.buildBluePrintFromRulesString(existingRules);
+        RuleFileBluePrint userRulesBluePrint = RuleFileParser.buildBluePrintFromRulesString(userUpdatedRules, false);
 
-        mergedRuleFileBlueprint.getRuleClasses()
+        userRulesBluePrint.getRuleClasses()
                 .forEach(ruleClass -> {
                     if (systemRules.stream()
                             .toList().contains(RuleIdentifier.fromName(ruleClass.ruleType().name()))) {
@@ -62,35 +62,40 @@ public class RuleBuilderService {
                         throw new RuntimeException("No system rule updates allowed in user rule update.");
                     }
                 });
-        ruleFileBluePrintExisting = removeAllRulesExceptSystemRules(ruleFileBluePrintExisting);
-        mergedRuleFileBlueprint.getAllRules()
-                .forEach(ruleFileBluePrintExisting::addRule);
-        Set<String> uniqueImports = Arrays.stream((ruleFileBluePrintExisting.getImports() + mergedRuleFileBlueprint.getImports()).replaceAll("\n", "").split("import"))
+
+        mergedRuleFileBluePrint = removeAllRulesExceptSystemRules(mergedRuleFileBluePrint);
+        userRulesBluePrint.getAllRules()
+                .forEach(mergedRuleFileBluePrint::addRule);
+
+        mergedRuleFileBluePrint.mergeImports(userRulesBluePrint);
+
+        Set<String> uniqueGlobals = Arrays.stream((mergedRuleFileBluePrint.getGlobals() + userRulesBluePrint.getGlobals()).replaceAll("\n", "").split("global"))
                 .map(String::trim)
+                .filter(s -> !s.isEmpty())
                 .collect(Collectors.toSet());
-        ruleFileBluePrintExisting.setImports(uniqueImports.stream()
-                                                     .collect(Collectors.joining("")));
-        Set<String> uniqueGlobals = Arrays.stream((ruleFileBluePrintExisting.getGlobals() + mergedRuleFileBlueprint.getGlobals()).replaceAll("\n", "").split("import"))
-                .map(String::trim)
-                .collect(Collectors.toSet());
-        ruleFileBluePrintExisting.setGlobals(uniqueGlobals.stream()
-                                                     .collect(Collectors.joining("")));
-        ruleFileBluePrintExisting.setFunctions(Stream.concat(ruleFileBluePrintExisting.getFunctions()
-                                                                     .stream(),
-                                                             mergedRuleFileBlueprint.getFunctions()
-                                                                     .stream())
-                                                       .distinct()
-                                                       .toList());
-        ruleFileBluePrintExisting.setDeclarations(Stream.concat(ruleFileBluePrintExisting.getDeclarations()
-                                                                        .stream(),
-                                                                mergedRuleFileBlueprint.getDeclarations()
-                                                                        .stream())
-                                                          .distinct()
-                                                          .toList());
+
+        mergedRuleFileBluePrint.setGlobals(uniqueGlobals.stream()
+                                                   .map(global -> "global " + global)
+                                                   .collect(Collectors.joining("\n")));
+
+        mergedRuleFileBluePrint.setFunctions(Stream.concat(mergedRuleFileBluePrint.getFunctions()
+                                                                   .stream(),
+                                                           userRulesBluePrint.getFunctions()
+                                                                   .stream())
+                                                     .distinct()
+                                                     .toList());
+
+        mergedRuleFileBluePrint.setDeclarations(Stream.concat(mergedRuleFileBluePrint.getDeclarations()
+                                                                      .stream(),
+                                                              userRulesBluePrint.getDeclarations()
+                                                                      .stream())
+                                                        .distinct()
+                                                        .toList());
+
         return RuleMergingResult.builder()
-                .mergedRules(RuleFileFactory.buildRuleString(mergedRuleFileBlueprint, false, false))
-                .addedGlobalsOffset(mergedRuleFileBlueprint.getGlobals().length())
-                .addedImportsOffset(mergedRuleFileBlueprint.getImports().length())
+                .mergedRules(RuleFileFactory.buildRuleString(mergedRuleFileBluePrint, false, false))
+                .addedGlobalsOffset(userRulesBluePrint.getGlobals().length())
+                .addedImportsOffset(userRulesBluePrint.getImports().length())
                 .build();
     }