diff --git a/julielab-neo4j-plugins-concepts-representation/pom.xml b/julielab-neo4j-plugins-concepts-representation/pom.xml
index b176b6a..b0b5a83 100644
--- a/julielab-neo4j-plugins-concepts-representation/pom.xml
+++ b/julielab-neo4j-plugins-concepts-representation/pom.xml
@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>de.julielab</groupId>
 		<artifactId>julielab-neo4j-server-plugins</artifactId>
-		<version>3.1.0</version>
+		<version>3.2.0</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 	<artifactId>julielab-neo4j-plugins-concepts-representation</artifactId>
diff --git a/julielab-neo4j-plugins-concepts/pom.xml b/julielab-neo4j-plugins-concepts/pom.xml
index 7e31696..54d63f4 100644
--- a/julielab-neo4j-plugins-concepts/pom.xml
+++ b/julielab-neo4j-plugins-concepts/pom.xml
@@ -4,7 +4,7 @@
     <parent>
         <groupId>de.julielab</groupId>
         <artifactId>julielab-neo4j-server-plugins</artifactId>
-        <version>3.1.0</version>
+        <version>3.2.0</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <artifactId>julielab-neo4j-plugins-concepts</artifactId>
@@ -33,7 +33,7 @@
         <dependency>
             <groupId>commons-io</groupId>
             <artifactId>commons-io</artifactId>
-            <version>2.7</version>
+            <version>2.11.0</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
@@ -46,7 +46,7 @@
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
-            <version>2.8.2</version>
+            <version>2.8.9</version>
         </dependency>
         <dependency>
             <groupId>org.assertj</groupId>
diff --git a/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/Export.java b/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/Export.java
index 87db870..223c7b1 100644
--- a/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/Export.java
+++ b/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/Export.java
@@ -50,6 +50,7 @@ public class Export {
     public static final String CONCEPT_ID_MAPPING = "concept_id_mapping";
     public static final String PARAM_UNIQUE_KEYS = "unique_keys";
     public static final String PARAM_SOURCE_ID_PROPERTY = "source_id_property";
+    public static final String PARAM_ADD_SOURCE_PREFIX = "add_source_prefix";
     public static final String PARAM_TARGET_ID_PROPERTY = "target_id_property";
     public static final String PARAM_FACET_NAMES = "facet_names";
     public static final String PARAM_LABELS = "labels";
@@ -290,7 +291,7 @@ private void writeHypernyms(Node n, Set<Node> visitedNodes, Map<Node, Set<String
      * it specifically fits the format used by the JCoRe Lingpipe Gazetteer component.</p>
      * @param labelsString One or multiple labels that identify the sets of nodes to process for dictionary creation. Lists of labels must be in JSON format. The labels are processed in the specified order. This is important if <tt>uniqueKeys</tt> is enabled.
      * @param exclusionLabelString One or multiple labels that serve as a node filter. Nodes having one of those labels will be skipped from dictionary creation.
-     * @param nodeCategories The node properties that should be the keys of the dictionary. Separate multiple properties with commas. There are restrictions regarding the types of the properties. They must either all be non-array values or all are arrays of the same length. For multiple properties, a single mapping-target string is created with "||" as a value separator. In case of array values, the string first lists all first elements, then the second elements, then the third elements etc.
+     * @param idProperties The node properties that should be the keys of the dictionary. Separate multiple properties with commas. There are restrictions regarding the types of the properties. They must either all be non-array values or all are arrays of the same length. For multiple properties, a single mapping-target string is created with "||" as a value separator. In case of array values, the string first lists all first elements, then the second elements, then the third elements etc.
      * @param uniqueKeys Determines if keys may occur multiple times or should be unique. In case of uniqueness, the <tt>labelsString</tt> becomes important: the first occurrence of a key will be included in the output, subsequent occurrences will be discarded.
      * @param log
      * @return The dictionary text string GZIP-compressed and Base64-ASCII-encoded.
@@ -302,7 +303,8 @@ private void writeHypernyms(Node n, Set<Node> visitedNodes, Map<Node, Set<String
     public String exportLingpipeDictionary(
             @QueryParam(PARAM_LABELS) String labelsString,
             @QueryParam(PARAM_EXCLUSION_LABEL) String exclusionLabelString,
-            @QueryParam(PARAM_SOURCE_ID_PROPERTY) String nodeCategories,
+            @QueryParam(PARAM_SOURCE_ID_PROPERTY) String idProperties,
+            @QueryParam(PARAM_ADD_SOURCE_PREFIX) boolean addSourcePrefix,
             @QueryParam(PARAM_UNIQUE_KEYS) boolean uniqueKeys,
             @Context Log log)
             throws IOException {
@@ -314,11 +316,23 @@ public String exportLingpipeDictionary(
         else
             labels = Arrays.stream(om.readValue(labelsString, String[].class)).map(Label::label).toArray(Label[]::new);
         List<String> propertiesToWrite = new ArrayList<>();
-        if (nodeCategories == null || nodeCategories.length() == 0) {
+        if (idProperties == null || idProperties.length() == 0) {
             propertiesToWrite.add(PROP_ID);
-        } else {
-            Collections.addAll(propertiesToWrite, nodeCategories.split(","));
-        }
+        } else if (!idProperties.contains("[")){
+            Collections.addAll(propertiesToWrite, idProperties.split(","));
+        } else
+            propertiesToWrite = Arrays.stream(om.readValue(idProperties, String[].class)).collect(Collectors.toList());
+
+        Map<String, String> sourcePropertyNamesByIdPropertyName = Map.of(PROP_ID, "",
+                PROP_ORG_ID, PROP_ORG_SRC,
+                PROP_SRC_IDS + 0,   PROP_SOURCES + 0,
+                PROP_SRC_IDS + 1,   PROP_SOURCES + 1,
+                PROP_SRC_IDS + 2,   PROP_SOURCES + 2,
+                PROP_SRC_IDS + 3,   PROP_SOURCES + 3,
+                PROP_SRC_IDS + 4,   PROP_SOURCES + 4,
+                PROP_SRC_IDS + 5,   PROP_SOURCES + 5,
+                PROP_SRC_IDS + 6,   PROP_SOURCES + 6,
+                PROP_SRC_IDS + 7, PROP_SOURCES + 7);
         log.info("Exporting lingpipe dictionary data for nodes with labels \"" + Arrays.stream(labels).map(Label::name).collect(Collectors.joining(", "))
                 + "\", mapping their names to their properties " + propertiesToWrite + ".");
         Label[] exclusionLabels = null;
@@ -342,20 +356,20 @@ public String exportLingpipeDictionary(
         try (GZIPOutputStream os = new GZIPOutputStream(baos)) {
             for (Label label : labels) {
                 try (Transaction tx = graphDb.beginTx()) {
-                    ResourceIterator<Node> terms = tx.findNodes(label);
+                    ResourceIterator<Node> conceptNodes = tx.findNodes(label);
                     int count = 0;
-                    while (terms.hasNext()) {
-                        Node term = terms.next();
+                    while (conceptNodes.hasNext()) {
+                        Node node = conceptNodes.next();
                         count++;
                         boolean termHasExclusionLabel = false;
                         for (int i = 0; null != exclusionLabels && i < exclusionLabels.length; i++) {
                             Label exclusionLabel = exclusionLabels[i];
-                            if (term.hasLabel(exclusionLabel)) {
+                            if (node.hasLabel(exclusionLabel)) {
                                 termHasExclusionLabel = true;
                                 break;
                             }
                         }
-                        if (!termHasExclusionLabel && term.hasProperty(PROP_ID) && term.hasProperty(PROP_PREF_NAME)) {
+                        if (!termHasExclusionLabel && node.hasProperty(PROP_ID) && node.hasProperty(PROP_PREF_NAME)) {
 
                             int arraySize;
                             String idProperty = propertiesToWrite.get(0);
@@ -363,42 +377,77 @@ public String exportLingpipeDictionary(
                             // arrays are of the same length. Thus, to determine the
                             // required number of iterations we just use the first
                             // array since the others should have the same length.
-                            String[] value = NodeUtilities.getNodePropertyAsStringArrayValue(term, idProperty);
+                            String[] ids = NodeUtilities.getNodePropertyAsStringArrayValue(node, idProperty);
 
-                            if (null == value && term.hasLabel(ConceptLabel.AGGREGATE))
+                            if (null == ids && node.hasLabel(ConceptLabel.AGGREGATE))
                                 // perhaps we have an aggregate term, then we can
                                 // try and retrieve the value from its elements
-                                value = ConceptAggregateManager.getPropertyValueOfElements(term, idProperty);
-                            if (null == value) {
-                                terms.close();
-                                throw new IllegalArgumentException("A concept occurred that does not have a value for the property \"" + idProperty + "\": " + NodeUtilities.getNodePropertiesAsString(term));
+                                ids = ConceptAggregateManager.getPropertyValueOfElements(node, idProperty);
+                            if (null == ids) {
+                                conceptNodes.close();
+                                throw new IllegalArgumentException("A concept occurred that does not have a value for the property \"" + idProperty + "\": " + NodeUtilities.getNodePropertiesAsString(node));
                             }
-                            arraySize = value.length;
+                            arraySize = ids.length;
 
                             List<String> categoryStrings = new ArrayList<>();
                             for (int i = 0; i < arraySize; ++i) {
                                 StringBuilder sb = new StringBuilder();
                                 for (int j = 0; j < propertiesToWrite.size(); ++j) {
                                     String property = propertiesToWrite.get(j);
-                                    value = NodeUtilities.getNodePropertyAsStringArrayValue(term, property);
-                                    if (null == value && term.hasLabel(ConceptLabel.AGGREGATE))
+                                    ids = NodeUtilities.getNodePropertyAsStringArrayValue(node, property);
+                                    String[] sources = null;
+                                    if (addSourcePrefix) {
+                                        final String sourceProperty = sourcePropertyNamesByIdPropertyName.get(property);
+                                        if (sourceProperty == null)
+                                            throw new IllegalArgumentException("Dictionary creation with source prefix should be performed but the source property is unknown for ID property '" + property + "'.");
+                                        // for PROP_ID we assigned an empty string
+                                        if (!sourceProperty.isEmpty()) {
+                                            sources = NodeUtilities.getNodePropertyAsStringArrayValue(node, sourceProperty);
+                                        } else {
+                                            sources = new String[ids.length];
+                                            for (int k = 0; k < sources.length; k++) {
+                                                sources[k] = "id";
+                                            }
+                                        }
+
+                                    }
+                                    if (null == ids && node.hasLabel(ConceptLabel.AGGREGATE)) {
                                         // perhaps we have an aggregate term, then
                                         // we can try and retrieve the value from
                                         // its elements
-                                        value = ConceptAggregateManager.getPropertyValueOfElements(term, idProperty);
-                                    if (null == value || value.length == 0) {
-                                        terms.close();
+                                        ids = ConceptAggregateManager.getPropertyValueOfElements(node, idProperty);
+                                        if (addSourcePrefix) {
+                                            final String sourceProperty = sourcePropertyNamesByIdPropertyName.get(property);
+                                            if (sourceProperty == null)
+                                                throw new IllegalArgumentException("Dictionary creation with source prefix should be performed but the source property is unknown for ID property '" + property + "'.");
+                                            // for PROP_ID we assigned an empty string
+                                            if (!sourceProperty.isEmpty()) {
+                                                sources = ConceptAggregateManager.getPropertyValueOfElements(node, sourceProperty);
+                                            } else {
+                                                sources = new String[ids.length];
+                                                for (int k = 0; k < sources.length; k++) {
+                                                    sources[k] = "id";
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    if (null == ids || ids.length == 0) {
+                                        conceptNodes.close();
                                         throw new IllegalArgumentException("The property \"" + property
-                                                + "\" does not contain a value for node " + term + " (properties: "
-                                                + PropertyUtilities.getNodePropertiesAsString(term) + ")");
+                                                + "\" does not contain a value for node " + node + " (properties: "
+                                                + PropertyUtilities.getNodePropertiesAsString(node) + ")");
                                     }
-                                    if (value.length != arraySize) {
-                                        terms.close();
+                                    if (ids.length != arraySize) {
+                                        conceptNodes.close();
                                         throw new IllegalArgumentException("The properties \"" + propertiesToWrite
-                                                + "\" on term " + PropertyUtilities.getNodePropertiesAsString(term)
+                                                + "\" on term " + PropertyUtilities.getNodePropertiesAsString(node)
                                                 + " do not have all the same number of value elements which is required for dictionary creation by this method.");
                                     }
-                                    sb.append(value[i]);
+                                    if (addSourcePrefix)
+                                        sb.append(sources[i]).append(":").append(ids[i]);
+                                        else
+                                    sb.append(ids[i]);
                                     if (j < propertiesToWrite.size() - 1)
                                         sb.append("||");
                                 }
@@ -406,10 +455,10 @@ public String exportLingpipeDictionary(
                             }
 
                             for (String categoryString : categoryStrings) {
-                                String preferredName = (String) term.getProperty(PROP_PREF_NAME);
+                                String preferredName = (String) node.getProperty(PROP_PREF_NAME);
                                 String[] synonyms = new String[0];
-                                if (term.hasProperty(PROP_SYNONYMS))
-                                    synonyms = (String[]) term.getProperty(PROP_SYNONYMS);
+                                if (node.hasProperty(PROP_SYNONYMS))
+                                    synonyms = (String[]) node.getProperty(PROP_SYNONYMS);
                                 // String[] writingVariants = new String[0];
                                 // if (term.hasProperty(PROP_WRITING_VARIANTS))
                                 // writingVariants = (String[]) term
@@ -419,7 +468,7 @@ public String exportLingpipeDictionary(
                                 for (String synonString : synonyms)
                                     writeNormalizedDictionaryEntry(synonString, categoryString, writtenKeys, os);
                                 TraversalDescription acronymsTraversal = PredefinedTraversals.getAcronymsTraversal(tx);
-                                Traverser traverse = acronymsTraversal.traverse(term);
+                                Traverser traverse = acronymsTraversal.traverse(node);
                                 for (Node acronymNode : traverse.nodes()) {
                                     String acronym = (String) acronymNode.getProperty(MorphoConstants.PROP_NAME);
                                     writeNormalizedDictionaryEntry(acronym, categoryString, writtenKeys, os);
diff --git a/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/concepts/ConceptAggregateManager.java b/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/concepts/ConceptAggregateManager.java
index f579acc..3c03103 100644
--- a/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/concepts/ConceptAggregateManager.java
+++ b/julielab-neo4j-plugins-concepts/src/main/java/de/julielab/neo4j/plugins/concepts/ConceptAggregateManager.java
@@ -59,6 +59,7 @@ public class ConceptAggregateManager {
     public static final String KEY_SKIP_EXISTING_PROPERTIES = "skip_existing_properties";
     public static final String KEY_ALLOWED_MAPPING_TYPES = "allowedMappingTypes";
     public static final String KEY_COPY_PROPERTIES = "copy_properties";
+    public static final String KEY_NAME_PROPERTY = "name_property";
     public static final String RET_KEY_NUM_AGGREGATES = "numAggregates";
     public static final String RET_KEY_NUM_ELEMENTS = "numElements";
     public static final String RET_KEY_NUM_PROPERTIES = "numProperties";
@@ -192,13 +193,14 @@ static void insertAggregateConcept(Transaction tx, ImportConcept jsonConcept,
      *
      * @param graphDb               The graph database to work on.
      * @param nodeLabels
+     * @param nameProperty
      * @param aggregatedLabels
      * @param copyProperties
      * @return
      */
-    public static int buildAggregatesForEqualNames(GraphDatabaseService graphDb, List<Label> nodeLabels, List<Label> aggregatedLabels, String[] copyProperties, Log log) {
+    public static int buildAggregatesForEqualNames(GraphDatabaseService graphDb, List<Label> nodeLabels, String nameProperty, List<Label> aggregatedLabels, String[] copyProperties, Log log) {
         int createdAggregates = 0;
-        Comparator<Node> nodeNameComparator = Comparator.comparing(n -> ((String) n.getProperty(PROP_PREF_NAME)).toLowerCase().replaceAll("\\s+", ""));
+        Comparator<Node> nodeNameComparator = Comparator.comparing(n -> ((String) n.getProperty(nameProperty)));
 
         // Sort the nodes with the target according to their preferred name
         log.info("Acquiring all non-aggregate nodes with labels %s", nodeLabels);
@@ -607,13 +609,10 @@ public static void copyAggregateProperties(Node aggregate, boolean skipExistingP
                     Object property = term.getProperty(copyProperty);
                     if (property.getClass().isArray()) {
                         final Object[] mergedValue = mergeArrayValue(newAggregateProperties.getOrDefault(copyProperty, null), JulieNeo4jUtilities.convertArray(property));
-                        // TODO
-//                        aggregate.setProperty(copyProperty, mergedValue);
                         newAggregateProperties.put(copyProperty, mergedValue);
                     } else {
                         if (!newAggregateProperties.containsKey(copyProperty))
                             newAggregateProperties.put(copyProperty, property);
-//                        setNonNullNodeProperty(aggregate, copyProperty, property);
                         Object aggregateProperty = newAggregateProperties.get(copyProperty);
                         if (!aggregateProperty.equals(property)) {
                             divergentProperties.add(copyProperty);
@@ -748,39 +747,20 @@ public Response buildAggregatesByPreferredName(String jsonParameterObject, @Cont
             if (!parameterMap.containsKey(KEY_LABELS))
                 throw new IllegalArgumentException("Parameter '" + KEY_LABELS + "' not specified.");
             List<Label> aggregatedLabels = List.of(AGGREGATE_EQUAL_NAMES);
+            String nameProperty = PROP_PREF_NAME;
+            if (parameterMap.containsKey(KEY_NAME_PROPERTY))
+                nameProperty = (String) parameterMap.get(KEY_NAME_PROPERTY);
             if (parameterMap.containsKey(KEY_AGGREGATED_LABELS))
                 aggregatedLabels = ((List<String>) parameterMap.get(KEY_AGGREGATED_LABELS)).stream().map(Label::label).collect(Collectors.toList());
             List<String> copyProperties = List.of(PROP_PREF_NAME, PROP_SYNONYMS);
             if (parameterMap.containsKey(KEY_COPY_PROPERTIES))
                 copyProperties = ((List<String>) parameterMap.get(KEY_COPY_PROPERTIES));
             List<Label> targetLabels = ((List<String>) parameterMap.get(KEY_LABELS)).stream().map(Label::label).collect(Collectors.toList());
-            log.info("Creating equal-name-aggregates for concepts with label %s and assigning them label", targetLabels, aggregatedLabels);
+            log.info("Creating equal-name-aggregates regarding the '%s' property for concepts with label %s and assigning them label %s", nameProperty, targetLabels, aggregatedLabels);
             GraphDatabaseService graphDb = dbms.database(DEFAULT_DATABASE_NAME);
             int createdAggregates;
             log.info("Beginning transaction for the creation of equal-name aggregates.");
-            createdAggregates = ConceptAggregateManager.buildAggregatesForEqualNames(graphDb, targetLabels, aggregatedLabels, copyProperties.toArray(String[]::new), log);
-//            log.info("Finding nodes");
-//            List<ConceptCoordinates> uniquelyNamedNodes = new ArrayList<>();
-//            try (Transaction tx = graphDb.beginTx()) {
-//                ResourceIterable<Node> nodeIterable = () -> tx.findNodes(targetLabel);
-//                for (Node n : nodeIterable) {
-//                    // omit aggregate nodes
-//                    if (n.hasLabel(AGGREGATE))
-//                        continue;
-//                    // omit nodes that are element of an equal-name aggregate
-//                    if (StreamSupport.stream(n.getRelationships(Direction.INCOMING, ConceptEdgeTypes.HAS_ELEMENT).spliterator(), false).anyMatch(r -> r.getOtherNode(n).hasLabel(AGGREGATE_EQUAL_NAMES)))
-//                        continue;
-//                    uniquelyNamedNodes.add(new ConceptCoordinates((String) n.getProperty(PROP_ORG_ID), (String) n.getProperty(PROP_ORG_SRC), CoordinateType.OSRC));
-//                }
-//
-//            }
-//            log.info("Adding label %s for all nodes that have a unique name and are not part of an equal-name aggregate.", AGGREGATE_EQUAL_NAMES);
-//            try (Transaction tx = graphDb.beginTx()) {
-//                ConceptAggregateManager.addUniqueNameLabels(tx, targetLabels, log);
-//                log.info("Finished labeling unique-named concepts with label %s.", targetLabels);
-//                log.info("Committing transaction for the creation of unique-named concepts.");
-//                tx.commit();
-//            }
+            createdAggregates = ConceptAggregateManager.buildAggregatesForEqualNames(graphDb, targetLabels, nameProperty, aggregatedLabels, copyProperties.toArray(String[]::new), log);
             log.info("Process for the creation of equal-name aggregates has finished.");
             return Response.ok(createdAggregates).build();
         } catch (IOException e) {
diff --git a/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportIntegrationTest.java b/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportIntegrationTest.java
index 1b3ac5b..dfddf4a 100644
--- a/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportIntegrationTest.java
+++ b/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportIntegrationTest.java
@@ -24,7 +24,8 @@
 import static org.neo4j.logging.FormattedLogFormat.PLAIN;
 
 public class ExportIntegrationTest {
-private static Log log;
+    private static Log log;
+
     static {
         Log4jLogProvider log4jLogProvider = new Log4jLogProvider(LogConfig.createBuilder(System.out, Level.INFO)
                 .withFormat(PLAIN)
@@ -63,8 +64,8 @@ public void exportIdMapping() throws IOException {
                     "CONCEPT1\ttid1\n",
                     "CONCEPT4\ttid4\n",
                     "CONCEPT3\ttid3\n");
-for (var item : expectedItems)
-    assertThat(mapping).contains(item);
+            for (var item : expectedItems)
+                assertThat(mapping).contains(item);
         }
     }
 }
diff --git a/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportTest.java b/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportTest.java
index 5bde5b5..dd36591 100644
--- a/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportTest.java
+++ b/julielab-neo4j-plugins-concepts/src/test/java/de/julielab/neo4j/plugins/ExportTest.java
@@ -7,6 +7,7 @@
 import de.julielab.neo4j.plugins.datarepresentation.ConceptCoordinates;
 import de.julielab.neo4j.plugins.datarepresentation.ImportConcept;
 import de.julielab.neo4j.plugins.datarepresentation.ImportConcepts;
+import de.julielab.neo4j.plugins.datarepresentation.constants.ConceptConstants;
 import de.julielab.neo4j.plugins.datarepresentation.util.ConceptsJsonSerializer;
 import de.julielab.neo4j.plugins.test.TestUtilities;
 import org.apache.commons.io.IOUtils;
@@ -25,10 +26,13 @@
 import java.io.ByteArrayOutputStream;
 import java.io.OutputStream;
 import java.lang.reflect.Method;
+import java.util.Base64;
+import java.util.zip.GZIPInputStream;
 
 import static de.julielab.neo4j.plugins.concepts.ConceptLabel.CONCEPT;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.neo4j.configuration.GraphDatabaseSettings.DEFAULT_DATABASE_NAME;
 
 public class ExportTest {
@@ -192,4 +196,91 @@ public void createIdMappingOneFacetOriginalId() throws Exception {
         assertEquals(3, countMatches);
     }
 
+    @Test
+    public void exportLingpipeDictionary() throws Exception {
+        new Indexes(graphDBMS).createIndexes((String) null);
+        ImportConcepts importConcepts = ConceptManagerTest.getTestConcepts(10);
+        ConceptManager tm = new ConceptManager(graphDBMS, LogUtilities.getLogger(ConceptManager.class));
+        tm.insertConcepts(new ByteArrayInputStream(ConceptsJsonSerializer.toJson(importConcepts).getBytes(UTF_8)));
+
+        Export export = new Export(graphDBMS);
+
+        // create mapping file contents for original Ids
+        final String gzippedBase64EncodedDictionary = export.exportLingpipeDictionary(CONCEPT.name(), null, ConceptConstants.PROP_SRC_IDS + 0, false, true, LogUtilities.getLogger(Export.class));
+        final byte[] gzippedBytes = Base64.getDecoder().decode(gzippedBase64EncodedDictionary);
+        String dictionary;
+        try (final GZIPInputStream is = new GZIPInputStream(new ByteArrayInputStream(gzippedBytes))) {
+            dictionary = IOUtils.toString(is, UTF_8);
+        }
+        assertTrue(dictionary.contains("prefname0\tCONCEPT0"));
+        assertTrue(dictionary.contains("prefname1\tCONCEPT1"));
+        assertTrue(dictionary.contains("prefname2\tCONCEPT2"));
+        assertTrue(dictionary.contains("prefname3\tCONCEPT3"));
+        assertTrue(dictionary.contains("prefname4\tCONCEPT4"));
+        assertTrue(dictionary.contains("prefname5\tCONCEPT5"));
+        assertTrue(dictionary.contains("prefname6\tCONCEPT6"));
+        assertTrue(dictionary.contains("prefname7\tCONCEPT7"));
+        assertTrue(dictionary.contains("prefname8\tCONCEPT8"));
+        assertTrue(dictionary.contains("prefname9\tCONCEPT9"));
+    }
+
+    @Test
+    public void exportLingpipeDictionary2() throws Exception {
+        new Indexes(graphDBMS).createIndexes((String) null);
+        ImportConcepts importConcepts = ConceptManagerTest.getTestConcepts(10);
+        ConceptManager tm = new ConceptManager(graphDBMS, LogUtilities.getLogger(ConceptManager.class));
+        tm.insertConcepts(new ByteArrayInputStream(ConceptsJsonSerializer.toJson(importConcepts).getBytes(UTF_8)));
+
+        Export export = new Export(graphDBMS);
+
+        // create mapping file contents for original Ids
+        final String gzippedBase64EncodedDictionary = export.exportLingpipeDictionary(CONCEPT.name(), null, ConceptConstants.PROP_SRC_IDS + 0, true, true, LogUtilities.getLogger(Export.class));
+        final byte[] gzippedBytes = Base64.getDecoder().decode(gzippedBase64EncodedDictionary);
+        String dictionary;
+        try (final GZIPInputStream is = new GZIPInputStream(new ByteArrayInputStream(gzippedBytes))) {
+            dictionary = IOUtils.toString(is, UTF_8);
+        }
+        assertTrue(dictionary.contains("prefname0\tTEST_DATA:CONCEPT0"));
+        assertTrue(dictionary.contains("prefname1\tTEST_DATA:CONCEPT1"));
+        assertTrue(dictionary.contains("prefname2\tTEST_DATA:CONCEPT2"));
+        assertTrue(dictionary.contains("prefname3\tTEST_DATA:CONCEPT3"));
+        assertTrue(dictionary.contains("prefname4\tTEST_DATA:CONCEPT4"));
+        assertTrue(dictionary.contains("prefname5\tTEST_DATA:CONCEPT5"));
+        assertTrue(dictionary.contains("prefname6\tTEST_DATA:CONCEPT6"));
+        assertTrue(dictionary.contains("prefname7\tTEST_DATA:CONCEPT7"));
+        assertTrue(dictionary.contains("prefname8\tTEST_DATA:CONCEPT8"));
+        assertTrue(dictionary.contains("prefname9\tTEST_DATA:CONCEPT9"));
+    }
+
+    @Test
+    public void exportLingpipeDictionary3() throws Exception {
+        new Indexes(graphDBMS).createIndexes((String) null);
+        ImportConcepts importConcepts = ConceptManagerTest.getTestConcepts(10);
+        for (var c : importConcepts.getConceptsAsList())
+            c.coordinates.originalSource = "ORG_SRC";
+        ConceptManager tm = new ConceptManager(graphDBMS, LogUtilities.getLogger(ConceptManager.class));
+        tm.insertConcepts(new ByteArrayInputStream(ConceptsJsonSerializer.toJson(importConcepts).getBytes(UTF_8)));
+
+        Export export = new Export(graphDBMS);
+
+        // create mapping file contents for original Ids
+        final String gzippedBase64EncodedDictionary = export.exportLingpipeDictionary(CONCEPT.name(), null, "[\""+ConceptConstants.PROP_SRC_IDS + 0 + "\",\""+ConceptConstants.PROP_ORG_ID + "\"]", true, true, LogUtilities.getLogger(Export.class));
+        final byte[] gzippedBytes = Base64.getDecoder().decode(gzippedBase64EncodedDictionary);
+        String dictionary;
+        try (final GZIPInputStream is = new GZIPInputStream(new ByteArrayInputStream(gzippedBytes))) {
+            dictionary = IOUtils.toString(is, UTF_8);
+        }
+        assertTrue(dictionary.contains("prefname5	TEST_DATA:CONCEPT5||ORG_SRC:CONCEPT5"));
+        assertTrue(dictionary.contains("prefname6	TEST_DATA:CONCEPT6||ORG_SRC:CONCEPT6"));
+        assertTrue(dictionary.contains("prefname3	TEST_DATA:CONCEPT3||ORG_SRC:CONCEPT3"));
+        assertTrue(dictionary.contains("prefname4	TEST_DATA:CONCEPT4||ORG_SRC:CONCEPT4"));
+        assertTrue(dictionary.contains("prefname9	TEST_DATA:CONCEPT9||ORG_SRC:CONCEPT9"));
+        assertTrue(dictionary.contains("prefname1	TEST_DATA:CONCEPT1||ORG_SRC:CONCEPT1"));
+        assertTrue(dictionary.contains("prefname2	TEST_DATA:CONCEPT2||ORG_SRC:CONCEPT2"));
+        assertTrue(dictionary.contains("prefname7	TEST_DATA:CONCEPT7||ORG_SRC:CONCEPT7"));
+        assertTrue(dictionary.contains("prefname8	TEST_DATA:CONCEPT8||ORG_SRC:CONCEPT8"));
+        assertTrue(dictionary.contains("prefname0	TEST_DATA:CONCEPT0||ORG_SRC:CONCEPT0"));
+
+    }
+
 }
diff --git a/julielab-neo4j-plugins-utilities/pom.xml b/julielab-neo4j-plugins-utilities/pom.xml
index 0fa73ee..961ec09 100644
--- a/julielab-neo4j-plugins-utilities/pom.xml
+++ b/julielab-neo4j-plugins-utilities/pom.xml
@@ -3,7 +3,7 @@
   <parent>
     <groupId>de.julielab</groupId>
     <artifactId>julielab-neo4j-server-plugins</artifactId>
-    <version>3.1.0</version>
+    <version>3.2.0</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
   <artifactId>julielab-neo4j-plugins-utilities</artifactId>
diff --git a/pom.xml b/pom.xml
index 938cd9a..c64b77f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,7 +7,7 @@
 		<version>2.5.0</version>
 	</parent>
 	<artifactId>julielab-neo4j-server-plugins</artifactId>
-	<version>3.1.0</version>
+	<version>3.2.0</version>
 	<name>JULIE Lab Neo4j Server Plugins</name>
 	<build>
 		<pluginManagement>