BigQuery GraphRAG की मदद से, मनी लॉन्ड्रिंग और धोखाधड़ी को रोकना

1. परिचय

इस कोडलैब में, आपको मनी लॉन्ड्रिंग (एएमएल) और वित्तीय धोखाधड़ी का पता लगाने के लिए, Graph Retrieval-Augmented Generation (GraphRAG) समाधान बनाने का तरीका बताया जाएगा. इसमें LangChain के ज़रिए, Vertex AI, Vector Search, और BigQuery की नेटिव Graph सुविधाओं का इस्तेमाल किया जाएगा. इस लैब के आखिर तक, आपको पता चल जाएगा कि लार्ज लैंग्वेज मॉडल (एलएलएम), सिमैंटिक ऑडिट लॉग और जटिल लेन-देन नेटवर्क को मिलाकर, गैर-कानूनी तरीके से फ़ंड ट्रांसफ़र करने का पता कैसे लगा सकता है.

GraphRAG आर्किटेक्चर फ़्लो

+------------------+     1. Vector Search      +---------------------+
| User Prompt /    | ------------------------> | BigQuery ML         |
| Investigation    |                           | (AccountAudits)     |
+------------------+                           +---------------------+
         |                                                |
         |                                                | 2. Seed Entity ID
         v                                                v
+------------------+     3. GQL Traversal      +---------------------+
| LangChain        | <------------------------ | BigQuery Property   |
| Graph Retriever  |                           | Graph (FinGraph)    |
+------------------+                           +---------------------+
         |
         | 4. Synthesized Context
         v
+------------------+
| Gemini 2.5 Flash | ---> Detailed Fraud Report
+------------------+

GraphRAG का इस्तेमाल क्यों करें? स्टैंडर्ड RAG, सेमेटिक समानता का इस्तेमाल करके अलग-अलग टेक्स्ट चंक को फिर से हासिल करता है. इसमें कई चरणों वाले संबंधों की जानकारी नहीं होती. GraphRAG, सीड एंटिटी ढूंढने के लिए वेक्टर सर्च का इस्तेमाल करता है. इसके बाद, BigQuery GQL का इस्तेमाल करके, कई चरणों वाले मनी ट्रेल (जैसे, मालिक → खाता → ट्रांसफ़र → खाता → लोन) को ट्रैवर्स करता है.

आपको क्या करना होगा

• पहला चरण: डेटासेट और प्रॉपर्टी ग्राफ़ सेटअप करना: संबंधपरक फ़ाइनेंशियल टेबल बनाएं और नेटिव BigQuery PROPERTY GRAPH बनाएं.
• दूसरा चरण: सिमैंटिक वेक्टर एम्बेडिंग जनरेट करना: AI.GENERATE_EMBEDDING (text-embedding-005) का इस्तेमाल करके, ऑडिट लॉग के लिए सीधे एसक्यूएल में टेक्स्ट एम्बेडिंग जनरेट करें.
• तीसरा चरण: कस्टम LangChain GraphRAG Retriever: वेक्टर सिमिलैरिटी (COSINE_DISTANCE) और आईएसओ GQL पाथ ट्रैवर्सल को मिलाकर, कस्टम Python Retriever बनाएं.
• चौथा चरण: एलएलएम की मदद से धोखाधड़ी के बारे में जानकारी पाना और ट्रेल विज़ुअलाइज़ेशन: Gemini की मदद से, मनी लॉन्ड्रिंग के गैर-कानूनी लूप का पता लगाएं. साथ ही, BigQuery Studio में पाथ ट्रेल को विज़ुअलाइज़ करें.

आपको किन चीज़ों की ज़रूरत होगी

• कोई वेब ब्राउज़र, जैसे कि Chrome.
• बिलिंग की सुविधा वाला Google क्लाउड प्रोजेक्ट.

यह कोडलैब, डेवलपर, डेटा इंजीनियर, और एआई के सभी लेवल के प्रैक्टिशनर के लिए बनाया गया है. इसमें शुरुआती लेवल के लोग भी शामिल हैं.

अनुमानित अवधि: 35 मिनट
अनुमानित लागत: 2.00 डॉलर से कम (इसमें इस्तेमाल के हिसाब से Vertex AI और BigQuery क्वेरी प्रोसेसिंग के लिए शुल्क लिया जाता है).

2. शुरू करने से पहले

Google Cloud प्रोजेक्ट बनाना

1. Google Cloud Console में जाकर, Google Cloud प्रोजेक्ट चुनें या बनाएं.
2. पक्का करें कि आपके क्लाउड प्रोजेक्ट के लिए बिलिंग की सुविधा चालू हो.

Cloud Shell शुरू करना

1. Google Cloud कंसोल में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें.
2. पुष्टि करें:

gcloud auth list

3. Cloud Shell में एनवायरमेंट वैरिएबल कॉन्फ़िगर करें:

export GCP_PROJECT=$(gcloud config get-value project)
export REGION="us-central1"
export BQ_DATASET="fingraph_rag"
gcloud config set project $GCP_PROJECT

एपीआई चालू करें

सभी ज़रूरी एपीआई चालू करने के लिए, यह निर्देश चलाएं:

gcloud services enable \
 bigquery.googleapis.com \
 aiplatform.googleapis.com

3. सेटअप और शुरू करना

इस चरण में, हम Python एनवायरमेंट सेट अप करेंगे, ज़रूरी लाइब्रेरी इंस्टॉल करेंगे, और BigQuery और Vertex AI क्लाइंट शुरू करेंगे. इन कमांड को Cloud Shell या Jupyter notebook एनवायरमेंट में चलाया जा सकता है.

1. Python का वर्चुअल एनवायरमेंट बनाएं और उसे चालू करें:

python3 -m venv venv
source venv/bin/activate

2. ज़रूरी Python पैकेज इंस्टॉल करें:

pip install langchain-google-vertexai langchain-core google-cloud-bigquery vertexai

3. एक Python फ़ाइल graphrag_aml.py बनाएं और उसमें शुरू करने के लिए कोड जोड़ें. की जगह अपना Google Cloud प्रोजेक्ट आईडी डालें.

import vertexai
from google.cloud import bigquery

# Configuration
GCP_PROJECT_ID = "<YOUR_PROJECT_ID>"
REGION = "us-central1"
BQ_DATASET_ID = "fingraph_rag"
MODEL_NAME = "gemini-2.5-flash"

# Initialize clients
bq_client = bigquery.Client(project=GCP_PROJECT_ID)
vertexai.init(project=GCP_PROJECT_ID, location=REGION)

4. टेबल और स्कीमा बनाना

इसके बाद, हम BigQuery डेटासेट और स्टैंडर्ड टेबल बनाकर, अपने फ़ाइनेंशियल ग्राफ़ के लिए स्कीमा तय करते हैं.

1. BigQuery डेटासेट बनाएं:

bq mk --location=US --dataset fingraph_rag

2. टेबल बनाना. इसे BigQuery Studio के यूज़र इंटरफ़ेस (यूआई) या Cloud Shell के ज़रिए चलाया जा सकता है. यहां SQL दिया गया है:

CREATE TABLE IF NOT EXISTS `fingraph_rag.Account` (id INT64, create_time TIMESTAMP, is_blocked BOOL, type STRING);
CREATE TABLE IF NOT EXISTS `fingraph_rag.Loan` (id INT64, loan_amount FLOAT64, balance FLOAT64, create_time TIMESTAMP, interest_rate FLOAT64);
CREATE TABLE IF NOT EXISTS `fingraph_rag.Person` (id INT64, name STRING);
CREATE TABLE IF NOT EXISTS `fingraph_rag.AccountRepayLoan` (id INT64, loan_id INT64, amount FLOAT64, create_time TIMESTAMP);
CREATE TABLE IF NOT EXISTS `fingraph_rag.AccountTransferAccount` (id INT64, to_id INT64, amount FLOAT64, create_time TIMESTAMP);
CREATE TABLE IF NOT EXISTS `fingraph_rag.PersonOwnAccount` (id INT64, account_id INT64, create_time TIMESTAMP);
CREATE TABLE IF NOT EXISTS `fingraph_rag.AccountAudits` (id INT64, audit_timestamp TIMESTAMP, audit_details STRING, embedding ARRAY<FLOAT64>);

5. डेटासेट जोड़ना

अब हम इकाइयों और उनके संबंधों को शामिल करेंगे, ताकि हम पैसे के लेन-देन का पता लगा सकें. इस डेटासेट में, संदिग्ध गतिविधियों को दिखाया गया है. ये गतिविधियां, जॉन डो (शेल कंपनी का संदिग्ध मालिक), जैकोबी (बिचौलिया), मेनविल (केवाईसी पूरा न करने वाला टारगेट), और स्मिथ (निर्दोष व्यक्ति) के बीच हुई हैं.

टेबल में डेटा भरने के लिए, यह एसक्यूएल चलाएं:

INSERT INTO `fingraph_rag.Account` VALUES 
  (10,'2020-01-10 06:22:20.222',false,'brokerage account'), 
  (20,'2020-01-27 17:55:09.206',false,'checking account'), 
  (30,'2020-02-15 09:12:33.111',false,'savings account'), 
  (40,'2019-11-05 14:33:10.000',false,'business account');

INSERT INTO `fingraph_rag.Loan` VALUES 
  (100,2022278.5,123359.0,'2020-03-18 16:42:57.719',0.064), 
  (200,50000.0,45000.0,'2020-03-23 19:03:05.567',0.097), 
  (300, 15000.0, 10000.0, '2020-05-10 10:00:00.000', 0.05);

INSERT INTO `fingraph_rag.Person` VALUES 
  (1,'Jacoby'), (2,'Menville'), (3,'Smith'), (4,'Doe');

INSERT INTO `fingraph_rag.AccountTransferAccount` VALUES 
  (40,10,25000.0,'2020-08-01 10:00:00.000'), 
  (10,20,24000.0,'2020-08-29 15:28:58.647'), 
  (30,20,150.0,'2020-09-01 12:00:00.000');

INSERT INTO `fingraph_rag.AccountRepayLoan` VALUES 
  (10,100,56809.8,'2020-12-12 07:25:02.597'), 
  (20,200,20000.0,'2021-01-18 01:40:25.317');

INSERT INTO `fingraph_rag.PersonOwnAccount` VALUES 
  (1,10,'2020-01-10 06:22:20.222'), (2,20,'2020-01-27 17:55:09.206'), 
  (3,30,'2020-02-15 09:12:33.111'), (4,40,'2019-11-05 14:33:10.000');

INSERT INTO `fingraph_rag.AccountAudits` (id, audit_timestamp, audit_details) VALUES 
  (10, '2020-05-14 06:57:02', 'Account 10 (Jacoby) flagged by AML system for suspicious high-volume transfers from offshore business accounts.'), 
  (20, '2021-03-09 02:51:45', 'Account 20 (Menville) failed KYC verification. Linked source of funds is unverified and customer is unresponsive.'), 
  (40, '2020-07-20 09:00:00', 'Account 40 (Doe) under investigation as a suspected shell company involved in illicit activities.');

डेटा सोर्स से लिए गए रिकॉर्ड की पुष्टि करना

अपनी फ़ाइनेंशियल टेबल में रिकॉर्ड की संख्या की पुष्टि करने के लिए, यह क्वेरी चलाएं:

SELECT 'Account' AS entity_table, COUNT(*) AS row_count FROM `fingraph_rag.Account`
UNION ALL SELECT 'Loan', COUNT(*) FROM `fingraph_rag.Loan`
UNION ALL SELECT 'Person', COUNT(*) FROM `fingraph_rag.Person`
UNION ALL SELECT 'AccountAudits', COUNT(*) FROM `fingraph_rag.AccountAudits`;

आपको क्वेरी का ऐसा आउटपुट दिखेगा जिसमें यह पुष्टि की गई हो कि लाइनें जोड़ी गई हैं:

6. BigQuery प्रॉपर्टी ग्राफ़ बनाना

रिलेशनल डेटा को सही जगह पर रखने के बाद, हम BigQuery के नेटिव Graph DDL का इस्तेमाल करके FinGraph को तय करते हैं. इससे डेटा को कॉपी या डुप्लीकेट किए बिना, मौजूदा रिलेशनल टेबल पर सिमैंटिक लेयर बनती है.

आईएसओ जीक्यूएल सिंटैक्स प्राइमर

BigQuery प्रॉपर्टी ग्राफ़, आईएसओ की स्टैंडर्ड ग्राफ़ क्वेरी लैंग्वेज (GQL) के पैटर्न का इस्तेमाल करते हैं:

• (node:Label), इकाई नोड (जैसे कि Account, Person, Loan) को तय करता है.
• -[edge:LABEL]-> से, डायरेक्ट किए गए संबंधों के बारे में पता चलता है. जैसे, Transfers, Repays, Owns.

प्रॉपर्टी ग्राफ़ बनाने के लिए, यहां दिया गया एसक्यूएल स्टेटमेंट चलाएं:

CREATE OR REPLACE PROPERTY GRAPH `fingraph_rag.FinGraph`
 NODE TABLES (
   `fingraph_rag.Account` KEY (id) LABEL Account PROPERTIES (id, type, is_blocked),
   `fingraph_rag.Loan` KEY (id) LABEL Loan PROPERTIES (id, loan_amount, balance),
   `fingraph_rag.Person` KEY (id) LABEL Person PROPERTIES (id, name)
 )
 EDGE TABLES(
   `fingraph_rag.AccountRepayLoan`
     KEY (id, loan_id, create_time)
     SOURCE KEY (id) REFERENCES `fingraph_rag.Account` (id)
     DESTINATION KEY (loan_id) REFERENCES `fingraph_rag.Loan` (id)
     LABEL Repays PROPERTIES (amount, create_time),
   `fingraph_rag.AccountTransferAccount`
     KEY (id, to_id, create_time)
     SOURCE KEY (id) REFERENCES `fingraph_rag.Account` (id)
     DESTINATION KEY (to_id) REFERENCES `fingraph_rag.Account` (id)
     LABEL Transfers PROPERTIES (amount, create_time),
   `fingraph_rag.PersonOwnAccount`
     KEY (id, account_id)
     SOURCE KEY (id) REFERENCES `fingraph_rag.Person` (id)
     DESTINATION KEY (account_id) REFERENCES `fingraph_rag.Account` (id)
     LABEL Owns PROPERTIES (create_time)
 );

ज़ीरो-ईटीएल पैराडाइम: BigQuery का CREATE PROPERTY GRAPH, मौजूदा रिलेशनल टेबल पर सीधे तौर पर ग्राफ़ स्ट्रक्चर तय करता है. इससे, ईटीएल पाइपलाइन और डेटा डुप्लीकेट होने की समस्या खत्म हो जाती है.

खातों, लोगों, और कर्ज़ के पूरे ग्राफ़ को विज़ुअलाइज़ करने के लिए, BigQuery Studio में यह एसक्यूएल क्वेरी चलाएं:

GRAPH `fingraph_rag.FinGraph`
MATCH (src)-[e]->(dst)
RETURN TO_JSON([
  TO_JSON(src),
  TO_JSON(e),
  TO_JSON(dst)
  ]) AS result;

आपको इस तरह का ग्राफ़ विज़ुअलाइज़ेशन का नतीजा दिखेगा:

7. ऑडिट लॉग के लिए एम्बेडिंग जनरेट करना

हमारा RAG पाइपलाइन, वेक्टर सर्च की सुविधा देता है. इसके लिए, हम AI.GENERATE_EMBEDDING टेबल-वैल्यूड फ़ंक्शन (टीवीएफ़) का इस्तेमाल करके, BigQuery में सीधे तौर पर बिना स्ट्रक्चर वाले ऑडिट लॉग के लिए टेक्स्ट एम्बेडिंग जनरेट करते हैं.

BigQuery रिमोट कनेक्शन बनाना और IAM अनुमतियां देना

BigQuery ML को CLOUD_RESOURCE कनेक्शन की ज़रूरत होती है, ताकि वह Vertex AI के एम्बेडिंग एंडपॉइंट के साथ सुरक्षित तरीके से कम्यूनिकेट कर सके. कनेक्शन बनाने, अपने-आप जनरेट हुए सेवा खाते का पता लगाने, और Vertex AI User (roles/aiplatform.user) की भूमिका देने के लिए, Cloud Shell में ये बैश कमांड चलाएं:

# 1. Set environment variables
export PROJECT_ID=$(gcloud config get-value project)
export LOCATION="us"
export CONNECTION_ID="vertex_ai_conn"

# 2. Create the BigQuery Cloud Resource Connection
bq mk --connection \
    --location=${LOCATION} \
    --project_id=${PROJECT_ID} \
    --connection_type=CLOUD_RESOURCE \
    ${CONNECTION_ID}

# 3. Retrieve the auto-generated Service Account ID associated with the connection
SA_ID=$(bq show --format=json --location=${LOCATION} --connection ${CONNECTION_ID} | jq -r '.cloudResource.serviceAccountId')
echo "Connection Service Account: ${SA_ID}"

# 4. Grant Vertex AI User (roles/aiplatform.user) permission to the Service Account
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:${SA_ID}" \
    --role="roles/aiplatform.user" \
    --condition=None

IAM की शर्त से जुड़े प्रॉम्प्ट के बारे में जानकारी:
अगर आपके Google Cloud प्रोजेक्ट में पहले से ही शर्त के साथ IAM बाइंडिंग मौजूद हैं, तो gcloud आपसे किसी शर्त का विकल्प चुनने के लिए इंटरैक्टिव प्रॉम्प्ट दिखा सकता है. जैसे, [1] ..., [2] ..., [3] None. इस लैब के लिए, roles/aiplatform.user की भूमिका बिना शर्त देने के लिए, None (विकल्प 3) चुनें. ऊपर दी गई कमांड में --condition=None जोड़ने पर, यह प्रॉम्प्ट अपने-आप हट जाता है.

रिमोट एम्बेडिंग मॉडल बनाना

इसके बाद, BigQuery ML का रिमोट मॉडल तय करें. यह मॉडल, नए कनेक्शन के ज़रिए Vertex AI के text-embedding-005 मॉडल से लिंक होता है:

CREATE OR REPLACE MODEL `fingraph_rag.embedding_model`
  REMOTE WITH CONNECTION `us.vertex_ai_conn`
  OPTIONS(ENDPOINT = 'text-embedding-005');

IAM अनुमतियों को लागू होने में लगने वाला समय:
नई IAM भूमिकाओं को Google Cloud की सभी सेवाओं में लागू होने में एक से तीन मिनट लग सकते हैं. अगर मॉडल बनाने या एम्बेड जनरेट करने के दौरान, अनुमति से जुड़ी गड़बड़ी (जैसे, The [e-mail] does not have the permission to access or use the endpoint...) होती है, तो कुछ मिनट इंतज़ार करें.इससे IAM बाइंडिंग सिंक हो जाएंगी. इसके बाद, क्वेरी को फिर से आज़माएँ.

एम्बेडिंग जनरेट करना

अब AccountAudits टेबल के लिए एम्बेडिंग जनरेट करें. इसके लिए, UPDATE स्टेटमेंट के FROM क्लॉज़ में AI.GENERATE_EMBEDDING को कॉल करें:

UPDATE `fingraph_rag.AccountAudits` target
SET embedding = source.embedding
FROM AI.GENERATE_EMBEDDING(
  MODEL `fingraph_rag.embedding_model`,
  (SELECT id, audit_details AS content FROM `fingraph_rag.AccountAudits` WHERE ARRAY_LENGTH(embedding) = 0)
) source
WHERE target.id = source.id;

जनरेट किए गए वेक्टर डाइमेंशन की पुष्टि करना

यह पुष्टि करने के लिए कि वेक्टर एम्बेडिंग भर दी गई हैं, यह क्वेरी चलाएं:

SELECT id, audit_details, ARRAY_LENGTH(embedding) AS embedding_dim 
FROM `fingraph_rag.AccountAudits`;

आपको क्वेरी का आउटपुट दिखेगा. इसमें 768 डाइमेंशन वाले वेक्टर एम्बेडिंग दिखेंगी. यह कुछ इस तरह दिखेगा:

AI.GENERATE_EMBEDDING और वेक्टर सर्च क्या है?
AI.GENERATE_EMBEDDING एक टेबल-वैल्यूड फ़ंक्शन (टीवीएफ़) है, जिसे FROM क्लॉज़ में कॉल किया जाना चाहिए. यह BigQuery ML रिमोट MODEL (जो CLOUD_RESOURCE कनेक्शन के ज़रिए Vertex AI से पुष्टि करता है) और content कॉलम वाली इनपुट क्वेरी को स्वीकार करता है. कंप्यूटिंग को सीधे Vertex AI पर ऑफ़लोड किया जाता है. इससे डेटा को BigQuery से बाहर नहीं ले जाना पड़ता. COSINE_DISTANCE, टारगेट एम्बेडिंग और क्वेरी वेक्टर के बीच वेक्टर समानता का हिसाब लगाता है, ताकि सिमैंटिक मैच का पता लगाया जा सके. ऐसा इसलिए, क्योंकि नियमों के आधार पर की जाने वाली जांच में सिमैंटिक मैच का पता नहीं चल पाता.

8. GraphRAG Retriever को तय करना

अब हम अपने Python एनवायरमेंट में, LangChain का कस्टम रिट्रीवर बनाएंगे. यह रिट्रीवर, सिमैंटिक वेक्टर सर्च (काम के शुरुआती पॉइंट ढूंढने के लिए) और नेटिव ग्राफ़ मैच क्वेरी (रिश्तों को समझने के लिए) को एक साथ इस्तेमाल करता है.

अपनी Python स्क्रिप्ट graphrag_aml.py में यह कोड जोड़ें:

from langchain_core.documents import Document
from langchain_core.retrievers import BaseRetriever
from typing import List

class FinGraphRetriever(BaseRetriever):
    project: str
    dataset: str

    def _get_relevant_documents(self, query: str) -> List[Document]:
        # 1. Vector Search
        vector_query = f"""
            SELECT id, audit_details
            FROM `{self.dataset}.AccountAudits`
            ORDER BY COSINE_DISTANCE(
                embedding,
                (
                    SELECT embedding
                    FROM AI.GENERATE_EMBEDDING(
                        MODEL `{self.dataset}.embedding_model`,
                        (SELECT @query AS content)
                    )
                )
            )
            LIMIT 1
        """
        res = bq_client.query(vector_query, job_config=bigquery.QueryJobConfig(
            query_parameters=[bigquery.ScalarQueryParameter("query", "STRING", query)]
        )).result()

        start_id = None
        audit_text = ""
        for row in res:
            start_id = row.id
            audit_text = row.audit_details

        if not start_id: return []

        # 2. Native Graph Traversal
        graph_query = f"""
            GRAPH `{self.dataset}.FinGraph`
            MATCH
              (sender_person:Person)-[:Owns]->(sender_acc:Account)
              -[tx:Transfers]->
              (a:Account)
              -[repays:Repays]->(l:Loan),
              (owner:Person)-[:Owns]->(a)
            WHERE a.id = @id
            RETURN
              owner.name as owner_name,
              a.type as account_type,
              sender_person.name as sender_name,
              tx.amount as transfer_amount,
              repays.amount as repayment_amount,
              l.id as loan_id
        """
        graph_res = bq_client.query(graph_query, job_config=bigquery.QueryJobConfig(
            query_parameters=[bigquery.ScalarQueryParameter("id", "INT64", start_id)]
        )).result()

        context_docs = [Document(page_content=f"Primary Audit Log (Target Account): {audit_text}")]
        sender_names = []
        for row in graph_res:
            sender_names.append(row['sender_name'])
            doc_str = (f"Account Owner: {row['owner_name']} (Account Type: {row['account_type']}). "
                       f"Received transfer of ${row['transfer_amount']} from {row['sender_name']}. "
                       f"Made loan repayment of ${row['repayment_amount']} to Loan {row['loan_id']}.")
            context_docs.append(Document(page_content=doc_str))

        if sender_names:
            names_list = "','".join(sender_names)
            sender_audit_query = f"""
                SELECT p.name, au.audit_details
                FROM `{self.dataset}.AccountAudits` au
                JOIN `{self.dataset}.Account` a ON au.id = a.id
                JOIN `{self.dataset}.PersonOwnAccount` poa ON a.id = poa.account_id
                JOIN `{self.dataset}.Person` p ON poa.id = p.id
                WHERE p.name IN ('{names_list}')
            """
            sender_audits = bq_client.query(sender_audit_query).result()
            for row in sender_audits:
                context_docs.append(Document(page_content=f"Audit Log for Sender {row['name']}: {row['audit_details']}"))

        return context_docs

ध्यान दें कि ग्राफ़ ट्रैवर्सल क्वेरी, MATCH (sender_person:Person)-[:Owns]->... की मदद से खाता मालिकों, ईमेल भेजने वालों, ट्रांसफ़र करने वालों, और कर्ज़ लेने वालों की जानकारी आसानी से इकट्ठा करती है. इसके लिए, जटिल एसक्यूएल JOIN की ज़रूरत नहीं होती!

डाइनैमिक मल्टी-एजेंट NL2SQL/GQL आर्किटेक्चर:
ऐडवांस प्रोडक्शन मल्टी-एजेंट सिस्टम में, रिट्रीवर में पहले से तय SQL/GQL क्वेरी टेंप्लेट का इस्तेमाल करने के बजाय, NL2SQL / NL2GQL एजेंट डिप्लॉय किया जा सकता है. इस खास एजेंट में, ग्राफ़ स्कीमा की परिभाषाएं और क्वेरी के उदाहरण, स्किल के तौर पर लोड किए जाते हैं. यह मुख्य एजेंट की जांच के मुख्य लक्ष्यों के आधार पर, ज़रूरत के हिसाब से GQL क्वेरी डाइनैमिक तरीके से जनरेट करता है. साथ ही, BigQuery के ख़िलाफ़ एसक्यूएल की जांच करता है और उसे मान्य करता है. इसके अलावा, यह टारगेट किए गए ग्राफ़ के नतीजे दिखाता है. डाइनैमिक एजेंटिक एसक्यूएल जनरेशन से, मल्टी-एजेंट वर्कफ़्लो की पूरी फ़्लेक्सिबिलिटी के बारे में पता चलता है. हालांकि, इस लैब में हम स्ट्रक्चर्ड क्वेरी का इस्तेमाल करते हैं, ताकि जानकारी को कम शब्दों में और साफ़ तौर पर बताया जा सके.

9. धोखाधड़ी की जांच करना

आखिर में, हम GraphRAG पाइपलाइन चलाते हैं, ताकि धोखाधड़ी की ज़्यादा जानकारी वाली रिपोर्ट जनरेट की जा सके. एलएलएम, प्रॉम्प्ट का जवाब देने के लिए, हमारे कस्टम ग्राफ़ रिट्रीवर से मिले कॉन्टेक्स्ट का इस्तेमाल करेगा.

डोमेन वैल्यू: धोखाधड़ी रोकने के लिए, गलत पॉज़िटिव की समस्या को हल करना
एएमएल की निगरानी के लिए, नियमों पर आधारित पारंपरिक सिस्टम हर साल लाखों गलत पॉज़िटिव को फ़्लैग करता है.ऐसा इसलिए होता है, क्योंकि नियम अलग-अलग लेन-देन का आकलन करते हैं. उदाहरण के लिए, स्मिथ के मेनविल को 150 डॉलर ट्रांसफ़र करने के लेन-देन को फ़्लैग करना. GraphRAG, सिमेंटिक ऑडिट लॉग कॉन्टेक्स्ट (Menville का केवाईसी पूरा नहीं हुआ) को मल्टी-हॉप ग्राफ़ टोपोलॉजी (Doe → Jacoby → Menville) के साथ जोड़ता है. इससे एलएलएम, कम जोखिम वाले नॉइज़ को फ़िल्टर कर पाते हैं. साथ ही, वे मनी लॉन्ड्रिंग के ज़्यादा जोखिम वाले लूप को भी पहचान पाते हैं.

अपनी स्क्रिप्ट graphrag_aml.py में यह कोड जोड़ें और python graphrag_aml.py का इस्तेमाल करके इसे रन करें:

from langchain_google_vertexai import ChatVertexAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Initialize the LLM and the Retriever
llm = ChatVertexAI(model_name=MODEL_NAME)
retriever = FinGraphRetriever(project=GCP_PROJECT_ID, dataset=BQ_DATASET_ID)

# Define the Prompt
prompt = ChatPromptTemplate.from_template("""
You are a Lead Fraud Analyst. Use the following audit logs and graph transaction history to answer the question.
Your goal is to connect the dots between the entities and explain the flow of funds.
If you see transfers from flagged users or shell companies, highlight the money laundering risk.

Context: {context}

Question: {question}

Detailed Fraud Report:
""")

# Create the LangChain
chain = (
    {"context": retriever , "question": lambda x: x}
    | prompt
    | llm
    | StrOutputParser()
)

# Execute the chain
question = "Why is Menville's loan repayment at risk? Flag any suspicious activity if you notice."
print(chain.invoke(question))

graphrag_aml.py स्क्रिप्ट पूरी हुई

रेफ़रंस के लिए, आपकी पूरी graphrag_aml.py स्क्रिप्ट ऐसी दिखनी चाहिए:

import vertexai
from google.cloud import bigquery
from langchain_core.documents import Document
from langchain_core.retrievers import BaseRetriever
from typing import List
from langchain_google_vertexai import ChatVertexAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Configuration
GCP_PROJECT_ID = "<YOUR_PROJECT_ID>"
REGION = "us-central1"
BQ_DATASET_ID = "fingraph_rag"
MODEL_NAME = "gemini-2.5-flash"

# Initialize clients
bq_client = bigquery.Client(project=GCP_PROJECT_ID)
vertexai.init(project=GCP_PROJECT_ID, location=REGION)

class FinGraphRetriever(BaseRetriever):
    project: str
    dataset: str

    def _get_relevant_documents(self, query: str) -> List[Document]:
        # 1. Vector Search using Cosine Distance
        vector_query = f"""
            SELECT id, audit_details
            FROM `{self.dataset}.AccountAudits`
            ORDER BY COSINE_DISTANCE(
                embedding,
                (
                    SELECT embedding
                    FROM AI.GENERATE_EMBEDDING(
                        MODEL `{self.dataset}.embedding_model`,
                        (SELECT @query AS content)
                    )
                )
            )
            LIMIT 1
        """
        res = bq_client.query(vector_query, job_config=bigquery.QueryJobConfig(
            query_parameters=[bigquery.ScalarQueryParameter("query", "STRING", query)]
        )).result()

        start_id = None
        audit_text = ""
        for row in res:
            start_id = row.id
            audit_text = row.audit_details

        if not start_id: return []

        # 2. Native Graph Traversal (GQL MATCH)
        graph_query = f"""
            GRAPH `{self.dataset}.FinGraph`
            MATCH
              (sender_person:Person)-[:Owns]->(sender_acc:Account)
              -[tx:Transfers]->
              (a:Account)
              -[repays:Repays]->(l:Loan),
              (owner:Person)-[:Owns]->(a)
            WHERE a.id = @id
            RETURN
              owner.name as owner_name,
              a.type as account_type,
              sender_person.name as sender_name,
              tx.amount as transfer_amount,
              repays.amount as repayment_amount,
              l.id as loan_id
        """
        graph_res = bq_client.query(graph_query, job_config=bigquery.QueryJobConfig(
            query_parameters=[bigquery.ScalarQueryParameter("id", "INT64", start_id)]
        )).result()

        context_docs = [Document(page_content=f"Primary Audit Log (Target Account): {audit_text}")]
        sender_names = []
        for row in graph_res:
            sender_names.append(row['sender_name'])
            doc_str = (f"Account Owner: {row['owner_name']} (Account Type: {row['account_type']}). "
                       f"Received transfer of ${row['transfer_amount']} from {row['sender_name']}. "
                       f"Made loan repayment of ${row['repayment_amount']} to Loan {row['loan_id']}.")
            context_docs.append(Document(page_content=doc_str))

        if sender_names:
            names_list = "','".join(sender_names)
            sender_audit_query = f"""
                SELECT p.name, au.audit_details
                FROM `{self.dataset}.AccountAudits` au
                JOIN `{self.dataset}.Account` a ON au.id = a.id
                JOIN `{self.dataset}.PersonOwnAccount` poa ON a.id = poa.account_id
                JOIN `{self.dataset}.Person` p ON poa.id = p.id
                WHERE p.name IN ('{names_list}')
            """
            sender_audits = bq_client.query(sender_audit_query).result()
            for row in sender_audits:
                context_docs.append(Document(page_content=f"Audit Log for Sender {row['name']}: {row['audit_details']}"))

        return context_docs

# Initialize LLM & Retriever
llm = ChatVertexAI(model_name=MODEL_NAME)
retriever = FinGraphRetriever(project=GCP_PROJECT_ID, dataset=BQ_DATASET_ID)

prompt = ChatPromptTemplate.from_template("""
You are a Lead Fraud Analyst. Use the following audit logs and graph transaction history to answer the question.
Your goal is to connect the dots between the entities and explain the flow of funds.
If you see transfers from flagged users or shell companies, highlight the money laundering risk.

Context: {context}

Question: {question}

Detailed Fraud Report:
""")

chain = (
    {"context": retriever, "question": lambda x: x}
    | prompt
    | llm
    | StrOutputParser()
)

question = "Why is Menville's loan repayment at risk? Flag any suspicious activity if you notice."
print(chain.invoke(question))

आपको एलएलएम की विश्लेषण रिपोर्ट के इस सैंपल से मिलता-जुलता आउटपुट दिखेगा:

10. काले धन को सफ़ेद करने के तरीके को विज़ुअलाइज़ करना

हमने अभी-अभी प्रोग्राम के हिसाब से मनी लॉन्ड्रिंग का पता लगाया है. इसे विज़ुअल तौर पर समझने के लिए, BigQuery Studio कंसोल में ग्राफ़ विज़ुअलाइज़ेशन क्वेरी चलाई जा सकती है.

इस क्वेरी को BigQuery Studio में चलाएं. (पक्का करें कि आपने ग्राफ़ विज़ुअलाइज़ेशन की सुविधा चालू की हो या अगर उपलब्ध हो, तो ग्राफ़ टैब पर क्लिक करें).

GRAPH `fingraph_rag.FinGraph`
 MATCH
   (p_shell:Person)-[o1:Owns]->(acc_shell:Account)-[t1:Transfers]->(acc_fraud:Account)-[t2:Transfers]->(acc_target:Account)-[r:Repays]->(l:Loan),
   (p_fraud:Person)-[o2:Owns]->(acc_fraud),
   (p_target:Person)-[o3:Owns]->(acc_target)
 WHERE p_target.name = 'Menville' AND p_fraud.name = 'Jacoby' AND p_shell.name = 'Doe'
 RETURN TO_JSON([
  TO_JSON(p_shell), TO_JSON(o1), TO_JSON(acc_shell),
  TO_JSON(t1), TO_JSON(acc_fraud), TO_JSON(p_fraud), TO_JSON(o2),
  TO_JSON(t2), TO_JSON(acc_target), TO_JSON(p_target), TO_JSON(o3),
  TO_JSON(r), TO_JSON(l)
]) AS result;

यह GQL क्वेरी, संदिग्ध शेल कंपनी के मालिक (Doe) से लेकर इंटरमीडियरी (Jacoby) और फ़ाइनल टारगेट (Menville) तक के पूरे पाथ और Loan के रीपेमेंट को ट्रैक करती है.

आपको इस तरह का ग्राफ़ विज़ुअलाइज़ेशन का नतीजा दिखेगा:

11. व्यवस्थित करें

अपने Google Cloud खाते से लगातार शुल्क लिए जाने से बचने के लिए, इस कोडलैब के दौरान बनाई गई संसाधन मिटाएं.

BigQuery डेटासेट और Cloud Resource Connection मिटाएं:

# Delete the BigQuery dataset
bq rm -r -f $PROJECT_ID:fingraph_rag

# Delete the BigQuery Cloud Resource Connection
bq rm --connection --location=us vertex_ai_conn

पुष्टि करें कि संसाधन मिटा दिए गए हैं:

bq ls --project_id $PROJECT_ID
bq ls --connection --location=us

12. बधाई हो

बधाई हो! आपने RAG ऐप्लिकेशन बना लिया है और उसके व्यवहार का विश्लेषण कर लिया है. आपने दिखाया कि BigQuery की नेटिव ग्राफ़ और वेक्टर सर्च की सुविधाओं का इस्तेमाल करके, GraphRAG कैसे किया जाता है. साथ ही, आपने बिना ईटीएल के मनी लॉन्ड्रिंग रोकने की स्कीम का पता लगाया.

आपने क्या सीखा

• स्टैंडर्ड टेबल के ऊपर BigQuery में प्रॉपर्टी ग्राफ़ कैसे बनाएं
• BigQuery ML का इस्तेमाल करके, वेक्टर एम्बेडिंग जनरेट और सेव करने का तरीका
• BigQuery Graph traversals और Vector Search को LangChain Retriever में कैसे जोड़ा जाता है
• एलएलएम, ग्राफ़ टोपोलॉजी के साथ सिमैंटिक ऑडिट लॉग को कैसे सिंथेसाइज़ कर सकते हैं, ताकि फ़ॉल्स पॉज़िटिव की संख्या कम हो सके

अगले चरण

• BigQuery प्रॉपर्टी ग्राफ़ की खास जानकारी देखें
• BigQuery Graph Query Language (GQL) के अन्य पैटर्न आज़माएं.

रेफ़रंस के लिए दस्तावेज़

• BigQuery ML का AI.GENERATE_EMBEDDING फ़ंक्शन
• BigQuery वेक्टर सर्च और दूरी के फ़ंक्शन
• LangChain और Google के इंटिग्रेशन