ข้ามไปยังเนื้อหาหลัก

สร้างผู้ช่วยถาม-ตอบ (Q&A) ใน Django ด้วย MongoDB Auto-Embeddings

สร้างการค้นหาเชิงความหมายใน Django ด้วย MongoDB auto-embeddings: ไม่ต้องเขียนโค้ดฝังเวกเตอร์ รีซิงค์อัตโนมัติเมื่อเอกสารถูกแก้ไข และค้นหาด้วยข้อความธรรมดา
· 7 นาที อ่าน

สำรวจด้วย AI

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 จะจัดการงานฝังเวกเตอร์ให้ทั้งหมด เอกสารถูกฝังเมื่อแทรก ถูกฝังใหม่เมื่อแก้ไข และคำค้นจะถูกฝังในขณะค้นหา โดยไม่ต้องเขียนโค้ดฝังเวกเตอร์เอง

มีสองวิธีในการทำตามบทแนะนำนี้

  • ตัวเลือก A: โคลนรีโป GitHub ที่มีโค้ดฉบับสมบูรณ์จากบทแนะนำนี้ ตั้งค่าตาม README ของรีโป และลองสำรวจเอง ลิงก์ไปยังโปรเจ็กต์ GitHub: https://github.com/mongodb-developer/django-mongodb-regulations-qa
  • ตัวเลือก B: สร้างโปรเจ็กต์ตั้งแต่ต้นโดยทำตามขั้นตอนด้านล่าง

การตั้งค่า

ก่อนเริ่มต้น ตรวจสอบให้แน่ใจว่ามี:

เมื่อครบตามข้อกำหนดเบื้องต้นแล้ว ขั้นตอนถัดไปคือสร้างโฟลเดอร์โปรเจ็กต์

สร้างโปรเจ็กต์และสภาพแวดล้อมเสมือน

สร้างโฟลเดอร์ว่างสำหรับโปรเจ็กต์และสั่ง 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

# documents/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

ต่อไป มาที่ส่วนการนำเข้า

# documents/management/commands/ingest_federal_register.py

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:

MongoDB Atlas Data Explorer แสดงเอกสาร Federal Register จำนวน 100 ฉบับในคอลเลกชัน regulations_qa.documents_document

กำหนด Auto-Embed Index

ดัชนี vector search จะบอก MongoDB ว่าจะทำ embeddings กับฟิลด์ใด และระบุว่าจะใช้โมเดลใด หลังจากนั้น MongoDB จะสร้างและจัดเก็บ embeddings โดยอัตโนมัติ

  1. ใน Atlas UI เปิดคลัสเตอร์ ไปที่ Search & Vector Search แล้วคลิก Create Search Index

หน้า Search & Vector Search ใน MongoDB Atlas พร้อมปุ่ม Create Search Index

  1. เลือก Vector Search เป็นชนิดการค้นหา และเลือก Automated Embedding เป็นวิธีตั้งค่าข้อมูลเวกเตอร์

การตั้งค่าดัชนีของ Atlas โดยเลือก Vector Search และ Automated Embedding

  1. เลือกตัวแก้ไข JSON เลือกฐานข้อมูลของคุณและคอลเลกชัน documents_document และตั้งชื่อลิงก์ดัชนีเป็น autoembed_index (ชื่อต้องตรงกับ VECTOR_INDEX_NAME ในไฟล์ .env) จากนั้นวางคำจำกัดความนี้:
{
  "fields": [
    {
      "type": "autoEmbed",
      "modality": "text",
      "path": "abstract",
      "model": "voyage-4-lite"
    }
  ]
}

ตัวแก้ไข JSON ของ Atlas พร้อมคำจำกัดความดัชนี autoEmbed สำหรับฟิลด์ abstract โดยใช้ voyage-4-lite

ตรวจทานคำจำกัดความ จากนั้นสร้างดัชนี

ขั้นตอน Review สำหรับดัชนีค้นหาเวกเตอร์ autoembed_index บน regulations_qa.documents_document

  1. รอจนกว่าสถานะดัชนีจะแสดงว่าพร้อมให้ค้นหา ขณะที่กำลังสร้าง embeddings อยู่เบื้องหลัง

รายการ Search & Vector Search ของ Atlas แสดง autoembed_index มีสถานะ READY และ queryable

ค้นหาด้วยข้อความธรรมดา

สำหรับ auto-embeddings จะใช้สเตจ $vectorSearch พร้อมคำค้นเป็นข้อความธรรมดา และฝังคำถามด้วยโมเดลเดียวกับที่ดัชนีใช้ ดังนั้นจึงไม่ต้องมีการเรียกฝังเวกเตอร์ในโค้ดของเรา

เพื่อทำสิ่งนี้ จะสร้างมอดูลบริการ

# documents/services/search_service.py
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)  # create the client once and reuse it
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 สเตจที่สองจะตัดแต่งผลลัพธ์ให้เหลือฟิลด์ที่ต้องการ และเพิ่มคะแนนความคล้ายคลึง

จากนั้นเพิ่มตัวช่วยสำหรับค้นหาเอกสาร:

# documents/management/commands/search_docs.py
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 ก็ได้

Atlas Search Tester สำหรับ autoembed_index บน regulations_qa.documents_document

ขั้นตอนที่ 1: ค้นหาผ่าน MongoDB Atlas และเชลล์

เพื่อทดสอบใน MongoDB Atlas UI ให้ป้อนคำค้นนี้:

which states need to clean up their air

ผลลัพธ์ Search Tester สำหรับคำค้น 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)))

เอาต์พุตจากเชลล์ Django แสดง 10 อันดับผลการค้นหาเชิงความหมายและคะแนน

ผลลัพธ์ควรเหมือนกับที่เห็นผ่าน 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")

เชลล์ Django เพิ่มประโยคลงท้ายในบทคัดย่อของเอกสาร 2026-16515 และบันทึก

ขั้นตอนที่ 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)))

ผลการค้นหาหลังแก้ไข โดยเอกสาร 2026-16515 ขยับจากอันดับ 10 มาอยู่อันดับ 5

ตอนนี้ควรเห็นว่าเอกสารถูกแก้ไขมีอันดับสูงขึ้นกว่าเดิม

รันคำค้นเดียวกันใน Search Tester เพื่อดูผลลัพธ์ผ่าน GUI

ที่เกิดขึ้นคือ MongoDB ตรวจพบว่าฟิลด์ที่ทำดัชนีมีการเปลี่ยนแปลงและสร้าง embedding ของเอกสารนั้นใหม่ ทำให้เอกสาร 2026-16515 ซึ่งเดิมอยู่อันดับที่ 10 ในตัวอย่าง ถูกจัดอันดับสูงขึ้นมาอยู่อันดับที่ 5 หลังการแก้ไขและซิงค์

สรุป

ขอแสดงความยินดีที่มาถึงจุดนี้! ตอนนี้มีผู้ช่วยถาม-ตอบสำหรับเอกสาร โดยใช้ข้อมูลที่ MongoDB จัดการเวิร์กโฟลว์การฝังเวกเตอร์ให้ทั้งหมด ทำได้ตามขั้นตอนต่อไปนี้:

  • Insert: โหลดเอกสารผ่าน Django ORM
  • Index: กำหนดดัชนีเพียงตัวเดียว สร้างใน Atlas UI ระบุฟิลด์และโมเดล
  • Query: ถามด้วยข้อความธรรมดาผ่านบริการขนาดเล็ก โดยไม่ต้องมีการเรียกฝังเวกเตอร์แยกต่างหาก
  • Edit: การแก้ไขฟิลด์ที่ทำดัชนีจะถูกซิงค์ใหม่ได้ โดยไม่ต้องมีสคริปต์ฝังใหม่

หมายเหตุ: ข้อมูลในบทแนะนำนี้มาจาก Federal Register ซึ่งเผยแพร่เอกสารของรัฐบาลสหรัฐ บทแนะนำนี้เป็นอิสระ ไม่ได้สังกัด รับรอง หรือได้รับการสนับสนุนจาก Federal Register

แหล่งอ้างอิง

หัวข้อ