Auto-Embeddings ช่วยให้ง่ายขึ้นอย่างไร
ในโครงแบบ retrieval-augmented generation (RAG) ทั่วไป จะมีการสร้าง embeddings เมื่อแทรกเอกสาร สร้างใหม่เมื่อเนื้อหาเปลี่ยนแปลง และฝังเวกเตอร์ให้กับทุกคำค้นด้วยตนเอง Automated Embedding ทำให้การสร้างการค้นหาเชิงความหมายง่ายขึ้น เพราะ MongoDB Atlas จะจัดการการสร้าง embeddings การอัปเดต และการค้นหาให้แบบเนทีฟ และ Vector Search จะจัดเก็บเวกเตอร์ที่สร้างไว้ในคลัสเตอร์ของคุณ
MongoDB ทำการฝังอัตโนมัติอย่างไร
เมื่อสร้างดัชนี vector search ที่มีชนิด autoEmbed MongoDB จะสร้าง embeddings ให้กับฟิลด์ที่เลือก โดยใช้โมเดล VoyageAI รักษาการซิงค์เมื่อมีการเปลี่ยนแปลงเอกสาร และฝังเวกเตอร์ให้กับข้อความคำค้นในขณะค้นหาด้วยโมเดลเดียวกัน Embeddings ที่สร้างจะถูกจัดเก็บแบบอะซิงก์บนคลัสเตอร์ MongoDB ในฐานข้อมูลภายในแยกต่างหาก
ในบทแนะนำนี้ จะสร้างผู้ช่วยถาม-ตอบเอกสาร (Q&A Docs Assistant) ด้วย MongoDB auto-embeddings โดยใช้ Django MongoDB backend เพื่อกำหนดโมเดลและนำเข้าเอกสาร ใช้ MongoDB เพื่อค้นหา สร้างและซิงค์ embeddings อัตโนมัติ และให้ LLM ส่งคืนเอกสารตามผลลัพธ์ที่เรียกกลับมา
เมื่อจบบทนี้ จะได้ส่วนการดึงคืนข้อมูลของไปป์ไลน์ RAG: การค้นหาเชิงความหมายเหนือเอกสาร Federal Register ที่ auto-embeddings จะจัดการงานฝังเวกเตอร์ให้ทั้งหมด เอกสารถูกฝังเมื่อแทรก ถูกฝังใหม่เมื่อแก้ไข และคำค้นจะถูกฝังในขณะค้นหา โดยไม่ต้องเขียนโค้ดฝังเวกเตอร์เอง
มีสองวิธีในการทำตามบทแนะนำนี้
การตั้งค่า
ก่อนเริ่มต้น ตรวจสอบให้แน่ใจว่ามี:
เมื่อครบตามข้อกำหนดเบื้องต้นแล้ว ขั้นตอนถัดไปคือสร้างโฟลเดอร์โปรเจ็กต์
สร้างโปรเจ็กต์และสภาพแวดล้อมเสมือน
สร้างโฟลเดอร์ว่างสำหรับโปรเจ็กต์และสั่ง cd เข้าไป
mkdir regulations_qa
cd regulations_qaขับเคลื่อนโดย
นี่คือไดเรกทอรีรากของโปรเจ็กต์ สร้างและเปิดใช้งานสภาพแวดล้อมเสมือนที่นี่ หากยังไม่ได้ทำ:
python -m venv .venvขับเคลื่อนโดย
เพื่อเปิดใช้งานสภาพแวดล้อมเสมือนบน macOS หรือ Linux ให้รัน:
source .venv/bin/activateขับเคลื่อนโดย
บน Windows ให้รัน:
.venv\ Scripts\ activateขับเคลื่อนโดย
ติดตั้ง Dependencies
สร้างไฟล์ requirements.txt ที่รูทของโปรเจ็กต์ด้วยเนื้อหาต่อไปนี้:
# requirements.txt
django-mongodb-backend
python-dotenv
requests #to fetch documents from the Federal Register API.ขับเคลื่อนโดย
จากนั้นติดตั้งทั้งหมด:
pip install -r requirements.txtขับเคลื่อนโดย
สร้างโปรเจ็กต์ Django และแอป Django
จากไดเรกทอรีรากของโปรเจ็กต์ ให้รันคำสั่งต่อไปนี้เพื่อสร้างโปรเจ็กต์และแอป Django อันใหม่ เพิ่ม . ต่อท้ายในคำสั่ง startproject เพื่อบอกให้ Django ติดตั้งโปรเจ็กต์ในไดเรกทอรีปัจจุบัน แทนที่จะสร้างโฟลเดอร์ย่อยใหม่
django-admin startproject regulations_qa --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/6.0.x.zip . ขับเคลื่อนโดย
สร้างแอป documents
python manage.py startapp documentsขับเคลื่อนโดย
ลงทะเบียนแอปใน regulations_qa/settings.py โดยเพิ่มเข้าไปใน INSTALLED_APPS:
INSTALLED_APPS = [
'regulations_qa.apps.MongoAdminConfig' ,
'regulations_qa.apps.MongoAuthConfig' ,
'regulations_qa.apps.MongoContentTypesConfig' ,
'django.contrib.sessions' ,
'django.contrib.messages' ,
'django.contrib.staticfiles' ,
'django_mongodb_backend' ,
'documents' ,
] ขับเคลื่อนโดย
กำหนดค่าตัวแปรสภาพแวดล้อม
สร้างไฟล์ .env ที่รูทของโปรเจ็กต์ด้วยค่าของคุณเอง และเพิ่มลงใน .gitignore เพื่อไม่ให้ถูกคอมมิตเมื่อทำการ push
# .env
SECRET_KEY=[REPLACE_WITH_YOUR_SECRET_KEY]
MONGODB_URI="mongodb+srv://<username>:<password>@<cluster>.mongodb.net/?retryWrites=true&w=majority"
DB_NAME=regulations_qa
VECTOR_INDEX_NAME=autoembed_indexขับเคลื่อนโดย
ลบบรรทัด SECRET_KEY = '...' แบบฮาร์ดโค้ดออกจาก settings.py คัดลอกค่า SECRET_KEY ที่ Django สร้างไว้ใน settings.py ตอนรัน startproject แล้วนำไปใส่แทนในไฟล์ .env ค่านี้ถูกฮาร์ดโค้ดไว้ตามค่าเริ่มต้น เราจึงย้ายไปไว้ใน .env เพื่อกันไม่ให้เข้าเวอร์ชันคอนโทรล เนื่องจาก Django ใช้ค่านี้ในการลงลายเซ็นคุกกี้เซสชัน โทเคน CSRF และข้อมูลที่อ่อนไหวด้านความปลอดภัยอื่น ๆ
เปิด regulations_qa/settings.py และตรวจสอบให้มีสิ่งต่อไปนี้ทั้งหมด บรรทัด import และ load_dotenv() ไว้ด้านบน แทนที่นิยาม SECRET_KEY และ DATABASES เดิม และเพิ่มบรรทัด VECTOR_INDEX_NAME:
import os
from dotenv import load_dotenv
load_dotenv( )
SECRET_KEY = os. getenv( "SECRET_KEY" )
VECTOR_INDEX_NAME = os. getenv( "VECTOR_INDEX_NAME" )
DATABASES = {
'default' : {
'ENGINE' : 'django_mongodb_backend' ,
'HOST' : os. getenv( "MONGODB_URI" ) ,
'NAME' : os. getenv( "DB_NAME" ) ,
} ,
} ขับเคลื่อนโดย
สร้างโฟลเดอร์สำหรับ management commands
ถัดไป สร้างโฟลเดอร์ที่มีไฟล์ __init__.py ว่าง ๆ สำหรับ management commands เพราะ Django จะค้นพบคำสั่งกำหนดเองเฉพาะในแพ็กเกจ management/commands/
mkdir -p documents/management/commands documents/services && touch documents/management/__init__.py documents/management/commands/__init__.py documents/services/__init__.pyขับเคลื่อนโดย
แหล่งข้อมูล: เอกสาร Federal Register
ในบทแนะนำนี้ จะทำดัชนีเอกสารจาก Federal Register; สิ่งพิมพ์รายวันของรัฐบาลสหรัฐสำหรับกฎ ระเบียบที่เสนอ และประกาศต่าง ๆ แหล่งข้อมูลเป็น API สาธารณะที่มีเอกสารซึ่งมีชื่อเรื่องและบทคัดย่อสั้น ๆ แบบร้อยแก้ว จึงเหมาะกับการค้นหาเชิงความหมาย
เอกสารประกอบ API: https://www.federalregister.gov/developers/documentation/api/v1
ระเบียนมีฟิลด์อย่างเช่น title, type, abstract, document_number (ID เฉพาะ), publication_date, html_url และรายการ agencies
บางเอกสารมีค่า null ดังนั้นจะข้ามไว้
บทคัดย่อมีมาร์กอัปอย่าง <INF>2.5<INF> ใน “PM2.5” จึงจะลบแท็กก่อนบันทึก
ผลลัพธ์มีการแบ่งหน้า สูงสุด 100 ต่อคำขอ และแต่ละหน้ามี next_page_url (แบบคิวเซอร์) ให้ตามต่อ
ทดสอบเอ็นด์พอยต์ผ่านเชลล์
curl -g "https://www.federalregister.gov/api/v1/documents.json?conditions[agencies][]=environmental-protection-agency&per_page=2" ขับเคลื่อนโดย
หมายเหตุ: นี่คือข้อมูลสาธารณะของรัฐบาลสหรัฐที่ใช้เพื่อการสาธิต ไม่ใช่แหล่งข้อมูลทางกฎหมาย สำหรับการวิจัยด้านกฎหมาย โปรดใช้ฉบับทางการ
นำเข้าข้อมูล
เริ่มจากการสร้างโมเดลในไฟล์ models.py
from django. db import models
class Document ( models. Model) :
document_number = models. CharField( max_length= 32 , unique= True )
title = models. TextField( )
doc_type = models. CharField( max_length= 32 )
agency = models. CharField( max_length= 128 )
publication_date = models. DateField( )
abstract = models. TextField( )
source_url = models. URLField( max_length= 500 )
def __str__ ( self) :
return f" { self. document_number} : { self. title[ : 60] } " ขับเคลื่อนโดย
ถัดไป สร้างและรัน migrations
python manage.py makemigrations documents
python manage.py migrateขับเคลื่อนโดย
ต่อไป มาที่ส่วนการนำเข้า
import re
import time
import requests
from django. core. management. base import BaseCommand
from documents. models import Document
API_URL = "https://www.federalregister.gov/api/v1/documents.json"
TAG_PATTERN = re. compile ( r"<[^>]+>" )
class Command ( BaseCommand) :
help = "Load Federal Register documents into MongoDB."
def add_arguments ( self, parser) :
parser. add_argument( "--agency" , default= "environmental-protection-agency" )
parser. add_argument( "--limit" , type = int , default= 300 )
def handle ( self, * args, ** options) :
params = [
( "conditions[agencies][]" , options[ "agency" ] ) ,
( "conditions[type][]" , "RULE" ) ,
( "conditions[type][]" , "PRORULE" ) ,
( "per_page" , "100" ) ,
]
headers = { "User-Agent" : "regulations-qa-tutorial" }
url, processed = API_URL, 0
while url and processed < options[ "limit" ] :
response = requests. get(
url,
params= params if url == API_URL else None ,
headers= headers,
timeout= 30 ,
)
response. raise_for_status( )
page = response. json( )
for item in page[ "results" ] :
abstract = TAG_PATTERN. sub( "" , item. get( "abstract" ) or "" ) . strip( )
if not abstract:
continue
agencies = item. get( "agencies" ) or [ { } ]
Document. objects. update_or_create(
document_number= item[ "document_number" ] ,
defaults= {
"title" : TAG_PATTERN. sub( "" , item[ "title" ] ) ,
"doc_type" : item[ "type" ] ,
"agency" : agencies[ 0 ] . get( "name" , "" ) ,
"publication_date" : item[ "publication_date" ] ,
"abstract" : abstract,
"source_url" : item[ "html_url" ] ,
} ,
)
processed += 1
if processed >= options[ "limit" ] :
break
url = page. get( "next_page_url" )
time. sleep( 1 )
self. stdout. write( f"Documents in database: { Document. objects. count( ) } " ) ขับเคลื่อนโดย
รันคำสั่ง:
python manage.py ingest_federal_register --limit 100 ขับเคลื่อนโดย
สามารถยืนยันการนำเข้าได้ใน MongoDB Atlas UI:
กำหนด Auto-Embed Index
ดัชนี vector search จะบอก MongoDB ว่าจะทำ embeddings กับฟิลด์ใด และระบุว่าจะใช้โมเดลใด หลังจากนั้น MongoDB จะสร้างและจัดเก็บ embeddings โดยอัตโนมัติ
ใน Atlas UI เปิดคลัสเตอร์ ไปที่ Search & Vector Search แล้วคลิก Create Search Index
เลือก Vector Search เป็นชนิดการค้นหา และเลือก Automated Embedding เป็นวิธีตั้งค่าข้อมูลเวกเตอร์
เลือกตัวแก้ไข JSON เลือกฐานข้อมูลของคุณและคอลเลกชัน documents_document และตั้งชื่อลิงก์ดัชนีเป็น autoembed_index (ชื่อต้องตรงกับ VECTOR_INDEX_NAME ในไฟล์ .env) จากนั้นวางคำจำกัดความนี้:
{
"fields" : [
{
"type" : "autoEmbed" ,
"modality" : "text" ,
"path" : "abstract" ,
"model" : "voyage-4-lite"
}
]
} ขับเคลื่อนโดย
ตรวจทานคำจำกัดความ จากนั้นสร้างดัชนี
รอจนกว่าสถานะดัชนีจะแสดงว่าพร้อมให้ค้นหา ขณะที่กำลังสร้าง embeddings อยู่เบื้องหลัง
ค้นหาด้วยข้อความธรรมดา
สำหรับ auto-embeddings จะใช้สเตจ $vectorSearch พร้อมคำค้นเป็นข้อความธรรมดา และฝังคำถามด้วยโมเดลเดียวกับที่ดัชนีใช้ ดังนั้นจึงไม่ต้องมีการเรียกฝังเวกเตอร์ในโค้ดของเรา
เพื่อทำสิ่งนี้ จะสร้างมอดูลบริการ
from functools import lru_cache
from django. conf import settings
from pymongo import MongoClient
from documents. models import Document
DEFAULT_LIMIT = 5
@lru_cache ( maxsize= 1 )
def _get_client ( ) :
return MongoClient( settings. DATABASES[ "default" ] [ "HOST" ] )
def _get_collection ( ) :
db_name = settings. DATABASES[ "default" ] [ "NAME" ]
return _get_client( ) [ db_name] [ Document. _meta. db_table]
def _get_index_name ( ) :
index_name = settings. VECTOR_INDEX_NAME
if not index_name:
raise ValueError( "VECTOR_INDEX_NAME is not set. Add it to your .env file." )
return index_name
def semantic_search ( question: str , limit: int = DEFAULT_LIMIT) - > list :
"""Search with a plain-text question.
There is no query vector to pass in: MongoDB embeds the question
with the index's model.
"""
pipeline = [
{
"$vectorSearch" : {
"index" : _get_index_name( ) ,
"path" : "abstract" ,
"query" : question,
"numCandidates" : limit * 20 ,
"limit" : limit,
}
} ,
{
"$project" : {
"_id" : 0 ,
"document_number" : 1 ,
"title" : 1 ,
"abstract" : 1 ,
"source_url" : 1 ,
"score" : { "$meta" : "vectorSearchScore" } ,
}
} ,
]
return list ( _get_collection( ) . aggregate( pipeline) ) ขับเคลื่อนโดย
_get_client() สร้างการเชื่อมต่อกับ MongoDB หนึ่งครั้งและนำกลับมาใช้ซ้ำ lru_cache จะจำผลลัพธ์ของการเรียกครั้งแรกไว้ ทำให้ทุกการค้นหาใช้ไคลเอนต์เดียวกัน แทนการเปิดการเชื่อมต่อใหม่ทุกครั้ง
_get_collection() เลือกฐานข้อมูล regulations_qa และคอลเลกชัน documents_document โดยใช้การตั้งค่าเดียวกับที่ Django ใช้
_get_index_name() อ่านชื่อตัวดัชนีจาก settings และให้ข้อผิดพลาดที่ชัดเจนหากไม่มีค่า
semantic_search() ส่งคำถามเป็นข้อความในฟิลด์ query สเตจที่สองจะตัดแต่งผลลัพธ์ให้เหลือฟิลด์ที่ต้องการ และเพิ่มคะแนนความคล้ายคลึง
จากนั้นเพิ่มตัวช่วยสำหรับค้นหาเอกสาร:
from django. core. management. base import BaseCommand
from documents. services. search_service import semantic_search
class Command ( BaseCommand) :
help = "Run a plain-text search."
def add_arguments ( self, parser) :
parser. add_argument( "question" )
def handle ( self, * args, ** options) :
for hit in semantic_search( options[ "question" ] ) :
self. stdout. write(
f" { hit[ 'score' ] : .3f } { hit[ 'document_number' ] } { hit[ 'title' ] [ : 80] } "
) ขับเคลื่อนโดย
ทดสอบโดยรัน:
python manage.py search_docs "limits on pollution from factories" ขับเคลื่อนโดย
ในตัวอย่าง จะเลือกคำถามที่ไม่ได้มีคีย์เวิร์ดร่วมกับบทคัดย่อ คำถามอย่าง “limits on pollution from factories” ควรดึงเอกสารเกี่ยวกับมาตรฐานการปล่อยมลพิษ
หมายเหตุ: บนคลัสเตอร์ฟรี (M0) ที่ไม่ได้ผูกวิธีการชำระเงิน การฝังเวกเตอร์สำหรับคำค้นอาจถูกจำกัดอัตรา
เดโม: แก้ไขเอกสารและดูการรีซิงค์
สำหรับเดโม สามารถใช้ Search Tester ใน MongoDB Atlas ซึ่งผูกกับ autoembed_index ที่สร้างไว้ก่อนหน้านี้บนคอลเลกชัน regulations_qa.documents_document หรือจะใช้เชลล์ Python ก็ได้
ขั้นตอนที่ 1: ค้นหาผ่าน MongoDB Atlas และเชลล์
เพื่อทดสอบใน MongoDB Atlas UI ให้ป้อนคำค้นนี้:
which states need to clean up their airขับเคลื่อนโดย
เพื่อลองผ่านเชลล์:
เปิดเชลล์ด้วย python manage.py shell แล้วรัน:
from documents. models import Document
from documents. services. search_service import semantic_search
Q = "which states need to clean up their air"
hits = semantic_search( Q, limit= 10 )
print ( "\n" . join( f" { i} { h[ 'score' ] : .3f } { h[ 'document_number' ] } { h[ 'title' ] [ : 70] } " for i, h in enumerate ( hits, 1 ) ) ) ขับเคลื่อนโดย
ผลลัพธ์ควรเหมือนกับที่เห็นผ่าน GUI
ขั้นตอนที่ 2: แก้ไขเอกสาร
target = hits[ - 1 ]
doc = Document. objects. get( document_number= target[ "document_number" ] )
original = doc. abstract
doc. abstract = original + " This action also identifies which states and areas must clean up their air to meet health-based standards."
doc. save( )
print ( target[ "document_number" ] , "edited" ) ขับเคลื่อนโดย
ขั้นตอนที่ 3: ค้นหาอีกครั้ง
Auto-embeddings ถูกสร้างแบบอะซิงก์ รอ 30–60 วินาที แล้วรันคำค้นเดิมอีกครั้ง:
hits = semantic_search( Q, limit= 10 )
print ( "\n" . join( f" { i} { h[ 'score' ] : .3f } { h[ 'document_number' ] } { h[ 'title' ] [ : 70] } " for i, h in enumerate ( hits, 1 ) ) ) ขับเคลื่อนโดย
ตอนนี้ควรเห็นว่าเอกสารถูกแก้ไขมีอันดับสูงขึ้นกว่าเดิม
รันคำค้นเดียวกันใน Search Tester เพื่อดูผลลัพธ์ผ่าน GUI
ที่เกิดขึ้นคือ MongoDB ตรวจพบว่าฟิลด์ที่ทำดัชนีมีการเปลี่ยนแปลงและสร้าง embedding ของเอกสารนั้นใหม่ ทำให้เอกสาร 2026-16515 ซึ่งเดิมอยู่อันดับที่ 10 ในตัวอย่าง ถูกจัดอันดับสูงขึ้นมาอยู่อันดับที่ 5 หลังการแก้ไขและซิงค์
สรุป
ขอแสดงความยินดีที่มาถึงจุดนี้! ตอนนี้มีผู้ช่วยถาม-ตอบสำหรับเอกสาร โดยใช้ข้อมูลที่ MongoDB จัดการเวิร์กโฟลว์การฝังเวกเตอร์ให้ทั้งหมด ทำได้ตามขั้นตอนต่อไปนี้:
Insert: โหลดเอกสารผ่าน Django ORM
Index: กำหนดดัชนีเพียงตัวเดียว สร้างใน Atlas UI ระบุฟิลด์และโมเดล
Query: ถามด้วยข้อความธรรมดาผ่านบริการขนาดเล็ก โดยไม่ต้องมีการเรียกฝังเวกเตอร์แยกต่างหาก
Edit: การแก้ไขฟิลด์ที่ทำดัชนีจะถูกซิงค์ใหม่ได้ โดยไม่ต้องมีสคริปต์ฝังใหม่
หมายเหตุ: ข้อมูลในบทแนะนำนี้มาจาก Federal Register ซึ่งเผยแพร่เอกสารของรัฐบาลสหรัฐ บทแนะนำนี้เป็นอิสระ ไม่ได้สังกัด รับรอง หรือได้รับการสนับสนุนจาก Federal Register
แหล่งอ้างอิง
Auto-Embeddings ช่วยให้ง่ายขึ้นอย่างไร
ในโครงแบบ retrieval-augmented generation (RAG) ทั่วไป จะมีการสร้าง embeddings เมื่อแทรกเอกสาร สร้างใหม่เมื่อเนื้อหาเปลี่ยนแปลง และฝังเวกเตอร์ให้กับทุกคำค้นด้วยตนเอง Automated Embedding ทำให้การสร้างการค้นหาเชิงความหมายง่ายขึ้น เพราะ MongoDB Atlas จะจัดการการสร้าง embeddings การอัปเดต และการค้นหาให้แบบเนทีฟ และ Vector Search จะจัดเก็บเวกเตอร์ที่สร้างไว้ในคลัสเตอร์ของคุณ
MongoDB ทำการฝังอัตโนมัติอย่างไร
เมื่อสร้างดัชนี vector search ที่มีชนิด
autoEmbedMongoDB จะสร้าง embeddings ให้กับฟิลด์ที่เลือก โดยใช้โมเดลVoyageAIรักษาการซิงค์เมื่อมีการเปลี่ยนแปลงเอกสาร และฝังเวกเตอร์ให้กับข้อความคำค้นในขณะค้นหาด้วยโมเดลเดียวกัน Embeddings ที่สร้างจะถูกจัดเก็บแบบอะซิงก์บนคลัสเตอร์ MongoDB ในฐานข้อมูลภายในแยกต่างหากในบทแนะนำนี้ จะสร้างผู้ช่วยถาม-ตอบเอกสาร (Q&A Docs Assistant) ด้วย MongoDB auto-embeddings โดยใช้ Django MongoDB backend เพื่อกำหนดโมเดลและนำเข้าเอกสาร ใช้ MongoDB เพื่อค้นหา สร้างและซิงค์ embeddings อัตโนมัติ และให้ LLM ส่งคืนเอกสารตามผลลัพธ์ที่เรียกกลับมา
เมื่อจบบทนี้ จะได้ส่วนการดึงคืนข้อมูลของไปป์ไลน์ RAG: การค้นหาเชิงความหมายเหนือเอกสาร Federal Register ที่ auto-embeddings จะจัดการงานฝังเวกเตอร์ให้ทั้งหมด เอกสารถูกฝังเมื่อแทรก ถูกฝังใหม่เมื่อแก้ไข และคำค้นจะถูกฝังในขณะค้นหา โดยไม่ต้องเขียนโค้ดฝังเวกเตอร์เอง
มีสองวิธีในการทำตามบทแนะนำนี้
การตั้งค่า
ก่อนเริ่มต้น ตรวจสอบให้แน่ใจว่ามี:
เมื่อครบตามข้อกำหนดเบื้องต้นแล้ว ขั้นตอนถัดไปคือสร้างโฟลเดอร์โปรเจ็กต์
สร้างโปรเจ็กต์และสภาพแวดล้อมเสมือน
สร้างโฟลเดอร์ว่างสำหรับโปรเจ็กต์และสั่ง
cdเข้าไปนี่คือไดเรกทอรีรากของโปรเจ็กต์ สร้างและเปิดใช้งานสภาพแวดล้อมเสมือนที่นี่ หากยังไม่ได้ทำ:
เพื่อเปิดใช้งานสภาพแวดล้อมเสมือนบน macOS หรือ Linux ให้รัน:
บน Windows ให้รัน:
ติดตั้ง Dependencies
สร้างไฟล์
requirements.txtที่รูทของโปรเจ็กต์ด้วยเนื้อหาต่อไปนี้:จากนั้นติดตั้งทั้งหมด:
สร้างโปรเจ็กต์ Django และแอป Django
จากไดเรกทอรีรากของโปรเจ็กต์ ให้รันคำสั่งต่อไปนี้เพื่อสร้างโปรเจ็กต์และแอป Django อันใหม่ เพิ่ม
.ต่อท้ายในคำสั่งstartprojectเพื่อบอกให้ Django ติดตั้งโปรเจ็กต์ในไดเรกทอรีปัจจุบัน แทนที่จะสร้างโฟลเดอร์ย่อยใหม่สร้างแอป
documentsลงทะเบียนแอปใน
regulations_qa/settings.pyโดยเพิ่มเข้าไปในINSTALLED_APPS:กำหนดค่าตัวแปรสภาพแวดล้อม
สร้างไฟล์
.envที่รูทของโปรเจ็กต์ด้วยค่าของคุณเอง และเพิ่มลงใน.gitignoreเพื่อไม่ให้ถูกคอมมิตเมื่อทำการ pushลบบรรทัด
SECRET_KEY = '...'แบบฮาร์ดโค้ดออกจากsettings.pyคัดลอกค่า SECRET_KEY ที่ Django สร้างไว้ในsettings.pyตอนรันstartprojectแล้วนำไปใส่แทนในไฟล์.envค่านี้ถูกฮาร์ดโค้ดไว้ตามค่าเริ่มต้น เราจึงย้ายไปไว้ใน.envเพื่อกันไม่ให้เข้าเวอร์ชันคอนโทรล เนื่องจาก Django ใช้ค่านี้ในการลงลายเซ็นคุกกี้เซสชัน โทเคน CSRF และข้อมูลที่อ่อนไหวด้านความปลอดภัยอื่น ๆเปิด
regulations_qa/settings.pyและตรวจสอบให้มีสิ่งต่อไปนี้ทั้งหมด บรรทัด import และload_dotenv()ไว้ด้านบน แทนที่นิยามSECRET_KEYและDATABASESเดิม และเพิ่มบรรทัดVECTOR_INDEX_NAME:สร้างโฟลเดอร์สำหรับ management commands
ถัดไป สร้างโฟลเดอร์ที่มีไฟล์
__init__.pyว่าง ๆ สำหรับ management commands เพราะ Django จะค้นพบคำสั่งกำหนดเองเฉพาะในแพ็กเกจmanagement/commands/แหล่งข้อมูล: เอกสาร Federal Register
ในบทแนะนำนี้ จะทำดัชนีเอกสารจาก Federal Register; สิ่งพิมพ์รายวันของรัฐบาลสหรัฐสำหรับกฎ ระเบียบที่เสนอ และประกาศต่าง ๆ แหล่งข้อมูลเป็น API สาธารณะที่มีเอกสารซึ่งมีชื่อเรื่องและบทคัดย่อสั้น ๆ แบบร้อยแก้ว จึงเหมาะกับการค้นหาเชิงความหมาย
เอกสารประกอบ API: https://www.federalregister.gov/developers/documentation/api/v1
ระเบียนมีฟิลด์อย่างเช่น
title,type,abstract,document_number(ID เฉพาะ),publication_date,html_urlและรายการagencies<INF>2.5<INF>ใน “PM2.5” จึงจะลบแท็กก่อนบันทึกnext_page_url(แบบคิวเซอร์) ให้ตามต่อทดสอบเอ็นด์พอยต์ผ่านเชลล์
หมายเหตุ: นี่คือข้อมูลสาธารณะของรัฐบาลสหรัฐที่ใช้เพื่อการสาธิต ไม่ใช่แหล่งข้อมูลทางกฎหมาย สำหรับการวิจัยด้านกฎหมาย โปรดใช้ฉบับทางการ
นำเข้าข้อมูล
เริ่มจากการสร้างโมเดลในไฟล์
models.pyถัดไป สร้างและรัน migrations
ต่อไป มาที่ส่วนการนำเข้า
รันคำสั่ง:
สามารถยืนยันการนำเข้าได้ใน MongoDB Atlas UI:
กำหนด Auto-Embed Index
ดัชนี vector search จะบอก MongoDB ว่าจะทำ embeddings กับฟิลด์ใด และระบุว่าจะใช้โมเดลใด หลังจากนั้น MongoDB จะสร้างและจัดเก็บ embeddings โดยอัตโนมัติ
documents_documentและตั้งชื่อลิงก์ดัชนีเป็นautoembed_index(ชื่อต้องตรงกับVECTOR_INDEX_NAMEในไฟล์.env) จากนั้นวางคำจำกัดความนี้:ตรวจทานคำจำกัดความ จากนั้นสร้างดัชนี
ค้นหาด้วยข้อความธรรมดา
สำหรับ auto-embeddings จะใช้สเตจ
$vectorSearchพร้อมคำค้นเป็นข้อความธรรมดา และฝังคำถามด้วยโมเดลเดียวกับที่ดัชนีใช้ ดังนั้นจึงไม่ต้องมีการเรียกฝังเวกเตอร์ในโค้ดของเราเพื่อทำสิ่งนี้ จะสร้างมอดูลบริการ
_get_client()สร้างการเชื่อมต่อกับ MongoDB หนึ่งครั้งและนำกลับมาใช้ซ้ำlru_cacheจะจำผลลัพธ์ของการเรียกครั้งแรกไว้ ทำให้ทุกการค้นหาใช้ไคลเอนต์เดียวกัน แทนการเปิดการเชื่อมต่อใหม่ทุกครั้ง_get_collection()เลือกฐานข้อมูลregulations_qaและคอลเลกชันdocuments_documentโดยใช้การตั้งค่าเดียวกับที่ Django ใช้_get_index_name()อ่านชื่อตัวดัชนีจาก settings และให้ข้อผิดพลาดที่ชัดเจนหากไม่มีค่าsemantic_search()ส่งคำถามเป็นข้อความในฟิลด์queryสเตจที่สองจะตัดแต่งผลลัพธ์ให้เหลือฟิลด์ที่ต้องการ และเพิ่มคะแนนความคล้ายคลึงจากนั้นเพิ่มตัวช่วยสำหรับค้นหาเอกสาร:
ทดสอบโดยรัน:
ในตัวอย่าง จะเลือกคำถามที่ไม่ได้มีคีย์เวิร์ดร่วมกับบทคัดย่อ คำถามอย่าง “limits on pollution from factories” ควรดึงเอกสารเกี่ยวกับมาตรฐานการปล่อยมลพิษ
หมายเหตุ: บนคลัสเตอร์ฟรี (M0) ที่ไม่ได้ผูกวิธีการชำระเงิน การฝังเวกเตอร์สำหรับคำค้นอาจถูกจำกัดอัตรา
เดโม: แก้ไขเอกสารและดูการรีซิงค์
สำหรับเดโม สามารถใช้
Search Testerใน MongoDB Atlas ซึ่งผูกกับautoembed_indexที่สร้างไว้ก่อนหน้านี้บนคอลเลกชันregulations_qa.documents_documentหรือจะใช้เชลล์ Python ก็ได้ขั้นตอนที่ 1: ค้นหาผ่าน MongoDB Atlas และเชลล์
เพื่อทดสอบใน MongoDB Atlas UI ให้ป้อนคำค้นนี้:
เพื่อลองผ่านเชลล์:
เปิดเชลล์ด้วย
python manage.py shellแล้วรัน:ผลลัพธ์ควรเหมือนกับที่เห็นผ่าน GUI
ขั้นตอนที่ 2: แก้ไขเอกสาร
ขั้นตอนที่ 3: ค้นหาอีกครั้ง
Auto-embeddings ถูกสร้างแบบอะซิงก์ รอ 30–60 วินาที แล้วรันคำค้นเดิมอีกครั้ง:
ตอนนี้ควรเห็นว่าเอกสารถูกแก้ไขมีอันดับสูงขึ้นกว่าเดิม
รันคำค้นเดียวกันใน Search Tester เพื่อดูผลลัพธ์ผ่าน GUI
ที่เกิดขึ้นคือ MongoDB ตรวจพบว่าฟิลด์ที่ทำดัชนีมีการเปลี่ยนแปลงและสร้าง embedding ของเอกสารนั้นใหม่ ทำให้เอกสาร
2026-16515ซึ่งเดิมอยู่อันดับที่ 10 ในตัวอย่าง ถูกจัดอันดับสูงขึ้นมาอยู่อันดับที่ 5 หลังการแก้ไขและซิงค์สรุป
ขอแสดงความยินดีที่มาถึงจุดนี้! ตอนนี้มีผู้ช่วยถาม-ตอบสำหรับเอกสาร โดยใช้ข้อมูลที่ MongoDB จัดการเวิร์กโฟลว์การฝังเวกเตอร์ให้ทั้งหมด ทำได้ตามขั้นตอนต่อไปนี้:
หมายเหตุ: ข้อมูลในบทแนะนำนี้มาจาก Federal Register ซึ่งเผยแพร่เอกสารของรัฐบาลสหรัฐ บทแนะนำนี้เป็นอิสระ ไม่ได้สังกัด รับรอง หรือได้รับการสนับสนุนจาก Federal Register
แหล่งอ้างอิง