Skip to main content

How CMF-CW works

CMF-CW is a web application composed of Chemical Match Finder (CMF), an in-house cheminformatics application, and its integrated database of lists of chemicals controlled under international chemical weapons disarmament and nonproliferation frameworks (CW-control lists). Read the sections below to learn more about how CMF-CW works.

Schematic diagram of the CMF-CW system architecture, divided into CMF-CW Frontend and Backend. The frontend accepts a search term or file, a selected SMILES resolution service, and search settings, and later assembles the HTML report. The backend processes the search term, optionally resolving it into a SMILES string via external services, then converts it into an RDKit molecule object. Variant generation is applied, producing multiple query structures. These are compared to CW-control list entries through both structure matching (including Markush-type families) and metadata search. Matches are returned to the frontend for reporting.
Figure: Schematic representation of the CMF-CW system architecture. The CMF-CW frontend accepts user input in the form of a search term or file, along with selected SMILES resolution services and search parameters. The backend performs structure resolution and variant generation, then compares the resulting query structures against chemical weapons control list entries using both structure-based and metadata-based matching. Identified matches are returned to the frontend and formatted into an HTML report.

General Description

The CMF-CW frontend, written in JavaScript and HTML, provides the user interface for the CMF application, where the user enters the search term (or a search file) and selects the search settings. It sends the search request to the backend and, once the backend has completed the search process, assembles and displays the report in HTML format.

The CMF-CW backend comprises the CMF cheminformatics engine and its integrated database of CW-control lists. Crucially, both components of the backend can handle databases that include entries that identify individual chemicals, represented as exact structures, as well as entries that define chemical families characterized by shared cores and a range of allowed variable chemical groups, represented as Markush structures. This feature is essential for CMF-CW, as some of the CW-control lists featured in its integrated database — namely the Schedules of the Chemical Weapons Convention (CWC) and the Wassenaar Arrangement Munitions List 7 (ML7) — include not only individual chemicals but also Markush-type chemical families.

The CW-control lists database is composed of CSV files (one per list) and Python scripts (one for each Markush-type entry). For each entry, the CSV file contains (i) a SMILES field that defines the exact structure of individually listed chemicals and the invariable core structure of Markush-type entries and (ii) a metadata field containing the names and family definitions explicitly listed in the CW-control lists, as well as certain SMILES strings that cannot be converted into structures. For each Markush-type entry, an entry-specific Python script encodes the allowed variable chemical groups, the rules for their connection to the core, and any exclusions specified in the regulatory text (i.e., chemicals that are excluded from entry coverage despite fitting the Markush definition).

The CMF cheminformatics engine is written in Python and is based on the RDKit [1] toolkit through its Python API [2]. The CMF cheminformatics engine detects matches between the search term and the database entries by performing the operations outlined below, with an architecture that allows it to match exact query structures with both exact and Markush-type database entries.

Step 1. Entry of Search Terms.

The user enters a single search term directly into the frontend, uploads multiple search terms in TXT format, or uploads chemical structures in SDF format. As the user types into the search box, the frontend retrieves autocomplete suggestions through the Wikidata entity-search API and the PubChem autocomplete API. The results are combined and duplicate suggestions are removed. Selecting a suggestion inserts it into the search box; the term is not processed until the search is launched.

Step 2. Conversion to Structure.

Upon receiving the search term from the frontend, the CMF cheminformatics engine first converts it into a molecular structure (an RDKit molecule object) – see Converting Search Terms into Structures.

Step 3. Generation of Variants.

If the Generate Variants option was selected, the CMF cheminformatics engine then generates chemically relevant variants of that structure – see Generating Molecular Variants.

Step 4. Evaluation of Structure and Metadata Matches.

Subsequently, the CMF cheminformatics engine checks the structure corresponding to the search term and any generated variants against the exact and Markush-type structures in the database, leading to the identification of any existing matches (Matches in Structure Search). Additionally, the cheminformatics engine checks the term directly, as a text string, against the metadata column in the database lists (Matches in Metadata Search) - Evaluating Structure and Metadata Matches.

Step 5. Production of Report.

Finally, the backend sends the results to the frontend, which formats them into an HTML report.

Converting Search Terms into Structures

For the CMF cheminformatics engine to be able to identify structural matches, search terms – whether typed manually or read from an uploaded TXT or SDF file – must be converted into a chemical structure represented as an RDKit molecule object.

Depending on the search term type, this conversion is either handled entirely by the CMF cheminformatics engine or assisted by external services (listed below), which resolve the search term into a SMILES string that CMF then uses to generate the corresponding RDKit molecule object. Depending on the service and the search term, the SMILES string may be generated algorithmically or retrieved via database lookup.

Search Term to SMILES services

Search Terms Directly Algorithmically Converted into RDKit Molecule Objects by CMF

Search Terms that Require Prior Resolution to SMILES

Generating variants

The CMF cheminformatics engine can generate representational and molecular variants of the input chemical. Representational variants are alternative computational representations of a chemical’s molecular structure (e.g., implicit vs explicit encoding of hydrogens or ionic vs coordination encoding of metal-nonmetal bonds). Molecular variants are alternative versions of a chemical that have the same heavy-atom connectivity (ignoring hydrogen placement and bond orders) but constitute different chemically plausible forms (e.g., isotopic or stereochemical variants, tautomers, and protonation states). The CMF cheminformatics engine also treats individual chemical components of mixtures, including salts and hydrates, as variants of the mixture. During componentization, standalone inorganic components, such as counterions and water, are dropped, yielding desalted or desolvated variants.

Once the search term has been converted into an RDKit molecule object, and if the Generate Variants option is selected, the CMF cheminformatics engine generates a pool of plausible representational or molecular variants by applying a series of transformations.

Representational variants are generated by:

Molecular variants are generated by:

All variants are generated combinatorially through a serial pipeline of transformation steps. Each variant generation step is applied not only to the original search term, but also to all variants produced by preceding steps in the pipeline. This recursive approach ensures that all combinations of modifications are captured and evaluated.

Whether variants are actually generated depends on the nature of the RDKit molecule object corresponding to the search term. For example, a single-component RDKit molecule object already in its standard representation, with no explicit isotopes or stereochemistry, and with no alternative protonation or tautomeric states possible, will not produce any variants.

Evaluating Structure and Metadata Matches

For search terms that can be converted to structures, the CMF cheminformatics engine performs structural comparisons as well. Once the search terms have been converted to RDKit molecule objects and variants have been generated (collectively referred to as query molecule objects), the CMF cheminformatics engine systematically compares them with each entry in the integrated database.

For entries that define individual chemicals, matching is performed by checking for identity between the query molecule objects and the molecule object derived from the SMILES listed for that entry. Comparing RDKit molecule objects rather than SMILES is essential, as different SMILES strings can represent the same molecular structure.

For entries that define Markush-type families, matching is performed using a two-step process. First, the CMF cheminformatics engine checks whether the query molecule objects contain the molecule object derived from the SMILES of the core scaffold listed for that entry. If the core matches, the CMF cheminformatics engine then invokes an entry-specific Python script to conduct a more detailed evaluation. This script checks whether the substituents and connectivity present in the query molecule object conform to the rules defined for that family and ensures that the molecule is not among any explicitly excluded compounds.

For all search terms, the CMF cheminformatics engine performs a direct text comparison, always case-insensitive, with the metadata field of each entry in the integrated CW-control lists database. The behavior differs depending on whether the user has enclosed the search term in quotation marks. Search terms enclosed in quotation marks are treated as an exact phrase: a match occurs only if the entire quoted phrase exactly matches one of the metadata fields associated with the entry. Unquoted search terms are treated as individual words: a full match occurs if the entire search term exactly matches one complete metadata field; a partial match occurs if at least one complete metadata field is fully contained within the user's search term. If a match is only partial, this is flagged in a warning message in the report.

Structural comparisons can only be performed for search terms that can be converted into structures. Conversely, metadata comparisons can be performed for all search terms, but are limited to the information explicitly listed in the metadata field of the integrated database. This combined approach enhances the robustness of the identification process, due to the complementary strengths and limitations of the two methods.

Learn More and Launch CMF-CW

To explore CMF-CW in more detail, visit the following pages:

When you are ready, launch the CMF-CW screening tool.

References

  1. RDKit: Open-Source Cheminformatics Software,
  2. Python API Reference,
  3. PubChem Data Counts,
  4. Kim, S., Chen, J., Cheng, T., Gindulyte, A., He, J., He, S., Li, Q., Shoemaker, B. A., Thiessen, P. A., Yu, B., Zaslavsky, L., Zhang, J., & Bolton, E. E. (2025). PubChem 2025 update. Nucleic Acids Res., 53(D1), D1516–D1525.
  5. NCI CADD Group – About,
  6. Chemical Identifier Resolver documentation,
  7. NCI/CADD Chemical Structure Web Services, ACS Meeting New Orleans 2013 (CINF),
  8. CAS Common Chemistry,
  9. Jacobs, A., Williams, D., Hickey, K., Patrick, N., Williams, A. J., Chalk, S., McEwen, L., Willighagen, E., Walker, M., Bolton, E., Sinclair, G., & Sanford, A. (2022). CAS Common Chemistry in 2021: Expanding Access to Trusted Chemical Information for the Scientific Community. Journal of Chemical Information and Modeling, 62(11), 2737–2743.
  10. Lowe, D. M., Corbett, P. T., Murray-Rust, P., & Glen, R. C. (2011). Chemical Name to Structure: OPSIN, an Open Source Solution. Journal of Chemical Information and Modeling, 51(3), 739–753.
  11. ChemSpider, Chemical Vendors,
  12. Pence, H. E., & Williams, A. (2010). ChemSpider: An Online Chemical Information Resource. Journal of Chemical Education, 87(11), 1123–1124.
  13. Kim, S., Yu, B., Li, Q., & Bolton, E. E. (2024). PubChem synonym filtering process using crowdsourcing. Journal of Cheminformatics, 16(1), Article 69.
  14. ChemSpider FAQs, https://www.chemspider.com/faq" target="_blank" rel="noreferrer" class="banner-logo-link">Link