Análisis de redes AML con $graphLookup

Descripción general de la solución

Los delincuentes financieros operan en redes. El lavado de dinero, las redes de fraude y la evasión de sanciones se basan en intrincadas redes de empresas fantasma, directores testaferros y complejas rutas de transacciones. Los equipos de cumplimiento normativo deben mapear y analizar la red de relaciones que rodea a una entidad sospechosa.

Los enfoques tradicionales se topan con dos obstáculos:

• Consultas costosas: Las bases de datos relacionales utilizan expresiones de tabla comunes (CTE) recursivas. Estas consultas se vuelven costosas a partir de dos o tres saltos.

• Viajes de ida y vuelta constantes en la red: el procesamiento de gráficos del lado del cliente extrae datos a la capa de aplicación. El cliente ejecuta una nueva consulta por cada salto.

En esta solución, usted:

• Construya un motor de análisis de redes que utilice operadores de MongoDB para evitar estos cuellos de botella.

• Ejecute recorridos de grafos de múltiples saltos, detección de rutas más cortas, puntuación de centralidad, detección de comunidades y propagación de riesgos directamente dentro del marco de agregación de MongoDB.

Esta solución se centra en el motor de análisis de red y los operadores de MongoDB que lo impulsan. Para implementar la arquitectura general con MongoDB Atlas, FastAPI y Next.js, siga también la Biblioteca de soluciones anterior, Mitigación de delitos financieros.

Arquitecturas de Referencia

El motor de análisis de red se sitúa entre la capa de servicio FastAPI y MongoDB Atlas, y procesa las operaciones de grafos a través del proceso de agregación.

haga clic para ampliar

Figura 1. Proceso de investigación de agentes

Dual $graphLookup Patrón

Las redes de lavado de dinero implican flujos bidireccionales. Una entidad puede obtener fondos a través de una relación y recibirlos a través de otra.

Un único $graphLookup recorre las aristas en una sola dirección. Esta solución ejecuta dos búsquedas paralelas —hacia adelante y hacia atrás— y combina los resultados en un grafo de red unificado.

pipeline = [
    {"$match": {"entityId": center_entity_id}},
    # Forward traversal: follow source → target edges
    {"$graphLookup": {
        "from": "relationships",
        "startWith": "$entityId",
        "connectFromField": "target.entityId",
        "connectToField": "source.entityId",
        "as": "forward_relationships",
        "maxDepth": max_depth - 1,
        "restrictSearchWithMatch": {
            "active": True,
            "confidence": {"$gte": min_confidence}
        }
    }},
    # Reverse traversal: follow target → source edges
    {"$graphLookup": {
        "from": "relationships",
        "startWith": "$entityId",
        "connectFromField": "source.entityId",
        "connectToField": "target.entityId",
        "as": "reverse_relationships",
        "maxDepth": max_depth - 1,
        "restrictSearchWithMatch": {
            "active": True,
            "confidence": {"$gte": min_confidence}
        }
    }},
    # Merge both directions
    {"$project": {
        "entityId": 1,
        "all_relationships": {
            "$concatArrays": [
                "$forward_relationships",
                "$reverse_relationships"
            ]
        }
    }},
    {"$unwind": "$all_relationships"},
    {"$replaceRoot": {"newRoot": "$all_relationships"}},
    {"$limit": max_relationships}
]

haga clic para ampliar

Figura 2. Búsqueda de grafos dual: descubrimiento de red bidireccional

La aplicación recibe el grafo de red completo en un solo viaje de ida y vuelta. Ambos recorridos se ejecutan en una única canalización de agregación, lo que elimina el problema de las consultas N+1 que implica realizar una consulta de seguimiento independiente para cada documento devuelto en la consulta inicial.

Cómo $graphLookup Recorre el grafo

$graphLookup Realiza una búsqueda en amplitud (BFS) en ondas discretas:

• Semilla: Evaluar startWith contra el documento de entrada. Los valores de la matriz inicializan la frontera simultáneamente (BFS de múltiples raíces).

• Consulta: Construye,{ connectToField: { $in: [frontier_values] }} fusionado con cualquier restrictSearchWithMatch filtro. Ejecuta como una consulta indexada estándar contra la colección de origen.

• Expandir: Para cada documento coincidente que no esté en el conjunto visitado, agréguelo a los resultados, extraiga connectFromField los valores y empújelos a la siguiente frontera.

• Repetir: Incrementar la profundidad. Volver al paso 2 hasta que la frontera se vacíe o maxDepth se alcance.

• Ensamblar: Colocar todos los documentos acumulados en una matriz bajo el campo "as".

La detección de ciclos es automática. Un conjunto interno de elementos visitados evita bucles infinitos en grafos cíclicos (A → B → C → A), comunes en las estructuras de lavado de dinero. Cada documento aparece en los resultados exactamente una vez.

La restrictSearchWithMatch Ventaja

restrictSearchWithMatch Incorpora los criterios de filtrado al recorrido en sí, en lugar de aplicarlos posteriormente. MongoDB elimina las ramas obsoletas durante el recorrido, en vez de explorar el grafo completo y filtrarlo después. En redes grandes, esto puede reducir el conjunto de trabajo en un orden de magnitud.

haga clic para ampliar

Figura 3. Filtrado durante el recorrido frente a filtrado posterior.

Enfoque de modelo de datos

La solución utiliza dos colecciones: entities y relationships. Estas siguen un patrón de lista de adyacencia. Los metadatos de los bordes (confianza, evidencia, estado de verificación) se encuentran como campos de primera clase en el documento de relación.

Esquema de relación

{
    "relationshipId": "REL_8910",
    "source": {
        "entityId": "ENT_123",
        "entityType": "individual"
    },
    "target": {
        "entityId": "ENT_456",
        "entityType": "organization"
    },
    "type": "beneficial_owner_of",
    "direction": "directed",
    "strength": 0.85,
    "confidence": 0.95,
    "active": true,
    "verified": true,
    "evidence": [
        {
            "evidence_type": "corporate_registry",
            "confidence": 0.95,
            "source": "Companies House UK"
        }
    ],
    "datasource": "KYC_onboarding"
}

Compilar la solución

Clona el repositorio y sigue las instrucciones de configuración que aparecen en el archivo README de GitHub:

git clone https://github.com/mongodb-industry-solutions/fsi-aml-fraud-detection.git
cd fsi-aml-fraud-detection/aml-backend
poetry install
poetry run uvicorn main:app --host 0.0.0.0 --port 8001 --reload

Las siguientes subsecciones repasan las seis operaciones gráficas principales implementadas en NetworkRepository.

db.relationships.createIndex({
    "source.entityId": 1,
    "active": 1,
    "confidence": -1
});
db.relationships.createIndex({
    "target.entityId": 1,
    "active": 1,
    "confidence": -1
});

pipeline = [
    {"$match": {"entityId": source_entity_id}},
    {"$graphLookup": {
        "from": "relationships",
        "startWith": "$entityId",
        "connectFromField": "source.entityId",
        "connectToField": "target.entityId",
        "as": "forward_paths",
        "maxDepth": max_depth - 1,
        "depthField": "depth"
    }},
    {"$graphLookup": {
        "from": "relationships",
        "startWith": "$entityId",
        "connectFromField": "target.entityId",
        "connectToField": "source.entityId",
        "as": "reverse_paths",
        "maxDepth": max_depth - 1,
        "depthField": "depth"
    }},
    {"$project": {
        "all_paths": {"$concatArrays": ["$forward_paths", "$reverse_paths"]}
    }},
    {"$unwind": "$all_paths"},
    {"$match": {"$or": [
        {"all_paths.source.entityId": target_entity_id},
        {"all_paths.target.entityId": target_entity_id}
    ]}},
    {"$sort": {"all_paths.depth": 1}},
    {"$limit": 1}
]

stats_pipeline = [
    {"$match": {"entityId": {"$in": network_entity_ids}}},
    {"$addFields": {
        "connection_count": {"$size": {"$ifNull": ["$connected_entities", []]}}
    }},
    {"$facet": {
        "basic_stats": [{"$group": {
            "_id": None,
            "total_nodes": {"$sum": 1},
            "avg_risk_score": {"$avg": "$riskAssessment.overall.score"},
            "max_risk_score": {"$max": "$riskAssessment.overall.score"}
        }}],
        "risk_distribution": [
            {"$group": {"_id": "$riskAssessment.overall.level", "count": {"$sum": 1}}},
            {"$sort": {"_id": 1}}
        ],
        "hub_entities": [
            {"$match": {"connection_count": {"$gte": 2}}},
            {"$sort": {"connection_count": -1}},
            {"$limit": 5},
            {"$project": {"entityId": 1, "name": 1, "connection_count": 1}}
        ]
    }}
]

"outgoing_risk_weighted": {
    "$sum": {"$multiply": [
        "$confidence",
        {"$switch": {
            "branches": [
                {"case": {"$in": ["$type", [
                    "confirmed_same_entity",
                    "business_associate_suspected"
                ]]}, "then": 0.9},
                {"case": {"$in": ["$type", [
                    "director_of", "ubo_of",
                    "parent_of_subsidiary"
                ]]}, "then": 0.7},
                {"case": {"$in": ["$type", [
                    "household_member",
                    "professional_colleague_public"
                ]]}, "then": 0.3}
            ],
            "default": 0.5
        }}
    ]}
}

adjacency_pipeline = [
    {"$match": {
        "$or": [
            {"source.entityId": {"$in": entity_ids}},
            {"target.entityId": {"$in": entity_ids}}
        ],
        "active": True,
        "confidence": {"$gte": 0.7}
    }},
    {"$group": {
        "_id": "$source.entityId",
        "connections": {"$addToSet": "$target.entityId"}
    }}
]

propagated_risk = (
    parent_entity_risk
    * propagation_factor        # decay per hop (default: 0.5)
    * relationship_confidence   # trust level for this edge
    * type_risk_weight          # domain-specific weight
)

Lecciones clave

• Utilice doble $graphLookup Para el descubrimiento de redes bidireccionales: ejecute dos búsquedas paralelas, hacia adelante y hacia atrás, y combine los resultados con $concatArrays para capturar la red completa en una sola agregación.

• Empujar filtros en el recorrido con restrictSearchWithMatch: Podar las ramas muertas durante la búsqueda en amplitud (BFS) en lugar de filtrar el grafo completo posteriormente para reducir el conjunto de trabajo en redes grandes.

• Crear índices compuestos en connectToField y sus filtros de recorrido: $graphLookup emite una $match/$in consulta en cada onda BFS, por lo que indexar connectToField junto con active y confidence evita escaneos de colección en cada salto.

• Calcular análisis de red del lado del servidor con $facet y $switch: Ejecutar la distribución de riesgos, la detección de hubs y la puntuación de centralidad en subcanales paralelos, y usar $switch para asignar ponderaciones de riesgo específicas del dominio a los tipos de relaciones dentro de la agregación.

• Aplique la disminución exponencial para la propagación del riesgo: combine $graphLookupel descubrimiento de redes basado en con una fórmula de disminución por salto que incluya la confianza y el tipo de relación, de modo que el modelo distinga automáticamente las conexiones estructurales de alto riesgo de los vínculos sociales de bajo riesgo. Esto coincide con la directriz de mantener los aprendizajes clave en un estilo imperativo coherente.

Autores

• Luis Pazmiño

• Mehar Grewal

• Andrea Alaman Calderon