Pencegahan Pencucian Uang & Penipuan dengan BigQuery GraphRAG

1. Pengantar

Dalam codelab ini, Anda akan membuat solusi Graph Retrieval-Augmented Generation (GraphRAG) untuk mendeteksi Pencucian Uang (AML) dan penipuan keuangan. Anda akan menggunakan Vertex AI, Vector Search, dan kemampuan Grafik native BigQuery, yang dikoordinasikan melalui LangChain. Pada akhir lab ini, Anda akan melihat bagaimana Model Bahasa Besar (LLM) dapat mengidentifikasi perutean dana terlarang dengan menyintesis log audit semantik dan jaringan transaksional yang kompleks.

Alur Arsitektur 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
+------------------+

Mengapa GraphRAG? RAG standar mengambil potongan teks terisolasi menggunakan kemiripan semantik, sehingga kehilangan hubungan multi-langkah. GraphRAG menggunakan Vector Search untuk menemukan entitas awal, lalu menggunakan BigQuery GQL untuk menjelajahi jejak uang multi-hop (misalnya, Pemilik → Akun → Transfer → Akun → Pinjaman).

Yang akan Anda lakukan

• Fase 1: Penyiapan Grafik Properti & Set Data: Buat tabel keuangan relasional dan susun PROPERTY GRAPH BigQuery native.
• Tahap 2: Pembuatan Embedding Vektor Semantik: Buat embedding teks langsung di SQL untuk log audit menggunakan AI.GENERATE_EMBEDDING (text-embedding-005).
• Fase 3: Pengambil GraphRAG LangChain Kustom: Bangun pengambil Python kustom yang menggabungkan kesamaan vektor (COSINE_DISTANCE) dan penelusuran jalur ISO GQL.
• Fase 4: Visualisasi Jejak & Penalaran Penipuan LLM: Jalankan rantai penalaran Gemini untuk mengekspos loop pencucian uang ilegal dan memvisualisasikan jejak jalur di BigQuery Studio.

Yang Anda butuhkan

• Browser web seperti Chrome.
• Project Google Cloud yang mengaktifkan penagihan.

Codelab ini dirancang untuk developer, data engineer, dan praktisi AI dari semua tingkat keahlian, termasuk pemula.

Perkiraan Durasi: 35 menit
Perkiraan Biaya: Kurang dari $2,00 USD (menggunakan pemrosesan kueri BigQuery dan Vertex AI bayar sesuai penggunaan).

2. Sebelum memulai

Buat Project Google Cloud

1. Di Konsol Google Cloud, pilih atau buat project Google Cloud.
2. Pastikan penagihan diaktifkan untuk project Cloud Anda.

Mulai Cloud Shell

1. Klik Activate Cloud Shell di bagian atas konsol Google Cloud.
2. Verifikasi autentikasi:

gcloud auth list

3. Konfigurasi variabel lingkungan di 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

Mengaktifkan API

Jalankan perintah ini untuk mengaktifkan semua API yang diperlukan:

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

3. Penyiapan dan Inisialisasi

Pada langkah ini, kita akan menyiapkan lingkungan Python, menginstal library yang diperlukan, dan melakukan inisialisasi klien BigQuery dan Vertex AI. Anda dapat menjalankan perintah ini di Cloud Shell atau lingkungan notebook Jupyter.

1. Membuat dan mengaktifkan lingkungan virtual Python:

python3 -m venv venv
source venv/bin/activate

2. Instal paket Python yang diperlukan:

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

3. Buat file Python graphrag_aml.py dan tambahkan kode inisialisasi. Ganti dengan Project ID Google Cloud Anda.

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. Membuat Tabel dan Skema

Selanjutnya, kita akan menentukan skema untuk Financial Graph dengan membuat set data BigQuery dan tabel standar.

1. Buat set data BigQuery:

bq mk --location=US --dataset fingraph_rag

2. Buat tabel. Anda dapat menjalankan kueri ini di UI BigQuery Studio atau melalui Cloud Shell. Berikut SQL-nya:

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. Menyisipkan Set Data

Sekarang kita akan memasukkan entitas dan hubungannya untuk membentuk jejak uang kita. Kumpulan data ini merepresentasikan aktivitas mencurigakan antara Doe (pemilik perusahaan cangkang yang dicurigai), Jacoby (perantara), Menville (target yang gagal melakukan KYC), dan Smith (pengamat yang tidak bersalah).

Jalankan SQL berikut untuk mengisi tabel:

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.');

Memverifikasi Data yang Di-Ingest

Jalankan kueri ini untuk memverifikasi jumlah kumpulan data di seluruh tabel keuangan Anda:

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`;

Anda akan melihat output kueri yang mengonfirmasi penyisipan baris yang mirip dengan ini:

6. Membuat Grafik Properti BigQuery

Dengan data relasional yang sudah ada, kita menentukan FinGraph menggunakan DDL Grafik native BigQuery. Cara ini membuat lapisan semantik di atas tabel relasional yang ada tanpa menyalin atau menduplikasi data.

Pengantar Sintaksis GQL ISO

Grafik Properti BigQuery menggunakan pola ISO Graph Query Language (GQL) standar:

• (node:Label) menentukan node entitas (misalnya, Account, Person, Loan).
• -[edge:LABEL]-> menentukan hubungan terarah (misalnya, Transfers, Repays, Owns).

Jalankan pernyataan SQL berikut untuk membuat grafik properti:

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)
 );

Paradigma Zero-ETL: CREATE PROPERTY GRAPH BigQuery menentukan struktur grafik secara langsung pada tabel relasional yang ada, sehingga menghilangkan pipeline ETL yang tidak stabil dan duplikasi data.

Untuk memvisualisasikan seluruh grafik akun, orang, dan pinjaman, jalankan kueri SQL berikut di BigQuery Studio:

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

Anda akan melihat hasil visualisasi grafik yang mirip dengan berikut ini:

7. Membuat Embedding untuk Log Audit

Untuk mengaktifkan bagian penelusuran vektor dari pipeline RAG, kita membuat embedding teks untuk log audit tidak terstruktur langsung di dalam BigQuery menggunakan AI.GENERATE_EMBEDDING Table-Valued Function (TVF).

Membuat Koneksi Jarak Jauh BigQuery & Memberikan Izin IAM

BigQuery ML memerlukan koneksi CLOUD_RESOURCE untuk berkomunikasi secara aman dengan endpoint penyematan Vertex AI. Jalankan perintah bash berikut di Cloud Shell untuk membuat koneksi, menemukan akun layanan yang dibuat otomatis, dan memberikan peran Vertex AI User (roles/aiplatform.user):

# 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

Catatan tentang Prompt Kondisi IAM:
Jika project Google Cloud Anda sudah berisi binding IAM bersyarat, gcloud dapat meminta Anda secara interaktif untuk memilih opsi kondisi (misalnya, [1] ..., [2] ..., [3] None). Pilih None (opsi 3) untuk memberikan peran roles/aiplatform.user tanpa syarat untuk lab ini. Menambahkan --condition=None dalam perintah di atas akan otomatis melewati perintah ini.

Membuat Model Embedding Jarak Jauh

Selanjutnya, tentukan model jarak jauh BigQuery ML yang ditautkan ke model text-embedding-005 Vertex AI melalui koneksi yang baru saja Anda beri otorisasi:

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

Penundaan Penerapan Izin IAM:
Peran IAM yang baru diberikan dapat memerlukan waktu 1 hingga 3 menit untuk diterapkan di seluruh layanan Google Cloud. Jika pembuatan model atau pembuatan sematan awalnya gagal karena error izin (misalnya, The [e-mail] does not have the permission to access or use the endpoint...), tunggu beberapa menit hingga binding IAM disinkronkan dan coba lagi kueri.

Membuat Embedding

Sekarang, buat embedding untuk tabel AccountAudits dengan memanggil AI.GENERATE_EMBEDDING dalam klausa FROM dari pernyataan UPDATE:

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;

Memverifikasi Dimensi Vektor yang Dibuat

Jalankan kueri berikut untuk memverifikasi bahwa embedding vektor telah diisi:

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

Anda akan melihat output kueri yang menampilkan embedding vektor 768 dimensi yang mirip dengan ini:

Apa yang dimaksud dengan AI.GENERATE_EMBEDDING & Vector Search?
AI.GENERATE_EMBEDDING adalah Fungsi Bernilai Tabel (TVF) yang harus dipanggil dalam klausa FROM. Model ini menerima model jarak jauh BigQuery ML MODEL (yang melakukan autentikasi ke Vertex AI melalui koneksi CLOUD_RESOURCE) dan kueri input yang berisi kolom content. Komputasi penyematan di-offload langsung ke Vertex AI tanpa data keluar dari BigQuery. COSINE_DISTANCE menghitung kemiripan vektor antara embedding target dan vektor kueri untuk menemukan kecocokan semantik yang tidak terdeteksi oleh pemeriksaan berbasis aturan.

8. Menentukan Pengambil GraphRAG

Sekarang kita akan membuat retriever LangChain kustom di lingkungan Python. Pengambil ini menggabungkan Penelusuran Vektor semantik (untuk menemukan titik awal yang relevan) dengan kueri Graph MATCH native (untuk melintasi hubungan).

Tambahkan kode berikut ke skrip Python Anda 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

Perhatikan bagaimana kueri penelusuran grafik dengan mudah menggabungkan pemilik akun, pengirim, transfer, dan pinjaman melalui MATCH (sender_person:Person)-[:Owns]->... — tidak memerlukan JOIN SQL yang rumit.

Arsitektur NL2SQL/GQL Multi-Agen Dinamis:
Dalam sistem multi-agen produksi tingkat lanjut, alih-alih menggunakan template kueri SQL/GQL yang telah ditentukan sebelumnya di retriever, Anda dapat men-deploy agen NL2SQL / NL2GQL khusus. Dengan definisi skema grafik dan contoh kueri sebagai kemampuannya, agen khusus ini secara dinamis membuat kueri GQL yang disesuaikan berdasarkan tujuan penyelidikan utama agen utama, melakukan uji coba dan memvalidasi SQL terhadap BigQuery, serta menampilkan hasil grafik yang ditargetkan. Meskipun pembuatan SQL berbasis agen dinamis menyoroti fleksibilitas penuh alur kerja multi-agen, kita menggunakan kueri terstruktur dalam lab ini agar lebih ringkas dan jelas.

9. Menjalankan Investigasi Penipuan

Terakhir, kita menjalankan pipeline GraphRAG untuk membuat laporan penipuan yang mendetail. LLM akan menggunakan konteks yang diambil oleh pengambil grafik kustom kami untuk menjawab perintah.

Nilai Domain: Memecahkan Masalah Positif Palsu dalam Operasi Anti-Penipuan
Pemantauan AML berbasis aturan tradisional menandai jutaan positif palsu setiap tahun karena aturan mengevaluasi transaksi secara terpisah (misalnya, menandai transfer $150 Smith ke Menville). GraphRAG menggabungkan konteks log audit semantik (Menville gagal KYC) dengan topologi grafik multi-hop (Doe → Jacoby → Menville), sehingga memungkinkan LLM memfilter derau yang tidak berbahaya sekaligus memunculkan loop pencucian uang berisiko tinggi.

Tambahkan kode berikut ke graphrag_aml.py skrip Anda dan eksekusi menggunakan 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))

Skrip graphrag_aml.py Selesai

Sebagai referensi, skrip graphrag_aml.py lengkap Anda akan terlihat seperti ini:

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))

Anda akan melihat output yang mirip dengan laporan analisis LLM contoh ini:

10. Memvisualisasikan Jejak Pencucian Uang

Untuk memahami secara visual jejak pencucian uang yang baru saja kita temukan secara terprogram, Anda dapat menjalankan kueri visualisasi grafik di konsol BigQuery Studio.

Jalankan kueri ini di BigQuery Studio. (Pastikan Anda mengaktifkan fitur visualisasi Grafik atau mengklik tab Grafik jika tersedia).

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;

Kueri GQL ini melacak seluruh jalur dari pemilik perusahaan cangkang yang mencurigakan (Doe) melalui perantara (Jacoby) hingga target akhir (Menville) dan pembayaran kembali Pinjaman.

Anda akan melihat hasil visualisasi grafik yang mirip dengan berikut ini:

11. Pembersihan

Untuk menghindari biaya berkelanjutan pada akun Google Cloud Anda, hapus resource yang dibuat selama codelab ini.

Hapus set data BigQuery dan Koneksi Resource Cloud:

# 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

Verifikasi bahwa resource telah dihapus:

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

12. Selamat

Selamat! Anda telah berhasil membuat aplikasi RAG dan menganalisis perilakunya. Anda mendemonstrasikan cara menggunakan kemampuan Penelusuran Vektor dan Grafik native BigQuery untuk melakukan GraphRAG, mendeteksi skema pencucian uang dengan ETL nol.

Yang telah Anda pelajari

• Cara membuat Grafik Properti di BigQuery di atas tabel standar
• Cara membuat dan menyimpan Embedding Vektor menggunakan BigQuery ML
• Cara menggabungkan penelusuran Grafik BigQuery dan Penelusuran Vektor ke dalam Pengambil LangChain
• Cara LLM dapat menyintesis log audit semantik dengan topologi grafik untuk mengurangi positif palsu

Langkah berikutnya

• Jelajahi Ringkasan Grafik Properti BigQuery
• Coba pola BigQuery Graph Query Language (GQL) lainnya.

Dokumen referensi

• Fungsi AI.GENERATE_EMBEDDING BigQuery ML
• Penelusuran Vektor dan Fungsi Jarak BigQuery
• Integrasi Google LangChain