Videos → How to perform RAG and Vector Search with MongoDB

LLM, Vector Search และ Semantic Search คืออะไร?0:00

โอเคนะครับผมก็ขอส่งต่อเวทีนี้กลับให้คุณเจมส์นะครับ

อ่าขอบคุณครับทุกคนครับ โอเค ถามก่อนครับในนี้ใครรู้จัก เอ่อ ทุกคนคงน่าจะเคยได้ยิน large language model กันใช่มั้ยครับ โอเค ใครในนี้เคยได้ยิน ยังไม่เคยได้ยินคำว่า vector search บ้างครับ ขอมือหน่อยฮะ จะได้รู้ background ทุกคนหน่อย โอเคแปลว่าทุกคนเคยได้ยินหมดแล้ว โอเคมีข้างหลังนะครับ ในนี้มีใครยังไม่เคยได้ยินคำว่า semantic search บ้างครับ

ทุกคนเคยได้ยินหมดแล้ว อ๋อๆ โอเคมี 2 ได้ครับ แปลว่าส่วนใหญ่น่าจะมีพื้นฐานใช่มั้ยครับ

ภาพรวม Workshop และแหล่งข้อมูลเพิ่มเติม0:38

โอเค เอิ่ม บอกก่อนครับว่า เอ่อ เซสชั่นเนี้ยจริงๆ มันเป็น workshop นะครับ รันกันประมาณ 3 ชั่วโมงนิดๆ นะครับ ก็เราพยายามย่อมาให้เหลือเป็น 40 นาทีนะครับ ก็ดีเทลบางอย่างเราอาจจะข้ามมันไปนะครับ ก็ในส่วนที่เป็นโค้ดเดี๋ยวผมจะ walk through ให้ดู แต่ว่าคงไม่ได้ลงลึกขนาดนั้นนะครับ ก็ เอ่อ แต่ anyway ครับเรามี GitHub เรามี Google Colab นะครับ แล้วเราก็มีบทความที่เขียนเอาไว้แล้ว follow up ได้นะครับ แล้วก็เร็วๆ นี้น่าจะมีเปิดรับลงทะเบียนสำหรับ ทำ workshop ตัวเนี้ยนะครับ ก็เดี๋ยวผมกับทีมเนี่ยจะมาสอนด้วยกันนะครับ สอนฟรีนะครับ ก็ดูในกลุ่มไว้แล้วกันนะครับ

RAG กับ Vector Search with MongoDB คืออะไร?1:18

โอเคครับ เอิ่ม จริงๆ วันนี้หัวข้อมันคือ RAG กับ

vector search with MongoDB นะครับ ก็จริงๆ เนี่ย พอพูดถึงคำว่า large language model เนาะ

นะครับ พูดถึง large language model เนี่ยมันทำอะไรได้บ้างนะครับ เราก็จะนึกถึงอะไรที่เราพิมพ์คำถามเข้าไปใช่มั้ยครับ เราพิมพ์คำถามเข้าไป แล้วจากนั้นเนี่ย มันก็พยายามที่จะให้คำตอบ อะไรบางอย่างกับเรากลับมาใช่มั้ยฮะ อ่ะลองดูนะครับ เอ่อ เห็นมั้ยฮะ

ผมขยายหน่อยแล้วกันนะ อืม เอ่อ ผมพิมพ์ว่า system ของผมเป็นยังไงบ้างครับวันนี้ฮะ แล้วผมลองส่ง request นะครับ

ตัวอย่างการใช้งาน RAG กับ MongoDB2:03

โอเคครับ เอ่อ สิ่งนี้ทำอะไรครับ สิ่งเนี้ยครับ มันจะรับคำสั่งเป็นคำถามแบบ meaning เข้าไปครับ แล้วมันก็จะพยายามไปเชื่อมต่อกับ 2 อย่างครับ ก็คือสิ่งที่เป็นตัว AI เองนะครับ ที่ก็คือเป็นโมเดลแยกเนาะ ของ OpenAI Azure OpenAI นะครับ ที่ผมใช้ แล้วก็พยายามที่จะเข้าไป get data บางอย่างจาก MongoDB นะครับ แล้วก็เอามาแสดงนะครับ

วิธีการ Get Data จาก MongoDB2:29

ประเด็นคือคำว่า get data บางอย่างเนี่ยมันทำได้หลายวิธี เดี๋ยววันนี้เราจะมาพูดถึง 2 วิธีนะครับที่เราจะใช้กันนะครับ ก็ครับ ซึ่งก็ เอ่อ โดย อันนี้เป็นข้อมูลที่เก็บมาเป็นข้อมูล logging นะครับ เป็นข้อมูล logging ของตัว HTTP request in general นะครับ ผมก็ถามว่า เออ system today ของผมเป็นยังไงนะครับ มันก็บอกเนาะว่า เออ วันนี้มันเกิดอะไรขึ้นเนาะ ด้วยอะไรแบบไหนนะครับ แปลงเป็นคำพูดออกมานะครับ

โอเคครับ นั่นก็คือเดโมพอหอมปากหอมคอนะครับ

โอเค แล้วนี่ก็คือตัวข้างหลังครับ จริงๆ ค่อนข้าง simple นะครับ ไม่ได้มีอะไรยิ่งใหญ่มากนะครับ แต่ว่าเดี๋ยวเราเนี่ย คงจะมาลงลึกเอ่อ นิดนึงนะครับ แตะนิดนึงในส่วนที่ 2 ที่เป็น query database นะครับ ที่ใช้ MongoDB เนาะ เดี๋ยวเรามาดูก่อนว่าเราใช้วิธีไหนได้บ้างนะครับ

LLM และ Model Knowledge3:18

โอเคครับ แต่ผมขอปูพื้นนิดนึงแล้วกันครับ ผมว่าหลายๆ คนคงจะรู้จักกับ LLM แหละนะครับ เราก็คงจะรู้ว่า LLM มี model knowledge เนาะ ใช่มั้ยครับ เจ้า model knowledge ตัวเนี้ยครับ มันเป็น model knowledge แบบ batch หมายความว่าไงครับ หมายความว่า รุ่นนี้มันอาจจะถูกมีโมเดลที่ feed เข้าไปเป็น pre-trained

อ่ะนะครับ ตั้งแต่วันนี้จนถึงวันนี้ จากนั้นก็จบแค่ตรงนั้นใช่มั้ยครับ อย่างถ้าเกิดว่าบางทีเนี่ยเราถามคำถามให้กับตัว assistant ของเรานะครับ แล้วเราถามว่า เออ Queen Elizabeth เนี่ยยังอยู่มั้ยนะครับ ที่ 2 นะครับ เขาก็จะบอกว่า เออ เขายังอยู่นะครับ ใช่มั้ย เพราะว่าโมเดลบางตัวเนี่ยมันยัง มันยังเป็นโมเดลที่ข่าวเนี่ยมันยังอยู่ในช่วงปีก่อนที่ Queen Elizabeth จะ pass away ใช่มั้ยครับเนาะ แต่ว่าโมเดลหลังจากนั้นก็อาจจะอัพเดตไปแล้วนะครับ

ข้อจำกัดของ Model Knowledge และวิธีแก้ไข4:04

โอเคนี่ก็เป็นประเด็นนึงนะครับ

แล้วอีกประเด็นนึงครับ บางทีเราอาจจะถามคำถามที่ เอ่อ มัน general มากนะครับ อย่างเช่นว่า เอ้ย ไม่ใช่ general แบบ คำถามที่มัน specific มากขึ้นนะครับ อย่างเช่น เออ ผมอยากจะได้ waterproof shoes ที่มันแบบอุ่นๆ หน่อยนะครับ ถ้าเกิดว่าปั่นๆ อยู่อะไรอย่างเงี้ยนะครับ เออ assistant ของเราที่เป็นตัว AI อ่ะครับ ถ้าเกิดว่าเขาไม่ได้มีข้อมูลที่มัน specific เจาะจง เขาก็จะพยายามดึงข้อมูลที่เป็น batch ของเขาออกมาตอบเราเนาะ นะครับ ซึ่งตรงเนี้ยครับ เป็นสิ่งที่ เอ่อ เราเนี่ย

ที่เป็นคนที่ทำแอปพลิเคชันบางอย่างที่มันจะต้องมีการต่อกับ LLM เนี่ยครับ จะต้องพยายามเข้าใจนะว่า เอ้ย จริงๆ แล้วเนี่ย แล้วถ้าเกิดว่าเรายังอยากให้เขาตอบให้มัน specific มากขึ้น หรือว่าให้มันพยายาม lead มาสู่การซื้อสินค้าของเรามากขึ้น หรืออะไรแบบเนี้ยมันควรจะต้องเป็นยังไงนะครับ นะครับ ก็ โดยส่วนใหญ่นะครับ

อันนี้เราพูดถึง knowledge ที่เป็นแบบขั้นพื้นฐานก่อน ก็คือเรา add prompt เข้าไปถูกมั้ยครับ prompt โดยปกติเลยใช่มั้ยครับ อย่างเช่นว่า เออ I need warm waterproof เราอาจจะ add prompt ที่เป็น meta prompt ว่า เออ จริงๆ แล้วอ่ะ you ควรจะต้องเป็น AI นะที่ตอบคำถาม เอ่อ เป็น AI นะที่ act ว่าตัวเองเนี่ยเป็น sales representative เนาะ เป็นเซลล์ขายของนะครับ ของบริษัทนี้ บริษัทนี้นะครับ แล้วเราก็ลุ้นนะครับว่า ไอ้บริษัทนี้ บริษัทนี้เนี่ย มันมี data อยู่ใน batch ที่มันถูก pre-trained เข้าไปรึเปล่านะครับ เอ่อ ซึ่งเราไม่ต้องการแบบนั้นครับ เราไม่ต้องการแบบนั้นนะครับ

Retrieval Augmented Generation (RAG)5:31

สิ่งที่เราพยายามทำเนี่ยคือการที่บอกว่าโอเค ถึงแม้โมเดลเนี่ย เอ่อ ที่เป็น LLM เนี่ยเขาจะเก่งนะครับ ในมุมของการพยายามที่จะเข้าใจ semantic meaning

ความหมายอะไรบางอย่างก็ตามนะครับ แต่เราก็จะต้องมีการ provide ข้อมูลที่เป็นข้อมูลอัพเดต หรือข้อมูลบางอย่างให้กับเขา เพื่อให้เขาสามารถเอาตรงเนี้ยครับ กับตัวความรู้ที่เป็น model knowledge ของเขาเนี่ย มา compile ซึ่งกันและกัน แล้วตอบคำถามให้มันเจาะจงมากขึ้นเนาะ นะครับ สิ่งเนี้ยครับมีชื่อว่า retrieval augmented generation นะครับ หรือว่า RAG นั่นแหละนะครับ

ขั้นตอนการทำงานของ RAG6:00

มันทำงานยังไงนะครับ ก็หลักๆ ครับ เวลาที่ user มี เอ่อ question เข้ามานะครับ

เราก็จะพยายามจับ question ตรงนั้นก่อนครับ แล้วดึง data ที่เกี่ยวข้องนะครับ กับ question ตรงนั้นนะครับ แล้วจากนั้นเนี่ย เราก็จะพยายาม

เอาไอ้ data ที่เกี่ยวข้องกับ question ตรงนั้นนะครับ ผสมกับ prompt ของเรานะครับ แล้วก็ใส่เข้าไปให้กับโมเดลเนาะ แล้วจากนั้นโมเดลมันก็จะพยายาม analyze นะครับ แล้วก็พยายาม send result บางอย่างออกมานะครับ นี่ก็คือท่ามาตรฐานทั่วไปนะครับ ของสิ่งที่มันเป็นนะครับ โอเคครับ ซึ่ง พอกลับมาตรงนี้ครับ เดี๋ยวปูพื้นกันนิดนึงครับ ยังไม่ไป MongoDB เลยนะครับ เรายังอยู่ที่ เอ่อ Azure OpenAI กันอยู่นะครับ เออ พอมาถึงตรงนี้ครับ sequence ในการทำงานของมันนะครับ โดยปกติเนี่ยมันเป็นยังไงนะครับ อ่า นี่คือ sequence diagram ในการทำงานของมันนะครับ ก็หลักๆ ครับมันจะรับตัว query เข้ามานะครับเนาะ แล้วก็หลังจากนั้นเนี่ย พอมันรับ query เข้ามานะครับ เสร็จเนี่ย มันก็จะพยายามที่จะเอา query ตัวเนี้ยครับ ยิงไปหาตัว OpenAI โมเดลก่อนเนาะ แล้วก็พยายามดูว่า OpenAI โมเดลเนี่ย มันต้องการข้อมูลอะไรเพิ่มมั้ยนะครับ ถ้ามันต้องการเพิ่มเดี๋ยวมันจะบอกกลับมาละหาเราครับ ถ้าเกิดว่า สมมติว่ามันบอกว่า เฮ้ย ชั้นต้องการ เราต้อง prompt เอาไว้นะว่า เฮ้ย ชั้นต้องการข้อมูลเกี่ยวกับ log วันนี้ วันนี้นะครับ

เขาก็จะพยายามเรียกกลับมาที่ backend application ของเราเนาะ แล้วจากนั้นเราก็ไป fetch ข้อมูลจาก MongoDB นะครับ แล้วจากนั้นก็ส่งข้อมูลกลับไปให้ LLM นะครับ พร้อมกับ prompt ของเราเนาะ แล้วคราวเนี้ย เราก็ return ตัว summary ตรงนั้นนะครับ กลับไปให้กับ user นะครับ ซึ่งเราก็จะเห็นนะครับว่า process ตรงเนี้ย มันจะมีการ involve data ที่เป็น data แบบ data ของเราเอง กับ pre-trained data ที่มันมีอยู่ในโมเดลอยู่แล้วใช่มั้ยครับ

Walkthrough โค้ด: การทำงานของ RAG7:41

ครับ ซึ่ง ผมจะ walk through ให้แบบคร่าวๆ แล้วกันนะครับเนาะ

มันเป็นยังไงนะครับ ก็มันเป็นแบบนี้ครับ เอ่อ จริงๆ อันนี้อยู่ใน GitHub นะครับ มีทุกอย่างเลยครับ เอ่อ ทั้งสไลด์ สไลด์น่าจะยัง อ่า เดี๋ยวไม่อัพเดต เดี๋ยวขออัพเดตนิดนึงนะครับ แล้วก็แต่ที่เหลือมีหมดแล้วนะครับ โอเค เห็นมั้ย เล็กมากนะฮะ ขอขยายหน่อย นะครับ

โอเคครับ หลักๆ ครับมันจะมี endpoint API อยู่ตรงนี้ครับ

นี่คือ API endpoint ของเราครับ ก็หลักๆ ครับ พอเราพิมพ์ข้อมูลปุ๊บ กดปุ่ม ask ปุ๊บใช่มั้ยครับ มันก็จะยิงคำถามเข้ามาในนี้ครับ จากนั้นก็ simple ครับ เราก็รับคำถามเข้ามาครับ extract คำถามออกมา จากนั้นเสร็จปุ๊บครับ เรา เราขั้นแรกเราโยนคำถามเนี้ยกลับ ไปให้กับ AI โมเดลก่อนนะครับเนาะ เรายังไม่ retrieve นะครับ เราพยายามโยนกลับไปก่อนนะครับ เพราะว่าคำถามที่มาเนี่ยมันเป็นคำถามแบบ semantic คือมันเป็นคำถามที่มีความหมายเนาะ ใช่มั้ยครับเนาะ เราก็พยายามที่จะเข้าใจว่า เอ้ย ความหมายของคำถามเนี้ยคืออะไรนะครับ นั่นเป็นงานที่ LLM เขาเก่งอยู่แล้วนะครับ แต่หลังจากที่เราได้คำถามมาแล้วอ่ะครับ เราอ่ะครับจะพยายาม extract ครับ อันนี้คือตัวของ response ที่ได้มาจาก LLM นะครับ เห็นใช่มั้ยฮะ โอเค ไอ้ response ตัวเนี้ยครับ เราจะพยายามบอกเขาครับ

pre-define บอกเขาว่า เฮ้ย ถ้ามันในคำถามเนี้ย ในความหมายของมันน่ะ มันมีอะไรบางอย่างที่มันจะต้องการข้อมูลเพิ่มเติมอ่ะ นายบอกมาหน่อยซิ ว่าไอ้ข้อมูลเพิ่มเติมที่นายต้องการน่ะคืออะไรครับเนาะ ซึ่ง ณ ที่นี้ครับ มันก็คือข้อมูลเพิ่มเติมที่เป็น ตัว recent log นะครับเนาะ ซึ่ง เอ่อ ในเชิง technical เลยครับ ก็คือว่าเรา define ฟังก์ชันให้เขาครับ เราโยนฟังก์ชันที่เป็น define แต่เราไม่ได้โยนฟังก์ชันเข้าไป นะครับ เราโยน definition ของฟังก์ชันเข้าไปให้ LLM นะฮะ LLM เนี่ยจะพยายามวิเคราะห์แล้วดูว่าฟังก์ชันเนี้ย เป็นฟังก์ชันที่เขาควรเรียกมั้ยนะครับ กับคำถามที่เกิดขึ้น ถ้าเขาควรเรียกครับ เขาก็จะโยนกลับมาให้เราบอกว่า เออ เรียกฟังก์ชันนี้ให้หน่อย แล้วจากนั้นครับ เราก็พยายามเรียกฟังก์ชันครับ เรียกฟังก์ชันเสร็จปุ๊บ เราก็พยายาม

เอาไอ้ data ให้ได้จากฟังก์ชันนั้นๆ น่ะครับ โยนกลับไปใหม่นะครับ ให้กับ LLM อีกรอบนึงนะครับเนาะ

แล้วท่าของมันก็จะเป็นประมาณแบบนี้นะครับ ซึ่งก็คือ โดยสรุปของสไลด์ตัวนี้นะครับ ก็คือ

ท่าแบบเมื่อกี้เนาะ นะครับ

การจัดการ Context Window และ Memory ของ LLM10:00

โอเค ซึ่งอันเนี้ยเป็นท่า RAG มาตรฐานครับ ผมว่าหลายๆ คนน่าจะพูดกันเยอะใช่มั้ยครับ ถ้าแบบว่า มันเรียกฟังก์ชัน

ก็มีโอกาสที่ context ที่ได้มาจากฟังก์ชันที่มันมีอยู่ นะครับ จะเกินตัว context window ของตัวโมเดล

หมายถึงตัวโทเค็นที่จะส่งเข้าไปหรือเปล่าครับ จริงๆ ตรงนี้ครับ ต้องพูดก่อนว่ามันมีโอกาสมั้ย

มีโอกาสที่ตัวโทเค็นจะเกินครับ แต่ว่าเรามีวิธี handle ได้หลายแบบนะครับ อย่างแรกคือเราเป็นคน handle memory เอง โอเค พอพูดถึง memory คนจะสับสนกันมาก ครับ memory ไม่ได้หมายถึง memory ที่เป็น memory แบบคอมพิวเตอร์แหละครับ แต่ว่าเรากำลังพูดถึงพวก ข้อมูลเหล่านี้นะครับ พวก message นะครับ ถ้าเกิดว่าใครรู้ครับว่า message ที่เราส่งเข้าไป ให้กับพวก LLM เนี่ย มันจะมี role ถูกมั้ยครับ role user role system role assistant อะไรอย่างเงี้ยครับ ตรงนี้เราสามารถ control memory เองได้นะครับ เพราะฉะนั้นครับ ตอบคำถามเมื่อกี้ ในแบบแรกก่อนครับ ใช่ครับ มันมีโอกาสครับ แต่ว่าเราก็จะพยายาม handle ตรงนี้ครับ ไม่ให้มันเกิน อันนี้คือประเด็นแรกนะครับ

ประเด็นที่ 2 ครับ โดยส่วนใหญ่นะครับ คำถามที่มันวิ่งเข้ามาหาเราครับ ตัว definition

ของฟังก์ชันที่เรามีนะครับ เดี๋ยวผมเปิดให้ดูนะครับ

definition ของฟังก์ชันที่เรามีครับ เราจะพยายามบอกอยู่แล้วครับว่า ฟังก์ชันนี้จะ call ก็ต่อเมื่อมันเป็นอะไรนะครับ ซึ่งโดย in general นะครับ ถ้าเกิดว่าคนนั้น ต้องการจะถามคำถามจริงๆ เนี่ยนะครับ มันก็จะ คือฟังก์ชันมันคงไม่ได้มีแค่ 2 ตัวนะครับ มันจะมีอื่นๆ นะครับ หรือว่าถ้าเกิดว่ามันมีการถาม แบบว่า เฮ้ย คุณถามฟังก์ชันนี้มา 3 รอบแล้วนะ ถ้าเกิดว่ามันเป็นรอบที่ 4 เนี่ย เราควรจะต้องไปเรียกอีกอันนึงแล้วนะ แล้วก็ควรจะต้อง reset memory อะไรอย่างเงี้ยครับ มันก็จะมีวิธีแบบนั้นเหมือนกันในการ handle หวังว่าตอบคำถาม ครับผม

anyway ครับ มันก็จะมีคนที่พยายามถามเรื่องเดียวย้ำๆ ครับ อันนี้ก็เป็นหน้าที่ของ engineer อย่างพวกเราแล้วล่ะครับนะครับ

ซึ่งถึงตรงนี้ครับ เราก็จะเห็นว่าโอเค เรายังไม่ได้แตะอะไรกับตัวที่เป็น MongoDB เลยนะครับ

การดึงข้อมูลจาก MongoDB และปัญหาเรื่องต้นทุน LLM12:00

คือแตะแหละ เราพยายามไป fetch data นะครับ ออกมานะครับ โอเค เดี๋ยวผมโชว์ data ให้ดูนิดนึงครับ

นี่คือ data นะครับ รอแป๊บนึงนะ เป็น system log ครับ มี request header body time บลาๆ โอเคมั้ยครับ ซึ่งวิธีที่ผมดึง ผมดึงตรงๆ เลยครับ ใช้ MongoDB ดึงออกมาเลยนะครับ ไม่ได้ใช้ AI อะไรเลย AI โยนมาปุ๊บ ผมดึงเลย fetch ตรงๆ นะครับ โอเค อันนี้อันนึงครับ แล้วคราวนี้ครับ ก็หลังจากได้ลองๆ ทำมาดูครับ

ปรากฏเวลาเราทำ LLM ครับ หรือว่าเวลาที่เราใช้งาน กับมันนะครับ เราไม่ได้ทำ LLM เองอยู่แล้วถูกมั้ยครับ ถ้าเกิดว่าใครทุกคนรู้ครับ เราใช้โมเดลที่มันสำเร็จ แล้วเราก็จ่ายเงินให้กับเค้าผ่านการ usage ผ่าน API นะครับ หรือถ้าเกิดเราจะ host เองก็ได้ครับ แต่มันก็จะแพงพอสมควรนะครับ ซึ่งสิ่งที่ทำให้โมเดลมันแพงครับ หลักๆ ก็คือ computational power และสิ่งที่ทำให้ computational power มันสูงก็คือโทเค็นที่เราโยนเข้าไปให้กับเค้า แล้วเค้า generate มันออกมาถูกมั้ยครับ โทเค็นคืออะไร ก็พวกตัวที่มันเป็น message

ของเรานั่นแหละครับนะครับ มันจะมีวิธีการนับโทเค็น ของมันนะครับ text message ยาวแบบนี้ โยนเข้าไปปุ๊บ เค้าต้อง generate ออกมาเท่านี้ยาวๆ เนี่ย พวกนี้โทเค็นหมดเลยนะครับ ซึ่งก็จะ relate สู่เงิน และ computational power และเวลาถูกมั้ยครับ

การเพิ่ม Cache เพื่อลดต้นทุน LLM13:23

โอเค แล้วเราจะทำยังไงได้บ้างครับนะครับ

หลังจาก work กับหลายๆ อย่างครับนะครับ เราก็เจอกับกระบวนการนึงครับ ที่เป็นกระบวนการแบบพื้นฐานมากๆ ครับ ในการทำกับ optimization นะครับ

ก็คือการเพิ่ม cache ครับ simple มากครับ วิธีการ simple มากๆ ครับ เพิ่ม cache ครับนะครับ ก็เพิ่ม cache ปุ๊บ แทนที่เราจะต้องไปพยายาม fetch ตัว LLM ใช่มั้ยครับ เราก็ไม่จำเป็นจะต้อง fetch LLM แล้วถูกมั้ยครับ เราก็ยิงเข้ามาปุ๊บ เช็ก cache เช็ก cache เสร็จปุ๊บ ดึง cache return ออกไป เสร็จสิ้นใช่มั้ยครับ เป็นวิธีมาตรฐานนะครับ ก็เราจะลด load ได้ดีขึ้นถูกมั้ยครับ โอเค นี่คือ basic cache key and value ครับ โอเค เรามีวิธีอื่นครับ แต่ว่านี่เป็น basic พื้นฐานนะครับ key value database ครับ มี key มี value ครับ เรา log เข้าไปครับ จบครับ ดึง cache ออกมาใช่มั้ยครับ ถ้าเป็นแบบ request ทั่วๆ ไป เรา cache ยังไงครับ เราก็เอา user ID เราก็เอาข้อบางอย่างใช่มั้ย ทำเป็น key ตั้ง value เป็น data ถูกมั้ยครับ แล้วก็จบใช่มั้ยครับ แล้วถ้าเราเจอ นี่คือตัวอย่างนะครับ ใช่มั้ย เรามี ID ครับ เราดึง เราเอา ID มาใส่ cache

ใช่มั้ยครับ แล้วก็ article data ใช่มั้ย จบนะครับ

ปัญหาการ Cache คำถามและคำตอบใน LLM14:47

คำถามคือแล้วถ้ามันเป็นแบบนี้ล่ะนะครับ คำถามคือถ้าสีเขียวมันคือคำถามล่ะ แต่ถ้าสีแดงมันคือคำตอบล่ะนะครับ เราจะ cache มันยังไงครับ เอาสีเขียวยัดเข้า cache เลยมั้ยครับ สีเขียวยัดเข้า key เลย สีแดงยัดเป็น response ครับ ทำได้มั้ย ทำได้นะครับ

แล้วถ้าเกิดว่า 3 อันนี้ล่ะครับ สมมติว่าเราจะ log 3 อันนี้เป็น cache เราก็ต้องทำไงครับ เราต้อง log 3 อันเป็น key ใช่มั้ยครับ แล้ว response เหมือนเดิมใช่มั้ยครับ หรือเปล่านะครับ จริงๆ แล้วครับ พอเราอ่านสิ่งนี้ ถ้าเรารู้สึกเอ๊ะว่าทำไมเราถึงทำแบบนั้นนะครับ คือไม่แปลกครับ เพราะว่าคอมพิวเตอร์เนี่ย พอพูดถึง key value เค้าจะเข้าใจเป็นแบบ exact match นะครับใช่มั้ยครับ pattern matching ใช่มั้ยครับ การทำ cache โดยปกติคือการหา pattern matching จาก memory ที่เรามีเพื่อลด computational power ในการ compute นะครับ time complexity ใช่มั้ยครับ แต่สิ่งนี้ครับ มัน pattern matching ไม่ได้ครับ มันทำได้แหละ แต่มันไม่ efficient เราทำยังไง ใช่มั้ยครับ สิ่งนี้ ถึงแม้ว่ามันจะไม่เหมือนกัน

ในเทอม pattern matching นะครับ แต่ว่าสิ่งที่มันเหมือนกันคือมันมี semantic meaning ที่เหมือนกันนะครับ semantic meaning ก็คือความหมายของคำที่เมื่อมัน convert เป็น vector เดี๋ยวอธิบายให้ฟัง vector คืออะไร เมื่อมัน convert เป็น vector แล้วครับ มันอยู่ในกลุ่มเดียวกันหรือกลุ่มใกล้ๆ กันนะครับนะครับ วิธีที่เรา cache ครับ เราจะไม่ได้ cache แบบ pattern matching แล้ว เราจะพยายามดึงสิ่งที่เป็น semantic meaning ออกมา แล้วเอาสิ่งนี้ไปเป็น key ในการ cache แล้วจากนั้นก็เอา response ครับ ไปเป็นตัว response ของมัน

Semantic Meaning และ Semantic Search16:16

ลองดูนะ semantic meaning ครับ semantic search ครับ

ถ้าเราสามารถดึง semantic meaning ได้ครับ เราก็สามารถทำ semantic search ได้ครับ semantic search ก็คือการ search ผ่านความหมายของมันนะครับ ถ้าเราทำ semantic search ได้ เราก็สามารถ semantic cache หรือว่า cache by ความหมายได้ครับ นี่คือวิธีการที่เรากำลังจะพูดถึง ต่อไปนะครับ semantic meaning ก่อนนะครับ

วิธีการที่ AI เข้าใจ data นะครับ ผมว่าหลายๆ คนน่าจะเคยคุ้นเนาะ เขาไม่ได้เข้าใจ text นะครับ เขาจะต้องพยายามแปลง text ให้มันกลายเป็นสิ่งที่ชื่อว่า สิ่งที่เป็นตัวเลขเนาะ numerical data แล้วเราก็มักจะมีความหมายของคำนี้ก็คือ vector ถูกไหมครับ คำว่า embedding, vectorizing, encoding สิ่งเหล่านี้ครับ คือการพยายามแปลง string ให้มันกลายเป็น vector

Vector คืออะไร? และ Embedding Model ทำงานอย่างไร?17:04

แล้วก็อาศัย pre-trained เพื่อที่จะพยายามหาความหมายให้กับคำเหล่านั้นเนาะ ใช่ไหมครับ เดี๋ยวลองดูครับ vector หน้าตาเป็นยังไงครับ หน้าตาเป็นแบบนี้เลยครับ

นะครับ เราโยน text เข้าไปครับ แล้วเราก็ได้ vector ออกมาจากฝั่งขวานะครับเนาะ vector เหล่านี้ครับ หน้าตาของมันก็จะเป็น เห็นเนาะ มันคือตัวเลขแหละครับ มันคือตัวเลขนั่นแหละครับ มองเป็นตัวเลขตัวนึงนะครับ ที่เป็น set of ตัวเลขบางอย่างนะครับ คราวนี้ครับ การจะแปลงให้เป็น vector ได้ครับ มันจะต้องใช้สิ่งที่ชื่อว่า embedding model เนาะนะครับ ก็เป็น LLM sub ของ LLM ที่เอาไว้สำหรับแบบหาความหมายของคำนั้นๆ นะครับ

ผมคงไม่ลงลึกว่ามันถูก train มายังไง หลักๆ ก็คือว่า มันจะถูก train มันจะมีการ match คำกับความหมายนะครับ เป็น vector แบบนี้ แล้วจากนั้น พอมันได้คำหมายเข้าไป มันก็จะพยายาม expose หรือว่า return ตัว vector ออกมาให้เรานะครับเนาะ มองมันเป็น array of number ก็ได้นะฮะ

Vector Search คืออะไร? และการหา Similarity18:04

โอเค แล้วคราวนี้ vector search คืออะไรนะครับ พอเรามี

อย่างที่บอกเนาะ พยายามที่จะหา semantic search semantic คือความหมายใช่ไหมครับ เราจะแบบทำ pattern matching ไม่ได้แล้ว สิ่งที่มันสามารถทำได้ก็คือ เราเอา vector เนี่ย ที่มันเป็นตัวเลขเนี่ย ใช่ไหมครับ ตัวเลขเนี่ยอาจจะเป็น array ใช่ไหมครับ

สมมติว่า array มีตัวเลขอยู่ในนั้นซัก 10 ตัวครับเนาะ 10 ตัวเนี่ยเราก็คือมี array 10 ตัวเนี่ย เมื่อ plot ออกมาเป็นกราฟครับ ถ้าเรา plot มาเป็นกราฟเนาะ เราสามารถ plot เป็นกราฟแบบ 10 มิติได้นะครับ ซึ่ง 10 มิติเป็นยังไงก็ไม่รู้นะครับ แต่ว่าเราจะสามารถ plot มา ในการเข้าสมการทางคณิตศาสตร์ตัวนึงนะครับ ก็คือการหา similarity บางอย่างนะครับ ไอ้จุดตรงนี้ครับ จุดตรงนี้ครับ มันก็คือ array ที่มีเลขอยู่ข้างในนะครับ แล้วจากนั้นเนี่ย เมื่อมันเข้าสมการตรงนั้นแล้วมัน plot ออกมาครับ มันก็จะกลายเป็นจุดที่อยู่บนนี้เนาะ แล้วจากนั้นนะครับ เราก็จะเห็นว่าจุดบางจุดอยู่ใกล้กับจุดอื่นๆ นะครับ ในขณะที่จุดบางจุดอยู่ไกลจังเลยนะครับ นี่แหละครับ คือการทำสิ่งที่ชื่อว่า semantic search หรือว่าการหา similarity ความหมายของมันเนาะ อย่าง 2 จุดนี้ครับ มันมีความหมายที่ใกล้กัน เพราะฉะนั้นมันจะต้องสามารถถูก group หรือว่าถูกดึง หรือว่าถูก search แล้วเนี่ย มันจะต้องมี score ที่สูงกว่า เมื่อหาความใกล้เคียงกันของ 2 คำนี้ ใช่ไหมครับ โอเคครับ

MongoDB Vector Search19:30

MongoDB ครับ มีการทำสิ่งที่ชื่อว่า vector search ครับ

vector search มองมันเป็น index ตัวนึงครับ มันคือการพยายามที่จะสร้าง index ตัวนึงขึ้นมาครับ แล้วก็ใช้ machine learning model ครับ ในการที่จะเอาค่าจาก index ตัวนี้ครับ ไป operate ในการ search หรือหาอะไรบางอย่างนะครับ อย่างตรงนี้ครับ ก็เป็นfield ในการสร้างนะครับเนาะ ก็ function similarity ครับ หรือว่าก็คือเนี่ย วิธีการที่เราจะหาไอ้จุด 2 จุดนี้ มันใกล้กันไหมเนี่ย มีหลาย function นะครับ machine learning model ที่เขาใช้ ณ ปัจจุบันแล้วก็กำลังจะมีเพิ่มขึ้นเรื่อยๆ function ที่เราจะสามารถหา similarity

ข้างในได้ปัจจุบันนะครับ มีอยู่ 3 ตัวนะครับเนาะ ก็คือ similarity function นะครับ ถ้าใครเรียน math มาเนาะ euclidean, cosine แล้วก็ตัว dot product ถูกไหมครับเนาะ เดี๋ยวผมลองเปิดให้ดูนะครับว่าหน้าตาของมันเป็นยังไงเนาะ

โอเค เดี๋ยวเปิดให้ดูนะครับ แต่ว่ามันเป็นอย่างนี้แหละครับ หน้าตาตัวนี้คือผมก็แคปออกมาจากตัวนั้นแหละนะครับ เดี๋ยวเอาไว้เปิดให้ดูตอนเรา walk through code แล้วกันนะครับ

คราวนี้ครับ เราเก็บ data ยังไงนะครับ

วิธีการ Retrieve Cache ใน MongoDB21:02

เรา cache ยังไงนะครับ เดี๋ยวลองมา walk through กันครับ

วิธีการที่เรา retrieve cache ก่อนนะครับ

มันน่าจะ simple สุดนะครับ เดี๋ยวผมจะเปิดให้ดูนะฮะ retrieve cache จะทำแบบนี้ครับ เรามี question เราเอา question ที่ได้มาครับ embed เข้าไปในตัว embedding model เพื่อ get vector ออกมาเนาะ เอา vector ที่ได้ครับ ไป search ผ่านกระบวนการที่ 3 ครับ แล้วจากนั้นเมื่อมันได้ เมื่อมัน search แล้วมันหา similarity ได้ มันจะ return ออกมาในกระบวนการที่ 4 นะครับ เดี๋ยวลองดูทำยังไงนะฮะ ผมมีไฟล์ที่ชื่อว่า app_cache นะครับเนาะ

app_cache ทำอะไรครับ อันเดิมเลยครับ อันเดิมเลยเนาะ อันเดิมเลยนะครับ monitoring assistant นะครับ หน้าที่ของเขาครับ เมื่อเขาได้รับคำสั่งเข้ามาครับ อย่างเช่น How about my system today เนาะ

มันจะไม่เห็นภาพ ผมว่าผมลองถามคำถามที่มันแบบต่างกันมากๆ เลยครับ

ไม่น่าจะตอบได้นะ ถ้าผมชื่ออะไรนะ มันจะตอบได้ไหม Sorry, I don't know ครับ I have no access to your private information. That's good นะครับ โอเคนะครับ หรือว่าถ้าเกิดว่าเราลองถามอะไรที่มันแบบยาวกว่าหน่อย ที่มันเกี่ยวกับ system เนาะ

ครับ คิดว่าสิ่งที่เราจะเบรกไหมครับ อาทิตย์หน้า

อืม สิ่งที่มันทำก็คือมันพยายามที่จะ get เอาพวกข้อมูลที่มันเป็นดีนายอะนะครับ

ข้อมูลที่มันแบบแปลกๆ ออกมาเนาะ แล้วก็พยายามวิเคราะห์ให้เรา ใช่ไหมครับ โอเค วิธีการที่มัน retrieve คือมันทำแบบนี้ครับเนาะ

การจัดการ Cache ที่กว้างเกินไปและการ Embed เวลา22:51

มันเอาอันนี้เข้ามา embed เสร็จปุ๊บครับ ครับผม Q: เรารู้ได้ยังไงครับว่า cache เรามันกว้างเกินไป

อย่างเช่น อย่างเมื่อกี้ถามว่าอาทิตย์หน้าฝนจะตกหรือเปล่า ครับ มันตอบออกมา มันเอาตอบมาให้อยู่ ครับ แต่ไม่ใช่สิ่งที่เราอยากได้

แต่กลายเป็นว่า similarity score มันคล้ายมากเกินไป อะไรเงี้ยครับ ถ้าเจออย่างงี้จะต้องทำยังไงครับ ครับ James: โดยส่วนใหญ่นะครับ เวลาที่เรา cache นะครับ เราจะพยายาม cache จากตัวของเป็นคำที่นะครับ จากตัวของ meaning ที่เราจะต้องดู 2 ส่วนเนาะ หลักๆ ที่เคยทำมาครับ meaning ของมันครับ กับตัว cache ของเราเองด้วยครับ อย่างเช่นนะครับ อย่างเช่น ถ้ามันถามว่า next week เนี่ยครับ next week เป็นคำที่กว้างเนาะ next week เนี่ย จริงๆ แล้ว next week นะครับ สิ่งที่มันควรจะเป็นจริงๆ ก็คือมันควรจะต้องไม่ได้ เอาแค่ว่า next week คืออะไร แต่มันควรจะต้องเอา data ของปัจจุบันมาด้วยถูกไหมฮะ ว่า today คืออะไรใช่ไหมครับ แล้วพยายามวิ่งไปหา next week จาก today วิ่งไปข้างหน้าถูกไหมฮะ อะ ถ้าเป็นแบบเนี้ยครับ เรา สิ่งที่เราต้องทำก็คือว่า ไอ้ตอนที่มันไปดึง เราก็ต้องไป define ตัว pre-define function ของมันอะนะครับเนาะ ซึ่งอยู่ตรงเนี้ยนะ นะครับ ให้มันมี function ตัวนึงนะครับ ที่มันเอาไว้สำหรับว่าถ้ามันมีการถามเกี่ยวกับเวลาครับ ให้มันเรียก function นี้ก่อนนะครับ แล้ว function เนี้ย บอกเค้าว่าโอเค คำว่า next week กับเวลาของมันจริงๆ คือแบบนี้ครับ แล้วจากนั้นครับ มันก็ เราก็เอาไอ้สิ่งเนี้ยครับ

ไป look up ต่อเนาะว่า เฮ้ย ใน cache ของเราเนี่ยครับ มันเป็นแบบไหนนะครับ ซึ่งเราสามารถกดเข้าไปใน embed ได้ แต่ตอนเนี้ยครับ วิธีที่ผม embed เข้าไปเนี่ย คือผม embed question อย่างเดียว โอเคไหมฮะ มันเลย มันเลยใช่ครับ มันเลยกว้างไปนิดนึงครับ ถ้าเกิดว่าจะ embed ในกรณีแบบเนี้ยครับ เราควรจะ embed ทั้ง question และ embed ทั้ง time ซึ่งเป็น specific range ลงไปด้วยครับ มันก็จะ specific ข้อความมากขึ้น

กรณีที่ไม่ทำ Cache และคำถามที่ไม่เกี่ยวข้อง24:43

Q: คือผมจะบอกว่า ถ้าสมมติว่าเราไม่ทำ cache เนี่ย

แล้วถ้าเราถามคำถามเมื่อกี้ไป มันควรจะตอบว่ามันไม่มีข้อมูล…ถูกต้องไหมครับ

ขอคำถามใหม่ครับ คือ สมมติว่าถ้าไม่ได้ทำ cache

ถ้าไม่ได้ cache ตัว embedding ไว้ แล้วเราถามคำถามว่า ที่ไม่เกี่ยวข้องกับ function ที่เรามีให้เนาะ ใช่ปะ ครับ มันก็ควรจะตอบคล้ายๆ กับที่มันตอบที่ที่เราถามว่า พ่อเราชื่ออะไร James: อ๋อ ใช่ครับ ถ้าเรา define function ที่มันแบบกำหนดเวลาไปแล้วเนาะ ใช่ครับ มันควรจะตอบแบบนั้น แต่ว่าพอเราทำ cache เสร็จ ใช่ครับ ครับ Q: แต่พอเราทำ cache ปรากฏว่าคำถามที่มันไม่ควรจะเข้า cache มันก็เลยมีโอกาสที่มันจะเข้า cache ครับ James: มันจะไม่เข้า cache ครับ เพราะว่าถ้าเกิดว่าเราทำแบบนั้นปุ๊บ เรา อย่างที่บอกครับ ตอนเนี้ยเราใช้ query ในการทำ embed เข้าไปถูกไหมครับ

แต่ถ้าเกิดว่าเราทำแบบนั้นปุ๊บ เราจะไม่ได้ใช้แค่ query ในการ embed เราจะใช้ query บวกกับเวลา embed เข้าไปเลยครับ เพราะฉะนั้น meaning ของมันจะไม่ใช่แค่ query แล้ว มันคือ query บวกเวลาและ เพราะฉะนั้นนะครับ

การวัด Score และ Embedding Model25:44

embedding vector ที่ได้ออกมาเนี่ย ก็จะไม่เหมือนกัน ครับ ค่าของ score ก็จะต่ำลงมา แต่อันนี้ก็ขึ้นอยู่กับว่าเราวัด score ยังไง ครับ

ครับ โอเคครับ เดี๋ยวๆ ให้ดู score ครับ มันมีวิธีวัด score ของมันอยู่เนาะ นะครับ

กำลังนึกอยู่ว่าถึงไหนแล้วนะฮะ

Walkthrough โค้ด: การ Retrieve Cache ใน MongoDB26:02

โอเค วิธีการครับก็คือ พอวิ่งเข้ามาปุ๊บ ใช่ไหมครับ

อะ monitoring ใช่ไหมครับ เสร็จปุ๊บใช่ไหมครับ วิธีการที่ผมทำก็คือ อะ ผมลองเข้าไปดูที่ cache handler นะครับ มันเป็น class ตัวนึงที่ผมสร้างขึ้นมาเองนะฮะ

เออ ผมพึ่งรู้ว่าเค้ามีสิ่งนี้ให้เราแล้วนะฮะ โอเคฮะ

เอิ่ม อะ ลอง find ดูนะครับ จริงๆ อะครับ ไอ้เจ้าตัว vector index อะครับ มันก็คือ เราสามารถที่จะ retrieve data ของมันออกมาได้ จากการทำ aggregation pipeline นะครับ aggregation pipeline ของผมเนี่ยนะครับ ก็คือแบบนี้เลยครับ ก็คือเรา วิ่งเข้าไปนะครับ เอา text มาครับ เอา text ไป get embedding ออกมาครับ จากนั้นเสร็จปุ๊บ เอาไปใส่ vector search นะครับ ก็บอกไปครับ อันนี้ก็คือตัวกำหนดแหละว่า เออ เราใช้ index อะไร path อะไรนะครับ อะ เดี๋ยวเราลองดูเนาะ นี่คือ cache ของผมนะครับ cache ผมเนี่ยมีอะไรบ้าง ผมมี query นะครับ อ่า มี response นะครับ แล้วก็มี embedding นะครับ

วิธีการที่ผมก็คือระบุเข้าไปว่า เออ path ในการที่จะใช้ embed ข้อมูลอะ มันคือตัวนี้นะ นะครับ จากนั้นเสร็จปุ๊บครับ ก็โยนเข้าไปครับ แล้วก็นัมเบอร์ออฟ candidate ก็คือตัว ตัว candidate อะครับ ที่ ที่เป็น สุด ถ้าเกิดว่าเรากลับไปดูกราฟอะเนาะ มันจะมีจุดๆๆ ใช่ไหมครับ ก็ลองดูครับว่าถ้าเกิดข้อมูลนี้วิ่งเข้าไปเนี่ย แล้วแบบ มันมี candidate ที่อยู่ใกล้กันเนี่ย จำนวน 20 ตัวเนี่ย ไหมเนี่ย เมื่อมัน match นะครับ ก็ให้มัน extract ออกมาเนาะ นะครับ จากนั้นครับ ผมก็ทำการครับ add field สิ่งที่ชื่อว่า score เข้าไปครับ โดยการดึงตัว vector search score เข้ามาใส่นะครับ จากนั้นครับ ผมจะไม่ได้เอามาทั้งหมดเนาะ เพราะอย่างที่บอกครับ บางทีเนี่ย ความแม่นของมันเนี่ยก็ขึ้นกับ score นะครับ แต่ว่า score เนี่ยยิ่งแม่นเท่าไหร่ ก็จะยิ่ง retrieve ข้อมูลออกมาได้ เจาะจงแหละ yes นะครับ แต่ก็ถ้าเกิดว่า มันขึ้นกับหลายแบบเนาะ บางทีเนี่ย

model ที่เราใช้อะครับ ในการที่เรา embed ค่าเข้าไปครับ มันอาจจะเป็น model ที่ pre-train มาแล้วมันรู้จักคำได้น้อยกว่า model อีกตัวนึง ที่มีความแม่น แต่ก็แลกมากับความเบาใช่ไหมครับ ตัว score ตรงเนี้ยครับ มันก็ต้องปรับให้ตรงกับตรงนั้นนะครับ อย่างผมเคยใช้อันนี้ ผมน่าจะใช้เป็น Azure OpenAI แบบ small embedding model นะครับ อ่า keyword เดียวกันนะครับ เมื่อเทียบกับที่มันเป็น large ตัว embedding model นะครับ score ต่างกันประมาณ 20 0.20 อะไรอย่างเงี้ยนะครับ ก็อันนี้ก็ต้องมา fine-tune กันเนาะ ก็เป็นงาน in general ของเรานะครับ ก็วัด score ออกมาครับ เสร็จปุ๊บยิงเข้า aggregation ครับ แล้วก็ return result ออกมาครับ ครับ

การเซฟ Cache ใน MongoDB28:36

เราก็จะได้ result ออกมาว่า เออ มัน มันเจอไหมครับ ถ้ามันเจอครับ return ออกมาเลยครับเนาะ ใช่ไหม ถ้ามันไม่เจอ ก็ ก็ตามท่า cache ไปต่อครับ คำนวณครับ ก็เอาเลยครับ ก็สร้าง prompt ใช่ไหมครับ ดูซิว่ามันต้องดึง function ไหม ถ้ามันต้องดึงก็ดึงครับ ดึงอะไรเสร็จปุ๊บ อ่า ผมน่าจะเอาไว้แถวนี้

อ่า นี่ครับ จริงๆ มันมี 2 ที่นะ มีที่นี่กับที่ข้างล่างนะ อะ การเซฟครับ ก็ ตรงไปตรงมาครับ

คือการเซฟเนี่ยก็คือว่าเราจะไม่ได้เซฟผ่าน

เราจะไม่ได้เซฟผ่าน pattern matching ใช่ไหมครับ เราจะเซฟผ่าน path ตัว embedding ที่เราได้ออกมาก็คือ vector ใช่ไหมครับ เพื่อให้มันทำ vector search ได้นะครับ แล้วจากนั้นเนี่ยเราก็ ที่ผมใส่ query เข้าไปเพื่อให้มันเห็นภาพมากขึ้นเนาะว่า เออ ไอ้ตรงนี้มันคือ query อะไรนะครับเนาะ แล้วก็ใส่ embedding เข้าไปนะครับ ใส่ response เข้าไปนะครับ จากนั้นปุ๊บพอเซฟก็จะได้ออกมาเป็นแบบนี้ นะฮะ ก็ ครับ จริงๆ แล้ว ถ้าเกิดว่าเราอยากจะให้มัน

มีความเจาะจงมากขึ้น อย่างเช่นพี่ท่านเมื่อกี้พูดเป็นคำถามที่ดีนะครับ หรือว่ามันจะต้องมี scenario บางอย่าง ที่มันใช้แค่ query ไม่ได้ เป็น question ไม่ได้เนี่ยนะครับ เราก็จะต้องเอาตรงนั้นนะครับ เข้าไป embed กับ model ด้วย เพื่อให้ model มัน มันสามารถบอกได้ว่าไอ้สิ่งเนี้ยมันเจาะจงมากขึ้นนะ พอเวลามันวัด score ออกมาครับ ของคำสั่งตัวเนี้ยเนาะ นะครับ score ของมันเนี่ย จะได้ไม่ mess กับตัวของ

criteria ที่เราตั้งนะครับ อันนี้ก็ต้อง fine-tune กันอีกทีนึงนะครับ โอเคนะครับ

โอเคครับ ทั้งหมดทั้งมวลครับ

อันนั้นก็คือกระบวนการในการเซฟครับผม เอ่อ เซฟก็แบบนี้ครับ มี question ปุ๊บ fetch answer fetch answer เสร็จปุ๊บครับ เชิญครับผม

การกำหนด Semantic Rules และการควบคุม Cache30:28

Q: แล้วเราจะ define semantic rules ที่ไหนครับ

คือเวลาเราหา semantic meaning เนี่ย มันก็แบบสามารถ define rules ได้ว่า ถ้าเกิดว่า query หรือ query ประมาณนี้ให้ตอบอย่างงี้ เราจะ config ที่ไหน James: อ๋อ หมายถึง config ให้ MongoDB มัน มัน search ให้เราอย่างงี้ใช่ไหมครับ คำถามคือแบบนั้นใช่ไหม โอเคครับ

Q: ให้มันว่าอย่างเช่นถ้าถามแบบนี้เราจะไม่ cache นะ มันต้องกดให้มันลืมขึ้น James: อ๋อ หมายถึงว่าจะ cache ไหมใช่ไหมฮะ ใช่ครับ

จริงๆ อันเนี้ยครับ มันเป็น เป็น logic ที่

เรา เรา เราทำเพิ่มเองขึ้นมาครับ คืออันนี้จะไม่ได้เกี่ยวกับ MongoDB และ MongoDB มีหน้าที่อย่างเดียวก็คือทำ index แล้วก็ search ผ่านตัว function บางอย่างใช่ไหมครับ อันเนี้ยครับ มันจะต้องเป็นฝั่ง application layer ของเราและว่าเราจะ cache มันไหมใช่ไหมครับ ถ้าที่ผมเคยทำครับ โดยปกติเราจะพยายาม cache

จากก็คือมันก็จะกลับไปที่ตัว Azure อ่า ตัว OpenAI เลยครับ เรามี pre-define function ถูกไหมครับ เราก็พยายามให้มัน get ดูครับว่า เราก็พยายาม define เข้าไปครับว่า เออ ถ้ามันเป็นข้อมูลประมาณเนี้ย หรือมันถามประมาณเนี้ย หรือมันออกมาเป็นประมาณเนี้ย เฮ้ย เรียก function นี้นะ แล้ว function นั้นก็จะเป็น function ที่กำหนดครับ ว่ามันจะ cache หรือไม่ ให้ตรงเนี้ยครับ เป็นตัว define meaning ของมัน ครับ

โอเค ไม่แน่ใจว่าเหลืออีกประมาณ หมดเวลาแล้ว

โอเค ครับ จริงๆ หมดแล้วครับ

สรุปขั้นตอนการเซฟ Cache และแหล่งข้อมูลเพิ่มเติม32:02

เซฟครับ เร็วๆ แล้วกันฮะ มี question fetch answer ออกมาครับ แล้วเราก็ embed ตัว embed ตัวของ question เนาะ

นะครับ แล้วก็เซฟ 3 กับ 2 ลงไปใน database นะฮะ

ครับ เอิ่ม ทั้งหมดทั้งมวลครับ จริงๆ มี article อยู่ครับ ผมพึ่ง publish กับ MongoDB Developer Center นะครับ เผื่อว่าอยากลองไปลองทำกันดูนะครับ ก็สแกนตรงนี้ได้ครับ เดี๋ยวๆ แชร์อันนี้ให้ในกลุ่มด้วยครับ เอ่อ สไลด์ทุกอย่างก็แชร์ได้นะครับ ลองเอาไปเล่นดูเนาะ

โปรโมทงาน Javascript Bangkok และแจกของรางวัล32:33

นะครับ โอเค อันนี้อันนึงครับ อะ ขอโปรโมทนิดนึงครับ Javascript Bangkok จะจัดวันที่ 18-19 ตุลาคมนะครับ เดือนหน้านะครับ ก็เรามี keynote หลักๆ ก็คือเป็นคนที่สร้าง Elysia framework เนาะ เป็นคนไทยคนนึงชื่อคุณออมนะครับ อีกคนนึงก็คือเป็นตัว Svelte core contributor นะครับ บินตรงมาจากไหนนะริฟฟี่ สิงคโปร์นะครับ ถ้าบินตรงมาจากพะเยาก็ไม่ได้นะครับ บินตรงมาจากสิงคโปร์นะครับ อ่า ก็มาลองดูกันได้นะครับ แล้วก็มี session อื่นๆ อีกมากมายนะครับ มี code ลด 10% ให้ตรงนี้ครับ แล้วก็เราวันนี้เรามี code JetBrains 2 ตัวมาใช่ไหมครับ อ่า แจกเลยไหม แจกเลยครับ ใครรู้บ้างครับว่า function ในการหา similarity ของ MongoDB นี่แหละ ดีกว่า

เพราะว่า คนไม่ได้ลงอะ คือคนต้องเช็กอิน เออ ได้ๆ ใครยังไม่ได้เช็กอินก็เช็กได้ อะ เอาสักอันนึงแจกไปก่อนก็ได้ฮะ เพราะว่าผมอยากถามคำถามเดียวกัน ผมว่า ผมเคยตกสัมภาษณ์เพราะคำถามนี้นะครับ

ใครจำได้บ้างครับว่า function ในการ search similarity ของ MongoDB มีอะไรบ้างครับ ใน vector search ครับ ใครจำได้บ้างครับ อ่า ยกมือครับ อะ อะ ยกมือครับ

เชิญครับ Euclidean Cosine similarity Dot product อ๋อ ถูกต้องครับ ถูกต้องครับ นี่สัมภาษณ์ผ่านนะฮะ อันนี้ ไม่ตกแบบผมนะ นะครับ เชิญครับ เชิญครับ

นะครับ โอเคครับ ก็ เอ่อ ประมาณนี้ครับ มีคำถามอะไรก็เดี๋ยวมาคุยกันนะครับ แล้วก็เดี๋ยว เบรกก่อน เอ่อ เดี๋ยวเบรกก่อนสักแป๊บนึงแล้วกันนะครับ โอเคครับ ขอบคุณทุกคนมากครับผม