Paggamit ng MiniIO para Bumuo ng Retrieval Augmented Generation Chat Application

Madalas na sinasabi na sa edad ng AI - ang data ay ang iyong moat. Para sa layuning iyon, ang pagbuo ng isang production-grade na RAG application ay nangangailangan ng angkop na imprastraktura ng data upang mag-imbak, mag-bersyon, magproseso, magsuri, at mag-query ng mga chunks ng data na bumubuo sa iyong proprietary corpus. Dahil ang MiniIO ay gumagamit ng data-first approach sa AI, ang aming default na inisyal na rekomendasyon sa imprastraktura para sa isang proyekto ng ganitong uri ay ang mag-set up ng Modern Data Lake (MinIO) at isang vector database. Bagama't ang iba pang mga pantulong na tool ay maaaring kailangang isaksak sa daan, ang dalawang yunit ng imprastraktura na ito ay batayan. Sila ay magsisilbing sentro ng grabidad para sa halos lahat ng mga gawaing kasunod na nakatagpo sa pagkuha ng iyong RAG application sa produksyon.

Ngunit ikaw ay nasa isang palaisipan. Narinig mo na ang mga katagang ito na LLM at RAG dati ngunit higit pa doon ay hindi ka pa nakipagsapalaran dahil sa hindi alam. Ngunit hindi ba mas maganda kung mayroong isang "Hello World" o boilerplate app na makakatulong sa iyong magsimula?

Huwag kang mag-alala, nasa iisang bangka ako. Kaya sa blog na ito, ipapakita namin kung paano gamitin ang MiniIO para bumuo ng Retrieval Augmented Generation(RAG) based chat application gamit ang commodity hardware.

• Gamitin ang MiniIO upang iimbak ang lahat ng mga dokumento, naprosesong mga tipak at ang mga pag-embed gamit ang vector database.

  
  

• Gamitin ang feature ng bucket notification ng MiniIO para mag-trigger ng mga event kapag nagdadagdag o nag-aalis ng mga dokumento sa isang bucket

  
  

• Webhook na kumukonsumo ng kaganapan at nagpoproseso ng mga dokumento gamit ang Langchain at nagse-save ng metadata at mga chunked na dokumento sa isang metadata bucket

  
  

• I-trigger ang mga kaganapan sa notification ng MiniIO bucket para sa mga bagong idinagdag o tinanggal na mga chunked na dokumento

  
  

• Isang Webhook na kumukonsumo ng mga kaganapan at bumubuo ng mga pag-embed at i-save ito sa Vector Database (LanceDB) na pinananatili sa MiniIO

Mga Key Tool na Ginamit

• MiniIO - Tindahan ng Bagay upang ipagpatuloy ang lahat ng Data
• LanceDB - Serverless open-source Vector Database na nagpatuloy ng data sa object store
• Ollama - Upang patakbuhin ang LLM at pag-embed ng modelo nang lokal (katugma sa OpenAI API)
• Gradio - Interface kung saan makikipag-ugnayan sa RAG application
• FastAPI - Server para sa Webhooks na tumatanggap ng bucket notification mula sa MiniIO at inilalantad ang Gradio App
• LangChain & Unstructured - Upang I-extract ang kapaki-pakinabang na teksto mula sa aming mga dokumento at I-chunk ang mga ito para sa Pag-embed

Mga Modelong Ginamit

• LLM - Phi-3-128K (3.8B Parameter)
• Mga Embedding - Nomic Embed Text v1.5 ( Matryoshka Embeddings / 768 Dim, 8K na konteksto)

Simulan ang MiniIO Server

Maaari mong i-download ang binary kung wala ka pa nito mula dito

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

Simulan ang Ollama Server + I-download ang LLM at Modelo ng Pag-embed

I-download ang Ollama mula dito

 # 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

Gumawa ng Basic Gradio App Gamit ang FastAPI para Subukan ang Modelo

 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)

Subukan ang Modelo sa Pag-embed

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

Pangkalahatang-ideya ng Ingestion Pipeline

Lumikha ng MiniIO Bucket

Gumamit ng mc command o gawin ito mula sa UI

• custom-corpus - Upang iimbak ang lahat ng mga dokumento
• warehouse - Upang iimbak ang lahat ng metadata, chunks at vector embeddings

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

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

Lumikha ng Webhook na Kumokonsumo ng Mga Notification ng Bucket mula sa 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?")

Lumikha ng Mga Notification ng MiniIO sa Kaganapan at I-link ito sa custom-corpus Bucket

Gumawa ng Webhook Event

Sa Console pumunta sa Events-> Add Event Destination -> Webhook

Punan ang mga patlang ng mga sumusunod na halaga at pindutin ang i-save

Identifier - doc-webhook

Endpoint - http://localhost:8808/api/v1/document/notification

I-click ang I-restart ang MiniIO sa itaas kapag na-pormpted sa

( Tandaan : Maaari mo ring gamitin ang mc para dito)

I-link ang Webhook Event sa custom-corpus bucket Events

Sa console pumunta sa Bucket (Administrator) -> custom-corpus -> Events

Punan ang mga patlang ng mga sumusunod na halaga at pindutin ang i-save

ARN - Piliin ang doc-webhook mula sa dropdown

Piliin ang Mga Kaganapan - Suriin ang PUT at DELETE

( Tandaan : Maaari mo ring gamitin ang mc para dito)

Mayroon kaming unang pag-setup ng webhook

Ngayon subukan sa pamamagitan ng pagdaragdag at pag-alis ng isang bagay

I-extract ang data mula sa Documents and Chunk

Gagamitin namin ang Langchain at Unstructured para magbasa ng isang object mula sa MiniIO at Split Documents sa multiple chunks

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

Idagdag ang Chunking logic sa Webhook

Idagdag ang chunk logic sa webhook at i-save ang metadata at chunks sa warehouse bucket

 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!"

I-update ang FastAPI server gamit ang bagong logic

 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)

Magdagdag ng bagong webhook upang iproseso ang metadata/chunk ng dokumento

Ngayon na mayroon na tayong unang webhook na gumagana sa susunod na hakbang ay ang kunin ang lahat ng chunks na may metadata Bumuo ng Mga Embeddings at iimbak ito sa vector Database

 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)

Lumikha ng Mga Notification ng MiniIO sa Kaganapan at I-link ito sa warehouse Bucket

Gumawa ng Webhook Event

Sa Console pumunta sa Events-> Add Event Destination -> Webhook

Punan ang mga patlang ng mga sumusunod na halaga at pindutin ang i-save

Identifier - metadata-webhook

Endpoint - http://localhost:8808/api/v1/metadata/notification

I-click ang I-restart ang MiniIO sa itaas kapag sinenyasan na

( Tandaan : Maaari mo ring gamitin ang mc para dito)

I-link ang Webhook Event sa custom-corpus bucket Events

Sa console pumunta sa Bucket (Administrator) -> warehouse -> Mga Kaganapan

Punan ang mga patlang ng mga sumusunod na halaga at pindutin ang i-save

ARN - Piliin ang metadata-webhook mula sa dropdown

Prefix - metadata/

Suffix - .json

Piliin ang Mga Kaganapan - Suriin ang PUT at DELETE

( Tandaan : Maaari mo ring gamitin ang mc para dito)

Mayroon kaming unang pag-setup ng webhook

Subukan ngayon sa pamamagitan ng pagdaragdag at pag-alis ng isang bagay sa custom-corpus at tingnan kung ma-trigger ang webhook na ito

Lumikha ng LanceDB Vector Database sa MiniIO

Ngayon na mayroon na tayong pangunahing webhook na gumagana, hayaan nating i-setup ang lanceDB vector databse sa MiniIO warehouse bucket kung saan ise-save natin ang lahat ng mga embed at karagdagang metadata field.

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

Magdagdag ng Pag-iimbak/pag-alis ng data mula sa lanceDB sa 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!"

Magdagdag ng scheduler na Nagpoproseso ng Data mula sa Mga Queue

 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)

I-update ang FastAPI gamit ang Vector Embedding Changes

 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) 

Ngayon na mayroon na tayong Ingestion pipeline na gumagana, isama natin ang huling RAG pipeline.

Magdagdag ng Vector Search Capability

Ngayong mayroon na tayong dokumentong naipasok sa lanceDB, idagdag natin ang kakayahan sa paghahanap

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

I-prompt ang LLM na gamitin ang Mga Kaugnay na Dokumento

 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

I-update ang FastAPI Chat Endpoint para magamit ang 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)

Nagawa mo bang dumaan at ipatupad ang RAG based chat sa MiniIO bilang backend ng data lake? Gagawa kami sa malapit na hinaharap ng isang webinar sa parehong paksa kung saan bibigyan ka namin ng live na demo habang binubuo namin itong RAG based chat application.

RAGs-R-Us

Bilang isang developer na nakatuon sa pagsasama ng AI sa MiniIO, patuloy kong tinutuklasan kung paano maaaring maayos na maisama ang aming mga tool sa mga modernong arkitektura ng AI upang mapahusay ang kahusayan at scalability. Sa artikulong ito, ipinakita namin sa iyo kung paano isama ang MiniIO sa Retrieval-Augmented Generation (RAG) upang bumuo ng isang chat application. Ito lang ang dulo ng iceberg, para bigyan ka ng tulong sa iyong quest na bumuo ng mas kakaibang used cases para sa RAG at MiniIO. Ngayon ay mayroon kang mga bloke ng gusali upang gawin ito. Gawin natin!

Kung mayroon kang anumang mga katanungan sa pagsasama ng MiniIO RAG siguraduhing makipag-ugnayan sa amin sa Slack !