ការប្រើប្រាស់ MinIO ដើម្បីបង្កើតកម្មវិធីជជែកកំសាន្តដែលបង្កើតឡើងវិញ

ជារឿយៗវាត្រូវបានគេនិយាយថានៅក្នុងយុគសម័យ AI - ទិន្នន័យគឺជាគូរបស់អ្នក។ ដល់ទីបញ្ចប់នេះ ការកសាងកម្មវិធី RAG កម្រិតផលិតកម្មទាមទារនូវហេដ្ឋារចនាសម្ព័ន្ធទិន្នន័យដែលសមស្របដើម្បីរក្សាទុក កំណែ ដំណើរការ វាយតម្លៃ និងផ្នែកសំណួរនៃទិន្នន័យដែលរួមមានសារពាង្គកាយកម្មសិទ្ធិរបស់អ្នក។ ចាប់តាំងពី MinIO ប្រើវិធីសាស្រ្តដំបូងទិន្នន័យចំពោះ AI ការណែនាំអំពីហេដ្ឋារចនាសម្ព័ន្ធដំបូងរបស់យើងសម្រាប់គម្រោងប្រភេទនេះគឺដើម្បីដំឡើង Modern Data Lake (MinIO) និងមូលដ្ឋានទិន្នន័យវ៉ិចទ័រ។ ខណៈពេលដែលឧបករណ៍បន្ថែមផ្សេងទៀតអាចនឹងត្រូវដោតជាប់នៅតាមផ្លូវ អង្គភាពហេដ្ឋារចនាសម្ព័ន្ធទាំងពីរនេះគឺជាមូលដ្ឋានគ្រឹះ។ ពួកគេនឹងបម្រើជាចំណុចកណ្តាលនៃទំនាញផែនដីសម្រាប់ស្ទើរតែគ្រប់កិច្ចការដែលជួបប្រទះជាបន្តបន្ទាប់ក្នុងការទទួលបានកម្មវិធី RAG របស់អ្នកចូលទៅក្នុងផលិតកម្ម។

ប៉ុន្តែ​អ្នក​ស្ថិត​នៅ​ក្នុង​ការ​ច្របូកច្របល់។ អ្នកធ្លាប់បានលឺពាក្យទាំងនេះ LLM និង RAG ពីមុនមក ប៉ុន្តែលើសពីនេះទៅទៀត អ្នកមិនបានបញ្ចេញអ្វីច្រើនទេ ដោយសារតែមិនស្គាល់។ ប៉ុន្តែតើវាមិនល្អទេប្រសិនបើមាន “Hello World” ឬកម្មវិធី boilerplate ដែលអាចជួយអ្នកក្នុងការចាប់ផ្តើម?

កុំបារម្ភ ខ្ញុំនៅក្នុងទូកតែមួយ។ ដូច្នេះនៅក្នុងប្លុកនេះ យើងនឹងបង្ហាញពីរបៀបប្រើប្រាស់ MinIO ដើម្បីបង្កើតកម្មវិធីជជែកដែលមានមូលដ្ឋានលើ Retrieval Augmented Generation (RAG) ដោយប្រើផ្នែករឹងទំនិញ។

• ប្រើ MinIO ដើម្បីរក្សាទុកឯកសារទាំងអស់ កំណាត់ដែលបានដំណើរការ និងការបង្កប់ដោយប្រើមូលដ្ឋានទិន្នន័យវ៉ិចទ័រ។

  
  

• ប្រើមុខងារជូនដំណឹងដាក់ធុងរបស់ MinIO ដើម្បីកេះព្រឹត្តិការណ៍នៅពេលបន្ថែម ឬយកឯកសារទៅដាក់ធុង

  
  

• Webhook ដែលប្រើប្រាស់ព្រឹត្តិការណ៍ និងដំណើរការឯកសារដោយប្រើ Langchain និងរក្សាទុកទិន្នន័យមេតា និងឯកសារដែលបានបំបែកទៅជាធុងទិន្នន័យមេតា

  
  

• កេះព្រឹត្តិការណ៍ជូនដំណឹងអំពីធុង MinIO សម្រាប់ឯកសារដែលបានបន្ថែមថ្មី ឬបានលុបចេញ

  
  

• Webhook ដែលប្រើប្រាស់ព្រឹត្តិការណ៍ និងបង្កើតការបង្កប់ និងរក្សាទុកវាទៅក្នុង Vector Database (LanceDB) ដែលបន្តនៅក្នុង MinIO

ឧបករណ៍គន្លឹះដែលបានប្រើ

• MinIO - Object Store ដើម្បីបន្តទិន្នន័យទាំងអស់។
• LanceDB - មូលដ្ឋានទិន្នន័យវ៉ិចទ័រប្រភពបើកចំហដែលមិនមានម៉ាស៊ីនមេដែលបន្តទិន្នន័យនៅក្នុងឃ្លាំងវត្ថុ
• Ollama - ដើម្បីដំណើរការ LLM និងបង្កប់គំរូក្នុងមូលដ្ឋាន (OpenAI API ឆបគ្នា)
• Gradio - ចំណុចប្រទាក់ដែលត្រូវធ្វើអន្តរកម្មជាមួយកម្មវិធី RAG
• FastAPI - ម៉ាស៊ីនមេសម្រាប់ Webhooks ដែលទទួលបានការជូនដំណឹងអំពីធុងពី MinIO និងបង្ហាញកម្មវិធី Gradio
• LangChain & Unstructured - ដើម្បីទាញយកអត្ថបទមានប្រយោជន៍ពីឯកសាររបស់យើង ហើយច្របាច់ពួកវាសម្រាប់ការបង្កប់

ម៉ូដែលដែលបានប្រើ

• LLM - Phi-3-128K (ប៉ារ៉ាម៉ែត្រ 3.8B)
• ការបង្កប់ - Nomic Embed Text v1.5 ( Matryoshka Embeddings / 768 Dim, 8K context)

ចាប់ផ្តើមម៉ាស៊ីនមេ MinIO

អ្នកអាចទាញយកប្រព័ន្ធគោលពីរ ប្រសិនបើអ្នកមិនទាន់មានវាពី ទីនេះ

 # Run MinIO detached !minio server ~/dev/data --console-address :9090 &

ចាប់ផ្តើមម៉ាស៊ីនមេ Ollama + ទាញយក LLM & គំរូបង្កប់

ទាញយក Ollama ពី ទីនេះ

 # Start the Server !ollama serve

 # Download Phi-3 LLM !ollama pull phi3:3.8b-mini-128k-instruct-q8_0

 # Download Nomic Embed Text v1.5 !ollama pull nomic-embed-text:v1.5

 # List All the Models !ollama ls

បង្កើតកម្មវិធី Gradio មូលដ្ឋានដោយប្រើ FastAPI ដើម្បីសាកល្បងគំរូ

 LLM_MODEL = "phi3:3.8b-mini-128k-instruct-q8_0" EMBEDDING_MODEL = "nomic-embed-text:v1.5" LLM_ENDPOINT = "http://localhost:11434/api/chat" CHAT_API_PATH = "/chat" def llm_chat(user_question, history): history = history or [] user_message = f"**You**: {user_question}" llm_resp = requests.post(LLM_ENDPOINT, json={"model": LLM_MODEL, "keep_alive": "48h", # Keep the model in-memory for 48 hours "messages": [ {"role": "user", "content": user_question } ]}, stream=True) bot_response = "**AI:** " for resp in llm_resp.iter_lines(): json_data = json.loads(resp) bot_response += json_data["message"]["content"] yield bot_response

 import json import gradio as gr import requests from fastapi import FastAPI, Request, BackgroundTasks from pydantic import BaseModel import uvicorn import nest_asyncio app = FastAPI() with gr.Blocks(gr.themes.Soft()) as demo: gr.Markdown("## RAG with MinIO") ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear") ch_interface.chatbot.show_label = False ch_interface.chatbot.height = 600 demo.queue() if __name__ == "__main__": nest_asyncio.apply() app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH) uvicorn.run(app, host="0.0.0.0", port=8808)

សាកល្បងគំរូបង្កប់

 import numpy as np EMBEDDING_ENDPOINT = "http://localhost:11434/api/embeddings" EMBEDDINGS_DIM = 768 def get_embedding(text): resp = requests.post(EMBEDDING_ENDPOINT, json={"model": EMBEDDING_MODEL, "prompt": text}) return np.array(resp.json()["embedding"][:EMBEDDINGS_DIM], dtype=np.float16)

 ## Test with sample text get_embedding("What is MinIO?")

ទិដ្ឋភាពទូទៅនៃបំពង់ស្រូបយក

បង្កើត MinIO Buckets

ប្រើពាក្យបញ្ជា mc ឬធ្វើវាពី UI

• custom-corpus - ដើម្បីរក្សាទុកឯកសារទាំងអស់។
• ឃ្លាំង - ដើម្បីរក្សាទុកទិន្នន័យមេតាទាំងអស់ កំណាត់ និងការបង្កប់វ៉ិចទ័រ

 !mc alias set 'myminio' 'http://localhost:9000' 'minioadmin' 'minioadmin'

 !mc mb myminio/custom-corpus !mc mb myminio/warehouse

បង្កើត Webhook ដែលប្រើប្រាស់ Bucket Notifications ពី Custom-corpus bucket

 import json import gradio as gr import requests from fastapi import FastAPI, Request from pydantic import BaseModel import uvicorn import nest_asyncio app = FastAPI() @app.post("/api/v1/document/notification") async def receive_webhook(request: Request): json_data = await request.json() print(json.dumps(json_data, indent=2)) with gr.Blocks(gr.themes.Soft()) as demo: gr.Markdown("## RAG with MinIO") ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear") ch_interface.chatbot.show_label = False demo.queue() if __name__ == "__main__": nest_asyncio.apply() app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH) uvicorn.run(app, host="0.0.0.0", port=8808)

 ## Test with sample text get_embedding("What is MinIO?")

បង្កើតការជូនដំណឹងអំពីព្រឹត្តិការណ៍ MinIO ហើយភ្ជាប់វាទៅធុងសំរាមផ្ទាល់ខ្លួន

បង្កើតព្រឹត្តិការណ៍ Webhook

នៅក្នុង Console សូមចូលទៅកាន់ Events-> Add Event Destination -> Webhook

បំពេញវាលជាមួយតម្លៃខាងក្រោម ហើយចុចរក្សាទុក

ឧបករណ៍កំណត់អត្តសញ្ញាណ - doc-webhook

ចំណុចបញ្ចប់ - http://localhost:8808/api/v1/document/notification

ចុច Restart MinIO នៅផ្នែកខាងលើ ពេលបញ្ចូលទៅ

( ចំណាំ ៖ អ្នកក៏អាចប្រើ mc សម្រាប់ការនេះផងដែរ)

ភ្ជាប់ព្រឹត្តិការណ៍ Webhook ទៅព្រឹត្តិការណ៍ដាក់ធុងផ្ទាល់ខ្លួន

នៅក្នុងកុងសូល សូមចូលទៅកាន់ Buckets (Administrator) -> custom-corpus -> Events

បំពេញវាលជាមួយតម្លៃខាងក្រោម ហើយចុចរក្សាទុក

ARN - ជ្រើសរើស doc-webhook ពីបញ្ជីទម្លាក់ចុះ

ជ្រើសរើសព្រឹត្តិការណ៍ - ពិនិត្យ PUT និង DELETE

( ចំណាំ ៖ អ្នកក៏អាចប្រើ mc សម្រាប់ការនេះផងដែរ)

យើងមានការដំឡើង webhook ដំបូងរបស់យើង។

ឥឡូវនេះសាកល្បងដោយបន្ថែម និងយកវត្ថុចេញ

ស្រង់ទិន្នន័យចេញពីឯកសារ និងកំណាត់

យើងនឹងប្រើ Langchain និង Unstructured ដើម្បីអានវត្ថុមួយពី MinIO និងបំបែកឯកសារទៅជាកំណាត់ច្រើន

 from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_community.document_loaders import S3FileLoader MINIO_ENDPOINT = "http://localhost:9000" MINIO_ACCESS_KEY = "minioadmin" MINIO_SECRET_KEY = "minioadmin" # Split Text from a given document using chunk_size number of characters text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=64, length_function=len) def split_doc_by_chunks(bucket_name, object_key): loader = S3FileLoader(bucket_name, object_key, endpoint_url=MINIO_ENDPOINT, aws_access_key_id=MINIO_ACCESS_KEY, aws_secret_access_key=MINIO_SECRET_KEY) docs = loader.load() doc_splits = text_splitter.split_documents(docs) return doc_splits

 # test the chunking split_doc_by_chunks("custom-corpus", "The-Enterprise-Object-Store-Feature-Set.pdf")

បន្ថែមតក្កវិជ្ជា Chunking ទៅ Webhook

បន្ថែមតក្កវិជ្ជាកំណាត់ទៅ webhook ហើយរក្សាទុកទិន្នន័យមេតា និងកំណាត់ទៅក្នុងឃ្លាំងស្តុក

 import urllib.parse import s3fs METADATA_PREFIX = "metadata" # Using s3fs to save and delete objects from MinIO s3 = s3fs.S3FileSystem() # Split the documents and save the metadata to warehouse bucket def create_object_task(json_data): for record in json_data["Records"]: bucket_name = record["s3"]["bucket"]["name"] object_key = urllib.parse.unquote(record["s3"]["object"]["key"]) print(record["s3"]["bucket"]["name"], record["s3"]["object"]["key"]) doc_splits = split_doc_by_chunks(bucket_name, object_key) for i, chunk in enumerate(doc_splits): source = f"warehouse/{METADATA_PREFIX}/{bucket_name}/{object_key}/chunk_{i:05d}.json" with s3.open(source, "w") as f: f.write(chunk.json()) return "Task completed!" def delete_object_task(json_data): for record in json_data["Records"]: bucket_name = record["s3"]["bucket"]["name"] object_key = urllib.parse.unquote(record["s3"]["object"]["key"]) s3.delete(f"warehouse/{METADATA_PREFIX}/{bucket_name}/{object_key}", recursive=True) return "Task completed!"

ធ្វើបច្ចុប្បន្នភាពម៉ាស៊ីនមេ FastAPI ជាមួយនឹងតក្កវិជ្ជាថ្មី។

 import json import gradio as gr import requests from fastapi import FastAPI, Request, BackgroundTasks from pydantic import BaseModel import uvicorn import nest_asyncio app = FastAPI() @app.post("/api/v1/document/notification") async def receive_webhook(request: Request, background_tasks: BackgroundTasks): json_data = await request.json() if json_data["EventName"] == "s3:ObjectCreated:Put": print("New object created!") background_tasks.add_task(create_object_task, json_data) if json_data["EventName"] == "s3:ObjectRemoved:Delete": print("Object deleted!") background_tasks.add_task(delete_object_task, json_data) return {"status": "success"} with gr.Blocks(gr.themes.Soft()) as demo: gr.Markdown("## RAG with MinIO") ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear") ch_interface.chatbot.show_label = False demo.queue() if __name__ == "__main__": nest_asyncio.apply() app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH) uvicorn.run(app, host="0.0.0.0", port=8808)

បន្ថែម webhook ថ្មីដើម្បីដំណើរការទិន្នន័យមេតា/កំណាត់ឯកសារ

ឥឡូវ​នេះ​យើង​មាន webhook ដំបូង​ដែល​ធ្វើ​ការ​ជំហាន​បន្ទាប់​គឺ​ទទួល​បាន​កំណាត់​ទាំងអស់​ជាមួយ​នឹង​ទិន្នន័យ​មេតា បង្កើត​ការ​បង្កប់​ហើយ​ទុក​វា​ក្នុង​មូលដ្ឋាន​ទិន្នន័យ​វ៉ិចទ័រ។

 import json import gradio as gr import requests from fastapi import FastAPI, Request, BackgroundTasks from pydantic import BaseModel import uvicorn import nest_asyncio app = FastAPI() @app.post("/api/v1/metadata/notification") async def receive_metadata_webhook(request: Request, background_tasks: BackgroundTasks): json_data = await request.json() print(json.dumps(json_data, indent=2)) @app.post("/api/v1/document/notification") async def receive_webhook(request: Request, background_tasks: BackgroundTasks): json_data = await request.json() if json_data["EventName"] == "s3:ObjectCreated:Put": print("New object created!") background_tasks.add_task(create_object_task, json_data) if json_data["EventName"] == "s3:ObjectRemoved:Delete": print("Object deleted!") background_tasks.add_task(delete_object_task, json_data) return {"status": "success"} with gr.Blocks(gr.themes.Soft()) as demo: gr.Markdown("## RAG with MinIO") ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear") ch_interface.chatbot.show_label = False demo.queue() if __name__ == "__main__": nest_asyncio.apply() app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH) uvicorn.run(app, host="0.0.0.0", port=8808)

បង្កើតការជូនដំណឹងអំពីព្រឹត្តិការណ៍ MinIO ហើយភ្ជាប់វាទៅឃ្លាំងដាក់ធុង

បង្កើតព្រឹត្តិការណ៍ Webhook

នៅក្នុង Console សូមចូលទៅកាន់ Events-> Add Event Destination -> Webhook

បំពេញវាលជាមួយតម្លៃខាងក្រោម ហើយចុចរក្សាទុក

ឧបករណ៍កំណត់អត្តសញ្ញាណ - metadata-webhook

ចំណុចបញ្ចប់ - http://localhost:8808/api/v1/metadata/notification

ចុច Restart MinIO នៅផ្នែកខាងលើ ពេលត្រូវបានសួរទៅ

( ចំណាំ ៖ អ្នកក៏អាចប្រើ mc សម្រាប់ការនេះផងដែរ)

ភ្ជាប់ព្រឹត្តិការណ៍ Webhook ទៅព្រឹត្តិការណ៍ដាក់ធុងផ្ទាល់ខ្លួន

នៅក្នុងកុងសូលសូមចូលទៅកាន់ Buckets (Administrator) -> warehouse -> Events

បំពេញវាលជាមួយតម្លៃខាងក្រោម ហើយចុចរក្សាទុក

ARN - ជ្រើសរើស metadata-webhook ពីបញ្ជីទម្លាក់ចុះ

បុព្វបទ - ទិន្នន័យមេតា/

បច្ច័យ - .json

ជ្រើសរើសព្រឹត្តិការណ៍ - ពិនិត្យ PUT និង DELETE

( ចំណាំ ៖ អ្នកក៏អាចប្រើ mc សម្រាប់ការនេះផងដែរ)

យើងមានការដំឡើង webhook ដំបូងរបស់យើង។

ឥឡូវនេះសាកល្បងដោយបន្ថែម និងយកវត្ថុមួយចេញនៅក្នុង custom-corpus ហើយមើលថាតើ webhook នេះត្រូវបានកេះឬអត់

បង្កើតមូលដ្ឋានទិន្នន័យវ៉ិចទ័រ LanceDB នៅក្នុង MinIO

ឥឡូវនេះយើងមាន webhook មូលដ្ឋានដែលកំពុងដំណើរការ អនុញ្ញាតឱ្យរៀបចំទិន្នន័យវ៉ិចទ័រ lanceDB នៅក្នុងធុងផ្ទុក MinIO ដែលយើងនឹងរក្សាទុកការបង្កប់ទាំងអស់ និងវាលទិន្នន័យមេតាបន្ថែម។

 import os import lancedb # Set these environment variables for the lanceDB to connect to MinIO os.environ["AWS_DEFAULT_REGION"] = "us-east-1" os.environ["AWS_ACCESS_KEY_ID"] = MINIO_ACCESS_KEY os.environ["AWS_SECRET_ACCESS_KEY"] = MINIO_SECRET_KEY os.environ["AWS_ENDPOINT"] = MINIO_ENDPOINT os.environ["ALLOW_HTTP"] = "True" db = lancedb.connect("s3://warehouse/v-db/")

 # list existing tables db.table_names()

 # Create a new table with pydantic schema from lancedb.pydantic import LanceModel, Vector import pyarrow as pa DOCS_TABLE = "docs" EMBEDDINGS_DIM = 768 table = None class DocsModel(LanceModel): parent_source: str # Actual object/document source source: str # Chunk/Metadata source text: str # Chunked text vector: Vector(EMBEDDINGS_DIM, pa.float16()) # Vector to be stored def get_or_create_table(): global table if table is None and DOCS_TABLE not in list(db.table_names()): return db.create_table(DOCS_TABLE, schema=DocsModel) if table is None: table = db.open_table(DOCS_TABLE) return table

 # Check if that worked get_or_create_table()

 # list existing tables db.table_names()

បន្ថែមការរក្សាទុក/យកទិន្នន័យចេញពី lanceDB ទៅ metadata-webhook

 import multiprocessing EMBEDDING_DOCUMENT_PREFIX = "search_document" # Add queue that keeps the processed meteadata in memory add_data_queue = multiprocessing.Queue() delete_data_queue = multiprocessing.Queue() def create_metadata_task(json_data): for record in json_data["Records"]: bucket_name = record["s3"]["bucket"]["name"] object_key = urllib.parse.unquote(record["s3"]["object"]["key"]) print(bucket_name, object_key) with s3.open(f"{bucket_name}/{object_key}", "r") as f: data = f.read() chunk_json = json.loads(data) embeddings = get_embedding(f"{EMBEDDING_DOCUMENT_PREFIX}: {chunk_json['page_content']}") add_data_queue.put({ "text": chunk_json["page_content"], "parent_source": chunk_json.get("metadata", "").get("source", ""), "source": f"{bucket_name}/{object_key}", "vector": embeddings }) return "Metadata Create Task Completed!" def delete_metadata_task(json_data): for record in json_data["Records"]: bucket_name = record["s3"]["bucket"]["name"] object_key = urllib.parse.unquote(record["s3"]["object"]["key"]) delete_data_queue.put(f"{bucket_name}/{object_key}") return "Metadata Delete Task completed!"

បន្ថែមកម្មវិធីកំណត់ពេលដែលដំណើរការទិន្នន័យពីជួរ

 from apscheduler.schedulers.background import BackgroundScheduler import pandas as pd def add_vector_job(): data = [] table = get_or_create_table() while not add_data_queue.empty(): item = add_data_queue.get() data.append(item) if len(data) > 0: df = pd.DataFrame(data) table.add(df) table.compact_files() print(len(table.to_pandas())) def delete_vector_job(): table = get_or_create_table() source_data = [] while not delete_data_queue.empty(): item = delete_data_queue.get() source_data.append(item) if len(source_data) > 0: filter_data = ", ".join([f'"{d}"' for d in source_data]) table.delete(f'source IN ({filter_data})') table.compact_files() table.cleanup_old_versions() print(len(table.to_pandas())) scheduler = BackgroundScheduler() scheduler.add_job(add_vector_job, 'interval', seconds=10) scheduler.add_job(delete_vector_job, 'interval', seconds=10)

ធ្វើបច្ចុប្បន្នភាព FastAPI ជាមួយនឹងការផ្លាស់ប្តូរការបង្កប់វ៉ិចទ័រ

 import json import gradio as gr import requests from fastapi import FastAPI, Request, BackgroundTasks from pydantic import BaseModel import uvicorn import nest_asyncio app = FastAPI() @app.on_event("startup") async def startup_event(): get_or_create_table() if not scheduler.running: scheduler.start() @app.on_event("shutdown") async def shutdown_event(): scheduler.shutdown() @app.post("/api/v1/metadata/notification") async def receive_metadata_webhook(request: Request, background_tasks: BackgroundTasks): json_data = await request.json() if json_data["EventName"] == "s3:ObjectCreated:Put": print("New Metadata created!") background_tasks.add_task(create_metadata_task, json_data) if json_data["EventName"] == "s3:ObjectRemoved:Delete": print("Metadata deleted!") background_tasks.add_task(delete_metadata_task, json_data) return {"status": "success"} @app.post("/api/v1/document/notification") async def receive_webhook(request: Request, background_tasks: BackgroundTasks): json_data = await request.json() if json_data["EventName"] == "s3:ObjectCreated:Put": print("New object created!") background_tasks.add_task(create_object_task, json_data) if json_data["EventName"] == "s3:ObjectRemoved:Delete": print("Object deleted!") background_tasks.add_task(delete_object_task, json_data) return {"status": "success"} with gr.Blocks(gr.themes.Soft()) as demo: gr.Markdown("## RAG with MinIO") ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear") ch_interface.chatbot.show_label = False ch_interface.chatbot.height = 600 demo.queue() if __name__ == "__main__": nest_asyncio.apply() app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH) uvicorn.run(app, host="0.0.0.0", port=8808) 

ឥឡូវនេះយើងមានបំពង់ Ingestion ដែលកំពុងដំណើរការ ចូរយើងបញ្ចូលបំពង់ RAG ចុងក្រោយ។

បន្ថែមសមត្ថភាពស្វែងរកវ៉ិចទ័រ

ឥឡូវនេះយើងមានឯកសារចូលទៅក្នុង lanceDB សូមបន្ថែមសមត្ថភាពស្វែងរក

 EMBEDDING_QUERY_PREFIX = "search_query" def search(query, limit=5): query_embedding = get_embedding(f"{EMBEDDING_QUERY_PREFIX}: {query}") res = get_or_create_table().search(query_embedding).metric("cosine").limit(limit) return res

 # Lets test to see if it works res = search("What is MinIO Enterprise Object Store Lite?") res.to_list()

ជម្រុញ LLM ឱ្យប្រើឯកសារពាក់ព័ន្ធ

 RAG_PROMPT = """ DOCUMENT: {documents} QUESTION: {user_question} INSTRUCTIONS: Answer in detail the user's QUESTION using the DOCUMENT text above. Keep your answer ground in the facts of the DOCUMENT. Do not use sentence like "The document states" citing the document. If the DOCUMENT doesn't contain the facts to answer the QUESTION only Respond with "Sorry! I Don't know" """

 context_df = [] def llm_chat(user_question, history): history = history or [] global context_df # Search for relevant document chunks res = search(user_question) documents = " ".join([d["text"].strip() for d in res.to_list()]) # Pass the chunks to LLM for grounded response llm_resp = requests.post(LLM_ENDPOINT, json={"model": LLM_MODEL, "messages": [ {"role": "user", "content": RAG_PROMPT.format(user_question=user_question, documents=documents) } ], "options": { # "temperature": 0, "top_p": 0.90, }}, stream=True) bot_response = "**AI:** " for resp in llm_resp.iter_lines(): json_data = json.loads(resp) bot_response += json_data["message"]["content"] yield bot_response context_df = res.to_pandas() context_df = context_df.drop(columns=['source', 'vector']) def clear_events(): global context_df context_df = [] return context_df

ធ្វើបច្ចុប្បន្នភាព FastAPI Chat Endpoint ដើម្បីប្រើ RAG

 import json import gradio as gr import requests from fastapi import FastAPI, Request, BackgroundTasks from pydantic import BaseModel import uvicorn import nest_asyncio app = FastAPI() @app.on_event("startup") async def startup_event(): get_or_create_table() if not scheduler.running: scheduler.start() @app.on_event("shutdown") async def shutdown_event(): scheduler.shutdown() @app.post("/api/v1/metadata/notification") async def receive_metadata_webhook(request: Request, background_tasks: BackgroundTasks): json_data = await request.json() if json_data["EventName"] == "s3:ObjectCreated:Put": print("New Metadata created!") background_tasks.add_task(create_metadata_task, json_data) if json_data["EventName"] == "s3:ObjectRemoved:Delete": print("Metadata deleted!") background_tasks.add_task(delete_metadata_task, json_data) return {"status": "success"} @app.post("/api/v1/document/notification") async def receive_webhook(request: Request, background_tasks: BackgroundTasks): json_data = await request.json() if json_data["EventName"] == "s3:ObjectCreated:Put": print("New object created!") background_tasks.add_task(create_object_task, json_data) if json_data["EventName"] == "s3:ObjectRemoved:Delete": print("Object deleted!") background_tasks.add_task(delete_object_task, json_data) return {"status": "success"} with gr.Blocks(gr.themes.Soft()) as demo: gr.Markdown("## RAG with MinIO") ch_interface = gr.ChatInterface(llm_chat, undo_btn=None, clear_btn="Clear") ch_interface.chatbot.show_label = False ch_interface.chatbot.height = 600 gr.Markdown("### Context Supplied") context_dataframe = gr.DataFrame(headers=["parent_source", "text", "_distance"], wrap=True) ch_interface.clear_btn.click(clear_events, [], context_dataframe) @gr.on(ch_interface.output_components, inputs=[ch_interface.chatbot], outputs=[context_dataframe]) def update_chat_context_df(text): global context_df if context_df is not None: return context_df return "" demo.queue() if __name__ == "__main__": nest_asyncio.apply() app = gr.mount_gradio_app(app, demo, path=CHAT_API_PATH) uvicorn.run(app, host="0.0.0.0", port=8808)

តើអ្នកអាចឆ្លងកាត់ និងអនុវត្តការជជែកដែលមានមូលដ្ឋានលើ RAG ជាមួយ MinIO ជា backend lake ទិន្នន័យបានទេ? នាពេលខាងមុខ យើងនឹងធ្វើសិក្ខាសាលាលើប្រធានបទដូចគ្នានេះ ដែលយើងនឹងផ្តល់ឱ្យអ្នកនូវការសាកល្បងផ្ទាល់ នៅពេលដែលយើងបង្កើតកម្មវិធីជជែកដែលមានមូលដ្ឋានលើ RAG នេះ។

RAGs-R-Us

ក្នុងនាមជាអ្នកអភិវឌ្ឍន៍ផ្តោតលើការរួមបញ្ចូល AI នៅ MinIO ខ្ញុំកំពុងស្វែងរកជានិច្ចអំពីរបៀបដែលឧបករណ៍របស់យើងអាចត្រូវបានរួមបញ្ចូលយ៉ាងរលូនទៅក្នុងស្ថាបត្យកម្ម AI ទំនើបដើម្បីបង្កើនប្រសិទ្ធភាព និងលទ្ធភាពធ្វើមាត្រដ្ឋាន។ នៅក្នុងអត្ថបទនេះ យើងបានបង្ហាញអ្នកពីរបៀបបញ្ចូល MinIO ជាមួយនឹង Retrieval-Augmented Generation (RAG) ដើម្បីបង្កើតកម្មវិធីជជែក។ នេះគ្រាន់តែជាព័ត៌មានជំនួយនៃផ្ទាំងទឹកកក ដើម្បីផ្តល់ឱ្យអ្នកនូវការជំរុញមួយក្នុងដំណើរស្វែងរករបស់អ្នកក្នុងការបង្កើតករណីប្រើប្រាស់តែមួយគត់សម្រាប់ RAG និង MinIO ។ ឥឡូវនេះអ្នកមានប្លុកអាគារដើម្បីធ្វើវា។ តោះធ្វើវា!

ប្រសិនបើអ្នកមានសំណួរណាមួយអំពីការរួមបញ្ចូល MinIO RAG ត្រូវប្រាកដថាទាក់ទងមកពួកយើង ស្លេក !