AWS Bedrock RAG Tutorial Sinhala | Retrieval Augmented Generation Guide

හායි යාලුවනේ! අද අපි කතා කරන්න යන්නේ Generative AI ලෝකයේ ගොඩක් වැදගත් සහ කතාබහට ලක්වෙන මාතෘකාවක් ගැන – ඒ තමයි Retrieval Augmented Generation (RAG). ඔයා Large Language Models (LLMs) ගැන දන්නවා නම්, සමහර වෙලාවට ඒ models අපිට වැරදි හෝ පරණ තොරතුරු දෙනවා වෙන්න පුළුවන්, නැත්නම් එයාලා පුහුණු කරලා තියෙන දත්තවලින් පිට තොරතුරු දෙන්න බැරි වෙන්න පුළුවන්. ඉතින් මේ ප්‍රශ්නවලට හොඳම විසඳුමක් තමයි RAG කියන්නේ.

මේ tutorial එකෙන් අපි RAG කියන්නේ මොකක්ද, ඒක වැඩ කරන්නේ කොහොමද, ඒකේ තියෙන ප්‍රධාන කොටස් මොනවද කියලා පැහැදිලිව බලමු. ඒ වගේම, Amazon Web Services (AWS) වල තියෙන AWS Bedrock Knowledge Bases භාවිතයෙන් RAG solution එකක් build කරගන්නේ කොහොමද කියලත් අපි ප්‍රායෝගිකව කතා කරනවා. එහෙනම්, අපි පටන් ගමු!

RAG කියන්නේ මොකක්ද? (What is Retrieval Augmented Generation?)

සරලවම කිව්වොත්, RAG කියන්නේ Generative AI model එකකට (විශේෂයෙන්ම LLM එකකට) ප්‍රශ්නයකට උත්තර දෙන්න කලින්, බාහිර Knowledge Base එකකින් අදාළ තොරතුරු හොයාගෙන, ඒ තොරතුරුත් එක්ක උත්තරය generate කරන්න පුළුවන් තාක්ෂණයක්. මේකෙන් LLM එකක accuracy එක, reliability එක සහ up-to-dateness එක ගොඩක් වැඩි වෙනවා.

උදාහරණයක් විදියට හිතන්න, ඔයාගේ Company එකේ internal documents ගොඩක් තියෙනවා කියලා. LLM එකක් පුහුණු කරලා තියෙන්නේ සාමාන්‍ය publicly available data වලින්. ඔයා LLM එකෙන් Company එකේ specific policy එකක් ගැන ඇහුවොත්, ඒක දන්නේ නැති වෙන්න පුළුවන්, නැත්නම් වැරදි දෙයක් කියන්නත් පුළුවන්. RAG භාවිතා කරනකොට, ඔයාගේ company documents තියෙන Knowledge Base එකෙන් අදාළ policy එක හොයාගෙන, ඒක LLM එකට දීලා, උත්තරය generate කරන්න පුළුවන්.

RAG භාවිතා කිරීමේ වාසි:

• වැඩි Accuracy එකක්: LLM එකට නිවැරදි, specific තොරතුරු ලබා දෙන නිසා, උත්තරත් නිවැරදි වෙනවා.
• Hallucinations අඩු වෙනවා: LLM එක තමන්ට නැති දේවල් 'ඇත්ත' වගේ කියන එක (hallucination) RAG නිසා ගොඩක් අඩු වෙනවා.
• Up-to-date තොරතුරු: LLM එක පුහුණු කරලා තියෙන දත්ත පරණ වුණත්, Knowledge Base එකට අලුත් තොරතුරු එකතු කරලා, හැම වෙලාවෙම up-to-date උත්තර දෙන්න පුළුවන්.
• Explainability: LLM එක උත්තරය දෙන්න පාවිච්චි කරපු source documents මොනවද කියලා පෙන්නන්න පුළුවන්.

RAG Architecture එකේ ප්‍රධාන කොටස් (Key Components of RAG Architecture)

RAG solution එකක් සාමාන්‍යයෙන් ප්‍රධාන කොටස් දෙකකට බෙදෙනවා: Retrieval කොටස සහ Generation කොටස.

1. Retrieval Process එක (Knowledge Base Building & Querying)

මේක තමයි RAG වල හදවත. මෙතනදී අපි අපේ documents LLM එකට තේරෙන විදියට සකස් කරගෙන, ඒවා search කරන්න පුළුවන් විදියට store කරනවා.

a. Data Source (දත්ත මූලාශ්‍රය)

මේක ඔයාගේ සියලුම තොරතුරු තියෙන තැන. PDF files, Word documents, web pages, databases, text files වගේ ඕනෑම එකක් වෙන්න පුළුවන්. මේවා තමයි LLM එකට අමතර context එක දෙන්න පාවිච්චි කරන්නේ.

b. Chunking Strategies (දත්ත කැබලි වලට කැඩීම)

ලොකු document එකක් එකපාරටම LLM එකට දෙන්න බැහැ. ඒ නිසා, අපි documents කුඩා 'chunks' වලට (කැබලි වලට) කඩනවා. මේ chunk එකක ප්‍රමාණය (e.g., words 200ක්, characters 500ක්) සහ overlapping (ඊළඟ chunk එකේ කලින් chunk එකේ කොටසක් තියෙනවා) වගේ දේවල් chunking strategy එකේදී වැදගත් වෙනවා. හොඳ chunking එකක් retrieval quality එකට බලපානවා.

def simple_chunking(text, chunk_size=500, overlap=50):
    chunks = []
    for i in range(0, len(text), chunk_size - overlap):
        chunks.append(text[i:i + chunk_size])
    return chunks

# Example Usage
long_document = "This is a very long document that needs to be broken down into smaller pieces for processing..."
chunks = simple_chunking(long_document, chunk_size=200, overlap=20)
print(f"Generated {len(chunks)} chunks.")

c. Embedding Models (Embedding Models)

අපි මේ කඩාගත්ත chunks LLM එකට තේරෙන 'භාෂාවකට' හරවන්න ඕනේ. ඒකට තමයි Embedding Models පාවිච්චි කරන්නේ. මේ models text chunk එකක් අරගෙන, ඒකට අදාළ numeric vector එකක් generate කරනවා. මේ vector එකෙන් ඒ text එකේ semantic meaning එක (අර්ථය) නිරූපණය වෙනවා. Similar meanings තියෙන texts වලට similar vectors තියෙනවා.

AWS Bedrock එකේ Titan Embeddings වගේ models මේකට පාවිච්චි කරන්න පුළුවන්.

d. Vector Databases (Vector Databases)

Embedding Models වලින් generate කරපු මේ numeric vectors ටික ගබඩා කරන්න තමයි Vector Databases පාවිච්චි කරන්නේ. මේවාට vector search කරන්න පුළුවන් capability එකක් තියෙනවා. ඒ කියන්නේ, අපේ user query එකට අදාළ vector එකක් generate කරලා, ඒ vector එකට closest (වඩාත්ම සමාන) vectors ටික database එකෙන් හොයාගන්න පුළුවන්. AWS OpenSearch, Pinecone, Redis, ChromaDB වගේ ඒවා vector databases විදියට පාවිච්චි කරන්න පුළුවන්.

e. Retrieval Optimization (Retrieval Optimization)

User query එකට අදාළ හොඳම chunks ටික හොයාගන්න, සමහර වෙලාවට retrieval process එක optimize කරන්න වෙනවා. මේකට Query Rewriting (query එක LLM එකක් හරහා improve කරනවා) සහ Re-ranking (මුලින්ම හොයාගත්ත chunks ටික තවත් model එකකින් prioritize කරනවා) වගේ techniques පාවිච්චි කරනවා.

2. Generation Process එක (LLM Interaction)

මේ තමයි අවසාන පියවර, මෙතනදී LLM එක උත්තරය generate කරනවා.

a. Context Injection (Context එක එකතු කිරීම)

Vector database එකෙන් හොයාගත්ත relevant chunks ටික LLM එකේ prompt එකට එකතු කරනවා. මේක LLM එකට උත්තරය දෙන්න අවශ්‍ය අමතර තොරතුරු සැපයීමක්.

User Query: "What is the policy for remote work?"

Retrieved Context:
"Chunk 1: ...Our remote work policy states that employees can work remotely up to 3 days a week with manager approval..."
"Chunk 2: ...For long-term remote work, an application form must be filled and submitted to HR..."

Full Prompt to LLM:
"Based on the following context, please answer the user's question:
Context:
<Chunk 1 Content>
<Chunk 2 Content>
User Question: What is the policy for remote work?"

b. LLM Response Generation (LLM උත්තරය දීම)

Context එකත් එක්ක දීපු prompt එකෙන් පස්සේ, LLM එක user query එකට අදාළ නිවැරදි උත්තරය generate කරනවා.

AWS Bedrock Knowledge Bases සමග RAG (RAG with AWS Bedrock Knowledge Bases)

AWS Bedrock කියන්නේ Generative AI models manage කරන්න සහ deploy කරන්න පුළුවන් fully managed service එකක්. Bedrock Knowledge Bases කියන්නේ RAG solution එකක් build කරන්න පුළුවන් සරලම සහ effective ම ක්‍රමයක්. මේකෙන් vector store එක manage කරන එක, embedding generate කරන එක වගේ දේවල් AWS එකෙන් බලාගන්නවා, ඒ නිසා අපේ වැඩේ ගොඩක් පහසු වෙනවා.

Bedrock Knowledge Base එකක් හදන්නේ කොහොමද? (How to Build a Bedrock Knowledge Base)

සරලවම කිව්වොත්, පියවර කිහිපයක් තියෙනවා:

පියවර 1: Knowledge Base එකක් Create කිරීම

AWS Console එකට ගිහින්, Bedrock service එක තෝරගෙන, වම් පැත්තේ තියෙන Knowledge Bases කියන එකට ගිහින් "Create knowledge base" කියන බොත්තම ඔබන්න. නමක් දීලා, අවශ්‍ය permissions (Service Role එකක්) ටික ලබා දෙන්න.

පියවර 2: Data Source එකක් Add කිරීම

ඊළඟට, ඔයාගේ documents තියෙන තැන specify කරන්න ඕනේ. සාමාන්‍යයෙන් මේකට Amazon S3 bucket එකක් පාවිච්චි කරනවා. ඔයාගේ documents (PDFs, .txt, .csv, .md files) S3 bucket එකකට upload කරන්න. Bedrock Knowledge Base එකට ඒ S3 bucket එකට access දෙන්න.

පියවර 3: Embedding Model සහ Vector Store එකක් තෝරා ගැනීම

• Embedding Model: මෙතනදී ඔයාට AWS Titan Embeddings වගේ built-in models තෝරගන්න පුළුවන්. මේවා texts vectors වලට හරවන්න පාවිච්චි කරනවා.
• Vector Store: Bedrock Knowledge Bases වලට Amazon OpenSearch Serverless, Pinecone, Redis Enterprise Cloud, හෝ Chroma වගේ vector databases එක්ක integrate වෙන්න පුළුවන්. ඔයාට කැමති එකක් තෝරගන්න පුළුවන්. AWS OpenSearch Serverless තමයි පහසුම option එක, මොකද ඒකත් fully managed නිසා.

පියවර 4: Data Ingestion (දත්ත එකතු කිරීම)

ඉහත පියවර සම්පූර්ණ කළාට පස්සේ, Knowledge Base එකට "Sync" කරන්න පුළුවන්. එතකොට Bedrock ඔයාගේ S3 bucket එකෙන් documents අරගෙන, ඒවා chunks වලට කඩලා, embedding generate කරලා, ඒවා vector store එකේ save කරනවා. මේ process එකෙන් පස්සේ තමයි Knowledge Base එක query කරන්න සූදානම් වෙන්නේ.

Bedrock Knowledge Base එකක් Query කරන්නේ කොහොමද? (How to Query a Bedrock Knowledge Base?)

Knowledge Base එකක් හැදුවට පස්සේ, ඔයාට Bedrock Runtime API එක පාවිච්චි කරලා ඒකෙන් තොරතුරු retrieve කරන්න පුළුවන්. මෙන්න ඒකට simple Python code snippet එකක් (boto3 SDK එක පාවිච්චි කරලා):

import boto3
import json

botocore_session = boto3.Session(region_name='us-east-1') # Change to your region
bedrock_agent_runtime = botocore_session.client('bedrock-agent-runtime')

knowledge_base_id = 'YOUR_KNOWLEDGE_BASE_ID' # Replace with your Knowledge Base ID
model_id = 'anthropic.claude-v2' # Or another suitable LLM model

def query_knowledge_base(query):
    try:
        response = bedrock_agent_runtime.retrieve_and_generate(
            input={
                'text': query
            },
            retrieveAndGenerateConfiguration={
                'type': 'KNOWLEDGE_BASE',
                'knowledgeBaseConfiguration': {
                    'knowledgeBaseId': knowledge_base_id,
                    'modelArn': f'arn:aws:bedrock:us-east-1::foundation-model/{model_id}' # Adjust region
                }
            }
        )
        
        # Extract the generated text response
        generated_text = response['output']['text']
        
        # Optionally, extract the retrieved source documents for explainability
        # retrieved_references = response['citations'] # Check response structure for exact path
        
        return generated_text
        
    except Exception as e:
        print(f"Error querying knowledge base: {e}")
        return None

# Example Usage:
user_question = "What is the new remote work policy for 2024?"
answer = query_knowledge_base(user_question)

if answer:
    print(f"\nUser Question: {user_question}")
    print(f"Answer: {answer}")
else:
    print("Could not get an answer.")

මේ retrieve_and_generate API call එකෙන් වෙන්නේ:

1. මුලින්ම user query එකට අදාළ documents Knowledge Base එකෙන් retrieve කරනවා.
2. ඒ retrieve කරපු context එක LLM එකේ prompt එකට inject කරනවා.
3. අන්තිමට, LLM එකෙන් උත්තරය generate කරලා අපිට දෙනවා.

මේ API එක RAG process එකේ retrieval සහ generation කියන දෙකම එකම call එකකින් handle කරනවා, ඒ නිසා deploy කරන එක ගොඩක් පහසුයි.

RAG වල අභියෝග (Challenges of RAG)

• Chunking Quality: Chunks හොඳට කඩලා නැත්නම්, retrieval quality එක අඩු වෙන්න පුළුවන්.
• Retrieval Latency: ලොකු Knowledge Base එකක් query කරනකොට response time එක වැඩි වෙන්න පුළුවන්.
• Cost: Embedding generate කරන එකට, vector database එකක් manage කරන එකට, සහ LLM calls වලට වියදමක් යනවා.
• Data Freshness: Knowledge Base එක නිතරම update කරන්න ඕනේ, නැත්නම් පරණ තොරතුරු ලැබෙන්න පුළුවන්. (Bedrock වල sync feature එකෙන් මේක පහසු වෙනවා).

අවසන් වශයෙන් (Conclusion)

ඉතින් යාලුවනේ, RAG කියන්නේ LLMs වලට තවත් බලයක් එකතු කරන, ගොඩක් ප්‍රයෝජනවත් තාක්ෂණයක්. ඒකෙන් LLMs වල accuracy එක, reliability එක වගේම up-to-dateness එකත් වැඩි කරන්න පුළුවන්. විශේෂයෙන්ම, AWS Bedrock Knowledge Bases වගේ fully managed services, RAG solution එකක් build කරන එක පුදුම විදියට පහසු කරනවා.

ඔයාට තියෙන internal knowledge base එකක් (Company documents, support articles, product manuals) LLM එකක් එක්ක integrate කරන්න ඕනේ නම්, RAG තමයි හොඳම විසඳුම. මේ tutorial එක ඔයාලට RAG ගැන සහ AWS Bedrock Knowledge Bases ගැන හොඳ අවබෝධයක් දෙන්න ඇති කියලා හිතනවා.

මේ ගැන ඔයාලගේ අත්දැකීම් මොනවද? ඔයාලා RAG implementation එකක් කරලා තියෙනවා නම්, comment section එකේ කියන්න. ඔයාලගේ අදහස් දැනගන්න අපි කැමතියි! මේක ඔයාගේ next project එකට try කරලා බලන්න!