উন্নত RAG কৌশল

1. ভূমিকা

সংক্ষিপ্ত বিবরণ

রিট্রিভ্যাল অগমেন্টেড জেনারেশন (RAG) বাহ্যিক জ্ঞানের উপর ভিত্তি করে লার্জ ল্যাঙ্গুয়েজ মডেল (LLM) প্রতিক্রিয়াগুলিকে উন্নত করে। তবে, একটি উৎপাদন-প্রস্তুত RAG সিস্টেম তৈরি করতে কেবল একটি সাধারণ ভেক্টর অনুসন্ধানের চেয়েও বেশি কিছুর প্রয়োজন। আপনাকে অবশ্যই অপ্টিমাইজ করতে হবে কীভাবে ডেটা গ্রহণ করা হয়, কীভাবে প্রাসঙ্গিক ফলাফলগুলিকে র‍্যাঙ্ক করা হয় এবং কীভাবে ব্যবহারকারীর প্রশ্নগুলি প্রক্রিয়া করা হয়।

এই বিস্তৃত ল্যাবে, আপনি PostgreSQL ( pgvector সহ বর্ধিত) এবং Vertex AI এর জন্য Cloud SQL ব্যবহার করে একটি শক্তিশালী RAG অ্যাপ্লিকেশন তৈরি করবেন। আপনি তিনটি উন্নত কৌশলের মাধ্যমে অগ্রগতি করবেন:

1. খণ্ডন কৌশল: আপনি লক্ষ্য করবেন কিভাবে টেক্সট বিভক্ত করার বিভিন্ন পদ্ধতি (অক্ষর, পুনরাবৃত্তিমূলক, টোকেন) পুনরুদ্ধারের মানকে প্রভাবিত করে।
2. পুনঃর‍্যাঙ্কিং: অনুসন্ধানের ফলাফলগুলিকে পরিমার্জন করতে এবং "মাঝখানে হারিয়ে যাওয়া" সমস্যার সমাধান করতে আপনি ভার্টেক্স এআই পুনঃর‍্যাঙ্কার বাস্তবায়ন করবেন।
3. কোয়েরি ট্রান্সফর্মেশন: আপনি HyDE (হাইপোথেটিক্যাল ডকুমেন্ট এম্বেডিং) এবং স্টেপ-ব্যাক প্রম্পটিং এর মতো কৌশলগুলির মাধ্যমে ব্যবহারকারীর কোয়েরিগুলি অপ্টিমাইজ করার জন্য জেমিনি ব্যবহার করবেন।

তুমি কি করবে

• pgvector দিয়ে PostgreSQL ইনস্ট্যান্সের জন্য একটি ক্লাউড SQL সেট আপ করুন।
• একটি ডেটা ইনজেশন পাইপলাইন তৈরি করুন যা একাধিক কৌশল ব্যবহার করে টেক্সটকে খণ্ডিত করে এবং ক্লাউড SQL-এ এম্বেডিং সংরক্ষণ করে।
• শব্দার্থিক অনুসন্ধান সম্পাদন করুন এবং বিভিন্ন চাঙ্কিং পদ্ধতি থেকে ফলাফলের মানের তুলনা করুন।
• প্রাসঙ্গিকতার উপর ভিত্তি করে পুনরুদ্ধার করা নথিগুলিকে পুনর্বিন্যাস করতে একটি রির্যাঙ্কারকে একীভূত করুন।
• অস্পষ্ট বা জটিল প্রশ্নের পুনরুদ্ধার উন্নত করতে LLM-চালিত ক্যোয়ারী রূপান্তর বাস্তবায়ন করুন।

তুমি কি শিখবে

• ভার্টেক্স এআই এবং ক্লাউড এসকিউএল এর সাথে ল্যাংচেইন কীভাবে ব্যবহার করবেন।
• ক্যারেক্টার , রিকার্সিভ এবং টোকেন টেক্সট স্প্লিটারের প্রভাব।
• PostgreSQL-এ ভেক্টর অনুসন্ধান কীভাবে বাস্তবায়ন করবেন।
• পুনঃর‍্যাঙ্কিংয়ের জন্য ContextualCompressionRetriever কীভাবে ব্যবহার করবেন।
• HyDE এবং Step-back Prompting কীভাবে বাস্তবায়ন করবেন।

2. প্রকল্প সেটআপ

গুগল অ্যাকাউন্ট

যদি আপনার ইতিমধ্যেই একটি ব্যক্তিগত Google অ্যাকাউন্ট না থাকে, তাহলে আপনাকে অবশ্যই একটি Google অ্যাকাউন্ট তৈরি করতে হবে।

কর্মক্ষেত্র বা স্কুল অ্যাকাউন্টের পরিবর্তে ব্যক্তিগত অ্যাকাউন্ট ব্যবহার করুন ।

কর্মক্ষেত্র এবং স্কুল অ্যাকাউন্টগুলিতে এমন বিধিনিষেধ থাকতে পারে যা আপনাকে এই ল্যাবের জন্য প্রয়োজনীয় API গুলি সক্ষম করতে বাধা দেয়।

গুগল ক্লাউড কনসোলে সাইন-ইন করুন

একটি ব্যক্তিগত গুগল অ্যাকাউন্ট ব্যবহার করে গুগল ক্লাউড কনসোলে সাইন-ইন করুন।

বিলিং সক্ষম করুন

$৫ গুগল ক্লাউড ক্রেডিট রিডিম করুন (ঐচ্ছিক)

এই কর্মশালাটি পরিচালনা করার জন্য, আপনার কিছু ক্রেডিট সহ একটি বিলিং অ্যাকাউন্ট প্রয়োজন। আপনি যদি নিজের বিলিং ব্যবহার করার পরিকল্পনা করেন, তাহলে আপনি এই ধাপটি এড়িয়ে যেতে পারেন।

1. এই লিঙ্কে ক্লিক করুন এবং একটি ব্যক্তিগত গুগল অ্যাকাউন্ট দিয়ে সাইন ইন করুন। আপনি এরকম কিছু দেখতে পাবেন:
2. আপনার ক্রেডিট অ্যাক্সেস করতে এখানে ক্লিক করুন বোতামটি ক্লিক করুন। এটি আপনাকে আপনার বিলিং প্রোফাইল সেট আপ করার জন্য একটি পৃষ্ঠায় নিয়ে যাবে।
3. আপনি এখন একটি Google Cloud Platform ট্রায়াল বিলিং অ্যাকাউন্টের সাথে সংযুক্ত আছেন কিনা তা নিশ্চিত করুন -এ ক্লিক করুন।

একটি ব্যক্তিগত বিলিং অ্যাকাউন্ট সেট আপ করুন

আপনি যদি গুগল ক্লাউড ক্রেডিট ব্যবহার করে বিলিং সেট আপ করেন, তাহলে আপনি এই ধাপটি এড়িয়ে যেতে পারেন।

একটি ব্যক্তিগত বিলিং অ্যাকাউন্ট সেট আপ করতে, ক্লাউড কনসোলে বিলিং সক্ষম করতে এখানে যান ।

কিছু নোট:

• এই ল্যাবটি সম্পূর্ণ করতে ক্লাউড রিসোর্সে $1 USD এর কম খরচ হবে।
• আরও চার্জ এড়াতে আপনি এই ল্যাবের শেষে রিসোর্স মুছে ফেলার ধাপগুলি অনুসরণ করতে পারেন।
• নতুন ব্যবহারকারীরা $300 USD বিনামূল্যে ট্রায়ালের জন্য যোগ্য।

একটি প্রকল্প তৈরি করুন (ঐচ্ছিক)

যদি আপনার এই ল্যাবের জন্য ব্যবহার করতে চান এমন কোন বর্তমান প্রকল্প না থাকে, তাহলে এখানে একটি নতুন প্রকল্প তৈরি করুন ।

৩. ক্লাউড শেল এডিটর খুলুন

1. সরাসরি ক্লাউড শেল এডিটরে যেতে এই লিঙ্কে ক্লিক করুন।
2. আজই যদি যেকোনো সময় অনুমোদনের অনুরোধ করা হয়, তাহলে চালিয়ে যেতে অনুমোদন করুন- এ ক্লিক করুন।
3. যদি স্ক্রিনের নীচে টার্মিনালটি না দেখা যায়, তাহলে এটি খুলুন:
   • ভিউ ক্লিক করুন
   • টার্মিনাল ক্লিক করুন
4. টার্মিনালে, এই কমান্ড দিয়ে আপনার প্রকল্পটি সেট করুন:

   gcloud config set project [PROJECT_ID]
   

   • উদাহরণ:

     gcloud config set project lab-project-id-example
     

   • যদি আপনি আপনার প্রজেক্ট আইডি মনে রাখতে না পারেন, তাহলে আপনি আপনার সমস্ত প্রজেক্ট আইডি তালিকাভুক্ত করতে পারেন:

     gcloud projects list
     

     
5. আপনার এই বার্তাটি দেখা উচিত:

   Updated property [core/project].
   

   যদি আপনি একটি WARNING দেখতে পান এবং জিজ্ঞাসা করা হয় Do you want to continue (Y/n)? , তাহলে সম্ভবত আপনি প্রজেক্ট আইডি ভুলভাবে প্রবেশ করেছেন। n টিপুন, Enter টিপুন, এবং আবার gcloud config set project কমান্ডটি চালানোর চেষ্টা করুন।

৪. API গুলি সক্ষম করুন

এই সমাধানটি তৈরি করতে, আপনাকে Vertex AI, Cloud SQL এবং Reranking পরিষেবার জন্য বেশ কয়েকটি Google Cloud API সক্রিয় করতে হবে।

1. টার্মিনালে, API গুলি সক্রিয় করুন:

   gcloud services enable \
     aiplatform.googleapis.com \
     sqladmin.googleapis.com \
     cloudresourcemanager.googleapis.com \
     serviceusage.googleapis.com \
     discoveryengine.googleapis.com
   
   
   

API গুলির সাথে পরিচয় করিয়ে দেওয়া হচ্ছে

• Vertex AI API ( aiplatform.googleapis.com ): জেনারেশনের জন্য Gemini এবং টেক্সট ভেক্টরাইজ করার জন্য Vertex AI Embeddings ব্যবহার সক্ষম করে।
• ক্লাউড এসকিউএল অ্যাডমিন এপিআই ( sqladmin.googleapis.com ): আপনাকে ক্লাউড এসকিউএল ইনস্ট্যান্সগুলি প্রোগ্রাম্যাটিকভাবে পরিচালনা করতে দেয়।
• ডিসকভারি ইঞ্জিন এপিআই ( discoveryengine.googleapis.com ): ভার্টেক্স এআই রির্যাঙ্কার ক্ষমতাগুলিকে শক্তিশালী করে।
• পরিষেবা ব্যবহারের API ( serviceusage.googleapis.com ): পরিষেবা কোটা পরীক্ষা এবং পরিচালনা করার জন্য প্রয়োজনীয়।

৫. একটি ভার্চুয়াল পরিবেশ তৈরি করুন এবং নির্ভরতা ইনস্টল করুন

যেকোনো পাইথন প্রকল্প শুরু করার আগে, একটি ভার্চুয়াল পরিবেশ তৈরি করা ভালো অভ্যাস। এটি প্রকল্পের নির্ভরতাগুলিকে বিচ্ছিন্ন করে, অন্যান্য প্রকল্প বা সিস্টেমের বিশ্বব্যাপী পাইথন প্যাকেজগুলির সাথে দ্বন্দ্ব রোধ করে।

1. rag-labs নামে একটি ফোল্ডার তৈরি করুন এবং এতে পরিবর্তন করুন। টার্মিনালে নিম্নলিখিত কোডটি চালান:

   mkdir rag-labs && cd rag-labs
   

2. একটি ভার্চুয়াল পরিবেশ তৈরি এবং সক্রিয় করুন:

   uv venv --python 3.12
   source .venv/bin/activate
   

3. প্রয়োজনীয় নির্ভরতা সহ একটি requirements.txt ফাইল তৈরি করুন। টার্মিনালে নিম্নলিখিত কোডটি চালান:

   cloudshell edit requirements.txt
   

4. নিম্নলিখিত অপ্টিমাইজ করা নির্ভরতাগুলি requirements.txt ফাইলে পেস্ট করুন। এই সংস্করণগুলি দ্বন্দ্ব এড়াতে এবং ইনস্টলেশনের গতি বাড়ানোর জন্য পিন করা হয়েছে।

   # Core LangChain & AI
   langchain-community==0.3.31
   langchain-google-vertexai==2.1.2
   langchain-google-community[vertexaisearch]==2.0.10
   
   # Google Cloud
   google-cloud-storage==2.19.0
   google-cloud-aiplatform[langchain]==1.130.0
   
   # Database
   cloud-sql-python-connector[pg8000]==1.19.0
   sqlalchemy==2.0.45
   pgvector==0.4.2
   
   # Utilities
   tiktoken==0.12.0
   python-dotenv==1.2.1
   requests==2.32.5
   

5. নির্ভরতা ইনস্টল করুন:

   uv pip install -r requirements.txt
   

৬. PostgreSQL এর জন্য ক্লাউড SQL সেট আপ করুন

এই কাজে, আপনি PostgreSQL ইনস্ট্যান্সের জন্য একটি ক্লাউড SQL সরবরাহ করবেন, একটি ডাটাবেস তৈরি করবেন এবং ভেক্টর অনুসন্ধানের জন্য এটি প্রস্তুত করবেন।

ক্লাউড SQL কনফিগারেশন সংজ্ঞায়িত করুন

1. আপনার কনফিগারেশন সংরক্ষণ করার জন্য একটি .env ফাইল তৈরি করুন। টার্মিনালে নিম্নলিখিত কোডটি চালান:

   cloudshell edit .env
   

2. নিম্নলিখিত কনফিগারেশনটি .env এ পেস্ট করুন।

   # Project Config
   PROJECT_ID="[YOUR_PROJECT_ID]"
   REGION="us-central1"
   
   # Database Config
   SQL_INSTANCE_NAME="rag-pg-instance-1"
   SQL_DATABASE_NAME="rag_harry_potter_db"
   SQL_USER="rag_user"
   SQL_PASSWORD="StrongPassword123!" 
   
   # RAG Config
   PGVECTOR_COLLECTION_NAME="rag_harry_potter"
   RANKING_LOCATION_ID="global"
   
   # Connection Name (Auto-generated in scripts usually, but useful to have)
   DB_INSTANCE_CONNECTION_NAME="${PROJECT_ID}:${REGION}:${SQL_INSTANCE_NAME}"
   

   দ্রষ্টব্য: প্রোডাকশন অ্যাপের জন্য, সংবেদনশীল পাসওয়ার্ড সংরক্ষণ করতে Google Cloud Secret Manager ব্যবহার করুন। এই ল্যাবের জন্য, একটি .env ফাইলই যথেষ্ট।

3. [YOUR_PROJECT_ID] কে আপনার আসল Google ক্লাউড প্রজেক্ট আইডি দিয়ে প্রতিস্থাপন করুন। (যেমন PROJECT_ID = "google-cloud-labs" )
   যদি আপনি আপনার প্রজেক্ট আইডি মনে করতে না পারেন, তাহলে আপনার টার্মিনালে নিম্নলিখিত কমান্ডটি চালান। এটি আপনাকে আপনার সমস্ত প্রজেক্ট এবং তাদের আইডিগুলির একটি তালিকা দেখাবে।

   gcloud projects list
   

4. আপনার শেল সেশনে ভেরিয়েবলগুলি লোড করুন:

   source .env
   

ইনস্ট্যান্স এবং ডাটাবেস তৈরি করুন

1. PostgreSQL ইনস্ট্যান্সের জন্য একটি ক্লাউড SQL তৈরি করুন। এই কমান্ডটি এই ল্যাবের জন্য উপযুক্ত একটি ছোট ইনস্ট্যান্স তৈরি করে।

   gcloud sql instances create ${SQL_INSTANCE_NAME} \
     --database-version=POSTGRES_15 \
     --tier=db-g1-small \
     --region=${REGION} \
     --project=${PROJECT_ID}
   

   দ্রষ্টব্য: একটি নতুন ক্লাউড SQL ইনস্ট্যান্স তৈরি করতে প্রায় ৫-৭ মিনিট সময় লাগতে পারে। দয়া করে ধৈর্য ধরুন।

2. একবার ইনস্ট্যান্স প্রস্তুত হয়ে গেলে, ডাটাবেস তৈরি করুন:

   gcloud sql databases create ${SQL_DATABASE_NAME} \
     --instance=${SQL_INSTANCE_NAME} \
     --project=${PROJECT_ID}
   

3. ডাটাবেস ব্যবহারকারী তৈরি করুন:

   gcloud sql users create ${SQL_USER} \
     --instance=${SQL_INSTANCE_NAME} \
     --password=${SQL_PASSWORD} \
     --project=${PROJECT_ID}
   

pgvector এক্সটেনশন সক্রিয় করুন

pgvector এক্সটেনশনটি PostgreSQL কে ভেক্টর এম্বেডিং সংরক্ষণ এবং অনুসন্ধান করার অনুমতি দেয়। আপনার ডাটাবেসে এটি স্পষ্টভাবে সক্ষম করতে হবে।

1. enable_pgvector.py নামে একটি স্ক্রিপ্ট তৈরি করুন। টার্মিনালে নিম্নলিখিত কোডটি চালান:

   cloudshell edit enable_pgvector.py
   

2. নিচের কোডটি enable_pgvector.py তে পেস্ট করুন। এই স্ক্রিপ্টটি আপনার ডাটাবেসের সাথে সংযোগ স্থাপন করে এবং CREATE EXTENSION IF NOT EXISTS vector; চালায়।

   import os
   import sqlalchemy
   from google.cloud.sql.connector import Connector, IPTypes
   import logging
   from dotenv import load_dotenv
   
   load_dotenv()
   logging.basicConfig(level=logging.INFO)
   
   # Config
   project_id = os.getenv("PROJECT_ID")
   region = os.getenv("REGION")
   instance_name = os.getenv("SQL_INSTANCE_NAME")
   db_user = os.getenv("SQL_USER")
   db_pass = os.getenv("SQL_PASSWORD")
   db_name = os.getenv("SQL_DATABASE_NAME")
   instance_connection_name = f"{project_id}:{region}:{instance_name}"
   
   def getconn():
       with Connector() as connector:
           conn = connector.connect(
               instance_connection_name,
               "pg8000",
               user=db_user,
               password=db_pass,
               db=db_name,
               ip_type=IPTypes.PUBLIC,
           )
           return conn
   
   def enable_pgvector():
       pool = sqlalchemy.create_engine(
           "postgresql+pg8000://",
           creator=getconn,
       )
       with pool.connect() as db_conn:
           # Check if extension exists
           result = db_conn.execute(sqlalchemy.text("SELECT extname FROM pg_extension WHERE extname = 'vector';")).fetchone()
           if result:
               logging.info("pgvector extension is already enabled.")
           else:
               logging.info("Enabling pgvector extension...")
               db_conn.execute(sqlalchemy.text("CREATE EXTENSION IF NOT EXISTS vector;"))
               db_conn.commit()
               logging.info("pgvector extension enabled successfully.")
   
   if __name__ == "__main__":
       enable_pgvector()
   

3. স্ক্রিপ্টটি চালান:

   python enable_pgvector.py
   

৭. পর্ব ১: ছাঁটাই কৌশল

যেকোনো RAG পাইপলাইনের প্রথম ধাপ হল নথিগুলিকে এমন একটি ফর্ম্যাটে রূপান্তর করা যা LLM বুঝতে পারে: chunks ।

LLM-এর একটি প্রসঙ্গ উইন্ডো সীমা থাকে (তারা একবারে কতটুকু টেক্সট প্রক্রিয়া করতে পারে)। অধিকন্তু, একটি নির্দিষ্ট প্রশ্নের উত্তর দেওয়ার জন্য ৫০ পৃষ্ঠার একটি নথি সংগ্রহ করলে তথ্য পাতলা হয়ে যায়। প্রাসঙ্গিক তথ্য আলাদা করার জন্য আমরা নথিগুলিকে ছোট ছোট "খণ্ডে" বিভক্ত করি।

তবে, আপনি কীভাবে লেখাটি ভাগ করবেন তা অত্যন্ত গুরুত্বপূর্ণ:

• ক্যারেক্টার স্প্লিটার: অক্ষর গণনার ভিত্তিতেই বিভক্ত। এটি দ্রুত কিন্তু ঝুঁকিপূর্ণ; এটি শব্দ বা বাক্যকে অর্ধেক করে ফেলতে পারে, যার ফলে শব্দার্থিক অর্থ নষ্ট হয়ে যায়।
• রিকার্সিভ স্প্লিটার: প্রথমে অনুচ্ছেদ, তারপর বাক্য, তারপর শব্দ দিয়ে বিভক্ত করার চেষ্টা করা হয়। এটি শব্দার্থিক এককগুলিকে একসাথে রাখার চেষ্টা করে।
• টোকেন স্প্লিটার: LLM-এর নিজস্ব শব্দভান্ডারের (টোকেন) উপর ভিত্তি করে বিভক্ত। এটি নিশ্চিত করে যে খণ্ডগুলি প্রসঙ্গ উইন্ডোতে পুরোপুরি ফিট করে কিন্তু গণনার দিক থেকে তৈরি করা আরও ব্যয়বহুল হতে পারে।

এই বিভাগে, আপনি তিনটি কৌশল ব্যবহার করে একই তথ্য গ্রহণ করে তাদের তুলনা করবেন।

ইনজেশন স্ক্রিপ্ট তৈরি করুন

আপনি এমন একটি স্ক্রিপ্ট ব্যবহার করবেন যা হ্যারি পটার ডেটাসেট ডাউনলোড করবে, ক্যারেক্টার , রিকার্সিভ এবং টোকেন কৌশল ব্যবহার করে এটিকে বিভক্ত করবে এবং ক্লাউড SQL-এর তিনটি পৃথক টেবিলে এম্বেডিং আপলোড করবে।

1. ingest_data.py ফাইলটি তৈরি করুন:

   cloudshell edit ingest_data.py
   

2. নিম্নলিখিত স্থির কোডটি ingest_data.py তে পেস্ট করুন। এই সংস্করণটি ডেটাসেটের JSON কাঠামো সঠিকভাবে পার্স করে।

   import os
   import json
   import logging
   import requests
   from typing import List, Dict, Any
   from dotenv import load_dotenv
   
   from google.cloud.sql.connector import Connector, IPTypes
   from langchain_google_vertexai import VertexAIEmbeddings
   from langchain_community.vectorstores import PGVector
   from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter, TokenTextSplitter
   from langchain.docstore.document import Document
   
   load_dotenv()
   logging.basicConfig(level=logging.INFO)
   
   # Configuration
   PROJECT_ID = os.getenv("PROJECT_ID")
   REGION = os.getenv("REGION")
   DB_USER = os.getenv("SQL_USER")
   DB_PASS = os.getenv("SQL_PASSWORD")
   DB_NAME = os.getenv("SQL_DATABASE_NAME")
   INSTANCE_CONNECTION_NAME = f"{PROJECT_ID}:{REGION}:{os.getenv('SQL_INSTANCE_NAME')}"
   BASE_COLLECTION_NAME = os.getenv("PGVECTOR_COLLECTION_NAME")
   BOOKS_JSON_URL = "https://storage.googleapis.com/github-repo/generative-ai/gemini/reasoning-engine/sample_data/harry_potter_books.json"
   
   CHUNK_SIZE = 500
   CHUNK_OVERLAP = 50
   MAX_DOCS_TO_PROCESS = 10 
   
   # Database Connector
   def getconn():
       with Connector() as connector:
           return connector.connect(
               INSTANCE_CONNECTION_NAME,
               "pg8000",
               user=DB_USER,
               password=DB_PASS,
               db=DB_NAME,
               ip_type=IPTypes.PUBLIC,
           )
   
   def download_data():
       logging.info(f"Downloading data from {BOOKS_JSON_URL}...")
       response = requests.get(BOOKS_JSON_URL)
       return response.json()
   
   def prepare_chunks(json_data, strategy):
       documents = []
   
       # Iterate through the downloaded data
       for entry in json_data[:MAX_DOCS_TO_PROCESS]:
   
           # --- JSON PARSING LOGIC ---
           # The data structure nests content inside 'kwargs' -> 'page_content'
           if "kwargs" in entry and "page_content" in entry["kwargs"]:
               content = entry["kwargs"]["page_content"]
   
               # Extract metadata if available, ensuring it's a dict
               metadata = entry["kwargs"].get("metadata", {})
               if not isinstance(metadata, dict):
                   metadata = {"source": "unknown"}
   
               # Add the strategy to metadata for tracking
               metadata["strategy"] = strategy
           else:
               continue
   
           if not content:
               continue
   
           # Choose the splitter based on the strategy
           if strategy == "character":
               splitter = CharacterTextSplitter(chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP, separator="\n")
           elif strategy == "token":
               splitter = TokenTextSplitter(chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP)
           else: # default to recursive
               splitter = RecursiveCharacterTextSplitter(chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP)
   
           # Split the content into chunks
           chunks = splitter.split_text(content)
   
           # Create Document objects for each chunk
           for chunk in chunks:
               documents.append(Document(page_content=chunk, metadata=metadata))
   
       return documents
   
   def main():
       logging.info("Initializing Embeddings...")
       embeddings = VertexAIEmbeddings(model_name="gemini-embedding-001", project=PROJECT_ID, location=REGION)
   
       data = download_data()
       strategies = ["character", "recursive", "token"]
   
       # Connection string for PGVector (uses the getconn helper)
       pg_conn_str = f"postgresql+pg8000://{DB_USER}:{DB_PASS}@placeholder/{DB_NAME}"
   
       for strategy in strategies:
           collection_name = f"{BASE_COLLECTION_NAME}_{strategy}"
           logging.info(f"--- Processing strategy: {strategy.upper()} ---")
           logging.info(f"Target Collection: {collection_name}")
   
           # Prepare documents with the specific strategy
           docs = prepare_chunks(data, strategy)
   
           if not docs:
               logging.warning(f"No documents generated for strategy {strategy}. Check data source.")
               continue
   
           logging.info(f"Generated {len(docs)} chunks. Uploading to Cloud SQL...")
   
           # Initialize the Vector Store
           store = PGVector(
               collection_name=collection_name,
               embedding_function=embeddings,
               connection_string=pg_conn_str,
               engine_args={"creator": getconn},
               pre_delete_collection=True # Clears old data for this collection before adding new
           )
   
           # Batch add documents
           store.add_documents(docs)
           logging.info(f"Successfully finished {strategy}.\n")
   
   if __name__ == "__main__":
       main()
   

3. ইনজেশন স্ক্রিপ্টটি চালান। এটি আপনার ডাটাবেসে তিনটি ভিন্ন টেবিল (সংগ্রহ) দিয়ে পূর্ণ করবে।

   python ingest_data.py
   

চাঙ্কিং ফলাফল তুলনা করুন

এখন যেহেতু ডেটা লোড করা হয়েছে, আসুন তিনটি সংগ্রহের বিরুদ্ধে একটি কোয়েরি চালাই যাতে দেখা যায় যে চাঙ্কিং কৌশল ফলাফলকে কীভাবে প্রভাবিত করে।

1. query_chunking.py তৈরি করুন:

   cloudshell edit query_chunking.py
   

2. নিম্নলিখিত কোডটি query_chunking.py তে পেস্ট করুন:

   import os
   import logging
   from dotenv import load_dotenv
   from google.cloud.sql.connector import Connector, IPTypes
   from langchain_google_vertexai import VertexAIEmbeddings
   from langchain_community.vectorstores import PGVector
   
   load_dotenv()
   logging.basicConfig(level=logging.ERROR) # Only show errors to keep output clean
   
   # Config
   PROJECT_ID = os.getenv("PROJECT_ID")
   REGION = os.getenv("REGION")
   DB_USER = os.getenv("SQL_USER")
   DB_PASS = os.getenv("SQL_PASSWORD")
   DB_NAME = os.getenv("SQL_DATABASE_NAME")
   INSTANCE_CONNECTION_NAME = f"{PROJECT_ID}:{REGION}:{os.getenv('SQL_INSTANCE_NAME')}"
   BASE_COLLECTION_NAME = os.getenv("PGVECTOR_COLLECTION_NAME")
   
   def getconn():
       with Connector() as connector:
           return connector.connect(
               INSTANCE_CONNECTION_NAME,
               "pg8000",
               user=DB_USER,
               password=DB_PASS,
               db=DB_NAME,
               ip_type=IPTypes.PUBLIC,
           )
   
   def main():
       embeddings = VertexAIEmbeddings(model_name="gemini-embedding-001", project=PROJECT_ID, location=REGION)
       pg_conn_str = f"postgresql+pg8000://{DB_USER}:{DB_PASS}@placeholder/{DB_NAME}"
   
       query = "Tell me about the Dursleys and their relationship with Harry Potter"
       print(f"\nQUERY: {query}\n" + "="*50)
   
       strategies = ["character", "recursive", "token"]
   
       for strategy in strategies:
           collection = f"{BASE_COLLECTION_NAME}_{strategy}"
           print(f"\nSTRATEGY: {strategy.upper()}")
   
           store = PGVector(
               collection_name=collection,
               embedding_function=embeddings,
               connection_string=pg_conn_str,
               engine_args={"creator": getconn}
           )
   
           results = store.similarity_search_with_score(query, k=2)
           for i, (doc, score) in enumerate(results):
               print(f"  Result {i+1} (Score: {score:.4f}): {doc.page_content[:150].replace(chr(10), ' ')}...")
   
   if __name__ == "__main__":
       main()
   

3. কোয়েরি স্ক্রিপ্টটি চালান:

   python query_chunking.py
   

আউটপুট লক্ষ্য করুন।

লক্ষ্য করুন কিভাবে ক্যারেক্টার স্প্লিট বাক্যগুলিকে মাঝপথে কেটে ফেলতে পারে, অন্যদিকে রিকার্সিভ অনুচ্ছেদের সীমানা মেনে চলার চেষ্টা করে। টোকেন স্প্লিটিংয়ের ফলে খণ্ডগুলি LLM কনটেক্সট উইন্ডোতে পুরোপুরি ফিট হয় তবে শব্দার্থিক কাঠামো উপেক্ষা করা যেতে পারে।

৮. পার্ট ২: পুনঃর‍্যাঙ্কিং

ভেক্টর অনুসন্ধান (পুনরুদ্ধার) অবিশ্বাস্যভাবে দ্রুত কারণ এটি সংকুচিত গাণিতিক উপস্থাপনা (এম্বেডিং) এর উপর নির্ভর করে। এটি Recall (সকল সম্ভাব্য প্রাসঙ্গিক আইটেম খুঁজে বের করা) নিশ্চিত করার জন্য একটি বিস্তৃত জাল বিস্তার করে, কিন্তু এটি প্রায়শই কম নির্ভুলতার (ঐ আইটেমগুলির র‍্যাঙ্কিং অসম্পূর্ণ হতে পারে) ভুগে।

প্রাসঙ্গিক নথিগুলি প্রায়শই ফলাফল তালিকার "মাঝখানে হারিয়ে গেছে" বলে মনে হয়। একজন এলএলএম পরীক্ষার্থী যদি শীর্ষ ৫টি ফলাফলের দিকে মনোযোগ দেন, তাহলে তিনি ৭ নম্বর অবস্থানে বসে গুরুত্বপূর্ণ উত্তরটি মিস করতে পারেন।

পুনঃর‍্যাঙ্কিং একটি দ্বিতীয় পর্যায় যোগ করে এই সমস্যার সমাধান করে।

1. Retriever: দ্রুত ভেক্টর অনুসন্ধান ব্যবহার করে একটি বৃহত্তর সেট (যেমন, শীর্ষ 25) আনে।
2. রির‍্যাঙ্কার: কোয়েরি এবং ডকুমেন্ট জোড়ার সম্পূর্ণ লেখা পরীক্ষা করার জন্য একটি বিশেষ মডেল (যেমন একটি ক্রস-এনকোডার) ব্যবহার করে। এটি ধীর কিন্তু অনেক বেশি নির্ভুল। এটি শীর্ষ ২৫-এর স্কোর পুনরায় করে এবং পরম সেরা ৩টি ফেরত দেয়।

এই কাজে, আপনি পার্ট ১-এ তৈরি recursive কালেকশনটি অনুসন্ধান করবেন, কিন্তু এবার ফলাফলগুলি পরিমার্জন করার জন্য আপনি Vertex AI Reranker প্রয়োগ করবেন।

1. query_reranking.py তৈরি করুন:

   cloudshell edit query_reranking.py
   

2. নিচের কোডটি পেস্ট করুন। লক্ষ্য করুন কিভাবে এটি স্পষ্টভাবে _recursive সংগ্রহকে লক্ষ্য করে এবং ContextualCompressionRetriever ব্যবহার করে।

   import os
   import logging
   from dotenv import load_dotenv
   from google.cloud.sql.connector import Connector, IPTypes
   from langchain_google_vertexai import VertexAIEmbeddings
   from langchain_community.vectorstores import PGVector
   
   # Reranking Imports
   from langchain.retrievers import ContextualCompressionRetriever
   from langchain_google_community.vertex_rank import VertexAIRank
   
   load_dotenv()
   logging.basicConfig(level=logging.ERROR)
   
   PROJECT_ID = os.getenv("PROJECT_ID")
   REGION = os.getenv("REGION")
   DB_USER = os.getenv("SQL_USER")
   DB_PASS = os.getenv("SQL_PASSWORD")
   DB_NAME = os.getenv("SQL_DATABASE_NAME")
   INSTANCE_CONNECTION_NAME = f"{PROJECT_ID}:{REGION}:{os.getenv('SQL_INSTANCE_NAME')}"
   
   # IMPORTANT: Target the recursive collection created in ingest_data.py
   COLLECTION_NAME = f"{os.getenv('PGVECTOR_COLLECTION_NAME')}_recursive"
   RANKING_LOCATION = os.getenv("RANKING_LOCATION_ID")
   
   def getconn():
       with Connector() as connector:
           return connector.connect(
               INSTANCE_CONNECTION_NAME,
               "pg8000",
               user=DB_USER,
               password=DB_PASS,
               db=DB_NAME,
               ip_type=IPTypes.PUBLIC,
           )
   
   def main():
       embeddings = VertexAIEmbeddings(model_name="gemini-embedding-001", project=PROJECT_ID, location=REGION)
       pg_conn_str = f"postgresql+pg8000://{DB_USER}:{DB_PASS}@placeholder/{DB_NAME}"
   
       print(f"Connecting to collection: {COLLECTION_NAME}")
       store = PGVector(
           collection_name=COLLECTION_NAME,
           embedding_function=embeddings,
           connection_string=pg_conn_str,
           engine_args={"creator": getconn}
       )
   
       query = "What are the Horcruxes?"
       print(f"QUERY: {query}\n")
   
       # 1. Base Retriever (Vector Search) - Fetch top 10
       base_retriever = store.as_retriever(search_kwargs={"k": 10})
   
       # 2. Reranker - Select top 3 from the 10
       reranker = VertexAIRank(
           project_id=PROJECT_ID,
           location_id=RANKING_LOCATION,
           ranking_config="default_ranking_config",
           title_field="source",
           top_n=3
       )
   
       compression_retriever = ContextualCompressionRetriever(
           base_compressor=reranker,
           base_retriever=base_retriever
       )
   
       # Execute
       try:
           reranked_docs = compression_retriever.invoke(query)
   
           if not reranked_docs:
               print("No documents returned. Check if the collection exists and is populated.")
   
           print(f"--- Top 3 Reranked Results ---")
           for i, doc in enumerate(reranked_docs):
               print(f"Result {i+1} (Score: {doc.metadata.get('relevance_score', 'N/A')}):")
               print(f"  {doc.page_content[:200]}...\n")
       except Exception as e:
           print(f"Error during reranking: {e}")
   
   if __name__ == "__main__":
       main()
   

3. পুনঃর‍্যাঙ্কিং কোয়েরিটি চালান:

   python query_reranking.py
   

পর্যবেক্ষণ করুন

আপনি হয়তো উচ্চতর প্রাসঙ্গিকতা স্কোর লক্ষ্য করতে পারেন অথবা একটি কাঁচা ভেক্টর অনুসন্ধানের তুলনায় ভিন্ন ক্রম লক্ষ্য করতে পারেন। এটি নিশ্চিত করে যে LLM সম্ভাব্য সবচেয়ে সুনির্দিষ্ট প্রসঙ্গ গ্রহণ করে।

৯. পার্ট ৩: কোয়েরি রূপান্তর

প্রায়শই, RAG-তে সবচেয়ে বড় বাধা হল ব্যবহারকারী। ব্যবহারকারীর প্রশ্নগুলি প্রায়শই অস্পষ্ট, অসম্পূর্ণ, অথবা খারাপভাবে বাক্যাংশযুক্ত হয়। যদি কোয়েরি এম্বেডিং ডকুমেন্ট এম্বেডিংয়ের সাথে গাণিতিকভাবে সামঞ্জস্যপূর্ণ না হয়, তাহলে পুনরুদ্ধার ব্যর্থ হয়।

কোয়েরি ট্রান্সফর্মেশন একটি LLM ব্যবহার করে ডাটাবেসে পৌঁছানোর আগেই কোয়েরিটি পুনর্লিখন বা প্রসারিত করে। আপনি দুটি কৌশল প্রয়োগ করবেন:

• HyDE (হাইপোথেটিক্যাল ডকুমেন্ট এম্বেডিং): একটি প্রশ্ন এবং একটি উত্তরের মধ্যে ভেক্টর সাদৃশ্য প্রায়শই একটি উত্তর এবং একটি কাল্পনিক উত্তরের সাদৃশ্যের চেয়ে কম হয়। HyDE LLM কে একটি নিখুঁত উত্তর হ্যালুসিনেট করতে বলে, সেটি এম্বেড করে এবং হ্যালুসিনেশনের মতো দেখতে ডকুমেন্টগুলি অনুসন্ধান করে।
• ধাপে ধাপে ফিরে যাওয়ার প্রম্পটিং: যদি কোনও ব্যবহারকারী একটি নির্দিষ্ট বিস্তারিত প্রশ্ন জিজ্ঞাসা করে, তাহলে সিস্টেমটি বৃহত্তর প্রেক্ষাপট মিস করতে পারে। ধাপে ধাপে ফিরে যাওয়ার প্রম্পটিং LLM-কে একটি উচ্চ-স্তরের, বিমূর্ত প্রশ্ন ("এই পরিবারের ইতিহাস কী?") তৈরি করতে বলে যাতে নির্দিষ্ট বিবরণের পাশাপাশি মৌলিক তথ্য পুনরুদ্ধার করা যায়।

1. query_transformation.py তৈরি করুন:

   cloudshell edit query_transformation.py
   

2. নিম্নলিখিত কোডটি পেস্ট করুন:

   import os
   import logging
   from dotenv import load_dotenv
   from google.cloud.sql.connector import Connector, IPTypes
   from langchain_google_vertexai import VertexAIEmbeddings, VertexAI
   from langchain_community.vectorstores import PGVector
   from langchain_core.prompts import PromptTemplate
   
   load_dotenv()
   logging.basicConfig(level=logging.ERROR)
   
   PROJECT_ID = os.getenv("PROJECT_ID")
   REGION = os.getenv("REGION")
   DB_USER = os.getenv("SQL_USER")
   DB_PASS = os.getenv("SQL_PASSWORD")
   DB_NAME = os.getenv("SQL_DATABASE_NAME")
   INSTANCE_CONNECTION_NAME = f"{PROJECT_ID}:{REGION}:{os.getenv('SQL_INSTANCE_NAME')}"
   COLLECTION_NAME = f"{os.getenv('PGVECTOR_COLLECTION_NAME')}_recursive"
   
   def getconn():
       with Connector() as connector:
           return connector.connect(
               INSTANCE_CONNECTION_NAME,
               "pg8000",
               user=DB_USER,
               password=DB_PASS,
               db=DB_NAME,
               ip_type=IPTypes.PUBLIC,
           )
   
   def generate_hyde_doc(query, llm):
       prompt = PromptTemplate(
           input_variables=["question"],
           template="Write a concise, hypothetical answer to the question. Question: {question} Answer:"
       )
       chain = prompt | llm
       return chain.invoke({"question": query})
   
   def generate_step_back(query, llm):
       prompt = PromptTemplate(
           input_variables=["question"],
           template="Write a more general, abstract question that concepts in this question. Original: {question} Step-back:"
       )
       chain = prompt | llm
       return chain.invoke({"question": query})
   
   def main():
       embeddings = VertexAIEmbeddings(model_name="gemini-embedding-001", project=PROJECT_ID, location=REGION)
       llm = VertexAI(model_name="gemini-2.5-flash", project=PROJECT_ID, location=REGION, temperature=0.5)
   
       pg_conn_str = f"postgresql+pg8000://{DB_USER}:{DB_PASS}@placeholder/{DB_NAME}"
       store = PGVector(
           collection_name=COLLECTION_NAME,
           embedding_function=embeddings,
           connection_string=pg_conn_str,
           engine_args={"creator": getconn}
       )
       retriever = store.as_retriever(search_kwargs={"k": 2})
   
       original_query = "Tell me about the Dursleys."
       print(f"ORIGINAL QUERY: {original_query}\n" + "-"*30)
   
       # 1. HyDE
       hyde_doc = generate_hyde_doc(original_query, llm)
       print(f"HyDE Generated Doc: {hyde_doc.strip()[:100]}...")
       hyde_results = retriever.invoke(hyde_doc)
       print(f"HyDE Retrieval: {hyde_results[0].page_content[:100]}...\n")
   
       # 2. Step-back
       step_back_q = generate_step_back(original_query, llm)
       print(f"Step-back Query: {step_back_q.strip()}")
       step_results = retriever.invoke(step_back_q)
       print(f"Step-back Retrieval: {step_results[0].page_content[:100]}...")
   
   if __name__ == "__main__":
       main()
   

3. রূপান্তর স্ক্রিপ্টটি চালান:

   python query_transformation.py
   

আউটপুট লক্ষ্য করুন।

লক্ষ্য করুন কিভাবে স্টেপ-ব্যাক কোয়েরিটি ডার্সলি পরিবারের ইতিহাস সম্পর্কে বিস্তৃত প্রসঙ্গ পুনরুদ্ধার করতে পারে, যখন HyDE কাল্পনিক উত্তরে উত্পন্ন নির্দিষ্ট বিবরণের উপর দৃষ্টি নিবদ্ধ করে।

১০. পার্ট ৪: এন্ড-টু-এন্ড জেনারেশন

আমরা আমাদের ডেটা কেটেছি, অনুসন্ধানকে আরও পরিমার্জিত করেছি এবং ব্যবহারকারীর প্রশ্নকে আরও সুন্দর করে তুলেছি। এখন, আমরা অবশেষে RAG: Generation- এ "G" রাখলাম।

এই বিন্দু পর্যন্ত, আমরা কেবল তথ্য খুঁজে পেয়েছি। একজন সত্যিকারের AI সহকারী তৈরি করতে, আমাদের সেই উচ্চ-মানের, পুনঃর্যাঙ্ক করা নথিগুলিকে একটি LLM (Gemini) এ ফিড করতে হবে যাতে একটি প্রাকৃতিক ভাষার উত্তর সংশ্লেষিত হয়।

একটি উৎপাদন পাইপলাইনে, এটি একটি নির্দিষ্ট প্রবাহকে অন্তর্ভুক্ত করে:

1. পুনরুদ্ধার করুন: দ্রুত ভেক্টর অনুসন্ধান ব্যবহার করে প্রার্থীদের একটি বিস্তৃত সেট (যেমন, শীর্ষ 10) পান।
2. রির‍্যাঙ্ক: ভার্টেক্স এআই রির‍্যাঙ্কার ব্যবহার করে পরম সেরা (যেমন, শীর্ষ ৩) ফিল্টার করুন।
3. প্রসঙ্গ গঠন: শীর্ষ ৩টি নথির বিষয়বস্তু একটি একক স্ট্রিংয়ে সেলাই করুন।
4. গ্রাউন্ডেড প্রম্পটিং: একটি কঠোর প্রম্পট টেমপ্লেটে সেই প্রসঙ্গ স্ট্রিংটি ঢোকান যা LLM-কে শুধুমাত্র সেই তথ্য ব্যবহার করতে বাধ্য করে।

জেনারেশন স্ক্রিপ্ট তৈরি করুন

আমরা জেনারেশন ধাপের জন্য gemini-2.5-flash ব্যবহার করব। এই মডেলটি RAG-এর জন্য আদর্শ কারণ এর একটি দীর্ঘ প্রসঙ্গ উইন্ডো এবং কম ল্যাটেন্সি রয়েছে, যা এটিকে একাধিক পুনরুদ্ধার করা নথি দ্রুত প্রক্রিয়া করার অনুমতি দেয়।

1. end_to_end_rag.py তৈরি করুন:

cloudshell edit end_to_end_rag.py

2. নিচের কোডটি পেস্ট করুন। template ভেরিয়েবলের দিকে মনোযোগ দিন—এখানেই আমরা মডেলটিকে কঠোরভাবে নির্দেশ দিচ্ছি যে তারা যেন "হ্যালুসিনেশন" (জিনিস তৈরি করা) এড়াতে প্রদত্ত প্রসঙ্গের সাথে আবদ্ধ হয়।

import os
import logging
from dotenv import load_dotenv
from google.cloud.sql.connector import Connector, IPTypes
from langchain_google_vertexai import VertexAIEmbeddings, VertexAI
from langchain_community.vectorstores import PGVector
from langchain.retrievers import ContextualCompressionRetriever
from langchain_google_community.vertex_rank import VertexAIRank
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

load_dotenv()
logging.basicConfig(level=logging.ERROR)

PROJECT_ID = os.getenv("PROJECT_ID")
REGION = os.getenv("REGION")
# We use the recursive collection as it generally provides the best context boundaries
COLLECTION_NAME = f"{os.getenv('PGVECTOR_COLLECTION_NAME')}_recursive"

def getconn():
    instance_conn = f"{PROJECT_ID}:{REGION}:{os.getenv('SQL_INSTANCE_NAME')}"
    with Connector() as connector:
        return connector.connect(
            instance_conn, "pg8000",
            user=os.getenv("SQL_USER"), password=os.getenv("SQL_PASSWORD"),
            db=os.getenv("SQL_DATABASE_NAME"), ip_type=IPTypes.PUBLIC
        )

def main():
    print("--- Initializing Production RAG Pipeline ---")

    # 1. Setup Embeddings (Gemini Embedding 001)
    # We use this to vectorize the user's query to match our database.
    embeddings = VertexAIEmbeddings(model_name="gemini-embedding-001", project=PROJECT_ID, location=REGION)

    # 2. Connect to Vector Store
    pg_conn_str = f"postgresql+pg8000://{os.getenv('SQL_USER')}:{os.getenv('SQL_PASSWORD')}@placeholder/{os.getenv('SQL_DATABASE_NAME')}"
    store = PGVector(
        collection_name=COLLECTION_NAME,
        embedding_function=embeddings,
        connection_string=pg_conn_str,
        engine_args={"creator": getconn}
    )

    # 3. Setup The 'Filter Funnel' (Retriever + Reranker)
    # Step A: Fast retrieval of top 10 similar documents
    base_retriever = store.as_retriever(search_kwargs={"k": 10})

    # Step B: Precise reranking to find the top 3 most relevant
    reranker = VertexAIRank(
        project_id=PROJECT_ID,
        location_id="global", 
        ranking_config="default_ranking_config",
        title_field="source",
        top_n=3
    )

    # Combine A and B into a single retrieval object
    compression_retriever = ContextualCompressionRetriever(
        base_compressor=reranker,
        base_retriever=base_retriever
    )

    # 4. Setup LLM (Gemini 2.5 Flash)
    # We use a low temperature (0.1) to reduce creativity and increase factual adherence.
    llm = VertexAI(model_name="gemini-2.5-flash", project=PROJECT_ID, location=REGION, temperature=0.1)

    # --- Execution Loop ---
    user_query = "Who is Harry Potter?"
    print(f"\nUser Query: {user_query}")
    print("Retrieving and Reranking documents...")

    # Retrieve the most relevant documents
    top_docs = compression_retriever.invoke(user_query)

    if not top_docs:
        print("No relevant documents found.")
        return

    # Build the Context String
    # We stitch the documents together, labeling them as Source 1, Source 2, etc.
    context_str = "\n\n".join([f"Source {i+1}: {d.page_content}" for i, d in enumerate(top_docs)])

    print(f"Found {len(top_docs)} relevant context chunks.")

    # 5. The Grounded Prompt
    template = """You are a helpful assistant. Answer the question strictly based on the provided context.
    If the answer is not in the context, say "I don't know."

    Context:
    {context}

    Question:
    {question}

    Answer:
    """

    prompt = PromptTemplate(template=template, input_variables=["context", "question"])

    # Create the chain: Prompt -> LLM
    chain = prompt | llm

    print("Generating Answer via Gemini 2.5 Flash...")
    final_answer = chain.invoke({"context": context_str, "question": user_query})

    print(f"\nFINAL ANSWER:\n{final_answer}")

if __name__ == "__main__":
    main()

3. চূড়ান্ত অ্যাপ্লিকেশনটি চালান:

python end_to_end_rag.py

আউটপুট বোঝা

এই স্ক্রিপ্টটি চালানোর সময়, কাঁচা পুনরুদ্ধার করা অংশগুলি (যা আপনি আগের ধাপগুলিতে দেখেছিলেন) এবং চূড়ান্ত উত্তরের মধ্যে পার্থক্য লক্ষ্য করুন। LLM একটি সিন্থেসাইজার হিসাবে কাজ করে - এটি রির্যাঙ্কার দ্বারা প্রদত্ত পাঠ্যের খণ্ডিত "খণ্ডগুলি" পড়ে এবং সেগুলিকে একটি সুসংগত, মানুষের পাঠযোগ্য বাক্যে মসৃণ করে।

এই উপাদানগুলিকে শৃঙ্খলিত করে, আপনি একটি স্টোকাস্টিক "অনুমান" থেকে একটি নির্ধারক, ভিত্তিগত কর্মপ্রবাহে চলে যান। রিট্রিভার জাল ফেলে, রির্যাঙ্কার সেরা ক্যাচ নির্বাচন করে এবং জেনারেটর খাবার রান্না করে।

১১. উপসংহার

অভিনন্দন! আপনি সফলভাবে একটি উন্নত RAG পাইপলাইন তৈরি করেছেন যা মৌলিক ভেক্টর অনুসন্ধানের চেয়ে অনেক বেশি এগিয়ে।

সংক্ষিপ্তসার

• আপনি স্কেলেবল ভেক্টর স্টোরেজের জন্য pgvector দিয়ে ক্লাউড SQL কনফিগার করেছেন।
• তথ্য প্রস্তুতি কীভাবে পুনরুদ্ধারকে প্রভাবিত করে তা বোঝার জন্য আপনি চাঙ্কিং কৌশলগুলির তুলনা করেছেন।
• আপনার ফলাফলের নির্ভুলতা উন্নত করতে আপনি Vertex AI এর সাথে Reranking বাস্তবায়ন করেছেন।
• আপনার ডেটার সাথে ব্যবহারকারীর উদ্দেশ্যকে সামঞ্জস্য করতে আপনি কোয়েরি ট্রান্সফর্মেশন (HyDE, Step-back) ব্যবহার করেছেন।

আরও জানুন

• RAG রেফারেন্স আর্কিটেকচার : RAG-সম্পর্কিত রেফারেন্স আর্কিটেকচার গাইডের একটি তালিকা অন্বেষণ করুন।

প্রোটোটাইপ থেকে উৎপাদন

এই ল্যাবটি গুগল ক্লাউড লার্নিং পাথ সহ প্রোডাকশন-রেডি এআই- এর অংশ।

• প্রোটোটাইপ থেকে উৎপাদন পর্যন্ত ব্যবধান পূরণ করতে সম্পূর্ণ পাঠ্যক্রমটি অন্বেষণ করুন ।
• #ProductionReadyAI হ্যাশট্যাগ ব্যবহার করে আপনার অগ্রগতি শেয়ার করুন ।