BigQuery GraphRAG ile Kara Para Aklamayı Önleme ve Sahtekarlığı Engelleme

1. Giriş

Bu codelab'de, kara para aklamayı önleme (AML) ve finansal sahtekarlığı tespit etmek için bir Graph Retrieval-Augmented Generation (GraphRAG) çözümü oluşturacaksınız. LangChain aracılığıyla koordine edilen Vertex AI, Vector Search ve BigQuery'nin yerel Graph özelliklerini kullanacaksınız. Bu laboratuvarın sonunda, bir büyük dil modelinin (LLM) semantik denetim günlüklerini ve karmaşık işlem ağlarını sentezleyerek yasa dışı fon yönlendirmesini nasıl tespit edebileceğini göreceksiniz.

GraphRAG Mimari Akışı

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

Neden GraphRAG? Standart RAG, anlamsal benzerliği kullanarak izole edilmiş metin parçalarını alır ve çok adımlı ilişkileri kaçırır. GraphRAG, başlangıç öğelerini bulmak için Vector Search'ü, çok adımlı para izlerini (ör. Sahip → Hesap → Transfer → Hesap → Kredi) geçmek için ise BigQuery GQL'yi kullanır.

Yapacaklarınız

• 1. aşama: Veri kümesi ve özellik grafiği kurulumu: İlişkisel finans tabloları oluşturun ve yerel bir BigQuery PROPERTY GRAPH oluşturun.
• 2. aşama: Anlamsal vektör gömmesi oluşturma: AI.GENERATE_EMBEDDING (text-embedding-005) kullanarak denetleme günlükleri için doğrudan SQL'de metin gömmeleri oluşturun.
• 3. Aşama: Özel LangChain GraphRAG Retriever: Vektör benzerliğini (COSINE_DISTANCE) ve ISO GQL yolu geçişlerini birleştiren özel bir Python alıcı oluşturun.
• 4. Aşama: LLM Sahtekarlık Nedeni ve İz Görselleştirme: Yasa dışı kara para aklama döngülerini ortaya çıkarmak için Gemini neden zincirini yürütün ve BigQuery Studio'da yol izlerini görselleştirin.

İhtiyacınız olanlar

• Chrome gibi bir web tarayıcısı
• Faturalandırmanın etkin olduğu bir Google Cloud projesi.

Bu codelab, yeni başlayanlar da dahil olmak üzere her seviyeden geliştirici, veri mühendisi ve yapay zeka uzmanı için tasarlanmıştır.

Tahmini Süre: 35 dakika
Tahmini Maliyet: 2,00 ABD dolarından az (kullandıkça öde Vertex AI ve BigQuery sorgu işleme kullanılır).

2. Başlamadan önce

Google Cloud projesi oluşturma

1. Google Cloud Console'da bir Google Cloud projesi seçin veya oluşturun.
2. Cloud projeniz için faturalandırmanın etkinleştirildiğinden emin olun.

Cloud Shell'i Başlatma

1. Google Cloud Console'un üst kısmında Activate Cloud Shell'i (Cloud Shell'i Etkinleştir) tıklayın.
2. Kimlik doğrulamayı doğrulayın:

gcloud auth list

3. Cloud Shell'de ortam değişkenlerini yapılandırma:

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

API'leri etkinleştir

Gerekli tüm API'leri etkinleştirmek için bu komutu çalıştırın:

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

3. Kurulum ve İlk Kullanıma Hazırlama

Bu adımda, Python ortamı oluşturacak, gerekli kitaplıkları yükleyecek ve BigQuery ile Vertex AI istemcilerini başlatacağız. Bu komutları Cloud Shell'de veya bir Jupyter not defteri ortamında çalıştırabilirsiniz.

1. Python sanal ortamı oluşturun ve etkinleştirin:

python3 -m venv venv
source venv/bin/activate

2. Gerekli Python paketlerini yükleyin:

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

3. Python dosyası oluşturun graphrag_aml.py ve başlatma kodunu ekleyin. kısmını Google Cloud proje kimliğinizle değiştirin.

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. Tablo ve Şema Oluşturma

Ardından, BigQuery veri kümesi ve standart tablolar oluşturarak Finansal Grafiğimizin şemasını tanımlıyoruz.

1. BigQuery veri kümesini oluşturun:

bq mk --location=US --dataset fingraph_rag

2. Tabloları oluşturun. Bu işlemi BigQuery Studio kullanıcı arayüzünde veya Cloud Shell üzerinden çalıştırabilirsiniz. SQL kodu:

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. Veri kümesini ekleme

Şimdi para izimizi oluşturmak için varlıkları ve ilişkilerini ekleyeceğiz. Bu veri kümesi, Doe (paravan şirket sahibi olduğundan şüphelenilen kişi), Jacoby (aracı), Menville (KYC'yi geçemeyen hedef) ve Smith (masum izleyici) arasındaki şüpheli etkinlikleri temsil etmektedir.

Tabloları doldurmak için aşağıdaki SQL'i çalıştırın:

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

Alınan Kayıtları Doğrulama

Finansal tablolarınızdaki kayıt sayılarını doğrulamak için bu sorguyu çalıştırın:

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

Şuna benzer bir satır ekleme işlemini onaylayan sorgu çıkışı görmeniz gerekir:

6. BigQuery Property Graph oluşturma

İlişkisel verilerimiz yerinde olduğundan, BigQuery'nin yerel Graph DDL'sini kullanarak FinGraph tanımlıyoruz. Bu işlem, verileri kopyalamadan veya çoğaltmadan mevcut ilişkisel tablolar üzerinde bir anlamsal katman oluşturur.

ISO GQL Söz Dizimi Temelleri

BigQuery Özellik Grafikleri, standart ISO Grafik Sorgu Dili (GQL) kalıplarını kullanır:

• (node:Label), öğe düğümlerini (ör. Account, Person, Loan) tanımlar.
• -[edge:LABEL]->, yönlendirilmiş ilişkileri (ör. Transfers, Repays, Owns) tanımlar.

Özellik grafiğini oluşturmak için aşağıdaki SQL ifadesini çalıştırın:

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

Sıfır ETL Paradigması: BigQuery'nin CREATE PROPERTY GRAPH özelliği, graf yapılarını doğrudan mevcut ilişkisel tablolarda tanımlayarak kırılgan ETL ardışık düzenlerini ve veri tekerrürünü ortadan kaldırır.

Hesaplar, kişiler ve krediler grafiğinin tamamını görselleştirmek için BigQuery Studio'da aşağıdaki SQL sorgusunu çalıştırın:

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

Şuna benzer bir grafik görselleştirme sonucu görmeniz gerekir:

7. Denetleme Günlükleri İçin Yerleştirilmiş Öğeler Oluşturma

RAG işlem hattımızın vektör arama bölümünü etkinleştirmek için AI.GENERATE_EMBEDDING Tablo Değerli İşlev (TVF) kullanarak doğrudan BigQuery'de yapılandırılmamış denetleme günlükleri için metin yerleştirmeleri oluştururuz.

BigQuery uzak bağlantısı oluşturma ve IAM izinleri verme

BigQuery ML, Vertex AI yerleştirme uç noktalarıyla güvenli bir şekilde iletişim kurmak için CLOUD_RESOURCE bağlantısı gerektirir. Bağlantıyı oluşturmak, otomatik olarak oluşturulan hizmet hesabını keşfetmek ve Vertex AI Kullanıcısı (roles/aiplatform.user) rolünü vermek için Cloud Shell'de aşağıdaki bash komutlarını çalıştırın:

# 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 koşul istemleriyle ilgili not:
Google Cloud projeniz zaten koşullu IAM bağlamaları içeriyorsa gcloud, koşul seçeneği (ör. [1] ..., [2] ..., [3] None) belirlemeniz için etkileşimli olarak sizi yönlendirebilir. Bu laboratuvarda roles/aiplatform.user rolünü koşulsuz olarak vermek için None (3 seçeneği) öğesini belirleyin. Yukarıdaki komuta --condition=None eklenmesi bu istemi otomatik olarak atlar.

Uzak yerleştirme modeli oluşturma

Ardından, yeni yetkilendirilmiş bağlantınız üzerinden Vertex AI'ın text-embedding-005 modeline bağlanan bir BigQuery ML uzak modeli tanımlayın:

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

IAM İzni Yayma Gecikmesi:
Yeni verilen IAM rollerinin Google Cloud hizmetlerine yayılması 1-3 dakika sürebilir. Model oluşturma veya yerleştirme oluşturma işlemi başlangıçta izin hatasıyla (ör. The [e-mail] does not have the permission to access or use the endpoint...) başarısız olursa IAM bağlamalarının senkronize olması için birkaç dakika bekleyin ve sorguyu yeniden deneyin.

Yerleştirilmiş öğeler oluşturma

Şimdi bir UPDATE ifadesinin FROM ifadesinde AI.GENERATE_EMBEDDING işlevini çağırarak AccountAudits tablosu için yerleştirmeler oluşturun:

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;

Oluşturulan vektör boyutlarını doğrulama

Vektör yerleştirmelerinin doldurulduğunu doğrulamak için aşağıdaki sorguyu çalıştırın:

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

Şuna benzer 768 boyutlu vektör yerleştirmelerini gösteren sorgu çıkışını görmeniz gerekir:

AI.GENERATE_EMBEDDING ve Vektör Araması nedir?
AI.GENERATE_EMBEDDING, FROM ifadesinde çağrılması gereken bir Tablo Değerli İşlevdir (TVF). MODEL (CLOUD_RESOURCE bağlantısı üzerinden Vertex AI'da kimlik doğrulaması yapar) ve content sütunu içeren bir giriş sorgusu kabul eder. Yerleştirme işlemi, veriler BigQuery'den ayrılmadan doğrudan Vertex AI'ye aktarılır. COSINE_DISTANCE, kural tabanlı kontrollerin kaçırdığı semantik eşleşmeleri yakalamak için hedef yerleştirmeler ve sorgu vektörleri arasındaki vektör benzerliğini hesaplar.

8. GraphRAG Retriever'ı tanımlama

Şimdi Python ortamımızda özel bir LangChain alıcı oluşturacağız. Bu alıcı, ilişkileri geçmek için yerel Graph MATCH sorgularıyla (ilişkileri geçmek için) semantik Vector Search'ü (alakalı başlangıç noktalarını bulmak için) birleştirir.

Python komut dosyanıza aşağıdaki kodu ekleyin 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

Grafik geçişi sorgusunun, MATCH (sender_person:Person)-[:Owns]->... aracılığıyla hesap sahiplerini, gönderenleri, transferleri ve kredileri nasıl zahmetsizce bir araya getirdiğine dikkat edin. Karmaşık SQL JOIN'lerine gerek yoktur.

Dinamik Çoklu Aracı NL2SQL/GQL Mimarisi:
Gelişmiş üretim amaçlı çoklu aracı sistemlerinde, alıcıda önceden tanımlanmış SQL/GQL sorgu şablonları kullanmak yerine özel bir NL2SQL / NL2GQL aracısı dağıtabilirsiniz. Beceri olarak grafik şema tanımları ve sorgu örnekleriyle yüklü olan bu uzmanlaşmış aracı, ana aracının temel araştırma hedeflerine göre özel GQL sorgularını dinamik olarak oluşturur, SQL'i BigQuery'ye karşı test eder ve doğrular, hedeflenen grafik sonuçlarını döndürür. Dinamik ajan tabanlı SQL oluşturma, çoklu ajan iş akışlarının tam esnekliğini vurgularken bu laboratuvarda kısa ve net olması için yapılandırılmış sorgular kullanıyoruz.

9. Sahtekarlık incelemesini çalıştırma

Son olarak, ayrıntılı bir sahtekarlık raporu oluşturmak için GraphRAG ardışık düzenini çalıştırırız. LLM, isteme yanıt vermek için özel grafik alıcımız tarafından alınan bağlamı kullanır.

Alan Değeri: Sahtekarlık İşlemlerinde Yanlış Pozitif Sorununu Çözme
Kural tabanlı geleneksel kara para aklamayı önleme izleme sistemi, kurallar işlemleri ayrı ayrı değerlendirdiği için (ör. Smith'in Menville'e 150 ABD doları tutarındaki transferini işaretleme) yılda milyonlarca yanlış pozitif işaretleme yapar. GraphRAG, semantik denetleme günlüğü bağlamını (Menville, KYC'yi geçemedi) çok adımlı grafik topolojisiyle (Doe → Jacoby → Menville) birleştirerek LLM'lerin zararsız gürültüyü filtrelemesini ve yüksek riskli kara para aklama döngülerini ortaya çıkarmasını sağlar.

Aşağıdaki kodu komut dosyanıza graphrag_aml.py ekleyin ve python graphrag_aml.py kullanarak uygulayın:

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

Complete graphrag_aml.py Script

Referans olarak, tam graphrag_aml.py komut dosyanız aşağıdaki gibi görünmelidir:

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

Şuna benzer bir çıkış alırsınız:

10. Kara Para Aklama İzini Görselleştirme

Programatik olarak keşfettiğimiz kara para aklama izini görsel olarak anlamak için BigQuery Studio konsolunda bir grafik görselleştirme sorgusu çalıştırabilirsiniz.

Bu sorguyu BigQuery Studio'da çalıştırın. (Grafik görselleştirme özelliğini etkinleştirdiğinizden veya varsa Grafik sekmesini tıkladığınızdan emin olun.)

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;

Bu GQL sorgusu, şüpheli paravan şirket sahibinden (Doe) aracıya (Jacoby) ve nihai hedefe (Menville) kadar olan tüm yolu ve kredi geri ödemesini izler.

Şuna benzer bir grafik görselleştirme sonucu görmeniz gerekir:

11. Temizleme

Google Cloud hesabınızın sürekli olarak ücretlendirilmesini önlemek için bu codelab sırasında oluşturulan kaynakları silin.

BigQuery veri kümesini ve Cloud Resource Connection'ı silin:

# 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

Kaynakların silindiğini doğrulayın:

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

12. Tebrikler

Tebrikler! Başarıyla bir RAG uygulaması oluşturdunuz ve davranışını analiz ettiniz. BigQuery'nin yerel Graph ve Vector Search özelliklerini kullanarak GraphRAG'yi nasıl gerçekleştireceğinizi, sıfır ETL ile kara para aklama planını nasıl tespit edeceğinizi gösterdiniz.

Öğrendikleriniz

• Standart tabloların üzerinde BigQuery'de Özellik Grafiği oluşturma
• BigQuery ML'yi kullanarak vektör yerleştirmeleri oluşturma ve depolama
• BigQuery Graph geçişlerini ve Vector Search'ü LangChain Retriever'da birleştirme
• LLM'ler, yanlış pozitifleri azaltmak için grafik topolojisiyle semantik denetleme günlüklerini nasıl sentezleyebilir?

Sonraki adımlar

• BigQuery Property Graphs'a Genel Bakış başlıklı makaleyi inceleyin.
• Diğer BigQuery Graph Query Language (GQL) kalıplarını deneyin.

Referans belgeleri

• BigQuery ML AI.GENERATE_EMBEDDING işlevi
• BigQuery Vector Search ve mesafe işlevleri
• LangChain Google Entegrasyonları