public Map CreateLinkChart( 
   string name,
   Uri knowledgeGraphServiceUri,
   KnowledgeGraphLayerIDSet idSet
)

// get the active investigation view
var iv = KnowledgeGraphInvestigationView.Active;

QueuedTask.Run(() =>
{
  // get the investigation
  var inv = iv.Investigation;

  // get the set of selected records
  var idSet = iv.GetSelectedRecords();

  // view these records in a link chart
  var map = MapFactory.Instance.CreateLinkChart("myLinkChart", new Uri(inv.ServiceUri), idSet);
  ProApp.Panes.CreateMapPaneAsync(map);
});

var map = MapView.Active.Map;
if (map.MapType != MapType.LinkChart)
  return;

// find the KG layer
var kgLayer = map.GetLayersAsFlattenedList().OfType<KnowledgeGraphLayer>().FirstOrDefault();
if (kgLayer == null)
  return;

// find the first LinkChartFeatureLayer in the KG layer
var lcFeatureLayer = kgLayer.GetLayersAsFlattenedList().OfType<LinkChartFeatureLayer>().FirstOrDefault();
if (lcFeatureLayer != null)
  return;

QueuedTask.Run(() =>
{
  // get the KG
  var kg = kgLayer.GetDatastore();

  // get the ID set of the KG layer
  var idSet = kgLayer.GetIDSet();

  // get the named object type in the KG that the LinkChartFeatureLayer represents
  var typeName = lcFeatureLayer.GetTypeName();
  // if there are items in the ID Set for this type
  if (idSet.Contains(typeName))
  {
    // build a new ID set containing only these records
    var dict = idSet.ToOIDDictionary();
    var oids = dict[typeName];

    var newDict = new Dictionary<string, List<long>>();
    newDict.Add(typeName, oids);

    var newIDSet = KnowledgeGraphLayerIDSet.FromDictionary(kg, newDict);

    // now create a new link chart using just this subset of records
    MapFactory.Instance.CreateLinkChart("subset LinkChart", kg, newIDSet);
  }
});

QueuedTask.Run(() =>
{
  //Create the link chart and show it
  //build the IDSet using KnowledgeGraphFilterType.AllNamedObjects
  var idSet = KnowledgeGraphLayerIDSet.FromKnowledgeGraph(
    kg, KnowledgeGraphFilterType.AllNamedObjects);
  var linkChart = MapFactory.Instance.CreateLinkChart(
                    "KG Link Chart", kg, idSet);
  FrameworkApplication.Panes.CreateMapPaneAsync(linkChart);
});

QueuedTask.Run(() =>
{
  //Create the link chart with a -null- id set
  //This will create a KG Layer with empty sub-layers
  //(Note: you cannot create an empty KG layer on a map - only on a link chart)
  var linkChart = MapFactory.Instance.CreateLinkChart(
                    "KG Link Chart", kg, null);
  FrameworkApplication.Panes.CreateMapPaneAsync(linkChart);
});

string url =
        @"https://acme.server.com/server/rest/services/Hosted/AcmeKnowledgeGraph/KnowledgeGraphServer";

QueuedTask.Run(() =>
{
  using (var kg = new KnowledgeGraph(new KnowledgeGraphConnectionProperties(new Uri(url))))
  {
    var idSet = KnowledgeGraphLayerIDSet.FromKnowledgeGraph(
      kg, KnowledgeGraphFilterType.AllEntities);
    var newLinkChart = MapFactory.Instance.CreateLinkChart(
      "All_Entities link chart", kg, idSet);
  };
});

//use the results of a query to create an idset. Create the link chart
//containing just records corresponding to the query results
var qry = @"MATCH (p1:PhoneNumber)-[r1:MADE_CALL|RECEIVED_CALL]->(c1:PhoneCall)<-" +
          @"[r2:MADE_CALL|RECEIVED_CALL]-(p2:PhoneNumber)-[r3:MADE_CALL|RECEIVED_CALL]" +
          @"->(c2:PhoneCall)<-[r4:MADE_CALL|RECEIVED_CALL]-(p3:PhoneNumber) " +
          @"WHERE p1.FULL_NAME = ""Robert Johnson"" AND " +
          @"p3.FULL_NAME= ""Dan Brown"" AND " +
          @"p1.globalid <> p2.globalid AND " +
          @"p2.globalid <> p3.globalid " +
          @"RETURN p1, r1, c1, r2, p2, r3, c2, r4, p3";

var dict = new Dictionary<string, List<long>>();

QueuedTask.Run(async () =>
{
  using (var kg = kg_layer.GetDatastore())
  {
    var graphQuery = new KnowledgeGraphQueryFilter()
    {
      QueryText = qry
    };

    using (var kgRowCursor = kg.SubmitQuery(graphQuery))
    {
      while (await kgRowCursor.WaitForRowsAsync())
      {
        while (kgRowCursor.MoveNext())
        {
          using (var graphRow = kgRowCursor.Current)
          {
            // process the row
            var cnt_val = (int)graphRow.GetCount();
            for (int v = 0; v < cnt_val; v++)
            {
              var obj_val = graphRow[v] as KnowledgeGraphNamedObjectValue;
              var type_name = obj_val.GetTypeName();
              var oid = (long)obj_val.GetObjectID();
              if (!dict.ContainsKey(type_name))
              {
                dict[type_name] = new List<long>();
              }
              if (!dict[type_name].Contains(oid))
                dict[type_name].Add(oid);
            }
          }
        }
      }
    }
    //make an ID Set to create the LinkChart
    var idSet = KnowledgeGraphLayerIDSet.FromDictionary(kg, dict);

    //Create the link chart and show it
    var linkChart = MapFactory.Instance.CreateLinkChart(
                      "KG With ID Set", kg, idSet);
    FrameworkApplication.Panes.CreateMapPaneAsync(linkChart);
  }
});

    //using ArcGIS.Core.Data.Knowledge.Extensions;

    await QueuedTask.Run(async() =>
    {
        var ffp_config = new CIMFilteredFindPathsConfiguration();
        ffp_config.Name = "Create Link Chart from FFP Results";
//set up config
//...
        
        var results = kg.RunFilteredFindPaths(ffp_config);

        var pathsEntitiesAndRelationships = results.ExtractPathsEntitiesAndRelationships(null);

        //Create a KG layer id set
        var kgLayerIdSet = KnowledgeGraphLayerIDSet.FromKnowledgeGraphIDSet(
            pathsEntitiesAndRelationships.ToKnowledgeGraphIDSet(
                KGResultContentFromFFP.EntitiesAndRelationships));

        //Create a brand new link chart with the results and show it
        var linkChart = MapFactory.Instance.CreateLinkChart(
                                            "KG Intro", kg, kgLayerIdSet);

        var mapPane = await FrameworkApplication.Panes.CreateMapPaneAsync(linkChart);
        var linkChartView = mapPane.MapView;

        //Change layout algo to match the default used by the UI after FFP
        await linkChartView.SetLinkChartLayoutAsync(
            KnowledgeLinkChartLayoutAlgorithm.Hierarchical_TopToBottom);

        //Set root nodes - they correspond to the origin nodes of the result paths
        var kgLayerIdSetForRootNodes = KnowledgeGraphLayerIDSet.FromKnowledgeGraphIDSet(
            pathsEntitiesAndRelationships.ToKnowledgeGraphIDSet(
                KGResultContentFromFFP.OnlyPathsOriginEntities));

        //To correctly identify the ids in the link chart we must change the ids
        //from Geodatabase oids returned in the KnowledgeGraphLayerIDSet to the
//temporary/synthetic oids used by layers in the link chart...
        var kg_layer = linkChart.GetLayersAsFlattenedList().OfType<KnowledgeGraphLayer>().First();
        var mapMembers = kg_layer.GetMapMembersAsFlattenedList();
        var oidDict = kgLayerIdSetForRootNodes.ToOIDDictionary();
        var mmDict = new Dictionary<MapMember, List<long>>();
        foreach (var kvp in oidDict)
        {
            var named_type = kvp.Key;
            foreach (var mm in mapMembers)
            {
                if (mm is LinkChartFeatureLayer fl_lc && fl_lc.IsEntity)
                {
                    if (fl_lc.GetTypeName().ToLower() == named_type.ToLower())
                    {
                        var lc_oids = new List<long>();
                        //these oids are from the geodatabase
                        var oid_field = $"{fl_lc.GetTypeName()}.objectid";
                        var id_list = string.Join(',', kvp.Value.ToArray());
                        var where = $"{fl_lc.GetTypeName()}.objectid IN ({id_list})";

                        var qf = new ArcGIS.Core.Data.QueryFilter()
                        {
                            WhereClause = where,
                            SubFields = $"LC.OID,{oid_field}"//the 'LC.OID' oids are the ones
                                           //we need for the mapmember id set
                                           //in the link chart
                        };
                        var rc = fl_lc.Search(qf);
                        var oid_idx = rc.FindField(oid_field);
                        while (rc.MoveNext())
                        {
                            var oid = (long)rc.Current[oid_idx];
                            var lc_oid = rc.Current.GetObjectID();
                            lc_oids.Add(lc_oid);
                        }
                        rc.Dispose();
                        mmDict[fl_lc] = lc_oids;
                        break;
                    }
                }
            }
        }

        var mmIdSet = MapMemberIDSet.FromDictionary(mmDict);
        linkChartView.SetRootNodes(mmIdSet);
    });