---
sourceDocument: Brazil Public Sector
sourceDocumentLink: https://www.servicenow.com/docs/r/government-industry

 Release :

    - brazil

ft:locale :

    - en-US

ft:publication_title :

    - Brazil Public Sector

ft:clusterId :

    - gvin

bundleId :

    - gvin

workflow :

    - Customer and Industry


---

# Configure entity link analysis

# Configure link analysis for entity records in Investigative Case Management {#ariaid-title1}

Release version: Brazil  
Updated March 10, 2026  
![](https://www.servicenow.com/docs/portal-asset/ico-clock) 4 minutes to read  
As an admin, you can set up link analysis used to visualize the relationship between multiple components of a case.

## About this task

Link Analysis is a shared, prebuilt graph visualization component that lives in the `sn-configurable-comps` plugin, that renders an interactive node/edge graph, per-node info cards, node taglines, status chips,
and search --- for any ServiceNow table. Use this plugin in Investigative Case Management to visualize the relationships between multiple entities, evidence, tasks, and related cases as an interactive knowledge graph, surfacing hidden connections and blind spots.

An interactive knowledge graph renders all entities, evidence, tasks, and related cases; blue dotted lines show direct case relationships and gray solid lines show entity-to-entity links. Any node can be set as the home node
to instantly re-map the network, and the view exports to PDF or PowerPoint for case reviews and handoffs.

## Before you begin

Before you begin, verify that

* The `com.sn-configurable-comps` (scope `sn_config_comps`) plugin is installed on your instance.
* You have a "home" table, the record that users will view when they open the graph (e.g., the case table)
* You have entity tables configured, and have linked the tables that connect them
{#psds-config-icm-entity-link-anaylsis__ul_ebl_n1w_5kc}

Role required: admin

## Procedure

1. Navigate to AllTask RelationshipsRelationship Types to define your graph ID.  
   Pick a unique string that identifies your graph. This does not need to be a real sys_id.

   For example, if you choose `myapp-case-graph` as your graph id, ICM will use the sys_id of its sys_meta_graph record.  
   Note:  
   This string is the `graphSysId` that scopes your entire configuration. Two teams using the same `graphSysId` will automatically merge their configurations into one graph.
2. Create a Script Include in your app scope that extends `sn_config_comps.NodeMapConfigProvider`.  

       var MyAppNodeMapConfigProvider = Class.create();
       MyAppNodeMapConfigProvider.prototype = Object.extendsObject(
           sn_config_comps.NodeMapConfigProvider,
           {
               MY_GRAPH_ID: 'myapp-case-graph',

               getConfig: function(graphSysId) {
                   // CRITICAL: Guard on graphSysId
                   if (graphSysId !== this.MY_GRAPH_ID) {
                       return { nodeTypes: {}, relationships: [], directRelationships: [] };
                   }

                   return {
                       nodeTypes: { /* ... */ },
                       relationships: [ /* ... */ ],
                       directRelationships: [ /* ... */ ],
                       iconMap: { /* ... */ },
                       defaultIcon: 'gear-fill',
                       captionConfig: { /* ... */ },
                       statusColorMap: { /* ... */ },
                       statusConfig: { /* ... */ },
                       edgeLabelConfig: { /* ... */ },
                   };
               },

               type: 'MyAppNodeMapConfigProvider'
           }
       );

   Note:  
   The `graphSysId` guard (the "if" at the top) must be included. Without it, your nodes will inject into every graph on the instance.
3. Define node types with one entry per logical node type.  
   Each entry describes one kind of node on your graph.  

       nodeTypes: {
           myapp_case: {
               tables: ['myapp_case'],
               baseTable: 'myapp_case',
               primaryLabelField: 'short_description',
               secondaryLabelField: 'state',
               secondaryLabelFallbackText: 'Case',
               iconMap: { myapp_case: 'folder-outline' },
               colorMap: { myapp_case: 'blue' },
               cardHeadings: { myapp_case: 'short_description' },
               fieldConfig: {
                   assigned_to: { label: 'Assigned to', valueType: 'text-link' },
                   priority: { label: 'Priority' },
               },
           },
           myapp_person: {
               tables: ['myapp_person'],
               baseTable: 'myapp_person',
               primaryLabelField: 'name',
               secondaryLabelFallbackText: 'Person',
               iconMap: { myapp_person: 'user-outline' },
               colorMap: { myapp_person: 'green' },
               cardHeadings: { myapp_person: 'name' },
               fieldConfig: {
                   email: { label: 'Email', valueType: 'text-link' },
                   phone: { label: 'Phone' },
               },
           },
       },

4. Define the relationships between entities via a many-to-many via join table.  

       relationships: [
           {
               table: 'myapp_case_person_link',    // the join/link table
               label: 'Related to',
               a: { col: 'case', type: 'myapp_case' },       // column referencing source
               b: { col: 'person', type: 'myapp_person' },    // column referencing target
           },
       ],

   Note:  
   If your link table is shared across multiple parent records (for example, if every case uses the same link table), add the following scopeField and scopeType values to prevent cross-record edge leaks:
   * rel.scopeField = `case`
   * rel.scopeType = `myapp_case`
   {#psds-config-icm-entity-link-anaylsis__ul_vxv_1cw_5kc}
5. Define the directRelationships via an FK.  

       directRelationships: [
           {
               fromType: 'myapp_task',
               toType: 'myapp_case',
               fkField: 'parent_case',    // FK column on myapp_task pointing at myapp_case
               label: 'Belongs to',
           },
       ],

6. Define the top-level visual configuration.  

       // Node bubble icons (filled variants)
       iconMap: {
           myapp_case: 'folder-fill',
           myapp_person: 'user-fill',
           myapp_task: 'clipboard-check-fill',
       },
       defaultIcon: 'gear-fill',

       // Card captions
       captionConfig: {
           myapp_case: { field: 'number' },
           myapp_person: { field: 'role', fallbackText: 'Person' },
       },

       // Status chips
       statusConfig: {
           myapp_person: { field: 'status' },
       },
       statusColorMap: {
           myapp_person: {
               1: { name: 'Active', color: 'positive', icon: 'activity-fill' },
               2: { name: 'Inactive', color: 'low', icon: 'ban-outline' },
           },
       },

       // Edge labels
       edgeLabelConfig: {
           default: { field: 'relationship_type' },
       },

7. Embed the Component in UI Builder.
   1. Navigate to UI Builder and navigate to your workspace record page.
   2. Open a new tab.
   3. Ensure the scope is set to sn_config_comps, and search the component palette for Link Analysis default.
   4. Place the compenent onto the page you wish for the link analysis component to appear.
   5. Add the following properties to the page context.  
      {#psds-config-icm-entity-link-anaylsis__table_mdc_tfm_1lc__entry__3}

      | Property | Bind To | Description |
      |-|-|-|
      | table | Page param: table name | The home record's table (e.g., "myapp_case") |
      | sysID | Page param: record sys_id | The home record's sys_id |
      | graphSysId | Static string: your MY_GRAPH_ID value | Must match the constant in your Config Provider |
      | maxLevels | Static number: 2 | How many relationship hops (1, 2, or 3) |
      [ ]

      {#psds-config-icm-entity-link-anaylsis__table_mdc_tfm_1lc}
   {#psds-config-icm-entity-link-anaylsis__substeps_lgp_3fm_1lc}

## Result

The link analysis is now set up, and the relationship between each entity can be viewed with a graph.

*[\>]: and then