I en typisk RAG-uppsättning (retrieval-augmented generation) genererar du embeddings när du lägger in ett dokument, återskapar dem när innehållet ändras och embed:ar varje fråga själv. Automated Embedding förenklar arbetet med att bygga semantisk sökning, eftersom MongoDB Atlas hanterar generering, uppdateringar och frågor inbyggt, och Vector Search lagrar genererade vektorembeddings i din kluster.
Hur MongoDB gör automatisk embedding
När ett vektorsökningsindex av typen autoEmbed skapas, genererar MongoDB embeddings för det valda fältet, använder modellen VoyageAI, håller dem synkade när dokumentet ändras och embed:ar frågetexten vid sökningstillfället med samma modell. De genererade embeddings lagras asynkront på MongoDB-klustret i en separat intern databas.
I den här handledningen bygger vi en Q&A-assistent för dokument med MongoDB auto-embeddings. Django MongoDB-backenden används för att definiera modeller och importera dokument, och MongoDB används för uppslagningar, för att generera och synka embeddings automatiskt, och LLM:et returnerar dokument baserat på de hämtade resultaten.
I slutet av den här handledningen har du byggt hämtningssteget i en RAG-pipeline: en semantisk sökning över Federal Register-dokument där auto-embeddings sköter embedding-arbetet åt dig. Dokument embed:as när du lägger in dem, embed:as på nytt när de ändras, och dina frågor embed:as vid sökningstillfället — allt utan att skriva embeddingskod.
Det finns två sätt att följa den här handledningen.
Från projektets rotkatalog, kör följande kommando för att skapa ett nytt Django-projekt och en app. Lägg till det avslutande . i kommandot startproject, vilket säger åt Django att installera projektet i den aktuella katalogen i stället för att skapa en ny underkatalog.
django-admin startproject regulations_qa --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/6.0.x.zip .Drivs av
Registrera appen i regulations_qa/settings.py genom att lägga till den i 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',]Drivs av
Konfigurera miljövariabler
Skapa en .env-fil i projektets rot med dina egna värden, och lista den i .gitignore så att den inte checkas in när du pushar.
# .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_indexDrivs av
Ta bort den ursprungliga hårdkodade raden SECRET_KEY = '...' från settings.py, kopiera värdet som Django genererade i settings.py när du körde startproject och ersätt det i din .env-fil. Det är hårdkodat där som standard, och vi flyttar det till .env för att hålla det utanför versionshanteringen, eftersom Django använder det för att signera sessionscookies, CSRF-token och annan säkerhetskänslig data.
Öppna regulations_qa/settings.py och säkerställ att den innehåller allt följande. Importerna och load_dotenv() ska ligga högst upp. Ersätt befintliga definitioner av SECRET_KEY och DATABASES, och lägg till raden 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"),},}Drivs av
Skapa mappar för management-kommandon
Nästa steg är att skapa mappar med tomma __init__.py-filer för management-kommandon, eftersom Django bara hittar egna kommandon i ett paket management/commands/.
mkdir-p documents/management/commands documents/services &&touch documents/management/__init__.py documents/management/commands/__init__.py documents/services/__init__.pyDrivs av
Datakällan: Federal Register-dokumenten
I den här handledningen indexerar vi dokument från Federal Register; USA:s dagliga publikation av regler, förslag till regler och meddelanden. Datakällan är ett offentligt API med dokument som har en titel och en kort textsammanfattning, vilket passar bra för semantisk sökning.
Poster har fält som title, type, abstract, document_number (ett unikt ID), publication_date, html_url och en lista agencies.
Vissa dokument innehåller null-värden, så vi utelämnar dem.
Abstracts innehåller markup som <INF>2.5<INF> i ”PM2.5”, så vi tar bort taggar innan vi sparar.
Resultat pagineras med upp till 100 per begäran, och varje sida har en next_page_url (kursbaserad) att följa.
Testa slutpunkten via shell
curl-g"https://www.federalregister.gov/api/v1/documents.json?conditions[agencies][]=environmental-protection-agency&per_page=2"Drivs av
Obs: Detta är offentlig amerikansk myndighetsdata som används för demonstration. Det är inte en juridisk källa; för juridisk forskning, använd den officiella utgåvan.
Importera data
Vi börjar med att skapa modeller i filen models.py.
python manage.py makemigrations documents
python manage.py migrateDrivs av
Sedan går vi vidare till importsteget.
# documents/management/commands/ingest_federal_register.pyimport 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"<[^>]+>")classCommand(BaseCommand):help="Load Federal Register documents into MongoDB."defadd_arguments(self, parser):
parser.add_argument("--agency", default="environmental-protection-agency")
parser.add_argument("--limit",type=int, default=300)defhandle(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,0while url and processed < options["limit"]:
response = requests.get(
url,
params=params if url == API_URL elseNone,
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()ifnot 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 +=1if processed >= options["limit"]:break
url = page.get("next_page_url")
time.sleep(1)
self.stdout.write(f"Documents in database: {Document.objects.count()}")Drivs av
Kör kommandot:
python manage.py ingest_federal_register --limit100Drivs av
Du kan bekräfta importen i MongoDB Atlas UI:
Definiera Auto-Embed-indexet
Vektorsökningsindexet talar om för MongoDB vilket fält som ska embed:as och anger vilken modell som ska användas. Därefter genererar och lagrar MongoDB embeddings automatiskt.
I Atlas UI, öppna ditt kluster, gå till Search & Vector Search och klicka på Create Search Index.
Välj Vector Search som söktyp och Automated Embedding som sätt att konfigurera din vektordata.
Välj JSON-redigeraren, välj din databas och samlingen documents_document, och namnge indexet autoembed_index (namnet måste matcha VECTOR_INDEX_NAME i din .env). Klistra in denna definition:
{"fields":[{"type":"autoEmbed","modality":"text","path":"abstract","model":"voyage-4-lite"}]}Drivs av
Granska definitionen och skapa sedan indexet.
Vänta tills indexstatus visar att det är redo att fråga, eftersom embeddings genereras i bakgrunden.
Fråga i klartext
För auto-embeddings använder vi steget $vectorSearch med en fråga i klartext och embed:ar frågan med samma modell som indexet använder, så det finns inget embedding-anrop i vår kod.
För att göra detta skapar vi en servicemodul.
# documents/services/search_service.pyfrom 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 itdef_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
ifnot index_name:raise ValueError("VECTOR_INDEX_NAME is not set. Add it to your .env file.")return index_name
defsemantic_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"},}},]returnlist(_get_collection().aggregate(pipeline))Drivs av
_get_client() skapar anslutningen till MongoDB en gång och återanvänder den. lru_cache minns resultatet av första anropet, så varje sökning delar en klient i stället för att öppna en ny anslutning varje gång.
_get_collection() väljer databasen regulations_qa och samlingen documents_document, med samma inställningar som Django använder.
_get_index_name() läser indexnamnet från inställningarna och ger ett tydligt fel om det saknas.
semantic_search() skickar frågan som text i fältet query. Det andra steget trimmar utdata till de fält vi behöver och lägger till likhetspoängen.
Sen lägger vi till en hjälpare för att söka i dokumenten:
# documents/management/commands/search_docs.pyfrom django.core.management.base import BaseCommand
from documents.services.search_service import semantic_search
classCommand(BaseCommand):help="Run a plain-text search."defadd_arguments(self, parser):
parser.add_argument("question")defhandle(self,*args,**options):for hit in semantic_search(options["question"]):
self.stdout.write(f"{hit['score']:.3f}{hit['document_number']}{hit['title'][:80]}")Drivs av
För att testa, kör nu:
python manage.py search_docs "limits on pollution from factories"Drivs av
I exemplet väljer vi frågor som inte delar nyckelord med abstracten. En fråga om ”limits on pollution from factories” bör hämta dokument om utsläppsstandarder.
Obs: På ett gratis (M0) kluster utan betalningsmetod kan embed:ingsförfrågningar för frågor hastighetsbegränsas.
Demo: Redigera ett dokument och se det synkas om
För demon kan vi antingen använda Search Tester i MongoDB Atlas, som är kopplad till autoembed_index vi skapade tidigare på samlingen regulations_qa.documents_document, eller Python-skalet.
Steg 1: Sök via MongoDB Atlas och skalet
För att testa detta i MongoDB Atlas UI, skriv in den här frågan:
Öppna skalet med python manage.py shell, kör sedan:
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 inenumerate(hits,1)))Drivs av
Utdata bör vara samma som vi såg via GUI:t.
Steg 2: Redigera dokumentet
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")Drivs av
Steg 3: Sök igen
Auto-embeddings genereras asynkront, så vänta 30–60 sekunder och kör sedan frågan igen:
hits = semantic_search(Q, limit=10)print("\n".join(f"{i}{h['score']:.3f}{h['document_number']}{h['title'][:70]}"for i, h inenumerate(hits,1)))Drivs av
Nu bör vi förvänta oss att det redigerade dokumentet rankas högre än tidigare.
Kör samma fråga i Search Tester för att se resultaten via GUI:t.
Vad som hände var att MongoDB noterade att det indexerade fältet ändrades och återskapade dokumentets embedding, så dokument 2026-16515, som var det 10:e dokumentet i urvalet, rankades högre och placerades på 5:e plats efter redigeringen och synkningen.
Sammanfattning
Grattis till att ha kommit hit! Vi har en Q&A-assistent för dokument med data där MongoDB hanterar embedding-flödet. Detta uppnåddes i följande steg:
Insert: dokument laddade via Django ORM
Index: en indexdefinition, skapad i Atlas UI, som anger fält och modell.
Query: frågor i klartext via en liten tjänst utan att lägga till ett separat embedding-anrop.
Edit: ändringar i det indexerade fältet synkas om utan något om-embedding-skript.
Obs: Data i denna handledning kommer från Federal Register, som publicerar dokument från USA:s myndigheter. Denna handledning är fristående och varken associerad med eller godkänd av Federal Register.
Vad Auto-Embeddings förenklar
I en typisk RAG-uppsättning (retrieval-augmented generation) genererar du embeddings när du lägger in ett dokument, återskapar dem när innehållet ändras och embed:ar varje fråga själv. Automated Embedding förenklar arbetet med att bygga semantisk sökning, eftersom MongoDB Atlas hanterar generering, uppdateringar och frågor inbyggt, och Vector Search lagrar genererade vektorembeddings i din kluster.
Hur MongoDB gör automatisk embedding
När ett vektorsökningsindex av typen
autoEmbedskapas, genererar MongoDB embeddings för det valda fältet, använder modellenVoyageAI, håller dem synkade när dokumentet ändras och embed:ar frågetexten vid sökningstillfället med samma modell. De genererade embeddings lagras asynkront på MongoDB-klustret i en separat intern databas.I den här handledningen bygger vi en Q&A-assistent för dokument med MongoDB auto-embeddings. Django MongoDB-backenden används för att definiera modeller och importera dokument, och MongoDB används för uppslagningar, för att generera och synka embeddings automatiskt, och LLM:et returnerar dokument baserat på de hämtade resultaten.
I slutet av den här handledningen har du byggt hämtningssteget i en RAG-pipeline: en semantisk sökning över Federal Register-dokument där auto-embeddings sköter embedding-arbetet åt dig. Dokument embed:as när du lägger in dem, embed:as på nytt när de ändras, och dina frågor embed:as vid sökningstillfället — allt utan att skriva embeddingskod.
Det finns två sätt att följa den här handledningen.
Förberedelser
Innan du börjar, se till att du har:
När dessa förutsättningar är på plats är nästa steg att skapa din projektmapp.
Skapa ett projekt och en virtuell miljö
Skapa en tom mapp för ditt projekt och kör
cdin i den.Detta är ditt projekts rotkatalog. Skapa och aktivera din virtuella miljö här om du inte redan gjort det:
För att aktivera den virtuella miljön på macOS eller Linux, kör:
På Windows, kör:
Installera beroenden
Skapa en fil
requirements.txti projektets rot med följande innehåll:Installera sedan allt:
Skapa Django-projekt och Django-app
Från projektets rotkatalog, kör följande kommando för att skapa ett nytt Django-projekt och en app. Lägg till det avslutande
.i kommandotstartproject, vilket säger åt Django att installera projektet i den aktuella katalogen i stället för att skapa en ny underkatalog.Skapa appen
documentsRegistrera appen i
regulations_qa/settings.pygenom att lägga till den iINSTALLED_APPS:Konfigurera miljövariabler
Skapa en
.env-fil i projektets rot med dina egna värden, och lista den i.gitignoreså att den inte checkas in när du pushar.Ta bort den ursprungliga hårdkodade raden
SECRET_KEY = '...'frånsettings.py, kopiera värdet som Django genererade isettings.pynär du kördestartprojectoch ersätt det i din.env-fil. Det är hårdkodat där som standard, och vi flyttar det till.envför att hålla det utanför versionshanteringen, eftersom Django använder det för att signera sessionscookies, CSRF-token och annan säkerhetskänslig data.Öppna
regulations_qa/settings.pyoch säkerställ att den innehåller allt följande. Importerna ochload_dotenv()ska ligga högst upp. Ersätt befintliga definitioner avSECRET_KEYochDATABASES, och lägg till radenVECTOR_INDEX_NAME:Skapa mappar för management-kommandon
Nästa steg är att skapa mappar med tomma
__init__.py-filer för management-kommandon, eftersom Django bara hittar egna kommandon i ett paketmanagement/commands/.Datakällan: Federal Register-dokumenten
I den här handledningen indexerar vi dokument från Federal Register; USA:s dagliga publikation av regler, förslag till regler och meddelanden. Datakällan är ett offentligt API med dokument som har en titel och en kort textsammanfattning, vilket passar bra för semantisk sökning.
API-dokumentation: https://www.federalregister.gov/developers/documentation/api/v1
Poster har fält som
title,type,abstract,document_number(ett unikt ID),publication_date,html_urloch en listaagencies.<INF>2.5<INF>i ”PM2.5”, så vi tar bort taggar innan vi sparar.next_page_url(kursbaserad) att följa.Testa slutpunkten via shell
Obs: Detta är offentlig amerikansk myndighetsdata som används för demonstration. Det är inte en juridisk källa; för juridisk forskning, använd den officiella utgåvan.
Importera data
Vi börjar med att skapa modeller i filen
models.py.Nästa steg är att skapa och köra migrationer.
Sedan går vi vidare till importsteget.
Kör kommandot:
Du kan bekräfta importen i MongoDB Atlas UI:
Definiera Auto-Embed-indexet
Vektorsökningsindexet talar om för MongoDB vilket fält som ska embed:as och anger vilken modell som ska användas. Därefter genererar och lagrar MongoDB embeddings automatiskt.
documents_document, och namnge indexetautoembed_index(namnet måste matchaVECTOR_INDEX_NAMEi din.env). Klistra in denna definition:Granska definitionen och skapa sedan indexet.
Fråga i klartext
För auto-embeddings använder vi steget
$vectorSearchmed en fråga i klartext och embed:ar frågan med samma modell som indexet använder, så det finns inget embedding-anrop i vår kod.För att göra detta skapar vi en servicemodul.
_get_client()skapar anslutningen till MongoDB en gång och återanvänder den.lru_cacheminns resultatet av första anropet, så varje sökning delar en klient i stället för att öppna en ny anslutning varje gång._get_collection()väljer databasenregulations_qaoch samlingendocuments_document, med samma inställningar som Django använder._get_index_name()läser indexnamnet från inställningarna och ger ett tydligt fel om det saknas.semantic_search()skickar frågan som text i fältetquery. Det andra steget trimmar utdata till de fält vi behöver och lägger till likhetspoängen.Sen lägger vi till en hjälpare för att söka i dokumenten:
För att testa, kör nu:
I exemplet väljer vi frågor som inte delar nyckelord med abstracten. En fråga om ”limits on pollution from factories” bör hämta dokument om utsläppsstandarder.
Obs: På ett gratis (M0) kluster utan betalningsmetod kan embed:ingsförfrågningar för frågor hastighetsbegränsas.
Demo: Redigera ett dokument och se det synkas om
För demon kan vi antingen använda
Search Testeri MongoDB Atlas, som är kopplad tillautoembed_indexvi skapade tidigare på samlingenregulations_qa.documents_document, eller Python-skalet.Steg 1: Sök via MongoDB Atlas och skalet
För att testa detta i MongoDB Atlas UI, skriv in den här frågan:
För att testa via skalet:
Öppna skalet med
python manage.py shell, kör sedan:Utdata bör vara samma som vi såg via GUI:t.
Steg 2: Redigera dokumentet
Steg 3: Sök igen
Auto-embeddings genereras asynkront, så vänta 30–60 sekunder och kör sedan frågan igen:
Nu bör vi förvänta oss att det redigerade dokumentet rankas högre än tidigare.
Kör samma fråga i Search Tester för att se resultaten via GUI:t.
Vad som hände var att MongoDB noterade att det indexerade fältet ändrades och återskapade dokumentets embedding, så dokument
2026-16515, som var det 10:e dokumentet i urvalet, rankades högre och placerades på 5:e plats efter redigeringen och synkningen.Sammanfattning
Grattis till att ha kommit hit! Vi har en Q&A-assistent för dokument med data där MongoDB hanterar embedding-flödet. Detta uppnåddes i följande steg:
Obs: Data i denna handledning kommer från Federal Register, som publicerar dokument från USA:s myndigheter. Denna handledning är fristående och varken associerad med eller godkänd av Federal Register.
Referenser