View source for AWS: LLM HuggingFace RAG

Berikut adalah panduan umum dan langkah-langkah yang dapat Anda ambil untuk membangun pipeline Retrieval Augmented Generation (RAG) sederhana menggunakan LLM dari Hugging Face di lingkungan AWS. Pendekatan ini tidak satu-satunya, namun dapat menjadi starting point yang solid.

==Konsep Dasar RAG:==
RAG umumnya melibatkan dua bagian utama:

* '''Retrieval (Pengambilan Informasi):''' Mengambil dokumen atau informasi relevan dari suatu knowledge base (misalnya kumpulan dokumen yang telah diindeks dan diembedding ke dalam vector store).  
   
* '''Augmented Generation (Pengayaan Prompt):''' Menggabungkan hasil retrieval tersebut ke dalam prompt yang diberikan ke model bahasa (LLM), sehingga model dapat memberikan jawaban yang kontekstual dan lebih akurat.

==Lingkungan AWS yang Bisa Digunakan:==
* '''Amazon EC2 atau Amazon SageMaker:''' Untuk men-deploy model LLM Hugging Face.
* '''Amazon S3:''' Untuk menyimpan data dokumen asli, model checkpoint, maupun embedding hasil proses.
* '''Layanan untuk Vector Store:'''  
** '''Amazon OpenSearch Service dengan plugin vector search''': Anda dapat mengindeks embedding dokumen di sini.  
** Alternatifnya, Anda bisa menggunakan basis data terkelola lain yang mendukung vector search, atau bahkan menyimpan embedding di database sendiri (misalnya DynamoDB) dan memprosesnya dengan FAISS secara manual di dalam container.
* '''Amazon Lambda / AWS API Gateway (opsional):''' Untuk menyiapkan endpoint yang memproses query user, melakukan retrieval, lalu memanggil model.

==Langkah-Langkah Detail:==

* '''Persiapan Model LLM di AWS:'''
** Anda dapat memulai dengan model open-source LLM dari Hugging Face Hub (misalnya Llama 2, Falcon, atau Dolly) yang telah tersedia di SageMaker JumpStart.  
** Jika Anda ingin menggunakan model custom dari Hugging Face, Anda dapat:  
** Unduh model dan simpan ke Amazon S3, lalu gunakan SageMaker untuk men-deploy container inference Hugging Face.  
** SageMaker menyediakan `HuggingFaceModel` yang memudahkan proses ini:  

 from sagemaker.huggingface import HuggingFaceModel
 
 huggingface_model = HuggingFaceModel(
      model_data='s3://bucket-name/path/to/model.tar.gz',
      role='arn:aws:iam::111122223333:role/SageMakerRole',
      transformers_version='4.17',
      pytorch_version='1.10',
      py_version='py38'
  )
 
 predictor = huggingface_model.deploy(
      initial_instance_count=1,
      instance_type='ml.g4dn.xlarge'
  )

* Pastikan Anda sudah menyesuaikan tipe instance dengan kebutuhan GPU/CPU.

* '''Membangun Vector Embedding untuk Dokumen:'''
** Ambil kumpulan dokumen (misalnya teks, PDF yang sudah diekstrak isinya, dsb.) dan simpan di Amazon S3.
** Gunakan model embedding (misalnya `sentence-transformers` atau `Instructor Embeddings`) untuk mengubah teks menjadi embedding vektor. Anda dapat melakukan ini secara offline di EC2 atau job SageMaker Processing:

 from sentence_transformers import SentenceTransformer
 
 model = SentenceTransformer('sentence-transformers/all-mpnet-base-v2')
 documents = ["Teks dokumen 1", "Teks dokumen 2", "Teks dokumen N"]
 embeddings = model.encode(documents)

** Simpan hasil embedding ke S3 atau langsung indeks ke Amazon OpenSearch.

3. '''Membuat Index Vector Store di Amazon OpenSearch:'''
   - Buat domain Amazon OpenSearch dengan fitur vector search diaktifkan.
   - Buat index untuk dokumen:
h
     PUT my-index
     {
       "mappings": {
         "properties": {
           "text": {"type": "text"},
           "embedding": {"type": "knn_vector", "dimension": 768} 
         }
       }
     }

     (Dimension menyesuaikan dengan model embedding yang digunakan.)
   
   - Indeks dokumen beserta embedding-nya ke OpenSearch.

     POST my-index/_doc
     {
       "text": "Teks dokumen 1",
       "embedding": [0.123, 0.234, ...] // embedding vektor hasil encode
     }
     ```

4. '''Alur Query (RAG):'''
   - User mengirim pertanyaan (query).  
   - Sistem mengambil pertanyaan user, me-generate embedding query dengan model embedding yang sama.
   - Lakukan pencarian di OpenSearch dengan `knn` search:

     POST my-index/_search
     {
       "size": 3,
       "query": {
         "knn": {
           "embedding": {
             "vector": [0.321, 0.456, ...], // embedding query
             "k": 3
           }
         }
       }
     }
     ```
   - Dapatkan dokumen teratas yang paling relevan.
   - Buat prompt baru untuk LLM dengan format:  

     Context:
     [Dokumen 1]
     [Dokumen 2]
     [Dokumen 3]

     Pertanyaan: {pertanyaan user}
     Jawaban:

   
   - Kirim prompt tersebut ke endpoint model Hugging Face di SageMaker:

     response = predictor.predict({"inputs": prompt})
     print(response)


5. '''Orkestrasi Alur:'''
   - Untuk menyederhanakan pipeline, Anda bisa membungkus semua alur (embedding query, searching di OpenSearch, membangun prompt, memanggil LLM) dalam satu Lambda function.
   - Gunakan AWS API Gateway untuk menyediakan endpoint publik.  
   
   Alurnya menjadi:
   1. User mengirim query ke endpoint API Gateway.
   2. API Gateway memanggil Lambda.
   3. Lambda:
      - Menghitung embedding query.
      - Melakukan knn search ke OpenSearch.
      - Menggabungkan hasil dan membentuk prompt.
      - Memanggil endpoint SageMaker untuk inference LLM.
      - Mengembalikan jawaban ke user.

==Tips:==

* '''Optimasi Biaya & Performa:''' Pertimbangkan untuk menggunakan instance GPU yang sesuai ukuran beban. Untuk beban rendah, Anda dapat memanfaatkan endpoint serverless di SageMaker (jika tersedia untuk model Hugging Face tertentu) atau scaling policy auto-scaling.

* '''Keamanan & IAM:''' Pastikan peran IAM (misalnya peran SageMaker, peran Lambda) memiliki hak akses untuk membaca S3, query OpenSearch, dan memanggil endpoint inference.

* '''Penyesuaian Prompt:''' Kualitas jawaban sangat tergantung dari cara Anda menyusun prompt dengan konteks hasil retrieval. Eksperimen dengan panjang konteks, jumlah dokumen, serta format prompt.

* '''Monitoring & Logging:''' Gunakan CloudWatch untuk memonitor kinerja inference endpoint, Lambda, dan OpenSearch queries. Log detail query & response untuk memudahkan debugging.

Dengan langkah-langkah di atas, Anda akan memiliki pipeline RAG sederhana: dokumen disimpan, diencode menjadi embedding, diindeks, dan pada saat query masuk, sistem akan melakukan retrieval sebelum mengumpankan konteks ke LLM yang dijalankan di AWS.


==Pranala Menarik==

* [[AWS]]