diff --git a/checkstyle.xml b/checkstyle.xml
index 5252bccc898..99185e15e97 100644
--- a/checkstyle.xml
+++ b/checkstyle.xml
@@ -98,7 +98,7 @@
         </module>
         -->
         <module name="IllegalImport">
-            <property name="illegalPkgs" value="org.apache.commons.lang, org.apache.commons.httpclient"/>
+            <property name="illegalPkgs" value="org.apache.commons.lang"/>
         </module>
         <!-- <module name="RedundantImport"/> -->
         <!-- <module name="UnusedImports">
diff --git a/doc/release-notes/7946-external-vocab-support.md b/doc/release-notes/7946-external-vocab-support.md
new file mode 100644
index 00000000000..c41f4b65220
--- /dev/null
+++ b/doc/release-notes/7946-external-vocab-support.md
@@ -0,0 +1,3 @@
+### Experimental Support for External Vocabulary Services
+
+Dataverse can now be configured to associate specific metadata fields with third-party vocabulary services to provide an easy way for users to select values from those vocabularies. The mapping involves use of external Javascripts. Two such scripts have been developed so far: one for vocabularies served via the SKOSMOS protocol (see https://skosmos.org) and one allowing people to be identified via their ORCID (see https://orcid.org). The guides contain info about the new :CVocConf setting used for configuration and additional information about this functionality. Scripts, examples, and additional documentation are available at https://github.com/gdcc/dataverse-external-vocab-support.
\ No newline at end of file
diff --git a/doc/sphinx-guides/source/admin/metadatacustomization.rst b/doc/sphinx-guides/source/admin/metadatacustomization.rst
index 7bc571c36dd..9e62b66febb 100644
--- a/doc/sphinx-guides/source/admin/metadatacustomization.rst
+++ b/doc/sphinx-guides/source/admin/metadatacustomization.rst
@@ -677,6 +677,37 @@ Great care must be taken when reloading a metadata block. Matching is done on fi
 
 The ability to reload metadata blocks means that SQL update scripts don't need to be written for these changes. See also the :doc:`/developers/sql-upgrade-scripts` section of the Developer Guide.
 
+Using External Vocabulary Services
+----------------------------------
+
+The Dataverse software has a mechanism to associate specific fields defined in metadata blocks with a vocabulary(ies) managed by external services. The mechanism relies on trusted third-party Javascripts. The mapping from field type to external vocabulary(ies) is managed via the :ref:`:CVocConf <:CVocConf>` setting.
+
+*This functionality is considered 'experimental'. It may require significant effort to configure and is likely to evolve in subsequent Dataverse software releases.*
+
+
+The effect of configuring this mechanism is similar to that of defining a field in a metadata block with 'allowControlledVocabulary=true':
+
+- Users are able to select from a controlled list of values.
+- Values can be shown in any language the term has been defined in.
+  
+In general, the external vocabulary support mechanism may be a better choice for large vocabularies, hierarchical/structured vocabularies, and/or vocabularies managed by third-parties. In addition, the external vocabulary mechanism differs from the internal controlled vocabulary mechanism in several ways that may make it a preferred option:
+
+- the machine-readable URI form of a vocabulary is stored in the Dataverse database and can be included in exported metadata files.
+- vocabulary mappings can be changed without changing the metadata block, making it possible for different Dataverse installations to use different vocabularies in the same field.
+- mappings can associate a field with more than one vocabulary.
+- mappings can be configured to also allow custom/free-text entries as well as vocabulary values.
+- mappings can be configured for compound fields and a user's selection of a given vocabulary value can be used to fill in related child fields (e.g. selection of a keyword could fill in a vocabulary name field as well).
+- removing a mapping does not affect stored values (the field would revert to allowing free text).
+ 
+The specifics of the user interface for entering/selecting a vocabulary term and how that term is then displayed are managed by third-party Javascripts. The initial Javascripts that have been created provide auto-completion, displaying a list of choices that match what the user has typed so far, but other interfaces, such as displaying a tree of options for a hierarchical vocabulary, are possible. 
+Similarly, existing scripts do relatively simple things for displaying a term - showing the term's name in the appropriate language and providing a link to an external URL with more information, but more sophisticated displays are possible.
+
+Scripts supporting use of vocabularies from services supporting the SKOMOS protocol (see https://skosmos.org) and retrieving ORCIDs (from https:/orcid.org) are available https://github.com/gdcc/dataverse-external-vocab-support. (Custom scripts can also be used and community members are encouraged to share new scripts through the dataverse-external-vocab-support repository.)
+
+Configuration involves specifying which fields are to be mapped, whether free-text entries are allowed, which vocabulary(ies) should be used, what languages those vocabulary(ies) are available in, and several service protocol and service instance specific parameters.
+These are all defined in the :ref:`:CVocConf <:CVocConf>` setting as a JSON array. Details about the required elements as well as example JSON arrays are available at https://github.com/gdcc/dataverse-external-vocab-support, along with an example metadata block that can be used for testing.
+The scripts required can be hosted locally or retrieved dynamically from https://gdcc.github.io/ (similar to how dataverse-previewers work).
+
 Tips from the Dataverse Community
 ---------------------------------
 
diff --git a/doc/sphinx-guides/source/installation/config.rst b/doc/sphinx-guides/source/installation/config.rst
index b6bb82c7565..bdc21ba29fc 100644
--- a/doc/sphinx-guides/source/installation/config.rst
+++ b/doc/sphinx-guides/source/installation/config.rst
@@ -2364,7 +2364,6 @@ Refer to "Physical Files Validation in a Dataset" API :ref:`dataset-files-valida
 
 Also refer to the "Datafile Integrity" API  :ref:`datafile-integrity`
 
-
 :SendNotificationOnDatasetCreation
 ++++++++++++++++++++++++++++++++++
 
@@ -2372,3 +2371,18 @@ A boolean setting that, if true will send an email and notification to users whe
  who have the ability/permission necessary to publish the dataset. The intent of this functionality is to simplify tracking activity and planning to follow-up contact.
   
 ``curl -X PUT -d true http://localhost:8080/api/admin/settings/:SendNotificationOnDatasetCreation``
+
+.. _:CVocConf:
+
+:CVocConf
++++++++++
+
+A JSON-structured setting that configures Dataverse to associate specific metadatablock fields with external vocabulary services and specific vocabularies/sub-vocabularies managed by that service. More information about this capability is available at :doc:`/admin/metadatacustomization`.
+
+Scripts that implement this association for specific service protocols are maintained at https://github.com/gdcc/dataverse-external-vocab-support. That repository also includes a json-schema for validating the structure required by this setting along with an example metadatablock and sample :CVocConf setting values associating entries in the example block with ORCID and SKOSMOS based services. 
+
+``wget https://gdcc.github.io/dataverse-external-vocab-support/examples/config/cvoc-conf.json``
+
+``curl -X PUT --upload-file cvoc-conf.json http://localhost:8080/api/admin/settings/:CVocConf``
+
+
diff --git a/src/main/java/edu/harvard/iq/dataverse/DatasetFieldServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/DatasetFieldServiceBean.java
index 03e677a1d74..5ccf9b458fd 100644
--- a/src/main/java/edu/harvard/iq/dataverse/DatasetFieldServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/DatasetFieldServiceBean.java
@@ -1,14 +1,52 @@
 package edu.harvard.iq.dataverse;
 
+import java.io.IOException;
+import java.io.StringReader;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.sql.Timestamp;
+import java.text.MessageFormat;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import javax.ejb.EJB;
 import javax.ejb.Stateless;
 import javax.inject.Named;
+import javax.json.Json;
+import javax.json.JsonArray;
+import javax.json.JsonException;
+import javax.json.JsonObject;
+import javax.json.JsonObjectBuilder;
+import javax.json.JsonReader;
+import javax.json.JsonString;
+import javax.json.JsonValue;
 import javax.persistence.EntityManager;
 import javax.persistence.NoResultException;
 import javax.persistence.NonUniqueResultException;
 import javax.persistence.PersistenceContext;
 import javax.persistence.TypedQuery;
 
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.commons.httpclient.HttpException;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseInterceptor;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.protocol.HttpContext;
+import org.apache.http.util.EntityUtils;
+
+import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
+
 /**
  *
  * @author xyang
@@ -19,8 +57,30 @@ public class DatasetFieldServiceBean implements java.io.Serializable {
 
     @PersistenceContext(unitName = "VDCNet-ejbPU")
     private EntityManager em;
+    
+    private static final Logger logger = Logger.getLogger(DatasetFieldServiceBean.class.getCanonicalName());
+
+    @EJB
+    SettingsServiceBean settingsService;
 
     private static final String NAME_QUERY = "SELECT dsfType from DatasetFieldType dsfType where dsfType.name= :fieldName";
+    
+    /*
+     * External vocabulary support: These fields cache information from the CVocConf
+     * setting which controls how Dataverse connects specific metadata block fields
+     * to third-party Javascripts and external vocabulary services to allow users to
+     * input values from a vocabulary(ies) those services manage.
+     */
+    
+    //Configuration json keyed by the id of the 'parent' DatasetFieldType 
+    Map <Long, JsonObject> cvocMap = null;
+    
+    //Configuration json keyed by the id of the child DatasetFieldType specified as the 'term-uri-field'
+    //Note that for primitive fields, the prent and term-uri-field are the same and these maps have the same entry
+    Map <Long, JsonObject> cvocMapByTermUri = null;
+    
+    //The hash of the existing CVocConf setting. Used to determine when the setting has changed and it needs to be re-parsed to recreate the cvocMaps
+    String oldHash = null;
 
     public List<DatasetFieldType> findAllAdvancedSearchFieldTypes() {
         return em.createQuery("select object(o) from DatasetFieldType as o where o.advancedSearchFieldType = true and o.title != '' order by o.id", DatasetFieldType.class).getResultList();
@@ -96,7 +156,6 @@ public ForeignMetadataFieldMapping findFieldMapping(String formatName, String pa
         } catch (NoResultException nre) {
             return null;
         }
-
         // TODO: cache looked up results.
     }
 
@@ -196,5 +255,438 @@ public ControlledVocabularyValue save(ControlledVocabularyValue cvv) {
     public ControlledVocabAlternate save(ControlledVocabAlternate alt) {
         return em.merge(alt);
     } 
+    
+
+    /**
+     * This method returns a Map relating DatasetFieldTypes with any external
+     * vocabulary configuration information associated with them via the CVocConf
+     * setting. THe mapping is keyed by the DatasetFieldType id for primitive fields
+     * and, for a compound field, by the id of either the 'parent' DatasetFieldType
+     * id or of the child field specified as the 'term-uri-field' (the field where
+     * the URI of the term is stored (and not one of the child fields where the term
+     * name, vocabulary URI, vocabulary Name or other managed information may go.)
+     * 
+     * The map only contains values for DatasetFieldTypes that are configured to use external vocabulary services.
+     * 
+     * @param byTermUriField - false: the id of the parent DatasetFieldType is the key, true: the 'term-uri-field' DatasetFieldType id is used as the key
+     * @return - a map of JsonObjects containing configuration information keyed by the DatasetFieldType id (Long)
+     */
+    public Map<Long, JsonObject> getCVocConf(boolean byTermUriField){
+        
+        //ToDo - change to an API call to be able to provide feedback if the json is invalid?
+        String cvocSetting = settingsService.getValueForKey(SettingsServiceBean.Key.CVocConf);
+        if (cvocSetting == null || cvocSetting.isEmpty()) {
+            oldHash=null;
+            return new HashMap<>();
+    } 
+        String newHash = DigestUtils.md5Hex(cvocSetting);
+        if(newHash.equals(oldHash)) {
+            
+            return byTermUriField ? cvocMapByTermUri : cvocMap;
+        } 
+            oldHash=newHash;
+        cvocMap=new HashMap<>();
+        cvocMapByTermUri=new HashMap<>();
+        
+        try (JsonReader jsonReader = Json.createReader(new StringReader(settingsService.getValueForKey(SettingsServiceBean.Key.CVocConf)))) {
+        JsonArray cvocConfJsonArray = jsonReader.readArray();
+            for (JsonObject jo : cvocConfJsonArray.getValuesAs(JsonObject.class)) {
+                DatasetFieldType dft = findByNameOpt(jo.getString("field-name"));
+                if (dft != null) {
+                    cvocMap.put(dft.getId(), jo);
+                } else {
+                    logger.warning("Ignoring External Vocabulary setting for non-existent field: "
+                            + jo.getString("field-name"));
+                }
+                if (jo.containsKey("term-uri-field")) {
+                    String termUriField = jo.getString("term-uri-field");
+                    if (!dft.isHasChildren()) {
+                        if (termUriField.equals(dft.getName())) {
+                            logger.fine("Found primitive field for term uri : " + dft.getName() + ": " + dft.getId());
+                            cvocMapByTermUri.put(dft.getId(), jo);
+                        }
+                    } else {
+                        DatasetFieldType childdft = findByNameOpt(jo.getString("term-uri-field"));
+                        logger.fine("Found term child field: " + childdft.getName()+ ": " + childdft.getId());
+                        cvocMapByTermUri.put(childdft.getId(), jo);
+                        if (childdft.getParentDatasetFieldType() != dft) {
+                            logger.warning("Term URI field (" + childdft.getDisplayName() + ") not a child of parent: "
+                                    + dft.getDisplayName());
+                        }
+                    }
+                    if (dft == null) {
+                        logger.warning("Ignoring External Vocabulary setting for non-existent child field: "
+                                + jo.getString("term-uri-field"));
+                    }
+
+                }if(jo.containsKey("child-fields")) {
+                    JsonArray childFields = jo.getJsonArray("child-fields");
+                    for (JsonString elm : childFields.getValuesAs(JsonString.class)) {
+                        dft = findByNameOpt(elm.getString());
+                        logger.info("Found: " + dft.getName());
+                        if (dft == null) {
+                            logger.warning("Ignoring External Vocabulary setting for non-existent child field: "
+                                    + elm.getString());
+                        }
+                    }
+                }
+            }
+            } catch(JsonException e) {
+                logger.warning("Ignoring External Vocabulary setting due to parsing error: " + e.getLocalizedMessage());
+            }
+        return byTermUriField ? cvocMapByTermUri : cvocMap;
+    }
+
+    /**
+     * Adds information about the external vocabulary term being used in this DatasetField to the ExternalVocabularyValue table if it doesn't already exist.
+     * @param df - the primitive/parent compound field containing a newly saved value
+     */
+    public void registerExternalVocabValues(DatasetField df) {
+        DatasetFieldType dft =df.getDatasetFieldType(); 
+        logger.fine("Registering for field: " + dft.getName());
+        JsonObject cvocEntry = getCVocConf(false).get(dft.getId());
+        if(dft.isPrimitive()) {
+            for(DatasetFieldValue dfv: df.getDatasetFieldValues()) {
+                registerExternalTerm(cvocEntry, dfv.getValue());
+            }
+            } else {
+                if (df.getDatasetFieldType().isCompound()) {
+                    DatasetFieldType termdft = findByNameOpt(cvocEntry.getString("term-uri-field"));
+                    for (DatasetFieldCompoundValue cv : df.getDatasetFieldCompoundValues()) {
+                        for (DatasetField cdf : cv.getChildDatasetFields()) {
+                            logger.fine("Found term uri field type id: " + cdf.getDatasetFieldType().getId());
+                            if(cdf.getDatasetFieldType().equals(termdft)) {
+                                registerExternalTerm(cvocEntry, cdf.getValue());
+                            }
+                        }
+                    }
+                }
+            }
+    }
+    
+    /**
+     * Retrieves indexable strings from a cached externalvocabularyvalue entry.
+     * 
+     * This method assumes externalvocabularyvalue entries have been filtered and
+     * the externalvocabularyvalue entry contain a single JsonObject whose values
+     * are either Strings or an array of objects with "lang" and "value" keys. The
+     * string, or the "value"s for each language are added to the set.
+     * 
+     * Any parsing error results in no entries (there can be unfiltered entries with
+     * unknown structure - getting some strings from such an entry could give fairly
+     * random info that would be bad to addd for searches, etc.)
+     * 
+     * @param termUri
+     * @return - a set of indexable strings
+     */
+    public Set<String> getStringsFor(String termUri) {
+        Set<String> strings = new HashSet<String>();
+        JsonObject jo = getExternalVocabularyValue(termUri);
+
+        if (jo != null) {
+            try {
+                for (String key : jo.keySet()) {
+                    JsonValue jv = jo.get(key);
+                    if (jv.getValueType().equals(JsonValue.ValueType.STRING)) {
+                        logger.fine("adding " + jo.getString(key) + " for " + termUri);
+                        strings.add(jo.getString(key));
+                    } else {
+                        if (jv.getValueType().equals(JsonValue.ValueType.ARRAY)) {
+                            JsonArray jarr = jv.asJsonArray();
+                            for (int i = 0; i < jarr.size(); i++) {
+                                logger.fine("adding " + jarr.getJsonObject(i).getString("value") + " for " + termUri);
+                                strings.add(jarr.getJsonObject(i).getString("value"));
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                logger.warning(
+                        "Problem interpreting external vocab value for uri: " + termUri + " : " + e.getMessage());
+                return new HashSet<String>();
+            }
+        }
+        logger.fine("Returning " + String.join(",", strings) + " for " + termUri);
+        return strings;
+    }    
+
+    /**
+     * Perform a query to retrieve a cached valie from the externalvocabularvalue table
+     * @param termUri
+     * @return - the entry's value as a JsonObject
+     */
+    public JsonObject getExternalVocabularyValue(String termUri) {
+        try {
+            ExternalVocabularyValue evv = em
+                    .createQuery("select object(o) from ExternalVocabularyValue as o where o.uri=:uri",
+                            ExternalVocabularyValue.class)
+                    .setParameter("uri", termUri).getSingleResult();
+            String valString = evv.getValue();
+            try (JsonReader jr = Json.createReader(new StringReader(valString))) {
+                return jr.readObject();
+            } catch (Exception e) {
+                logger.warning("Problem parsing external vocab value for uri: " + termUri + " : " + e.getMessage());
+            }
+        } catch (NoResultException nre) {
+            logger.warning("No external vocab value for uri: " + termUri);
+        }
+        return null;
+    }
+
+    /**
+     * Perform a call to the external service to retrieve information about the term URI
+     * @param cvocEntry - the configuration for the DatasetFieldType associated with this term 
+     * @param term - the term uri as a string
+     */
+    public void registerExternalTerm(JsonObject cvocEntry, String term) {
+        String retrievalUri = cvocEntry.getString("retrieval-uri");
+        String prefix = cvocEntry.getString("prefix", null);
+        if(term.isBlank()) {
+            logger.fine("Ingoring blank term");
+            return;
+        }
+        logger.fine("Registering term: " + term);
+        try {
+            URI uri = new URI(term);
+            ExternalVocabularyValue evv = null;
+            try {
+                evv = em.createQuery("select object(o) from ExternalVocabularyValue as o where o.uri=:uri",
+                        ExternalVocabularyValue.class).setParameter("uri", term).getSingleResult();
+            } catch (NoResultException nre) {
+                evv = new ExternalVocabularyValue(term, null);
+            }
+            if (evv.getValue() == null) {
+                String adjustedTerm = (prefix==null)? term: term.replace(prefix, "");
+                retrievalUri = retrievalUri.replace("{0}", adjustedTerm);
+                logger.fine("Didn't find " + term + ", calling " + retrievalUri);
+                try (CloseableHttpClient httpClient = HttpClients.custom()
+                        .addInterceptorLast(new HttpResponseInterceptor() {
+                            @Override
+                            public void process(HttpResponse response, HttpContext context) throws HttpException, IOException {
+                                int statusCode = response.getStatusLine().getStatusCode();
+                                if (statusCode == 504) {
+                                    //Throwing an exception triggers the retry handler
+                                    throw new IOException("Retry due to 504 response");
+                                }
+                            }
+                        })
+                        //The retry handler will also do retries for network errors/other things that cause an IOException
+                        .setRetryHandler(new DefaultHttpRequestRetryHandler(3, false))
+                        .build()) {
+                    HttpGet httpGet = new HttpGet(retrievalUri);
+                    httpGet.addHeader("Accept", "application/json+ld, application/json");
+
+                    HttpResponse response = httpClient.execute(httpGet);
+                    String data = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
+                    int statusCode = response.getStatusLine().getStatusCode();
+                    if (statusCode == 200) {
+                        logger.fine("Returned data: " + data);
+                        try (JsonReader jsonReader = Json.createReader(new StringReader(data))) {
+                            String dataObj =filterResponse(cvocEntry, jsonReader.readObject(), term).toString(); 
+                            evv.setValue(dataObj);
+                            evv.setLastUpdateDate(Timestamp.from(Instant.now()));
+                            logger.fine("JsonObject: " + dataObj);
+                            em.merge(evv);
+                            em.flush();
+                            logger.fine("Wrote value for term: " + term);
+                        } catch (JsonException je) {
+                            logger.severe("Error retrieving: " + retrievalUri + " : " + je.getMessage());
+                        }
+                    } else {
+                        logger.severe("Received response code : " + statusCode + " when retrieving " + retrievalUri
+                                + " : " + data);
+                    }
+                } catch (IOException ioe) {
+                    logger.severe("IOException when retrieving url: " + retrievalUri + " : " + ioe.getMessage());
+                }
+
+            }
+        } catch (URISyntaxException e) {
+            logger.fine("Term is not a URI: " + term);
+        }
+
+    }
 
+    /**
+     * Parse the raw value returned by an external service for a give term uri and
+     * filter it according to the 'retrieval-filtering' configuration for this
+     * DatasetFieldType, creating a Json value with the specified structure
+     * 
+     * @param cvocEntry - the config for this DatasetFieldType
+     * @param readObject - the raw response from the service
+     * @param termUri - the term uri
+     * @return - a JsonObject with the structure defined by the filtering configuration
+     */
+    private JsonObject filterResponse(JsonObject cvocEntry, JsonObject readObject, String termUri) {
+
+        JsonObjectBuilder job = Json.createObjectBuilder();
+        JsonObject filtering = cvocEntry.getJsonObject("retrieval-filtering");
+        logger.fine("RF: " + filtering.toString());
+        JsonObject managedFields = cvocEntry.getJsonObject("managed-fields");
+        logger.fine("MF: " + managedFields.toString());
+        for (String filterKey : filtering.keySet()) {
+            if (!filterKey.equals("@context")) {
+                try {
+                    JsonObject filter = filtering.getJsonObject(filterKey);
+                    logger.fine("F: " + filter.toString());
+                    JsonArray params = filter.getJsonArray("params");
+                    if (params == null) {
+                        params = Json.createArrayBuilder().build();
+                    }
+                    logger.fine("Params: " + params.toString());
+                    List<Object> vals = new ArrayList<Object>();
+                    for (int i = 0; i < params.size(); i++) {
+                        String param = params.getString(i);
+                        if (param.startsWith("/")) {
+                            // Remove leading /
+                            param = param.substring(1);
+                            String[] pathParts = param.split("/");
+                            logger.fine("PP: " + String.join(", ", pathParts));
+                            JsonValue curPath = readObject;
+                            for (int j = 0; j < pathParts.length - 1; j++) {
+                                if (pathParts[j].contains("=")) {
+                                    JsonArray arr = ((JsonArray) curPath);
+                                    for (int k = 0; k < arr.size(); k++) {
+                                        String[] keyVal = pathParts[j].split("=");
+                                        logger.fine("Looking for object where " + keyVal[0] + " is " + keyVal[1]);
+                                        JsonObject jo = arr.getJsonObject(k);
+                                        String val = jo.getString(keyVal[0]);
+                                        String expected = keyVal[1];
+                                        if (expected.equals("@id")) {
+                                            expected = termUri;
+                                        }
+                                        if (val.equals(expected)) {
+                                            logger.fine("Found: " + jo.toString());
+                                            curPath = jo;
+                                            break;
+                                        }
+                                    }
+                                } else {
+                                    curPath = ((JsonObject) curPath).get(pathParts[j]);
+                                    logger.fine("Found next Path object " + curPath.toString());
+                                }
+                            }
+                            JsonValue jv = ((JsonObject) curPath).get(pathParts[pathParts.length - 1]);
+                            if (jv.getValueType().equals(JsonValue.ValueType.STRING)) {
+                                vals.add(i, ((JsonString) jv).getString());
+                            } else if (jv.getValueType().equals(JsonValue.ValueType.ARRAY)) {
+                                vals.add(i, jv);
+                            } else if (jv.getValueType().equals(JsonValue.ValueType.OBJECT)) {
+                                vals.add(i, jv);
+                            }
+                            logger.fine("Added param value: " + i + ": " + vals.get(i));
+                        } else {
+                            logger.fine("Param is: " + param);
+                            // param is not a path - either a reference to the term URI
+                            if (param.equals("@id")) {
+                                logger.fine("Adding id param: " + termUri);
+                                vals.add(i, termUri);
+                            } else {
+                                // or a hardcoded value
+                                logger.fine("Adding hardcoded param: " + param);
+                                vals.add(i, param);
+                            }
+                        }
+                    }
+                    // Shortcut: nominally using a pattern of {0} and a param that is @id or
+                    // hardcoded value allows the same options as letting the pattern itself be @id
+                    // or a hardcoded value
+                    String pattern = filter.getString("pattern");
+                    logger.fine("Pattern: " + pattern);
+                    if (pattern.equals("@id")) {
+                        logger.fine("Added #id pattern: " + filterKey + ": " + termUri);
+                        job.add(filterKey, termUri);
+                    } else if (pattern.contains("{")) {
+                        if (pattern.equals("{0}")) {
+                            if (vals.get(0) instanceof JsonArray) {
+                                job.add(filterKey, (JsonArray) vals.get(0));
+                            } else {
+                                job.add(filterKey, (String) vals.get(0));
+                            }
+                        } else {
+                            String result = MessageFormat.format(pattern, vals.toArray());
+                            logger.fine("Result: " + result);
+                            job.add(filterKey, result);
+                            logger.fine("Added : " + filterKey + ": " + result);
+                        }
+                    } else {
+                        logger.fine("Added hardcoded pattern: " + filterKey + ": " + pattern);
+                        job.add(filterKey, pattern);
+                    }
+                } catch (Exception e) {
+                    logger.warning("External Vocabulary: " + termUri + " - Failed to find value for " + filterKey + ": "
+                            + e.getMessage());
+                }
+            }
+        }
+        JsonObject filteredResponse = job.build();
+        if(filteredResponse.isEmpty()) {
+            logger.severe("Unable to filter response for term: " + termUri + ",  received: " + readObject.toString());
+            //Better to store nothing in this case so unknown values don't propagate to exported metadata (we'll just send the termUri itself in those cases).
+            return null;
+        } else {
+            return filteredResponse;
+        }
+    }
+
+    /**
+     * Supports validation of externally controlled values. If the value is a URI it
+     * must be in the namespace (start with) one of the uriSpace values of an
+     * allowed vocabulary. If free text entries are allowed for this field (per the
+     * configuration), non-uri entries are also assumed valid.
+     * 
+     * @param dft
+     * @param value
+     * @return - true: valid
+     */
+    public boolean isValidCVocValue(DatasetFieldType dft, String value) {
+        JsonObject jo = getCVocConf(true).get(dft.getId());
+        JsonArray vocabs = jo.getJsonArray("vocabs");
+        boolean valid = false;
+        boolean couldBeFreeText = true;
+        boolean freeTextAllowed = jo.getBoolean("allow-free-text", false);
+        for (JsonObject vocab : vocabs.getValuesAs(JsonObject.class)) {
+            String baseUri = vocab.getString("uriSpace");
+            if (value.startsWith(baseUri)) {
+                valid = true;
+                break;
+            } else {
+                String protocol = baseUri.substring(baseUri.indexOf("://") + 3);
+                if (value.startsWith(protocol)) {
+                    couldBeFreeText = false;
+                    // No break because we need to check for conflicts with all vocabs
+                }
+            }
+        }
+        if (!valid) {
+            if (freeTextAllowed && couldBeFreeText) {
+                valid = true;
+            }
+        }
+        return valid;
+    }
+    
+    public List<String> getVocabScripts( Map<Long, JsonObject> cvocConf) {
+        //ToDo - only return scripts that are needed (those fields are set on display pages, those blocks/fields are allowed in the Dataverse collection for create/edit)?
+        Set<String> scripts = new HashSet<String>();
+        for(JsonObject jo: cvocConf.values()) {
+            scripts.add(jo.getString("js-url"));
+        }
+        return Arrays.asList(scripts.toArray(new String[0]));
+    }
+
+    public String getFieldLanguage(String languages, String localeCode) {
+        // If the fields list of supported languages contains the current locale (e.g.
+        // the lang of the UI, or the current metadata input/display lang (tbd)), use
+        // that. Otherwise, return the first in the list
+        String[] langStrings = languages.split("\\s*,\\s*");
+        if (langStrings.length > 0) {
+            if (Arrays.asList(langStrings).contains(localeCode)) {
+                return localeCode;
+            } else {
+                return langStrings[0];
+            }
+        }
+        return null;
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/DatasetPage.java b/src/main/java/edu/harvard/iq/dataverse/DatasetPage.java
index 7c95e94d93d..128470ddbde 100644
--- a/src/main/java/edu/harvard/iq/dataverse/DatasetPage.java
+++ b/src/main/java/edu/harvard/iq/dataverse/DatasetPage.java
@@ -61,6 +61,7 @@
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.StringReader;
 import java.sql.Timestamp;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
@@ -83,6 +84,11 @@
 import javax.faces.view.ViewScoped;
 import javax.inject.Inject;
 import javax.inject.Named;
+import javax.json.Json;
+import javax.json.JsonArray;
+import javax.json.JsonObject;
+import javax.json.JsonReader;
+import javax.json.JsonString;
 
 import org.primefaces.event.FileUploadEvent;
 import org.primefaces.model.file.UploadedFile;
@@ -316,6 +322,9 @@ public void setSelectedHostDataverse(Dataverse selectedHostDataverse) {
     private Boolean hasRsyncScript = false;
 
     private Boolean hasTabular = false;
+    
+    //External Vocabulary support
+    Map<Long, JsonObject> cachedCvocMap=null;
 
     /**
      * If the dataset version has at least one tabular file. The "hasTabular"
@@ -3443,6 +3452,12 @@ public String save() {
                 ((UpdateDatasetVersionCommand) cmd).setValidateLenient(true);
             }
             dataset = commandEngine.submit(cmd);
+            for (DatasetField df : dataset.getLatestVersion().getDatasetFields()) {
+                logger.fine("Found id: " + df.getDatasetFieldType().getId());
+                if (fieldService.getCVocConf(false).containsKey(df.getDatasetFieldType().getId())) {
+                    fieldService.registerExternalVocabValues(df);
+                }
+            }
             if (editMode == EditMode.CREATE) {
                 if (session.getUser() instanceof AuthenticatedUser) {
                     userNotificationService.sendNotification((AuthenticatedUser) session.getUser(), dataset.getCreateDate(), UserNotification.Type.CREATEDS, dataset.getLatestVersion().getId());
@@ -5515,4 +5530,20 @@ public String getLocaleDisplayName(String code) {
         }
         return displayName; 
     }
+    
+    public Map<Long, JsonObject> getCVocConf() {
+        //Cache this in the view
+        if(cachedCvocMap==null) {
+        cachedCvocMap = fieldService.getCVocConf(false);
+        }
+        return cachedCvocMap;
+    }
+    
+    public List<String> getVocabScripts() {
+        return fieldService.getVocabScripts(getCVocConf());
+    }
+
+    public String getFieldLanguage(String languages) {
+        return fieldService.getFieldLanguage(languages,session.getLocaleCode());
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/ExternalVocabularyValue.java b/src/main/java/edu/harvard/iq/dataverse/ExternalVocabularyValue.java
new file mode 100644
index 00000000000..3618da79630
--- /dev/null
+++ b/src/main/java/edu/harvard/iq/dataverse/ExternalVocabularyValue.java
@@ -0,0 +1,93 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package edu.harvard.iq.dataverse;
+
+import java.io.Serializable;
+import java.sql.Timestamp;
+import java.util.Objects;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Index;
+import javax.persistence.Table;
+
+/**
+ *
+ * @author qqmyers
+ */
+@Entity
+@Table(indexes = { @Index(columnList = "uri")})
+public class ExternalVocabularyValue implements Serializable {
+
+    public ExternalVocabularyValue() {
+    }
+
+    public ExternalVocabularyValue(String uri, String value) {
+        this.uri = uri;
+        this.value = value;
+    }
+
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    
+    @Column(columnDefinition = "TEXT", unique=true, nullable = false)
+    private String uri;
+
+    public String getUri() {
+        return uri;
+    }
+
+    public void setUri(String uri) {
+        this.uri = uri;
+    }
+
+    @Column(columnDefinition = "TEXT", nullable = true)
+    private String value;
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    private Timestamp lastUpdateDate;
+
+    public Timestamp getLastUpdateDate() {
+        return lastUpdateDate;
+    }
+
+    public void setLastUpdateDate(Timestamp lastUpdateDate) {
+        this.lastUpdateDate = lastUpdateDate;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 0;
+        hash += (this.uri != null ? this.uri.hashCode() : 0);
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (!(object instanceof ExternalVocabularyValue)) {
+            return false;
+        }
+        ExternalVocabularyValue other = (ExternalVocabularyValue) object;
+        return Objects.equals(getUri(), other.getUri());
+    }
+
+    @Override
+    public String toString() {
+        return "edu.harvard.iq.dataverse.ExternalVocabularyValue[ uri=" + uri + " ]";
+    }
+}
diff --git a/src/main/java/edu/harvard/iq/dataverse/export/ExportService.java b/src/main/java/edu/harvard/iq/dataverse/export/ExportService.java
index 52de3cf1d78..0e6b1d2b1b3 100644
--- a/src/main/java/edu/harvard/iq/dataverse/export/ExportService.java
+++ b/src/main/java/edu/harvard/iq/dataverse/export/ExportService.java
@@ -154,6 +154,9 @@ public void exportAllFormats(Dataset dataset) throws ExportException {
             }
         } catch (ServiceConfigurationError serviceError) {
             throw new ExportException("Service configuration error during export. " + serviceError.getMessage());
+        } catch (Exception e) {
+            e.printStackTrace();
+            logger.warning(e.getMessage());
         }
         // Finally, if we have been able to successfully export in all available 
         // formats, we'll increment the "last exported" time stamp: 
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/AdvancedSearchPage.java b/src/main/java/edu/harvard/iq/dataverse/search/AdvancedSearchPage.java
index 55516d68880..a7a89def449 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/AdvancedSearchPage.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/AdvancedSearchPage.java
@@ -6,6 +6,7 @@
 import edu.harvard.iq.dataverse.DatasetFieldType;
 import edu.harvard.iq.dataverse.Dataverse;
 import edu.harvard.iq.dataverse.DataverseServiceBean;
+import edu.harvard.iq.dataverse.DataverseSession;
 import edu.harvard.iq.dataverse.MetadataBlock;
 import edu.harvard.iq.dataverse.WidgetWrapper;
 import static edu.harvard.iq.dataverse.search.SearchUtil.constructQuery;
@@ -13,16 +14,21 @@
 import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.StringTokenizer;
 import java.util.logging.Logger;
 import javax.ejb.EJB;
 import javax.faces.view.ViewScoped;
 import javax.inject.Inject;
 import javax.inject.Named;
+import javax.json.JsonObject;
+
 import org.apache.commons.lang3.StringUtils;
 
 @ViewScoped
@@ -38,6 +44,7 @@ public class AdvancedSearchPage implements java.io.Serializable {
     DatasetFieldServiceBean datasetFieldService;
     
     @Inject WidgetWrapper widgetWrapper;
+    @Inject DataverseSession session;
 
     private Dataverse dataverse;
     private String dataverseIdentifier;
@@ -59,6 +66,8 @@ public class AdvancedSearchPage implements java.io.Serializable {
     private String fileFieldVariableLabel;
     private String fileFieldFileTags;
 
+    Map<Long, JsonObject> cachedCvocMap=null;
+    
     public void init() {
 
         if (dataverseIdentifier != null) {
@@ -331,5 +340,23 @@ public String getFileFieldFileTags() {
     public void setFileFieldFileTags(String fileFieldFileTags) {
         this.fileFieldFileTags = fileFieldFileTags;
     }
+    
+    
+    //External Vocabulary Support
+
+    public Map<Long, JsonObject> getCVocConf() {
+        //Cache this in the view
+        if(cachedCvocMap==null) {
+        cachedCvocMap = datasetFieldService.getCVocConf(true);
+        }
+        return cachedCvocMap;
+    }
+    
+    public List<String> getVocabScripts() {
+        return datasetFieldService.getVocabScripts(getCVocConf());
+    }
 
+    public String getFieldLanguage(String languages) {
+        return datasetFieldService.getFieldLanguage(languages,session.getLocaleCode());
+    }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/FacetCategory.java b/src/main/java/edu/harvard/iq/dataverse/search/FacetCategory.java
index dc9307c463d..58a48d5bf8f 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/FacetCategory.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/FacetCategory.java
@@ -7,6 +7,7 @@ public class FacetCategory {
     private String name;
     private List<FacetLabel> facetLabel;
     private String friendlyName;
+    private Long datasetFieldTypeId;
 
     public String getName() {
         return name;
@@ -32,4 +33,12 @@ public void setFriendlyName(String friendlyName) {
         this.friendlyName = friendlyName;
     }
 
+    public Long getDatasetFieldTypeId() {
+        return datasetFieldTypeId;
+    }
+
+    public void setDatasetFieldTypeId(Long datasetFieldId) {
+        this.datasetFieldTypeId = datasetFieldId;
+    }
+
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java
index d72e2a7f642..7fbb953299e 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/IndexServiceBean.java
@@ -6,6 +6,7 @@
 import edu.harvard.iq.dataverse.Dataset;
 import edu.harvard.iq.dataverse.DatasetField;
 import edu.harvard.iq.dataverse.DatasetFieldConstant;
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.DatasetFieldType;
 import edu.harvard.iq.dataverse.DatasetLinkingServiceBean;
 import edu.harvard.iq.dataverse.DatasetServiceBean;
@@ -59,6 +60,7 @@
 import javax.ejb.TransactionAttribute;
 import static javax.ejb.TransactionAttributeType.REQUIRES_NEW;
 import javax.inject.Named;
+import javax.json.JsonObject;
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import org.apache.commons.lang3.StringUtils;
@@ -121,6 +123,9 @@ public class IndexServiceBean {
     
     @EJB
     IndexBatchServiceBean indexBatchService;
+    
+    @EJB
+    DatasetFieldServiceBean datasetFieldService;
 
     public static final String solrDocIdentifierDataverse = "dataverse_";
     public static final String solrDocIdentifierFile = "datafile_";
@@ -781,6 +786,7 @@ private String addOrUpdateDataset(IndexableDataset indexableDataset, Set<Long> d
                 solrInputDocument.addField(SearchFields.PUBLICATION_STATUS, IN_REVIEW_STRING);
             }
 
+            Map<Long, JsonObject> cvocMap = datasetFieldService.getCVocConf(false);
             for (DatasetField dsf : datasetVersion.getFlatDatasetFields()) {
 
                 DatasetFieldType dsfType = dsf.getDatasetFieldType();
@@ -849,6 +855,19 @@ private String addOrUpdateDataset(IndexableDataset indexableDataset, Set<Long> d
                             }
                             solrInputDocument.addField(SearchFields.NAME_SORT, dsf.getValues());
                         }
+                        
+                        if(cvocMap.containsKey(dsfType.getId())) {
+                            List<String> vals = dsf.getValues_nondisplay();
+                            Set<String> searchStrings = new HashSet<String>();
+                            for (String val: vals) {
+                                searchStrings.add(val);
+                                searchStrings.addAll(datasetFieldService.getStringsFor(val));
+                            }
+                            solrInputDocument.addField(solrFieldSearchable, searchStrings);
+                            if (dsfType.getSolrField().isFacetable()) {
+                                solrInputDocument.addField(solrFieldFacetable, vals);
+                            }
+                        }
                         if (dsfType.isControlledVocabulary()) {
                             for (ControlledVocabularyValue controlledVocabularyValue : dsf.getControlledVocabularyValues()) {
                                 if (controlledVocabularyValue.getStrValue().equals(DatasetField.NA_VALUE)) {
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/SearchIncludeFragment.java b/src/main/java/edu/harvard/iq/dataverse/search/SearchIncludeFragment.java
index cc97f8e2866..df17d4a5a86 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/SearchIncludeFragment.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/SearchIncludeFragment.java
@@ -4,6 +4,7 @@
 import edu.harvard.iq.dataverse.DataFileServiceBean;
 import edu.harvard.iq.dataverse.DataTable;
 import edu.harvard.iq.dataverse.Dataset;
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.DatasetFieldType;
 import edu.harvard.iq.dataverse.DatasetFieldType.FieldType;
 import edu.harvard.iq.dataverse.DatasetServiceBean;
@@ -76,6 +77,8 @@ public class SearchIncludeFragment implements java.io.Serializable {
     DataversePage dataversePage;
     @EJB
     SystemConfig systemConfig;
+    @EJB
+    DatasetFieldServiceBean datasetFieldService;
 
     private String browseModeString = "browse";
     private String searchModeString = "search";
@@ -1100,13 +1103,11 @@ public String getTypeFromFilterQuery(String filterQuery) {
             return null;
         }
 
-        String[] parts = filterQuery.split(":");
-
-        if (parts.length != 2) {
-            //Filter query must has 2 parts delimited by a :
+        if(!filterQuery.contains(":")) {
+            //Filter query must be delimited by a :
             return null;
         } else {
-            return parts[0];
+            return filterQuery.substring(0,filterQuery.indexOf(":"));
         }
     }
     
@@ -1119,13 +1120,13 @@ public List<String> getFriendlyNamesFromFilterQuery(String filterQuery) {
             return null;
         }
         
-        String[] parts = filterQuery.split(":");
-        if (parts.length != 2){
-            //logger.log(Level.INFO, "String array has {0} part(s).  Should have 2: {1}", new Object[]{parts.length, filterQuery});
+        if(!filterQuery.contains(":")) {
             return null;
         }
-        String key = parts[0];
-        String value = parts[1];
+        
+        int index = filterQuery.indexOf(":");
+        String key = filterQuery.substring(0,index);
+        String value = filterQuery.substring(index+1);
 
         List<String> friendlyNames = new ArrayList<>();
 
@@ -1157,6 +1158,15 @@ public List<String> getFriendlyNamesFromFilterQuery(String filterQuery) {
         return friendlyNames;
     }
     
+    public Long getFieldTypeId(String friendlyName) {
+        List<DatasetFieldType> types = datasetFieldService.findAllFacetableFieldTypes();
+        for (DatasetFieldType type : types) {
+            if (datasetfieldFriendlyNamesBySolrField.get(type.getSolrField().getNameFacetable()).equals(friendlyName)) {
+                return type.getId();
+            }
+        }
+        return null;
+    }
 
     public String getNewSelectedTypes(String typeClicked) {
         List<String> newTypesSelected = new ArrayList<>();
diff --git a/src/main/java/edu/harvard/iq/dataverse/search/SearchServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/search/SearchServiceBean.java
index 8969d7523cd..66de72d798d 100644
--- a/src/main/java/edu/harvard/iq/dataverse/search/SearchServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/search/SearchServiceBean.java
@@ -605,6 +605,7 @@ public SolrQueryResponse search(DataverseRequest dataverseRequest, List<Datavers
                 if (solrFieldNameForDataset != null && facetField.getName().equals(solrFieldNameForDataset)) {
                     metadataBlockName = datasetField.getMetadataBlock().getName() ;
                     datasetFieldName = datasetField.getName();
+                    facetCategory.setDatasetFieldTypeId(datasetField.getId());
                     break;
                 }
             }
diff --git a/src/main/java/edu/harvard/iq/dataverse/settings/SettingsServiceBean.java b/src/main/java/edu/harvard/iq/dataverse/settings/SettingsServiceBean.java
index e7c9f372616..f90ed7ac128 100644
--- a/src/main/java/edu/harvard/iq/dataverse/settings/SettingsServiceBean.java
+++ b/src/main/java/edu/harvard/iq/dataverse/settings/SettingsServiceBean.java
@@ -1,18 +1,10 @@
 package edu.harvard.iq.dataverse.settings;
 
-import edu.harvard.iq.dataverse.Dataset;
 import edu.harvard.iq.dataverse.actionlogging.ActionLogRecord;
 import edu.harvard.iq.dataverse.actionlogging.ActionLogServiceBean;
 import edu.harvard.iq.dataverse.api.ApiBlockingFilter;
-import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.util.StringUtil;
 
-import java.io.StringReader;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 import javax.ejb.EJB;
 import javax.ejb.Stateless;
 import javax.inject.Named;
@@ -20,6 +12,12 @@
 import javax.json.JsonObject;
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
+import java.io.StringReader;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * Service bean accessing a persistent hash map, used as settings in the application.
@@ -192,12 +190,14 @@ public enum Key {
         /** Optionally override http://guides.dataverse.org . */
         GuidesBaseUrl,
 
+        CVocConf,
+
         /**
          * A link to an installation of https://github.com/IQSS/miniverse or
          * some other metrics app.
          */
         MetricsUrl,
-        
+
         /**
          * Number of minutes before a metrics query can be rerun. Otherwise a cached value is returned.
          * Previous month dates always return cache. Only applies to new internal caching system (not miniverse).
@@ -498,7 +498,7 @@ public String get( String name ) {
     }
     
     /**
-     * Same as {@link #get(java.lang.String)}, but with static checking.
+     * Same as {@link #get(String)}, but with static checking.
      * @param key Enum value of the name.
      * @return The setting, or {@code null}.
      */
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/DatasetFieldWalker.java b/src/main/java/edu/harvard/iq/dataverse/util/DatasetFieldWalker.java
index 4c6434b83a5..df97998d9e8 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/DatasetFieldWalker.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/DatasetFieldWalker.java
@@ -3,6 +3,7 @@
 import edu.harvard.iq.dataverse.ControlledVocabularyValue;
 import edu.harvard.iq.dataverse.DatasetField;
 import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.DatasetFieldType;
 import edu.harvard.iq.dataverse.DatasetFieldValue;
 import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
@@ -10,10 +11,14 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.logging.Logger;
 
+import javax.json.Json;
+import javax.json.JsonObject;
+
 /**
  * A means of iterating over {@link DatasetField}s, or a collection of them.
  * As these may have a complex structure (compound values, etc), this object 
@@ -28,9 +33,11 @@ public class DatasetFieldWalker {
 
     public interface Listener {
         void startField( DatasetField f );
+        void addExpandedValuesArray( DatasetField f );
         void endField( DatasetField f );
+        void externalVocabularyValue( DatasetFieldValue dsfv, JsonObject cvocEntry );
         void primitiveValue( DatasetFieldValue dsfv );
-        void controledVocabularyValue( ControlledVocabularyValue cvv );
+        void controlledVocabularyValue( ControlledVocabularyValue cvv );
         void startCompoundValue( DatasetFieldCompoundValue dsfcv );
         void endCompoundValue( DatasetFieldCompoundValue dsfcv );
     }
@@ -40,8 +47,8 @@ public interface Listener {
      * @param dsf the field to walk over.
      * @param l the listener to execute on {@code dsf}'s values and structure.
      */
-    public static void walk( DatasetField dsf, Listener l ) {
-        DatasetFieldWalker joe = new DatasetFieldWalker(l);
+    public static void walk( DatasetField dsf, Listener l, Map<Long, JsonObject> cvocMap ) {
+        DatasetFieldWalker joe = new DatasetFieldWalker(l, cvocMap);
         SettingsServiceBean nullServiceBean = null;
         joe.walk(dsf, nullServiceBean);
     }
@@ -53,32 +60,34 @@ public static void walk( DatasetField dsf, Listener l ) {
      * @param exclude the fields to skip
      * @param l the listener to execute on each field values and structure.
      */
-    public static void walk(List<DatasetField> fields, SettingsServiceBean settingsService, Listener l) {
-        DatasetFieldWalker joe = new DatasetFieldWalker(l);
+    public static void walk(List<DatasetField> fields, SettingsServiceBean settingsService, Map<Long, JsonObject> cvocMap, Listener l) {
+        DatasetFieldWalker joe = new DatasetFieldWalker(l, cvocMap);
         for ( DatasetField dsf : sort( fields, DatasetField.DisplayOrder) ) {
             joe.walk(dsf, settingsService);
         }
     }
     
     private Listener l;
+    private Map<Long, JsonObject> cvocMap;
     
     
-    public DatasetFieldWalker(Listener l) {
+    public DatasetFieldWalker(Listener l, Map<Long, JsonObject> cvocMap) {
         this.l = l;
+        this.cvocMap = cvocMap;
     }
     
     public DatasetFieldWalker(){
-        this( null );
+        this( null, null);
     }
     
     public void walk(DatasetField fld, SettingsServiceBean settingsService) {
         l.startField(fld);
         DatasetFieldType datasetFieldType = fld.getDatasetFieldType();
-
+        
         if ( datasetFieldType.isControlledVocabulary() ) {
             for ( ControlledVocabularyValue cvv 
                     : sort(fld.getControlledVocabularyValues(), ControlledVocabularyValue.DisplayOrder) ) {
-                l.controledVocabularyValue(cvv);
+                l.controlledVocabularyValue(cvv);
             }
             
         } else if ( datasetFieldType.isPrimitive() ) {
@@ -98,6 +107,16 @@ public void walk(DatasetField fld, SettingsServiceBean settingsService) {
                l.endCompoundValue(dsfcv);
            }
         }
+        l.addExpandedValuesArray(fld); 
+        if(datasetFieldType.isPrimitive() && cvocMap.containsKey(datasetFieldType.getId())) {
+            for ( DatasetFieldValue evv : sort(fld.getDatasetFieldValues(), DatasetFieldValue.DisplayOrder) ) {
+                if (settingsService != null && settingsService.isTrueForKey(SettingsServiceBean.Key.ExcludeEmailFromExport, false) && DatasetFieldType.FieldType.EMAIL.equals(evv.getDatasetField().getDatasetFieldType().getFieldType())) {
+                    continue;
+                }
+                l.externalVocabularyValue(evv, cvocMap.get(datasetFieldType.getId()));
+            }
+            
+        }
         l.endField(fld);
     }
     
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMap.java b/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMap.java
index b0abc3ce9a5..0b7befe0f94 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMap.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMap.java
@@ -5,6 +5,7 @@
 import edu.harvard.iq.dataverse.DatasetField;
 import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
 import edu.harvard.iq.dataverse.DatasetFieldConstant;
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.DatasetFieldType;
 import edu.harvard.iq.dataverse.DatasetVersion;
 import edu.harvard.iq.dataverse.FileMetadata;
@@ -23,6 +24,8 @@
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.Map.Entry;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 import javax.json.Json;
 import javax.json.JsonArray;
@@ -31,9 +34,14 @@
 import javax.json.JsonObjectBuilder;
 import javax.json.JsonValue;
 
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.apache.log4j.lf5.LogLevel;
+
 public class OREMap {
 
     static SettingsServiceBean settingsService;
+    static DatasetFieldServiceBean datasetFieldService;
+    private static final Logger logger = Logger.getLogger(OREMap.class.getCanonicalName());
     
     public static final String NAME = "OREMap";
     private Map<String, String> localContext = new TreeMap<String, String>();
@@ -84,6 +92,7 @@ public JsonObjectBuilder getOREMapBuilder(boolean aggregationOnly) throws Except
         JsonObjectBuilder aggBuilder = Json.createObjectBuilder();
         List<DatasetField> fields = version.getDatasetFields();
         // That has it's own metadata
+        Map<Long, JsonObject> cvocMap = datasetFieldService.getCVocConf(false);
         for (DatasetField field : fields) {
             if (!field.isEmpty()) {
                 DatasetFieldType dfType = field.getDatasetFieldType();
@@ -99,7 +108,27 @@ public JsonObjectBuilder getOREMapBuilder(boolean aggregationOnly) throws Except
                 JsonArrayBuilder vals = Json.createArrayBuilder();
                 if (!dfType.isCompound()) {
                     for (String val : field.getValues_nondisplay()) {
-                        vals.add(val);
+                        if (cvocMap.containsKey(dfType.getId())) {
+                            try {
+                            JsonObject cvocEntry = cvocMap.get(dfType.getId());
+                            if (cvocEntry.containsKey("retrieval-filtering")) {
+                                JsonObject filtering = cvocEntry.getJsonObject("retrieval-filtering");
+                                JsonObject context = filtering.getJsonObject("@context");
+                                for (String prefix : context.keySet()) {
+                                    localContext.putIfAbsent(prefix, context.getString(prefix));
+                                }
+                                vals.add(datasetFieldService.getExternalVocabularyValue(val));
+                            } else {
+                                vals.add(val);
+                            }
+                            } catch(Exception e) {
+                                logger.warning("Couldn't interpret value for : " + val + " : " + e.getMessage());
+                                logger.log(Level.FINE, ExceptionUtils.getStackTrace(e));
+                                vals.add(val);
+                            }
+                        } else {
+                            vals.add(val);
+                        }
                     }
                 } else {
                     // ToDo: Needs to be recursive (as in JsonPrinter?)
@@ -404,7 +433,8 @@ private JsonLDTerm getTermFor(String type, String subType) {
         return null;
     }
 
-    public static void injectSettingsService(SettingsServiceBean settingsSvc) {
+    public static void injectSettingsService(SettingsServiceBean settingsSvc, DatasetFieldServiceBean datasetFieldSvc) {
         settingsService = settingsSvc;
+        datasetFieldService = datasetFieldSvc;
     }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMapHelper.java b/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMapHelper.java
index bced52a7752..6cd7f0928dc 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMapHelper.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/bagit/OREMapHelper.java
@@ -1,5 +1,6 @@
 package edu.harvard.iq.dataverse.util.bagit;
 
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
 
 import javax.annotation.PostConstruct;
@@ -18,8 +19,11 @@ public class OREMapHelper {
     @EJB
     SettingsServiceBean settingsSvc;
     
+    @EJB
+    DatasetFieldServiceBean datasetFieldSvc;
+    
     @PostConstruct
     public void injectService() {
-        OREMap.injectSettingsService(settingsSvc);
+        OREMap.injectSettingsService(settingsSvc, datasetFieldSvc);
     }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JSONLDUtil.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JSONLDUtil.java
index 1e868fa0fc7..ca128dd5c69 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JSONLDUtil.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JSONLDUtil.java
@@ -168,7 +168,6 @@ public static DatasetVersion updateDatasetVersionMDFromJsonLD(DatasetVersion dsv
                         dsf.setDatasetFieldType(dsft);
                     }
 
-                    // Todo - normalize object vs. array
                     JsonArray valArray = getValues(jsonld.get(key), dsft.isAllowMultiples(), dsft.getName());
 
                     addField(dsf, valArray, dsft, datasetFieldSvc, append);
@@ -363,6 +362,8 @@ private static void addField(DatasetField dsf, JsonArray valArray, DatasetFieldT
         logger.fine("Compound: " + dsft.isCompound());
         logger.fine("CV: " + dsft.isAllowControlledVocabulary());
 
+        Map<Long, JsonObject> cvocMap = datasetFieldSvc.getCVocConf(true);
+        
         if (dsft.isCompound()) {
             /*
              * List<DatasetFieldCompoundValue> vals = parseCompoundValue(type,
@@ -428,7 +429,7 @@ private static void addField(DatasetField dsf, JsonArray valArray, DatasetFieldT
                 }
                 // Only add value to the list if it is not a duplicate
                 if (strValue.equals("Other")) {
-                    System.out.println("vals = " + vals + ", contains: " + vals.contains(cvv));
+                    logger.fine("vals = " + vals + ", contains: " + vals.contains(cvv));
                 }
                 if (!vals.contains(cvv)) {
                     if (vals.size() > 0) {
@@ -441,10 +442,21 @@ private static void addField(DatasetField dsf, JsonArray valArray, DatasetFieldT
             dsf.setControlledVocabularyValues(vals);
 
         } else {
+
+            boolean extVocab=false;
+            if(cvocMap.containsKey(dsft.getId())) {
+                extVocab=true;
+            }
             List<DatasetFieldValue> vals = dsf.getDatasetFieldValues();
 
             for (JsonString strVal : valArray.getValuesAs(JsonString.class)) {
                 String strValue = strVal.getString();
+                if(extVocab) {
+                    if(!datasetFieldSvc.isValidCVocValue(dsft, strValue)) {
+                        throw new BadRequestException("Invalid values submitted for " + dsft.getName() + " which is limited to specific vocabularies.");
+                    }
+                    datasetFieldSvc.registerExternalTerm(cvocMap.get(dsft.getId()), strValue);
+                }
                 DatasetFieldValue datasetFieldValue = new DatasetFieldValue();
 
                 datasetFieldValue.setDisplayOrder(vals.size());
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
index a902d93daca..6d5ebdb1d1a 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonParser.java
@@ -587,6 +587,7 @@ public DatasetField parseField(JsonObject json, Boolean testType) throws JsonPar
             throw new JsonParseException("incorrect  typeClass for field " + json.getString("typeName", "") + ", should be controlledVocabulary");
         }
        
+        
         ret.setDatasetFieldType(type);
                
         if (type.isCompound()) {
@@ -605,6 +606,7 @@ public DatasetField parseField(JsonObject json, Boolean testType) throws JsonPar
 
         } else {
             // primitive
+            
                 List<DatasetFieldValue> values = parsePrimitiveValue(type, json);
                 for (DatasetFieldValue val : values) {
                     val.setDatasetField(ret);
@@ -691,6 +693,13 @@ public List<DatasetFieldCompoundValue> parseCompoundValue(DatasetFieldType compo
 
     public List<DatasetFieldValue> parsePrimitiveValue(DatasetFieldType dft , JsonObject json) throws JsonParseException {
 
+        Map<Long, JsonObject> cvocMap = datasetFieldSvc.getCVocConf(true);
+        boolean extVocab=false;
+        if(cvocMap.containsKey(dft.getId())) {
+            extVocab=true;
+        }
+
+        
         List<DatasetFieldValue> vals = new LinkedList<>();
         if (dft.isAllowMultiples()) {
            try {
@@ -702,6 +711,12 @@ public List<DatasetFieldValue> parsePrimitiveValue(DatasetFieldType dft , JsonOb
                 DatasetFieldValue datasetFieldValue = new DatasetFieldValue();
                 datasetFieldValue.setDisplayOrder(vals.size() - 1);
                 datasetFieldValue.setValue(val.getString().trim());
+                if(extVocab) {
+                    if(!datasetFieldSvc.isValidCVocValue(dft, datasetFieldValue.getValue())) {
+                        throw new JsonParseException("Invalid values submitted for " + dft.getName() + " which is limited to specific vocabularies.");
+                    }
+                    datasetFieldSvc.registerExternalTerm(cvocMap.get(dft.getId()), datasetFieldValue.getValue());
+                }
                 vals.add(datasetFieldValue);
             }
 
@@ -712,6 +727,12 @@ public List<DatasetFieldValue> parsePrimitiveValue(DatasetFieldType dft , JsonOb
             }            
             DatasetFieldValue datasetFieldValue = new DatasetFieldValue();
             datasetFieldValue.setValue(json.getString("value", "").trim());
+            if(extVocab) {
+                if(!datasetFieldSvc.isValidCVocValue(dft, datasetFieldValue.getValue())) {
+                    throw new JsonParseException("Invalid values submitted for " + dft.getName() + " which is limited to specific vocabularies.");
+                }
+                datasetFieldSvc.registerExternalTerm(cvocMap.get(dft.getId()), datasetFieldValue.getValue());
+            }
             vals.add(datasetFieldValue);
         }
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
index 90f79b7f33e..d2846b455d1 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
@@ -9,6 +9,7 @@
 import edu.harvard.iq.dataverse.DatasetFieldType;
 import edu.harvard.iq.dataverse.DatasetField;
 import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.DatasetFieldValue;
 import edu.harvard.iq.dataverse.DatasetLock;
 import edu.harvard.iq.dataverse.DatasetVersion;
@@ -76,8 +77,12 @@ public class JsonPrinter {
     @EJB
     static SettingsServiceBean settingsService;
 
-    public static void injectSettingsService(SettingsServiceBean ssb) {
+    @EJB
+    static DatasetFieldServiceBean datasetFieldService;
+    
+    public static void injectSettingsService(SettingsServiceBean ssb, DatasetFieldServiceBean dfsb) {
             settingsService = ssb;
+            datasetFieldService = dfsb;
     }
 
     public JsonPrinter() {
@@ -481,8 +486,8 @@ public static JsonObjectBuilder json(MetadataBlock block, List<DatasetField> fie
         blockBld.add("name", block.getName());
         
         final JsonArrayBuilder fieldsArray = Json.createArrayBuilder();
-
-        DatasetFieldWalker.walk(fields, settingsService, new DatasetFieldsToJson(fieldsArray));
+        Map<Long, JsonObject> cvocMap = (datasetFieldService==null) ? new HashMap<Long, JsonObject>() :datasetFieldService.getCVocConf(false); 
+        DatasetFieldWalker.walk(fields, settingsService, cvocMap, new DatasetFieldsToJson(fieldsArray));
 
         blockBld.add("fields", fieldsArray);
         return blockBld;
@@ -503,7 +508,8 @@ public static JsonObject json(DatasetField dfv) {
             return null;
         } else {
             JsonArrayBuilder fieldArray = Json.createArrayBuilder();
-            DatasetFieldWalker.walk(dfv, new DatasetFieldsToJson(fieldArray));
+            Map<Long, JsonObject> cvocMap = (datasetFieldService==null) ? new HashMap<Long, JsonObject>() :datasetFieldService.getCVocConf(false);
+            DatasetFieldWalker.walk(dfv, new DatasetFieldsToJson(fieldArray), cvocMap);
             JsonArray out = fieldArray.build();
             return out.getJsonObject(0);
         }
@@ -693,19 +699,44 @@ public void startField(DatasetField f) {
             objectStack.peek().add("multiple", typ.isAllowMultiples());
             objectStack.peek().add("typeClass", typeClassString(typ));
         }
+        
+        @Override
+        public void addExpandedValuesArray(DatasetField f) {
+            // Invariant: all values are multiple. Diffrentiation between multiple and single is done at endField.
+            valueArrStack.push(Json.createArrayBuilder());
+        }
 
         @Override
         public void endField(DatasetField f) {
             JsonObjectBuilder jsonField = objectStack.pop();
+            JsonArray expandedValues = valueArrStack.pop().build();
             JsonArray jsonValues = valueArrStack.pop().build();
             if (!jsonValues.isEmpty()) {
                 jsonField.add("value",
                         f.getDatasetFieldType().isAllowMultiples() ? jsonValues
                                 : jsonValues.get(0));
+                if (!expandedValues.isEmpty()) {
+                    jsonField.add("expandedvalue",
+                            f.getDatasetFieldType().isAllowMultiples() ? expandedValues
+                                    : expandedValues.get(0));
+                }
+                
                 valueArrStack.peek().add(jsonField);
             }
         }
 
+        @Override
+        public void externalVocabularyValue(DatasetFieldValue dsfv, JsonObject cvocEntry) {
+            if (dsfv.getValue() != null) {
+                if (cvocEntry.containsKey("retrieval-filtering")) {
+                    JsonObject value = datasetFieldService.getExternalVocabularyValue(dsfv.getValue());
+                    if (value!=null) {
+                        valueArrStack.peek().add(value);
+                    }
+                }
+            }
+        }
+        
         @Override
         public void primitiveValue(DatasetFieldValue dsfv) {
             if (dsfv.getValue() != null) {
@@ -714,7 +745,7 @@ public void primitiveValue(DatasetFieldValue dsfv) {
         }
 
         @Override
-        public void controledVocabularyValue(ControlledVocabularyValue cvv) {
+        public void controlledVocabularyValue(ControlledVocabularyValue cvv) {
             valueArrStack.peek().add(cvv.getStrValue());
         }
 
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinterHelper.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinterHelper.java
index 62f3569bb8d..1c7dce24680 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinterHelper.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinterHelper.java
@@ -1,5 +1,6 @@
 package edu.harvard.iq.dataverse.util.json;
 
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
 
 import javax.annotation.PostConstruct;
@@ -18,8 +19,11 @@ public class JsonPrinterHelper {
     @EJB
     SettingsServiceBean settingsSvc;
     
+    @EJB
+    DatasetFieldServiceBean datasetFieldSvc;
+    
     @PostConstruct
     public void injectService() {
-        JsonPrinter.injectSettingsService(settingsSvc);
+        JsonPrinter.injectSettingsService(settingsSvc, datasetFieldSvc);
     }
 }
diff --git a/src/main/webapp/datasetFieldForEditFragment.xhtml b/src/main/webapp/datasetFieldForEditFragment.xhtml
index 271904e6a31..26fb70342d9 100644
--- a/src/main/webapp/datasetFieldForEditFragment.xhtml
+++ b/src/main/webapp/datasetFieldForEditFragment.xhtml
@@ -1,17 +1,17 @@
 <ui:composition
-    xmlns:h="http://java.sun.com/jsf/html"
-    xmlns:f="http://java.sun.com/jsf/core"
-    xmlns:ui="http://java.sun.com/jsf/facelets"
-    xmlns:c="http://java.sun.com/jsp/jstl/core"
-    xmlns:p="http://primefaces.org/ui"
-    xmlns:pt="http://java.sun.com/jsf/passthrough"
-    xmlns:jsf="http://xmlns.jcp.org/jsf">
+        xmlns:h="http://java.sun.com/jsf/html"
+        xmlns:f="http://java.sun.com/jsf/core"
+        xmlns:ui="http://java.sun.com/jsf/facelets"
+        xmlns:c="http://java.sun.com/jsp/jstl/core"
+        xmlns:p="http://primefaces.org/ui"
+        xmlns:pt="http://java.sun.com/jsf/passthrough"
+        xmlns:jsf="http://xmlns.jcp.org/jsf">
 
     <ui:remove>
-    <!-- input text start UPDATE: UI:REMOVE applied due to duplicate ID errors, left code as reference incase test scripts complain -->
-    <span id="pre-input-#{dsf.datasetFieldType.name}" class="pre-input-tag"/></ui:remove>
-    
-    <p:inputText value="#{dsfv.valueForEdit}" id="inputText" pt:aria-required="#{dsf.required}"
+        <!-- input text start UPDATE: UI:REMOVE applied due to duplicate ID errors, left code as reference incase test scripts complain -->
+        <span id="pre-input-#{dsf.datasetFieldType.name}" class="pre-input-tag"/></ui:remove>
+    <ui:fragment rendered="#{cvoc==null}">
+        <p:inputText value="#{dsfv.valueForEdit}" id="inputText" pt:aria-required="#{dsf.required}"
                  styleClass="form-control #{dsfv.datasetField.datasetFieldType.name == 'title' and DatasetPage.editMode == 'CREATE'  ? 'datasetfield-title' : ''}"
                  rendered="#{!dsfv.datasetField.datasetFieldType.controlledVocabulary
                              and (dsfv.datasetField.datasetFieldType.fieldType == 'TEXT'
@@ -19,14 +19,49 @@
                              or dsfv.datasetField.datasetFieldType.fieldType == 'FLOAT'
                              or dsfv.datasetField.datasetFieldType.fieldType == 'URL'
                              or dsfv.datasetField.datasetFieldType.fieldType == 'DATE'
-                             or dsfv.datasetField.datasetFieldType.fieldType == 'EMAIL')}"/>
-    <p:watermark for="inputText" value="#{dsfv.datasetField.datasetFieldType.localeWatermark}"></p:watermark>
-
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'EMAIL')}">
+        </p:inputText>
+        <p:watermark for="inputText" value="#{dsfv.datasetField.datasetFieldType.localeWatermark}"></p:watermark>
+    </ui:fragment>
+    <ui:fragment rendered="#{cvoc!=null and cvoc.getString('term-uri-field').equals(dsfv.datasetField.datasetFieldType.name)}">
+        <p:inputText value="#{dsfv.valueForEdit}" id="cvocInputText" pt:aria-required="#{dsf.required}"
+                 styleClass="form-control #{dsfv.datasetField.datasetFieldType.name == 'title' and DatasetPage.editMode == 'CREATE'  ? 'datasetfield-title' : ''}"
+                 rendered="#{!dsfv.datasetField.datasetFieldType.controlledVocabulary
+                             and (dsfv.datasetField.datasetFieldType.fieldType == 'TEXT'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'INT'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'FLOAT'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'URL'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'DATE'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'EMAIL')}">
+            <f:passThroughAttribute name="lang" value="#{DatasetPage.getFieldLanguage(cvoc.getString('languages'))}"/>
+            <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvoc.getString('cvoc-url','')}"/>
+            <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvoc.getString('protocol','')}"/>
+            <f:passThroughAttribute name="data-cvoc-filter" value="#{cvoc.getString('term-parent-uri','')}"/>
+            <f:passThroughAttribute name="data-cvoc-vocabs" value="#{cvoc.get('vocabs').toString()}"/>
+            <f:passThroughAttribute name="data-cvoc-allowfreetext" value="#{cvoc.getBoolean('allow-free-text', false)}"/>
+            <f:passThroughAttribute name="data-cvoc-parent" value="#{cvoc.getString('field-name','')}"/>
+            <f:passThroughAttribute name="data-cvoc-managedfields" value="#{cvoc.get('managed-fields').toString()}"/>
+        </p:inputText>
+    </ui:fragment>
+    <ui:fragment rendered="#{cvoc!=null and !cvoc.getString('term-uri-field').equals(dsfv.datasetField.datasetFieldType.name)}">
+        <p:inputText value="#{dsfv.valueForEdit}" id="cvocInputText2" pt:aria-required="#{dsf.required}"
+                 styleClass="form-control #{dsfv.datasetField.datasetFieldType.name == 'title' and DatasetPage.editMode == 'CREATE'  ? 'datasetfield-title' : ''}"
+                 rendered="#{!dsfv.datasetField.datasetFieldType.controlledVocabulary
+                             and (dsfv.datasetField.datasetFieldType.fieldType == 'TEXT'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'INT'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'FLOAT'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'URL'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'DATE'
+                             or dsfv.datasetField.datasetFieldType.fieldType == 'EMAIL')}">
+            <f:passThroughAttribute name="data-cvoc-managed-field" value="#{dsfv.datasetField.datasetFieldType.name}"/>
+        </p:inputText>
+    </ui:fragment>
+    
     <p:inputTextarea value="#{dsfv.valueForEdit}" id="description" pt:aria-required="#{dsf.required}"
                      rows="5" cols="60" styleClass="form-control"
                      rendered="#{dsfv.datasetField.datasetFieldType.fieldType == 'TEXTBOX'}"/>
     <p:watermark for="description" value="#{dsfv.datasetField.datasetFieldType.localeWatermark}"></p:watermark>
-    
+
     <div class="ui-message ui-message-error ui-widget ui-corner-all" aria-live="polite" jsf:rendered="#{dsfvIndex eq 0 and !empty dsfv.datasetField.validationMessage}">
         <span class="ui-message-error-detail">#{dsfv.datasetField.validationMessage}</span>
     </div>
diff --git a/src/main/webapp/dataverse_template.xhtml b/src/main/webapp/dataverse_template.xhtml
index 8594cd0b579..ddb02ebd19b 100644
--- a/src/main/webapp/dataverse_template.xhtml
+++ b/src/main/webapp/dataverse_template.xhtml
@@ -86,6 +86,10 @@
         <script defer="defer" src="#{resource['js/jquery.matchHeight.js']}?version=#{systemConfig.getVersion()}"></script>
         <script defer="defer" src="#{resource['js/jquery.sharrre.js']}?version=#{systemConfig.getVersion()}"></script>
         <script defer="defer" src="#{resource['js/clipboard.min.js']}?version=#{systemConfig.getVersion()}"></script>
+        <ui:fragment rendered="#{DatasetPage.getCVocConf().size() > 0}">
+            <link href="https://cdn.jsdelivr.net/npm/select2@4.1.0-rc.0/dist/css/select2.min.css" rel="stylesheet" />
+            <script src="https://cdn.jsdelivr.net/npm/select2@4.1.0-rc.0/dist/js/select2.min.js"></script>
+        </ui:fragment>
         <ui:fragment rendered="#{systemConfig.isShibPassiveLoginEnabled()}">
             <script defer="defer" src="#{resource['js/shib/isPassive.js']}"></script>
         </ui:fragment>
diff --git a/src/main/webapp/metadataFragment.xhtml b/src/main/webapp/metadataFragment.xhtml
index 983eb890cdc..ffdfa7ba831 100755
--- a/src/main/webapp/metadataFragment.xhtml
+++ b/src/main/webapp/metadataFragment.xhtml
@@ -6,6 +6,13 @@
                 xmlns:p="http://primefaces.org/ui"
                 xmlns:o="http://omnifaces.org/ui"
                 xmlns:jsf="http://xmlns.jcp.org/jsf">
+        <p:fragment>
+           <p:autoUpdate/>
+        <ui:repeat value="#{DatasetPage.vocabScripts}" var="vocabScriptUrl">
+           <script defer="defer" src="#{vocabScriptUrl}?version=#{systemConfig.getVersion()}"/>
+        </ui:repeat>
+        </p:fragment>
+        <c:set var="cvocConf" value="#{DatasetPage.getCVocConf()}"/>
     <!-- View Mode -->
     <div class="panel-group" jsf:rendered="${empty editMode  or managePage}">
         <o:importFunctions type="edu.harvard.iq.dataverse.util.MarkupChecker" />
@@ -60,9 +67,28 @@
                                           <td jsf:rendered="#{!anonymized or !settingsWrapper.shouldBeAnonymized(dsf)}">
                                             <!-- Primitive datasetFields -->
                                             <ui:fragment rendered="#{dsf.datasetFieldType.primitive}">
-                                                <h:outputText value="#{dsf.getDisplayValue(mdLangCode)}" rendered="#{!dsf.datasetFieldType.allowMultiples}"
-                                                              escape="#{dsf.datasetFieldType.isEscapeOutputText()}"/>
-                                                <ui:repeat value="#{dsf.getValues(mdLangCode)}" var="value" varStatus="loop" rendered="#{dsf.datasetFieldType.allowMultiples}">
+                                                <h:outputText value="#{dsf.value}"
+                                                    rendered="#{!dsf.datasetFieldType.allowMultiples and cvocConf.containsKey(dsf.datasetFieldType.id)}"
+                                                    escape="#{dsf.datasetFieldType.isEscapeOutputText()}">
+                                                    <f:passThroughAttribute name="lang" value="#{DatasetPage.getFieldLanguage(cvocConf.get(dsf.datasetFieldType.id).getString('languages'))}" />
+                                                    <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvocConf.get(dsf.datasetFieldType.id).getString('cvoc-url','')}" />
+                                                    <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvocConf.get(dsf.datasetFieldType.id).getString('protocol','')}" />
+                                                    <f:passThroughAttribute name="data-cvoc-managedfields" value="#{cvocConf.get(dsf.datasetFieldType.id).get('managedfields').toString()}" />
+                                                </h:outputText>
+                                                <h:outputText value="#{dsf.getDisplayValue(mdLangCode)}"
+                                                    rendered="#{!dsf.datasetFieldType.allowMultiples and !cvocConf.containsKey(dsf.datasetFieldType.id)}"
+                                                    escape="#{dsf.datasetFieldType.isEscapeOutputText()}"/>
+                                                <ui:repeat value="#{dsf.getValues_nondisplay()}" var="value" varStatus="loop" rendered="#{dsf.datasetFieldType.allowMultiples and cvocConf.containsKey(dsf.datasetFieldType.id)}">
+                                                    <h:outputText value="#{loop.first?'':'; '}"/>
+                                                    <h:outputText value="#{ value }"
+                                                                  escape="#{dsf.datasetFieldType.isEscapeOutputText()}">
+                                                        <f:passThroughAttribute name="lang" value="#{DatasetPage.getFieldLanguage(cvocConf.get(dsf.datasetFieldType.id).getString('languages'))}" />
+                                                        <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvocConf.get(dsf.datasetFieldType.id).getString('cvoc-url','')}" />
+                                                        <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvocConf.get(dsf.datasetFieldType.id).getString('protocol','')}" />
+                                                        <f:passThroughAttribute name="data-cvoc-managedfields" value="#{cvocConf.get(dsf.datasetFieldType.id).get('managedfields').toString()}" />
+                                                    </h:outputText>
+                                                </ui:repeat>
+                                                <ui:repeat value="#{dsf.getValues(mdLangCode)}" var="value" varStatus="loop" rendered="#{dsf.datasetFieldType.allowMultiples and !cvocConf.containsKey(dsf.datasetFieldType.id)}">
                                                     <h:outputText value="#{loop.first?'':'; '}#{ value }"
                                                                   escape="#{dsf.datasetFieldType.isEscapeOutputText()}"/>
                                                 </ui:repeat>
@@ -75,10 +101,19 @@
                                                     </p>
                                                 </ui:fragment>
                                                 <ui:repeat value="#{dsf.datasetFieldCompoundValues}" var="compoundValue">
-                                                    <ui:repeat value="#{compoundValue.displayValueMap.entrySet().toArray()}" var="cvPart" varStatus="partStatus">                                           
-                                                        <h:outputText value="#{dsf.datasetFieldType.displayFormat} " rendered="${!partStatus.first}"/>
+                                                    <ui:repeat value="#{compoundValue.displayValueMap.entrySet().toArray()}" var="cvPart" varStatus="partStatus">
+                                                        <h:outputText value="#{dsf.datasetFieldType.displayFormat} " rendered="${!partStatus.first and !cvocConf.containsKey(dsf.datasetFieldType.id)}"/>
                                                         <h:outputText value="#{cvPart.value}"
-                                                                      escape="#{cvPart.key.datasetFieldType.isEscapeOutputText()}"/>
+                                                                      escape="#{cvPart.key.datasetFieldType.isEscapeOutputText()}" 
+                                                                      rendered="${!cvocConf.containsKey(dsf.datasetFieldType.id)}"/>
+                                                        <h:outputText value="#{cvPart.key.value}"
+                                                                      escape="#{cvPart.key.datasetFieldType.isEscapeOutputText()}" 
+                                                                      rendered="${cvocConf.containsKey(dsf.datasetFieldType.id) and cvPart.key.datasetFieldType.name.equals(cvocConf.get(dsf.datasetFieldType.id).getString('term-uri-field'))}">
+                                                                      <f:passThroughAttribute name="lang" value="#{DatasetPage.getFieldLanguage(cvocConf.get(dsf.datasetFieldType.id).getString('languages'))}" />
+                                                                      <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvocConf.get(dsf.datasetFieldType.id).getString('cvoc-url','')}" />
+                                                                      <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvocConf.get(dsf.datasetFieldType.id).getString('protocol','')}" />
+                                                                      <f:passThroughAttribute name="data-cvoc-managedfields" value="#{cvocConf.get(dsf.datasetFieldType.id).get('managedfields').toString()}" />
+                                                        </h:outputText>
                                                     </ui:repeat>
                                                     <br/>
                                                 </ui:repeat>
@@ -111,9 +146,9 @@
                                                                  or metadataBlockVal.key.isHasRequired())
                                                                  or (!datasetPage)}">
                     <div data-toggle="collapse" data-target="#panelCollapse#{block.index}" class="panel-heading text-info">
-                        #{metadataBlockVal.key.localeDisplayName} <span class="glyphicon #{block.first || editMode == 'CREATE'  ? 'glyphicon-chevron-up' : 'glyphicon-chevron-down'}"/>
+                        #{metadataBlockVal.key.localeDisplayName} <span class="glyphicon #{block.first or editMode == 'CREATE' or !cvocConf.isEmpty() ? 'glyphicon-chevron-up' : 'glyphicon-chevron-down'}"/>
                     </div>
-                    <div id="panelCollapse#{block.index}" class="collapse #{block.first || editMode == 'CREATE' ? 'in' : ''}">
+                    <div id="panelCollapse#{block.index}" class="collapse #{block.first or editMode == 'CREATE' or !cvocConf.isEmpty() ? 'in' : ''}">
                         <div class="panel-body">
                             <ui:repeat value="#{metadataBlockVal.value}" var="dsf">
                                 <div class="form-group" role="group" aria-labelledby="metadata_#{dsf.datasetFieldType.name}"
@@ -141,6 +176,7 @@
                                                                 <ui:include src="datasetFieldForEditFragment.xhtml">
                                                                     <ui:param name="dsfv" value="#{dsfv}"/>
                                                                     <ui:param name="dsfvIndex" value="#{valCount.index}"/>
+                                                                    <ui:param name="cvoc" value="#{cvocConf.containsKey(dsf.datasetFieldType.id)? cvocConf.get(dsf.datasetFieldType.id): null}"/>
                                                                 </ui:include>
                                                             </div>
                                                             <!-- Add / Remove buttons -->
@@ -207,9 +243,9 @@
                                                 <p class="help-block">
                                                     <h:outputText value="#{bundle.conditionalRequiredMsg}"/>
                                                 </p>
-                                            </ui:fragment>                                            
+                                            </ui:fragment>
                                             <ui:repeat value="#{dsf.datasetFieldCompoundValues}" var="compoundValue" varStatus="valCount">
-                                                <div class="form-group form-col-container col-sm-9 edit-compound-field">
+                                                <div class="form-group form-col-container col-sm-9 edit-compound-field"  data-cvoc-parentfield="#{cvocConf.containsKey(dsf.datasetFieldType.id)?cvocConf.get(dsf.datasetFieldType.id).getString('field-name'):''}">
                                                     <!-- Sub Fields -->
                                                     <ui:repeat value="#{compoundValue.childDatasetFields}" var="subdsf">
                                                         <div class="form-col-container #{subdsf.datasetFieldType.fieldType == 'TEXTBOX' ? 'col-sm-12' : 'col-sm-6'}">
@@ -229,6 +265,7 @@
                                                                 <ui:include src="datasetFieldForEditFragment.xhtml">
                                                                     <ui:param name="dsfv" value="#{subdsf.singleValue}"/>
                                                                     <ui:param name="dsfvIndex" value="0"/>
+                                                                    <ui:param name="cvoc" value="#{cvocConf.containsKey(dsf.datasetFieldType.id)? cvocConf.get(dsf.datasetFieldType.id): null}"/>
                                                                 </ui:include>
                                                             </ui:fragment>
                                                             <!-- MOVED SELECT ONE TO dataFieldForEdit -->
@@ -286,4 +323,17 @@
         </div>
         </p:fragment>
     </ui:fragment>
+ <script>
+    //<![CDATA[
+    $(document).ready(function() {
+      //The select2 widget used in external vocab scripts has trouble determining the width of an input field if it is initially hidden
+      //Starting with the metadatablocks displayed and collapsing them here is a work-around to fix that.
+      if(#{!cvocConf.isEmpty()}) {
+        for(let i=1;i< #{fn:length(metadataBlocks)};i++) {
+          $('#panelCollapse'+i).collapse('hide');
+        }
+      }
+    });
+    //]]>
+    </script>
 </ui:composition>
diff --git a/src/main/webapp/resources/css/structure.css b/src/main/webapp/resources/css/structure.css
index bfa1da9f573..82f02c9a693 100644
--- a/src/main/webapp/resources/css/structure.css
+++ b/src/main/webapp/resources/css/structure.css
@@ -390,6 +390,7 @@ div.btn-group ul.dropdown-menu li.disabled span.ui-commandlink.ui-state-disabled
 div.field-add-delete a.btn {margin:0 1em 0 0;}
 div.field-add-delete a.btn:last-child {margin-right:0;}
 div.field-add-delete a.btn.compound-field-btn {margin-top:1.8em;}
+div[data-cvoc-parentfield] ~ div.field-add-delete a.btn.compound-field-btn {margin-top:0px;}
 div.field-add-delete a.btn.nolabel-field-btn {margin-top:0;}
 
 /* Featured Dataverses*/
@@ -1000,3 +1001,37 @@ progress::-webkit-progress-bar {
 progress::-webkit-progress-value {
   background-color:green;
 }
+
+/*External vocabulary support*/
+
+.select2-container .select2-selection--single {
+        border:1px solid #cccccc;
+        border-radius: 3px;
+        height:34px;
+        display:inline;
+        background:#ffffff;
+}
+.select2-container {
+        display: inline!important;
+}
+.select2-container .select2-selection--single .select2-selection__rendered {
+        display:inline-block!important;
+        max-width:90%
+}
+.select2-selection__clear, .select2-selection__rendered {
+        vertical-align: -webkit-baseline-middle;
+}
+.select2-results li {
+        font-weight:400;
+        font-size:14px;
+}
+.select2-rendered__match {
+        font-weight:600;
+}
+.cvoc-vocab {
+padding-left:0px;
+padding-right:0px;
+}
+.cvoc-term {
+padding-right:0px;
+}
diff --git a/src/main/webapp/search-include-fragment.xhtml b/src/main/webapp/search-include-fragment.xhtml
index f70b321cea4..1d3aeefbf4b 100644
--- a/src/main/webapp/search-include-fragment.xhtml
+++ b/src/main/webapp/search-include-fragment.xhtml
@@ -9,7 +9,13 @@
      xmlns:jsf="http://xmlns.jcp.org/jsf">
 
     <c:set var="page" value="/dataverse/#{DataversePage.dataverse.alias}"/>
-
+    <c:set var="cvocConf" value="#{DatasetPage.getCVocConf()}"/>
+    <p:fragment>
+        <p:autoUpdate/>
+        <ui:repeat value="#{DatasetPage.vocabScripts}" var="vocabScriptUrl">
+          <script defer="defer" src="#{vocabScriptUrl}?version=#{systemConfig.getVersion()}"/>
+        </ui:repeat>
+    </p:fragment>
     <!-- Search Form + Add Data Button -->
     <div class="row panelSearchForm" jsf:rendered="#{!SearchIncludeFragment.solrIsDown}">
         <div class="#{widgetWrapper.widgetView ? 'col-xs-12' : 'col-sm-9'}">
@@ -188,8 +194,12 @@
                     <h:outputText value="#{facetCategory.friendlyName}" styleClass="facetCategoryName"/>
                     <p:dataList value="#{facetCategory.facetLabel}" var="facetLabel" rows="#{DataversePage.getNumberOfFacets(facetCategory.name,5)}">
                         <h:outputLink value="#{widgetWrapper.wrapURL(page)}" rendered="#{!DataversePage.filterQueries.contains(facetLabel.filterQuery)}" styleClass="facetLink">
-                            <h:outputFormat value="{0} &#40;{1}&#41;">
-                                <f:param value="#{facetLabel.name}"/>
+                            <h:outputText value="#{facetLabel.name}">
+                                <f:passThroughAttribute name="lang" value="#{DatasetPage.getFieldLanguage(cvocConf.get(facetCategory.datasetFieldTypeId).getString('languages'))}" />
+                                <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvocConf.get(facetCategory.datasetFieldTypeId).getString('cvoc-url','')}" />
+                                <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvocConf.get(facetCategory.datasetFieldTypeId).getString('protocol','')}" />
+                            </h:outputText>
+                            <h:outputFormat value=" &#40;{0}&#41;">
                                 <f:param value="#{facetLabel.count}"/>
                             </h:outputFormat>
                             <f:param name="q" value="#{DataversePage.query}"/>
@@ -203,8 +213,12 @@
                         </h:outputLink>
 
                         <h:outputLink value="#{widgetWrapper.wrapURL(page)}" rendered="#{DataversePage.filterQueries.contains(facetLabel.filterQuery)}" styleClass="facetLink facetSelected">
-                            <h:outputFormat value="{0} &#40;{1}&#41;">
-                                <f:param value="#{facetLabel.name}"/>
+                            <h:outputText value="#{facetLabel.name}">
+                                <f:passThroughAttribute name="lang" value="#{DatasetPage.getFieldLanguage(cvocConf.get(facetCategory.datasetFieldTypeId).getString('languages'))}" />
+                                <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvocConf.get(facetCategory.datasetFieldTypeId).getString('cvoc-url','')}" />
+                                <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvocConf.get(facetCategory.datasetFieldTypeId).getString('protocol','')}" />
+                            </h:outputText>
+                            <h:outputFormat value=" &#40;{0}&#41;">
                                 <f:param value="#{facetLabel.count}"/>
                             </h:outputFormat>
                             <span class="glyphicon glyphicon-remove"></span>
@@ -341,7 +355,13 @@
                     <ui:param name="filterType" value="#{SearchIncludeFragment.getTypeFromFilterQuery(filterQuery)}"/>
                     <h:outputLink value="#{widgetWrapper.wrapURL(page)}" styleClass="facetLink facetSelected" rendered="#{not empty friendlyNames
                                 and filterType != DataversePage.searchFieldType and filterType != DataversePage.searchFieldSubtree}">
-                        <h:outputText value="#{friendlyNames.get(0)}: #{friendlyNames.get(1)}"/> <span class="glyphicon glyphicon-remove"></span>
+                        <h:outputText value="#{friendlyNames.get(0)}: "/>
+                        <h:outputText value="#{friendlyNames.get(1)}">
+                                <f:passThroughAttribute name="lang" value="#{DatasetPage.getFieldLanguage(cvocConf.get(SearchIncludeFragment.getFieldTypeId(friendlyNames.get(0))).getString('languages'))}" />
+                                <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvocConf.get(SearchIncludeFragment.getFieldTypeId(friendlyNames.get(0))).getString('cvoc-url','')}" />
+                                <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvocConf.get(SearchIncludeFragment.getFieldTypeId(friendlyNames.get(0))).getString('protocol','')}" />
+                        </h:outputText>
+                        <span class="glyphicon glyphicon-remove"></span>
                         <f:param name="q" value="#{SearchIncludeFragment.query}"/>
                         <c:forEach items="#{SearchIncludeFragment.filterQueries}" var="clickedFilterQuery" varStatus="status">
                             <f:param name="fq#{status.index}" value='#{clickedFilterQuery}' disable="#{clickedFilterQuery == filterQuery}"/>
diff --git a/src/main/webapp/search/advanced.xhtml b/src/main/webapp/search/advanced.xhtml
index d4c621226b6..d0f7e3292d6 100644
--- a/src/main/webapp/search/advanced.xhtml
+++ b/src/main/webapp/search/advanced.xhtml
@@ -2,6 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml"
       xmlns:h="http://java.sun.com/jsf/html"
       xmlns:f="http://java.sun.com/jsf/core"
+      xmlns:c="http://xmlns.jcp.org/jsp/jstl/core"
       xmlns:ui="http://java.sun.com/jsf/facelets"
       xmlns:p="http://primefaces.org/ui"
       xmlns:jsf="http://xmlns.jcp.org/jsf">
@@ -21,6 +22,13 @@
                     <f:viewParam name="dataverseIdentifier" value="#{AdvancedSearchPage.dataverseIdentifier}"/>
                     <f:viewAction action="#{dataverseHeaderFragment.initBreadcrumbs(AdvancedSearchPage.dataverse, bundle['dataverse.search.advancedSearch'])}"/>
                 </f:metadata>
+                <p:fragment>
+                    <p:autoUpdate/>
+                    <ui:repeat value="#{AdvancedSearchPage.vocabScripts}" var="vocabScriptUrl">
+                        <script src="#{vocabScriptUrl}?version=#{systemConfig.getVersion()}"/>
+                    </ui:repeat>
+                </p:fragment>
+                <c:set var="cvocConf" value="#{AdvancedSearchPage.getCVocConf()}"/>
                 <!-- Search Panel -->
                 <div class="panel-group">
                     <h:form id="advancedSearchForm">
@@ -94,9 +102,9 @@
                         <ui:repeat value="#{AdvancedSearchPage.metadataBlocks}" var="mdb" varStatus="status">
                             <div class="panel panel-default" jsf:rendered="#{not empty AdvancedSearchPage.metadataFieldMap.get(mdb.getId())}">
                                 <div data-toggle="collapse" data-target="#panelCollapseCitationFieldList#{mdb.id}" class="panel-heading">
-                                    <h:outputText value="#{bundle['advanced.search.header.datasets']}: #{mdb.localeDisplayName}"/> &#160;<span class="glyphicon #{status.first?'glyphicon-chevron-up':'glyphicon-chevron-down'}"/>
+                                    <h:outputText value="#{bundle['advanced.search.header.datasets']}: #{mdb.localeDisplayName}"/> &#160;<span class="glyphicon glyphicon-chevron-down"/>
                                 </div>
-                                <div id="panelCollapseCitationFieldList#{mdb.id}" class="collapse #{status.first?'in':''} panel-body form-horizontal">
+                                <div id="panelCollapseCitationFieldList#{mdb.id}" class="collapse in panel-body form-horizontal">
                                     <ui:repeat value="#{AdvancedSearchPage.metadataFieldMap.get(mdb.getId())}" var="item">
                                         <div class="form-group">
                                             <label class="col-sm-4 control-label">
@@ -105,7 +113,22 @@
                                                       data-toggle="tooltip" data-placement="auto right" data-original-title="#{item.localeDescription}"></span>
                                             </label>
                                             <div class="col-sm-6">
-                                                <p:inputText id="searchValue" styleClass="form-control" value="#{item.searchValue}" rendered="#{empty item.controlledVocabularyValues}"/>
+                                                <ui:param name="cvoc" value="#{cvocConf.containsKey(item.id)? cvocConf.get(item.id): null}"/>
+                                                <ui:fragment rendered="#{cvoc==null}">
+                                                    <p:inputText id="searchValue" styleClass="form-control" value="#{item.searchValue}" rendered="#{empty item.controlledVocabularyValues}"/>
+                                                </ui:fragment>
+                                                <ui:fragment rendered="#{cvoc!=null and cvoc.getString('term-uri-field').equals(item.name)}">
+                                                    <p:inputText id="searchValue2" styleClass="form-control" value="#{item.searchValue}" rendered="#{empty item.controlledVocabularyValues}">
+                                                        <f:passThroughAttribute name="lang" value="#{AdvancedSearchPage.getFieldLanguage(cvoc.getString('languages'))}"/>
+                                                        <f:passThroughAttribute name="data-cvoc-service-url" value="#{cvoc.getString('cvoc-url','')}"/>
+                                                        <f:passThroughAttribute name="data-cvoc-protocol" value="#{cvoc.getString('protocol','')}"/>
+                                                        <f:passThroughAttribute name="data-cvoc-filter" value="#{cvoc.getString('term-parent-uri','')}"/>
+                                                        <f:passThroughAttribute name="data-cvoc-vocabs" value="#{cvoc.get('vocabs').toString()}"/>
+                                                        <f:passThroughAttribute name="data-cvoc-allowfreetext" value="#{cvoc.getBoolean('allow-free-text', false)}"/>
+                                                        <f:passThroughAttribute name="data-cvoc-parent" value="#{cvoc.getString('field-name','')}"/>
+                                                        <f:passThroughAttribute name="data-cvoc-managedfields" value="#{cvoc.get('managed-fields').toString()}"/>
+                                                    </p:inputText>
+                                                </ui:fragment>
                                                 <div class="ui-inputfield form-control select-scroll-block" jsf:rendered="#{!empty item.controlledVocabularyValues}">
                                                     <p:selectManyCheckbox value="#{item.listValues}" layout="pageDirection">
                                                         <f:selectItems value="#{item.controlledVocabularyValues}" var="cvs"
@@ -224,6 +247,18 @@
                         </div>
                     </h:form>
                 </div>
+                <script>
+                    //<![CDATA[
+                    $(document).ready(function() {
+                        //The select2 widget used in external vocab scripts has trouble determining the width of an input field if it is initially hidden
+                        //Starting with the metadatablocks displayed and collapsing them here is a work-around to fix that.
+                        //Note - putting defer='defer' on the included ext vocab scripts (~line 28) would make them run after this which doesn't work.
+                        if(#{!cvocConf.isEmpty()}) {
+                            $("div[id^='panelCollapseCitationFieldList']").collapse('hide');
+                        }
+                    });
+                    //]]>
+                </script>
             </ui:define>
         </ui:composition>
     </h:body>
diff --git a/src/test/java/edu/harvard/iq/dataverse/mocks/MockDatasetFieldSvc.java b/src/test/java/edu/harvard/iq/dataverse/mocks/MockDatasetFieldSvc.java
index 1cb0c32b722..a8177537d5f 100644
--- a/src/test/java/edu/harvard/iq/dataverse/mocks/MockDatasetFieldSvc.java
+++ b/src/test/java/edu/harvard/iq/dataverse/mocks/MockDatasetFieldSvc.java
@@ -3,6 +3,8 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import javax.json.JsonObject;
+
 import edu.harvard.iq.dataverse.ControlledVocabularyValue;
 import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.DatasetFieldType;
@@ -48,5 +50,9 @@ public ControlledVocabularyValue findControlledVocabularyValueByDatasetFieldType
         cvv.setStrValue(strValue);
         return cvv;
     }
+    
+    public Map<Long, JsonObject> getCVocConf(boolean byTermUriField){
+        return new HashMap<Long, JsonObject>();
+    }
 
 }
\ No newline at end of file
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
index 26d761639e6..efff64cc6e2 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
@@ -9,6 +9,7 @@
 import edu.harvard.iq.dataverse.DatasetField;
 import edu.harvard.iq.dataverse.DatasetFieldCompoundValue;
 import edu.harvard.iq.dataverse.DatasetFieldConstant;
+import edu.harvard.iq.dataverse.DatasetFieldServiceBean;
 import edu.harvard.iq.dataverse.DatasetFieldType;
 import edu.harvard.iq.dataverse.DatasetFieldType.FieldType;
 import edu.harvard.iq.dataverse.DatasetFieldValue;
@@ -202,7 +203,8 @@ public void testDatasetContactOutOfBoxNoPrivacy() {
         fields.add(datasetContactField);
 
         SettingsServiceBean nullServiceBean = null;
-        JsonPrinter.injectSettingsService(nullServiceBean);
+        DatasetFieldServiceBean nullDFServiceBean = null;
+        JsonPrinter.injectSettingsService(nullServiceBean, nullDFServiceBean);
         
         JsonObject jsonObject = JsonPrinter.json(block, fields).build();
         assertNotNull(jsonObject);
@@ -242,8 +244,9 @@ public void testDatasetContactWithPrivacy() {
         vals.add(val);
         datasetContactField.setDatasetFieldCompoundValues(vals);
         fields.add(datasetContactField);
-
-        JsonPrinter.injectSettingsService(new MockSettingsSvc());
+        
+        DatasetFieldServiceBean nullDFServiceBean = null;
+        JsonPrinter.injectSettingsService(new MockSettingsSvc(), nullDFServiceBean);
 
         JsonObject jsonObject = JsonPrinter.json(block, fields).build();
         assertNotNull(jsonObject);