graphiti-core 0.15.1__py3-none-any.whl → 0.17.0__py3-none-any.whl

graphiti_core/utils/bulk_utils.py

@@ -16,50 +16,40 @@ limitations under the License.
 
 import logging
 import typing
-from collections import defaultdict
 from datetime import datetime
-from math import ceil
 
-from numpy import dot, sqrt
-from pydantic import BaseModel
+import numpy as np
+from pydantic import BaseModel, Field
 from typing_extensions import Any
 
 from graphiti_core.driver.driver import GraphDriver, GraphDriverSession
-from graphiti_core.edges import Edge, EntityEdge, EpisodicEdge
+from graphiti_core.edges import Edge, EntityEdge, EpisodicEdge, create_entity_edge_embeddings
 from graphiti_core.embedder import EmbedderClient
 from graphiti_core.graph_queries import (
     get_entity_edge_save_bulk_query,
     get_entity_node_save_bulk_query,
 )
 from graphiti_core.graphiti_types import GraphitiClients
-from graphiti_core.helpers import DEFAULT_DATABASE, semaphore_gather
-from graphiti_core.llm_client import LLMClient
+from graphiti_core.helpers import normalize_l2, semaphore_gather
 from graphiti_core.models.edges.edge_db_queries import (
     EPISODIC_EDGE_SAVE_BULK,
 )
 from graphiti_core.models.nodes.node_db_queries import (
     EPISODIC_NODE_SAVE_BULK,
 )
-from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode
-from graphiti_core.search.search_filters import SearchFilters
-from graphiti_core.search.search_utils import get_relevant_edges, get_relevant_nodes
-from graphiti_core.utils.datetime_utils import utc_now
+from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode, create_entity_node_embeddings
 from graphiti_core.utils.maintenance.edge_operations import (
-    build_episodic_edges,
-    dedupe_edge_list,
-    dedupe_extracted_edges,
     extract_edges,
+    resolve_extracted_edge,
 )
 from graphiti_core.utils.maintenance.graph_data_operations import (
     EPISODE_WINDOW_LEN,
     retrieve_episodes,
 )
 from graphiti_core.utils.maintenance.node_operations import (
-    dedupe_extracted_nodes,
-    dedupe_node_list,
     extract_nodes,
+    resolve_extracted_nodes,
 )
-from graphiti_core.utils.maintenance.temporal_operations import extract_edge_dates
 
 logger = logging.getLogger(__name__)
 
@@ -68,6 +58,7 @@ CHUNK_SIZE = 10
 
 class RawEpisode(BaseModel):
     name: str
+    uuid: str | None = Field(default=None)
     content: str
     source_description: str
     source: EpisodeType
@@ -100,7 +91,7 @@ async def add_nodes_and_edges_bulk(
     entity_edges: list[EntityEdge],
     embedder: EmbedderClient,
 ):
-    session = driver.session(database=DEFAULT_DATABASE)
+    session = driver.session()
     try:
         await session.execute_write(
             add_nodes_and_edges_bulk_tx,
@@ -179,233 +170,258 @@ async def add_nodes_and_edges_bulk_tx(
 async def extract_nodes_and_edges_bulk(
     clients: GraphitiClients,
     episode_tuples: list[tuple[EpisodicNode, list[EpisodicNode]]],
+    edge_type_map: dict[tuple[str, str], list[str]],
     entity_types: dict[str, BaseModel] | None = None,
     excluded_entity_types: list[str] | None = None,
-) -> tuple[list[EntityNode], list[EntityEdge], list[EpisodicEdge]]:
-    extracted_nodes_bulk = await semaphore_gather(
+    edge_types: dict[str, BaseModel] | None = None,
+) -> tuple[list[list[EntityNode]], list[list[EntityEdge]]]:
+    extracted_nodes_bulk: list[list[EntityNode]] = await semaphore_gather(
         *[
             extract_nodes(clients, episode, previous_episodes, entity_types, excluded_entity_types)
             for episode, previous_episodes in episode_tuples
         ]
     )
 
-    episodes, previous_episodes_list = (
-        [episode[0] for episode in episode_tuples],
-        [episode[1] for episode in episode_tuples],
-    )
-
-    extracted_edges_bulk = await semaphore_gather(
+    extracted_edges_bulk: list[list[EntityEdge]] = await semaphore_gather(
         *[
             extract_edges(
                 clients,
                 episode,
                 extracted_nodes_bulk[i],
-                previous_episodes_list[i],
-                {},
-                episode.group_id,
+                previous_episodes,
+                edge_type_map=edge_type_map,
+                group_id=episode.group_id,
+                edge_types=edge_types,
             )
-            for i, episode in enumerate(episodes)
+            for i, (episode, previous_episodes) in enumerate(episode_tuples)
         ]
     )
 
-    episodic_edges: list[EpisodicEdge] = []
-    for i, episode in enumerate(episodes):
-        episodic_edges += build_episodic_edges(extracted_nodes_bulk[i], episode, episode.created_at)
-
-    nodes: list[EntityNode] = []
-    for extracted_nodes in extracted_nodes_bulk:
-        nodes += extracted_nodes
-
-    edges: list[EntityEdge] = []
-    for extracted_edges in extracted_edges_bulk:
-        edges += extracted_edges
-
-    return nodes, edges, episodic_edges
+    return extracted_nodes_bulk, extracted_edges_bulk
 
 
 async def dedupe_nodes_bulk(
-    driver: GraphDriver,
-    llm_client: LLMClient,
-    extracted_nodes: list[EntityNode],
-) -> tuple[list[EntityNode], dict[str, str]]:
-    # Compress nodes
-    nodes, uuid_map = node_name_match(extracted_nodes)
-
-    compressed_nodes, compressed_map = await compress_nodes(llm_client, nodes, uuid_map)
-
-    node_chunks = [nodes[i : i + CHUNK_SIZE] for i in range(0, len(nodes), CHUNK_SIZE)]
-
-    existing_nodes_chunks: list[list[EntityNode]] = list(
-        await semaphore_gather(
-            *[get_relevant_nodes(driver, node_chunk, SearchFilters()) for node_chunk in node_chunks]
-        )
-    )
-
-    results: list[tuple[list[EntityNode], dict[str, str]]] = list(
-        await semaphore_gather(
-            *[
-                dedupe_extracted_nodes(llm_client, node_chunk, existing_nodes_chunks[i])
-                for i, node_chunk in enumerate(node_chunks)
-            ]
-        )
-    )
-
-    final_nodes: list[EntityNode] = []
-    for result in results:
-        final_nodes.extend(result[0])
-        partial_uuid_map = result[1]
-        compressed_map.update(partial_uuid_map)
-
-    return final_nodes, compressed_map
-
-
-async def dedupe_edges_bulk(
-    driver: GraphDriver, llm_client: LLMClient, extracted_edges: list[EntityEdge]
-) -> list[EntityEdge]:
-    # First compress edges
-    compressed_edges = await compress_edges(llm_client, extracted_edges)
-
-    edge_chunks = [
-        compressed_edges[i : i + CHUNK_SIZE] for i in range(0, len(compressed_edges), CHUNK_SIZE)
-    ]
+    clients: GraphitiClients,
+    extracted_nodes: list[list[EntityNode]],
+    episode_tuples: list[tuple[EpisodicNode, list[EpisodicNode]]],
+    entity_types: dict[str, BaseModel] | None = None,
+) -> tuple[dict[str, list[EntityNode]], dict[str, str]]:
+    embedder = clients.embedder
+    min_score = 0.8
 
-    relevant_edges_chunks: list[list[EntityEdge]] = list(
-        await semaphore_gather(
-            *[get_relevant_edges(driver, edge_chunk, SearchFilters()) for edge_chunk in edge_chunks]
-        )
+    # generate embeddings
+    await semaphore_gather(
+        *[create_entity_node_embeddings(embedder, nodes) for nodes in extracted_nodes]
     )
 
-    resolved_edge_chunks: list[list[EntityEdge]] = list(
-        await semaphore_gather(
-            *[
-                dedupe_extracted_edges(llm_client, edge_chunk, relevant_edges_chunks[i])
-                for i, edge_chunk in enumerate(edge_chunks)
-            ]
-        )
+    # Find similar results
+    dedupe_tuples: list[tuple[list[EntityNode], list[EntityNode]]] = []
+    for i, nodes_i in enumerate(extracted_nodes):
+        existing_nodes: list[EntityNode] = []
+        for j, nodes_j in enumerate(extracted_nodes):
+            if i == j:
+                continue
+            existing_nodes += nodes_j
+
+        candidates_i: list[EntityNode] = []
+        for node in nodes_i:
+            for existing_node in existing_nodes:
+                # Approximate BM25 by checking for word overlaps (this is faster than creating many in-memory indices)
+                # This approach will cast a wider net than BM25, which is ideal for this use case
+                node_words = set(node.name.lower().split())
+                existing_node_words = set(existing_node.name.lower().split())
+                has_overlap = not node_words.isdisjoint(existing_node_words)
+                if has_overlap:
+                    candidates_i.append(existing_node)
+                    continue
+
+                # Check for semantic similarity even if there is no overlap
+                similarity = np.dot(
+                    normalize_l2(node.name_embedding or []),
+                    normalize_l2(existing_node.name_embedding or []),
+                )
+                if similarity >= min_score:
+                    candidates_i.append(existing_node)
+
+        dedupe_tuples.append((nodes_i, candidates_i))
+
+    # Determine Node Resolutions
+    bulk_node_resolutions: list[
+        tuple[list[EntityNode], dict[str, str], list[tuple[EntityNode, EntityNode]]]
+    ] = await semaphore_gather(
+        *[
+            resolve_extracted_nodes(
+                clients,
+                dedupe_tuple[0],
+                episode_tuples[i][0],
+                episode_tuples[i][1],
+                entity_types,
+                existing_nodes_override=dedupe_tuples[i][1],
+            )
+            for i, dedupe_tuple in enumerate(dedupe_tuples)
+        ]
     )
 
-    edges = [edge for edge_chunk in resolved_edge_chunks for edge in edge_chunk]
-    return edges
-
-
-def node_name_match(nodes: list[EntityNode]) -> tuple[list[EntityNode], dict[str, str]]:
-    uuid_map: dict[str, str] = {}
-    name_map: dict[str, EntityNode] = {}
-    for node in nodes:
-        if node.name in name_map:
-            uuid_map[node.uuid] = name_map[node.name].uuid
-            continue
-
-        name_map[node.name] = node
-
-    return [node for node in name_map.values()], uuid_map
-
+    # Collect all duplicate pairs sorted by uuid
+    duplicate_pairs: list[tuple[EntityNode, EntityNode]] = []
+    for _, _, duplicates in bulk_node_resolutions:
+        for duplicate in duplicates:
+            n, m = duplicate
+            if n.uuid < m.uuid:
+                duplicate_pairs.append((n, m))
+            else:
+                duplicate_pairs.append((m, n))
+
+    # Build full deduplication map
+    duplicate_map: dict[str, str] = {}
+    for value, key in duplicate_pairs:
+        if key.uuid in duplicate_map:
+            existing_value = duplicate_map[key.uuid]
+            duplicate_map[key.uuid] = value.uuid if value.uuid < existing_value else existing_value
+        else:
+            duplicate_map[key.uuid] = value.uuid
 
-async def compress_nodes(
-    llm_client: LLMClient, nodes: list[EntityNode], uuid_map: dict[str, str]
-) -> tuple[list[EntityNode], dict[str, str]]:
-    # We want to first compress the nodes by deduplicating nodes across each of the episodes added in bulk
-    if len(nodes) == 0:
-        return nodes, uuid_map
+    # Now we compress the duplicate_map, so that 3 -> 2 and 2 -> becomes 3 -> 1 (sorted by uuid)
+    compressed_map: dict[str, str] = compress_uuid_map(duplicate_map)
 
-    # Our approach involves us deduplicating chunks of nodes in parallel.
-    # We want n chunks of size n so that n ** 2 == len(nodes).
-    # We want chunk sizes to be at least 10 for optimizing LLM processing time
-    chunk_size = max(int(sqrt(len(nodes))), CHUNK_SIZE)
+    node_uuid_map: dict[str, EntityNode] = {
+        node.uuid: node for nodes in extracted_nodes for node in nodes
+    }
 
-    # First calculate similarity scores between nodes
-    similarity_scores: list[tuple[int, int, float]] = [
-        (i, j, dot(n.name_embedding or [], m.name_embedding or []))
-        for i, n in enumerate(nodes)
-        for j, m in enumerate(nodes[:i])
-    ]
+    nodes_by_episode: dict[str, list[EntityNode]] = {}
+    for i, nodes in enumerate(extracted_nodes):
+        episode = episode_tuples[i][0]
 
-    # We now sort by semantic similarity
-    similarity_scores.sort(key=lambda score_tuple: score_tuple[2])
+        nodes_by_episode[episode.uuid] = [
+            node_uuid_map[compressed_map.get(node.uuid, node.uuid)] for node in nodes
+        ]
 
-    # initialize our chunks based on chunk size
-    node_chunks: list[list[EntityNode]] = [[] for _ in range(ceil(len(nodes) / chunk_size))]
+    return nodes_by_episode, compressed_map
 
-    # Draft the most similar nodes into the same chunk
-    while len(similarity_scores) > 0:
-        i, j, _ = similarity_scores.pop()
-        # determine if any of the nodes have already been drafted into a chunk
-        n = nodes[i]
-        m = nodes[j]
-        # make sure the shortest chunks get preference
-        node_chunks.sort(reverse=True, key=lambda chunk: len(chunk))
 
-        n_chunk = max([i if n in chunk else -1 for i, chunk in enumerate(node_chunks)])
-        m_chunk = max([i if m in chunk else -1 for i, chunk in enumerate(node_chunks)])
+async def dedupe_edges_bulk(
+    clients: GraphitiClients,
+    extracted_edges: list[list[EntityEdge]],
+    episode_tuples: list[tuple[EpisodicNode, list[EpisodicNode]]],
+    _entities: list[EntityNode],
+    edge_types: dict[str, BaseModel],
+    _edge_type_map: dict[tuple[str, str], list[str]],
+) -> dict[str, list[EntityEdge]]:
+    embedder = clients.embedder
+    min_score = 0.6
+
+    # generate embeddings
+    await semaphore_gather(
+        *[create_entity_edge_embeddings(embedder, edges) for edges in extracted_edges]
+    )
 
-        # both nodes already in a chunk
-        if n_chunk > -1 and m_chunk > -1:
-            continue
+    # Find similar results
+    dedupe_tuples: list[tuple[EpisodicNode, EntityEdge, list[EntityEdge]]] = []
+    for i, edges_i in enumerate(extracted_edges):
+        existing_edges: list[EntityEdge] = []
+        for j, edges_j in enumerate(extracted_edges):
+            if i == j:
+                continue
+            existing_edges += edges_j
+
+        for edge in edges_i:
+            candidates: list[EntityEdge] = []
+            for existing_edge in existing_edges:
+                # Approximate BM25 by checking for word overlaps (this is faster than creating many in-memory indices)
+                # This approach will cast a wider net than BM25, which is ideal for this use case
+                edge_words = set(edge.fact.lower().split())
+                existing_edge_words = set(existing_edge.fact.lower().split())
+                has_overlap = not edge_words.isdisjoint(existing_edge_words)
+                if has_overlap:
+                    candidates.append(existing_edge)
+                    continue
+
+                # Check for semantic similarity even if there is no overlap
+                similarity = np.dot(
+                    normalize_l2(edge.fact_embedding or []),
+                    normalize_l2(existing_edge.fact_embedding or []),
+                )
+                if similarity >= min_score:
+                    candidates.append(existing_edge)
+
+            dedupe_tuples.append((episode_tuples[i][0], edge, candidates))
+
+    bulk_edge_resolutions: list[
+        tuple[EntityEdge, EntityEdge, list[EntityEdge]]
+    ] = await semaphore_gather(
+        *[
+            resolve_extracted_edge(
+                clients.llm_client, edge, candidates, candidates, episode, edge_types
+            )
+            for episode, edge, candidates in dedupe_tuples
+        ]
+    )
 
-        # n has a chunk and that chunk is not full
-        elif n_chunk > -1 and len(node_chunks[n_chunk]) < chunk_size:
-            # put m in the same chunk as n
-            node_chunks[n_chunk].append(m)
+    duplicate_pairs: list[tuple[EntityEdge, EntityEdge]] = []
+    for i, (_, _, duplicates) in enumerate(bulk_edge_resolutions):
+        episode, edge, candidates = dedupe_tuples[i]
+        for duplicate in duplicates:
+            if edge.uuid < duplicate.uuid:
+                duplicate_pairs.append((edge, duplicate))
+            else:
+                duplicate_pairs.append((duplicate, edge))
+
+    # Build full deduplication map
+    duplicate_map: dict[str, str] = {}
+    for value, key in duplicate_pairs:
+        if key.uuid in duplicate_map:
+            existing_value = duplicate_map[key.uuid]
+            duplicate_map[key.uuid] = value.uuid if value.uuid < existing_value else existing_value
+        else:
+            duplicate_map[key.uuid] = value.uuid
 
-        # m has a chunk and that chunk is not full
-        elif m_chunk > -1 and len(node_chunks[m_chunk]) < chunk_size:
-            # put n in the same chunk as m
-            node_chunks[m_chunk].append(n)
+    # Now we compress the duplicate_map, so that 3 -> 2 and 2 -> becomes 3 -> 1 (sorted by uuid)
+    compressed_map: dict[str, str] = compress_uuid_map(duplicate_map)
 
-        # neither node has a chunk or the chunk is full
-        else:
-            # add both nodes to the shortest chunk
-            node_chunks[-1].extend([n, m])
+    edge_uuid_map: dict[str, EntityEdge] = {
+        edge.uuid: edge for edges in extracted_edges for edge in edges
+    }
 
-    results = await semaphore_gather(
-        *[dedupe_node_list(llm_client, chunk) for chunk in node_chunks]
-    )
+    edges_by_episode: dict[str, list[EntityEdge]] = {}
+    for i, edges in enumerate(extracted_edges):
+        episode = episode_tuples[i][0]
 
-    extended_map = dict(uuid_map)
-    compressed_nodes: list[EntityNode] = []
-    for node_chunk, uuid_map_chunk in results:
-        compressed_nodes += node_chunk
-        extended_map.update(uuid_map_chunk)
+        edges_by_episode[episode.uuid] = [
+            edge_uuid_map[compressed_map.get(edge.uuid, edge.uuid)] for edge in edges
+        ]
 
-    # Check if we have removed all duplicates
-    if len(compressed_nodes) == len(nodes):
-        compressed_uuid_map = compress_uuid_map(extended_map)
-        return compressed_nodes, compressed_uuid_map
+    return edges_by_episode
 
-    return await compress_nodes(llm_client, compressed_nodes, extended_map)
 
+def compress_uuid_map(uuid_map: dict[str, str]) -> dict[str, str]:
+    compressed_map = {}
 
-async def compress_edges(llm_client: LLMClient, edges: list[EntityEdge]) -> list[EntityEdge]:
-    if len(edges) == 0:
-        return edges
-    # We only want to dedupe edges that are between the same pair of nodes
-    # We build a map of the edges based on their source and target nodes.
-    edge_chunks = chunk_edges_by_nodes(edges)
+    def find_min_uuid(start: str) -> str:
+        path = []
+        visited = set()
+        curr = start
 
-    results = await semaphore_gather(
-        *[dedupe_edge_list(llm_client, chunk) for chunk in edge_chunks]
-    )
+        while curr in uuid_map and curr not in visited:
+            visited.add(curr)
+            path.append(curr)
+            curr = uuid_map[curr]
 
-    compressed_edges: list[EntityEdge] = []
-    for edge_chunk in results:
-        compressed_edges += edge_chunk
+        # Also include the last resolved value (could be outside the map)
+        path.append(curr)
 
-    # Check if we have removed all duplicates
-    if len(compressed_edges) == len(edges):
-        return compressed_edges
+        # Resolve to lex smallest UUID in the path
+        min_uuid = min(path)
 
-    return await compress_edges(llm_client, compressed_edges)
+        # Assign all UUIDs in the path to the min_uuid
+        for node in path:
+            compressed_map[node] = min_uuid
 
+        return min_uuid
 
-def compress_uuid_map(uuid_map: dict[str, str]) -> dict[str, str]:
-    # make sure all uuid values aren't mapped to other uuids
-    compressed_map = {}
-    for key, uuid in uuid_map.items():
-        curr_value = uuid
-        while curr_value in uuid_map:
-            curr_value = uuid_map[curr_value]
+    for key in uuid_map:
+        if key not in compressed_map:
+            find_min_uuid(key)
 
-        compressed_map[key] = curr_value
     return compressed_map
 
 
@@ -420,63 +436,3 @@ def resolve_edge_pointers(edges: list[E], uuid_map: dict[str, str]):
         edge.target_node_uuid = uuid_map.get(target_uuid, target_uuid)
 
     return edges
-
-
-async def extract_edge_dates_bulk(
-    llm_client: LLMClient,
-    extracted_edges: list[EntityEdge],
-    episode_pairs: list[tuple[EpisodicNode, list[EpisodicNode]]],
-) -> list[EntityEdge]:
-    edges: list[EntityEdge] = []
-    # confirm that all of our edges have at least one episode
-    for edge in extracted_edges:
-        if edge.episodes is not None and len(edge.episodes) > 0:
-            edges.append(edge)
-
-    episode_uuid_map: dict[str, tuple[EpisodicNode, list[EpisodicNode]]] = {
-        episode.uuid: (episode, previous_episodes) for episode, previous_episodes in episode_pairs
-    }
-
-    results = await semaphore_gather(
-        *[
-            extract_edge_dates(
-                llm_client,
-                edge,
-                episode_uuid_map[edge.episodes[0]][0],  # type: ignore
-                episode_uuid_map[edge.episodes[0]][1],  # type: ignore
-            )
-            for edge in edges
-        ]
-    )
-
-    for i, result in enumerate(results):
-        valid_at = result[0]
-        invalid_at = result[1]
-        edge = edges[i]
-
-        edge.valid_at = valid_at
-        edge.invalid_at = invalid_at
-        if edge.invalid_at:
-            edge.expired_at = utc_now()
-
-    return edges
-
-
-def chunk_edges_by_nodes(edges: list[EntityEdge]) -> list[list[EntityEdge]]:
-    # We only want to dedupe edges that are between the same pair of nodes
-    # We build a map of the edges based on their source and target nodes.
-    edge_chunk_map: dict[str, list[EntityEdge]] = defaultdict(list)
-    for edge in edges:
-        # We drop loop edges
-        if edge.source_node_uuid == edge.target_node_uuid:
-            continue
-
-        # Keep the order of the two nodes consistent, we want to be direction agnostic during edge resolution
-        pointers = [edge.source_node_uuid, edge.target_node_uuid]
-        pointers.sort()
-
-        edge_chunk_map[pointers[0] + pointers[1]].append(edge)
-
-    edge_chunks = [chunk for chunk in edge_chunk_map.values()]
-
-    return edge_chunks

graphiti_core/utils/maintenance/community_operations.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel
 from graphiti_core.driver.driver import GraphDriver
 from graphiti_core.edges import CommunityEdge
 from graphiti_core.embedder import EmbedderClient
-from graphiti_core.helpers import DEFAULT_DATABASE, semaphore_gather
+from graphiti_core.helpers import semaphore_gather
 from graphiti_core.llm_client import LLMClient
 from graphiti_core.nodes import CommunityNode, EntityNode, get_community_node_from_record
 from graphiti_core.prompts import prompt_library
@@ -37,7 +37,6 @@ async def get_community_clusters(
         RETURN 
             collect(DISTINCT n.group_id) AS group_ids
         """,
-            database_=DEFAULT_DATABASE,
         )
 
         group_ids = group_id_values[0]['group_ids'] if group_id_values else []
@@ -56,7 +55,6 @@ async def get_community_clusters(
             """,
                 uuid=node.uuid,
                 group_id=group_id,
-                database_=DEFAULT_DATABASE,
             )
 
             projection[node.uuid] = [
@@ -224,7 +222,6 @@ async def remove_communities(driver: GraphDriver):
     MATCH (c:Community)
     DETACH DELETE c
     """,
-        database_=DEFAULT_DATABASE,
     )
 
 
@@ -243,7 +240,6 @@ async def determine_entity_community(
         c.summary AS summary
     """,
         entity_uuid=entity.uuid,
-        database_=DEFAULT_DATABASE,
     )
 
     if len(records) > 0:
@@ -261,7 +257,6 @@ async def determine_entity_community(
         c.summary AS summary
     """,
         entity_uuid=entity.uuid,
-        database_=DEFAULT_DATABASE,
     )
 
     communities: list[CommunityNode] = [