Xây dựng Ứng dụng Công thức Nấu ăn AI Siêu Thông Minh với Django, MongoDB và Tìm kiếm Vector

Lê Lân

06/07/2025

Django MongoDB Backend: Tích Hợp MongoDB Với Django Cho Ứng Dụng Web Hiện Đại

Mở Đầu

Trong thế giới phát triển web Python, Django được xem là một framework hàng đầu với cộng đồng phát triển sôi động và hiệu suất cao.

Django đã có mặt từ lâu như một trong những framework để xây dựng ứng dụng web mạnh mẽ và an toàn. Với mô hình MVT (Model-View-Template), Django giúp lập trình viên phát triển nhanh chóng, có cấu trúc rõ ràng và dễ dàng mở rộng. Tuy nhiên, điểm mới nổi bật hiện nay chính là sự tích hợp sâu rộng giữa Django và MongoDB, cơ sở dữ liệu NoSQL phổ biến với khả năng lưu trữ tài liệu linh hoạt và hỗ trợ vector search cho ứng dụng AI.

Bài viết này sẽ hướng dẫn bạn từng bước từ việc cài đặt môi trường, tạo dự án Django sử dụng MongoDB, xử lý dữ liệu với mô hình MongoDB đặc trưng, đến việc xây dựng các chức năng tìm kiếm nâng cao bằng vector search, và tích hợp mô hình ngôn ngữ lớn (LLM) tạo trải nghiệm người dùng cá nhân hóa.

Các Khái Niệm Cơ Bản Về Django Và MongoDB

Django Framework: Tổng Quan

Django là framework Python mã nguồn mở dùng để xây dựng các ứng dụng web chạy trên server. Framework này tuân theo mô hình Model-View-Template, có:

Model: Mô hình dữ liệu, định nghĩa cách tương tác với cơ sở dữ liệu.

View: Xử lý logic ứng dụng dựa trên URL yêu cầu.

Template: Giao diện người dùng dưới dạng HTML với khả năng nhúng dữ liệu động.

Django nổi bật với nguyên tắc “batteries included” - nghĩa là framework cung cấp sẵn rất nhiều công cụ cần thiết để phát triển nhanh, như admin site tự động, ORM mạnh mẽ, hệ thống routing, và nhiều plugin hỗ trợ.

MongoDB: Cơ sở dữ liệu tài liệu NoSQL

MongoDB lưu trữ dữ liệu dưới dạng tài liệu JSON linh hoạt (BSON) làm tăng tính mở rộng, dễ dàng thao tác trên các đối tượng phức tạp, như mảng, tài liệu lồng nhau hay vector embedding phục vụ AI. MongoDB đặc biệt hỗ trợ các chỉ số chuyên dụng cho tìm kiếm văn bản và vector search, hoàn hảo cho ứng dụng thế hệ mới.

Lý Do Tích Hợp MongoDB Với Django

Trước đây, Django chủ yếu tương tác với các cơ sở dữ liệu quan hệ. Việc tích hợp MongoDB qua Django MongoDB Backend (DMB) ra đời nhằm:

Giữ nguyên ưu điểm của Django trong việc phát triển nhanh, có cấu trúc, đồng thời tận dụng sức mạnh lưu trữ và truy vấn tài liệu linh hoạt của MongoDB.

Hỗ trợ tính năng vector search giúp xây dựng các ứng dụng AI cá nhân hóa, ví dụ như gợi ý dựa trên nội dung, tìm kiếm ngữ nghĩa,...

Cung cấp admin site tương thích MongoDB, sử dụng dễ dàng như với các database truyền thống.

Bắt Đầu Với Dự Án Django Sử Dụng MongoDB Backend

Chuẩn Bị Môi Trường Phát Triển

Bạn cần chuẩn bị:

Python 3.10 trở lên (khuyến nghị 3.12.6)

IDE như Visual Studio Code

Docker (tuỳ chọn)

MongoDB Atlas hoặc cài đặt cục bộ bằng Atlas CLI

API Key từ các dịch vụ Voyage AI (embedding vector) và Anthropic (LLM Claude)

Tạo Local Atlas Deployment

Dùng Atlas CLI tạo cụm MongoDB local:

atlas deployments setup
# Chọn Local Database deployment

Kết nối mặc định địa chỉ: mongodb://localhost:12404/?directConnection=true

Thiết Lập Virtual Environment Python

python -m venv venv
source venv/bin/activate   # Unix/Mac
# hoặc venv\Scripts\activate cho Windows

Cài Đặt Dependencies

Tạo file requirements.txt với:

anthropic==0.47.2
django-mongodb-backend==5.1.0b0
python-dotenv==1.0.1
voyageai==0.3.2

Sau đó chạy:

pip install -r requirements.txt

Tạo Dự Án Django Với MongoDB Backend

Khởi Tạo Dự Án

Dùng template chính thức từ MongoDB Labs:

django-admin startproject cookbook --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/5.0.x.zip

Cấu Hình Kết Nối MongoDB

Sửa cookbook/settings.py :

DATABASES = {
  "default": django_mongodb_backend.parse_uri(
    "mongodb://localhost:12404/cookbook?directConnection=true"
  ),
}

Lưu ý: Phải có tên database ( cookbook ) trong URI.

Chạy Server Phát Triển

cd cookbook
python manage.py runserver

Bạn sẽ thấy server khởi chạy cùng thông báo về migrations chưa áp dụng.

Xây Dựng Ứng Dụng Quản Lý Công Thức Nấu Ăn

Tạo Ứng Dụng `recipes`

python manage.py startapp recipes --template https://github.com/mongodb-labs/django-mongodb-app/archive/refs/heads/5.0.x.zip

Định Nghĩa Mô Hình Dữ Liệu

Trong recipes/models.py :

from django.db import models
from django_mongodb_backend.fields import ArrayField, EmbeddedModelField
from django_mongodb_backend.models import EmbeddedModel
from django_mongodb_backend.managers import MongoManager

class Features(EmbeddedModel):
    preparation_time = models.CharField(max_length=100)
    complexity = models.CharField(max_length=100)
    prep_time = models.IntegerField()
    cuisine = models.CharField(max_length=100, null=True, blank=True)

class Recipe(models.Model):
    title = models.CharField(max_length=200)
    instructions = models.TextField(blank=True)
    features = EmbeddedModelField(Features, null=True, blank=True)
    ingredients = ArrayField(models.CharField(max_length=100), null=True, blank=True)
    embedding_ingredients = models.CharField(max_length=500, null=True, blank=True)
    voyage_embedding = models.JSONField(null=True, blank=True)

    objects = MongoManager()

    class Meta:
        db_table = "recipes"
        managed = False

    def __str__(self):
        return f"Recipe {self.title}"

Đăng Ký App Và Kích Hoạt Admin

Trong settings.py , thêm vào:

INSTALLED_APPS = [
    "recipes.apps.RecipesConfig",
    "cookbook.apps.MongoAdminConfig",
    "cookbook.apps.MongoAuthConfig",
    "cookbook.apps.MongoContentTypesConfig",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

Trong recipes/admin.py :

from django.contrib import admin
from .models import Recipe

admin.site.register(Recipe)

Áp Dụng Migrations Và Tạo Superuser

python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser

Bây giờ bạn có thể truy cập trang admin và quản lý dữ liệu.

Nhập Dữ Liệu Công Thức Và Tạo Embeddings Voyage AI

Chuẩn Bị File `.env`

Tạo file .env tại root:

MONGO_URI=mongodb://localhost:12404/?directConnection=true
MONGO_DB=cookbook
MONGO_COLLECTION=recipes
VOYAGE_API_KEY=YOUR_VOYAGE_API_KEY
ANTHROPIC_API_KEY=YOUR_ANTHROPIC_API_KEY

Script Nhập Dữ Liệu JSON

import_json_recipes.py :

import os
import pymongo
import json
from dotenv import load_dotenv

load_dotenv()

MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:12404/?directConnection=true")
MONGO_DB = os.getenv("MONGO_DB", "cookbook")

try:
    client = pymongo.MongoClient(MONGO_URI)
    db = client[MONGO_DB]

    with open("bigger_sample.json", "r") as f:
        recipes_data = json.load(f)

    for recipe in recipes_data:
        recipe_doc = {
            "title": recipe["title"],
            "ingredients": recipe["ingredients"],
            "instructions": recipe["instructions"],
            "embedding_ingredients": recipe["embedding_ingredients"],
            "features": recipe["features"],
        }
        db.recipes.insert_one(recipe_doc)
    print(f"Inserted {len(recipes_data)} recipes into MongoDB")
except Exception as e:
    print(f"Error: {e}")

Chạy:

python import_json_recipes.py

Script Tạo Embeddings Với Voyage AI

generate_embeddings.py :

import os
import time
import pymongo
import voyageai
from dotenv import load_dotenv
from tqdm import tqdm

load_dotenv()

MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:12404/?directConnection=true")
MONGO_DB = os.getenv("MONGO_DB", "cookbook")

try:
    client = pymongo.MongoClient(MONGO_URI)
    db = client[MONGO_DB]
    collection = db["recipes"]

    vo = voyageai.Client()

    docs = list(collection.find({"voyage_embedding": {"$exists": False}}))
    print(f"Found {len(docs)} documents without Voyage embeddings")

    for doc in tqdm(docs, desc="Adding embeddings"):
        content = f"{doc['title']}. Ingredients: {doc['embedding_ingredients']}"
        try:
            embedding_result = vo.embed(
                [content],
                model="voyage-lite-01-instruct",
                input_type="document",
            )
            embedding = embedding_result.embeddings[0]
            collection.update_one(
                {"_id": doc["_id"]}, {"$set": {"voyage_embedding": embedding}}
            )
            time.sleep(25)  # Để tránh vượt giới hạn API
        except Exception as e:
            print(f"Error generating embedding for recipe '{doc['title']}': {e}")

    print(f"Successfully added embeddings")
except Exception as e:
    print(f"Error: {e}")

Xây Dựng Giao Diện Và Views Cơ Bản Với Django

Mẫu Template Cơ Bản `base.html`

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>{% block title %}Django MongoDB Backend Recipes{% endblock %}</title>
  <script src="https://unpkg.com/@tailwindcss/browser@4"></script>
  {% block extra_css %}{% endblock %}
</head>
<body class="flex flex-col min-h-screen bg-gray-50">
  <main class="container mx-auto px-4 py-6 flex-grow">
    {% block content %}
    <h1 class="text-3xl font-bold underline">Hello world!</h1>
    {% endblock %}
  </main>
  <footer class="bg-gray-800 text-white py-6">
    <div class="container mx-auto px-4">
      <p>&copy; {% now "Y" %} Django + MongoDB &lt;3</p>
    </div>
  </footer>
</body>
</html>

View Trang Chủ Đơn Giản `index()`

from django.shortcuts import render

def index(request):
    return render(request, "index.html", {"message": "Recipes App"})

Template index.html :

{% extends 'base.html' %}
{% block content %}
  <h1 class="text-3xl font-bold text-center">{{ message }}</h1>
{% endblock %}

View Danh Sách Công Thức Sắp Xếp Theo Tên

def recipe_list(request):
    recipes = Recipe.objects.all().order_by("title")[:20]
    return render(request, "recipe_list.html", {"recipes": recipes})

Template recipe_list.html :

{% extends 'base.html' %}
{% block content %}
<h1 class="text-3xl font-bold mb-6">Alphabetical list of recipes</h1>
<ul class="list-disc pl-5">
  {% for recipe in recipes %}
    <li class="mb-1">{{ recipe.title }}</li>
  {% endfor %}
</ul>
{% endblock %}

View Chi Tiết Công Thức Theo ID MongoDB

from bson import ObjectId
from bson.errors import InvalidId
from django.http import Http404
from django.shortcuts import get_object_or_404

def recipe_detail(request, recipe_id):
    try:
        object_id = ObjectId(recipe_id)
    except InvalidId:
        raise Http404(f"Invalid recipe ID: {recipe_id}")

    recipe = get_object_or_404(Recipe, id=object_id)
    return render(request, "recipe_detail.html", {"recipe": recipe})

Template recipe_detail.html :

{% extends 'base.html' %}
{% block title %}{{ recipe.title }}{% endblock %}
{% block content %}
<div class="max-w-2xl mx-auto py-4">
  <h1 class="text-xl font-semibold mb-3">{{ recipe.title }}</h1>
  <div class="mb-4">
    <h2 class="text-md font-medium mb-1">Ingredients</h2>
    <ul class="pl-4">
      {% for ingredient in recipe.ingredients %}
        <li>{{ ingredient }}</li>
      {% endfor %}
    </ul>
  </div>
  <div>
    <h2 class="text-md font-medium mb-1">Instructions</h2>
    <div class="pl-4">{{ recipe.instructions|linebreaks }}</div>
  </div>
</div>
{% endblock %}

Tìm Kiếm Nâng Cao Với MongoDB Aggregation Và Indexes

Thống Kê Số Lượng Công Thức Theo Loại Ẩm Thực

Sử dụng Raw Aggregation API của Django MongoDB Backend:

def recipe_statistics(request):
    pipeline = [
        {"$project": {"_id": 1, "cuisine": "$features.cuisine"}},
        {"$group": {"_id": "$cuisine", "count": {"$sum": 1}}},
        {"$sort": {"count": -1}},
        {"$project": {"_id": 1, "cuisine": {"$ifNull": ["$_id", "Unspecified"]}, "count": 1}},
    ]
    stats = Recipe.objects.raw_aggregate(pipeline)
    return render(request, "statistics.html", {"cuisine_stats": list(stats)})

Template statistics.html :

{% extends 'base.html' %}
{% block content %}
<h1 class="text-2xl font-bold mb-6">Recipe Statistics</h1>
<div>
  <h2 class="text-xl font-semibold mb-4">Recipes by Cuisine</h2>
  {% if cuisine_stats %}
    <ul>
    {% for item in cuisine_stats %}
      <li>{{ item.cuisine }}: {{ item.count }} recipe{{ item.count|pluralize }}</li>
    {% endfor %}
    </ul>
  {% else %}
    <p>No cuisine data available.</p>
  {% endif %}
</div>
{% endblock %}

Tạo Index Tìm Kiếm Và Vector Search

Tạo chỉ số Atlas Search text cho title , ingredients , instructions .

Tạo index vector cho trường voyage_embedding với số chiều 1024, sử dụng độ đo cosine.

Tích Hợp Tìm Kiếm Vector Với Voyage AI

Hàm Thực Hiện Vector Search

import voyageai

def perform_vector_search(query_text, limit=10, num_candidates=None):
    if num_candidates is None:
        num_candidates = limit * 3
    try:
        vo = voyageai.Client()
        query_embedding = vo.embed(
            [query_text], model="voyage-lite-01-instruct", input_type="query"
        ).embeddings[0]

        results = Recipe.objects.raw_aggregate([
            {
                "$vectorSearch": {
                    "index": "recipe_vector_index",
                    "path": "voyage_embedding",
                    "queryVector": query_embedding,
                    "numCandidates": num_candidates,
                    "limit": limit,
                }
            },
            {
                "$project": {
                    "_id": 1,
                    "title": 1,
                    "ingredients": 1,
                    "instructions": 1,
                    "features": 1,
                    "score": {"$meta": "vectorSearchScore"},
                }
            },
        ])

        recipes = []
        for recipe in results:
            recipes.append({
                "id": str(recipe.id),
                "title": recipe.title,
                "ingredients": recipe.ingredients,
                "instructions": getattr(recipe, "instructions", ""),
                "features": getattr(recipe, "features", {}),
                "similarity_score": getattr(recipe, "score", 0),
            })
        return recipes
    except Exception as e:
        print(f"Error in vector search: {str(e)}")
        return []

View Tìm Kiếm Công Thức Qua Vector Search

def ingredient_vector_search(request):
    query = request.GET.get("query", "")
    results = []
    if query:
        ingredient_query = f"Ingredients: {query}"
        results = perform_vector_search(ingredient_query, limit=10)
    return render(request, "vector_search.html", {"query": query, "results": results})

Template vector_search.html :

{% extends 'base.html' %}
{% block content %}
<h1>Search Recipes by Ingredients</h1>
<form method="GET" action="{% url 'ingredient_search' %}">
  <input type="text" name="query" placeholder="chicken, garlic, lemon" value="{{ query }}">
  <button type="submit">Search</button>
</form>
{% if query %}
  <h2>Results for "{{ query }}"</h2>
  {% if results %}
    {% for recipe in results %}
      <div>
        <h3>{{ recipe.title }}</h3>
        <p>Similarity: {{ recipe.similarity_score|floatformat:2 }}</p>
        <ul>
          {% for ing in recipe.ingredients %}
          <li>{{ ing }}</li>
          {% endfor %}
        </ul>
        <a href="{% url 'recipe_detail' recipe.id %}">View full recipe</a>
      </div>
    {% endfor %}
  {% else %}
    <p>No recipes found matching your ingredients.</p>
  {% endif %}
{% endif %}
{% endblock %}

Tích Hợp Mô Hình Ngôn Ngữ Lớn (LLM) Claude Để Gợi Ý Công Thức Cá Nhân Hóa

Hàm Gọi API Anthropic Claude

from anthropic import Anthropic
import json
import os

ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

def get_claude_suggestions(user_ingredients, similar_recipes, max_suggestions=4):
    client = Anthropic(api_key=ANTHROPIC_API_KEY)
    prompt = f"""
I have these ingredients: {", ".join(user_ingredients)}.
Based on these ingredients, I need {max_suggestions} meal suggestions. Similar recipes: {json.dumps(similar_recipes, indent=2)}.
For each suggestion, provide:
1. Recipe name
2. Ingredients used
3. Possible substitutions
4. Brief cooking instructions
5. Difficulty level
Be concise and practical.
"""
    response = client.messages.create(
        model="claude-3-haiku-20240307",
        max_tokens=1500,
        temperature=0.7,
        system="You are a helpful cooking assistant.",
        messages=[{"role": "user", "content": prompt}],
    )
    suggestions_text = response.content[0].text
    
    # Parse the suggestions text into list
    raw_suggestions = []
    current = ""
    for line in suggestions_text.split("\n"):
        if line.strip() and (line.strip()[0].isdigit() and line.strip()[1:3] in [". ", ") "]):
            if current:
                raw_suggestions.append(current.strip())
            current = line
        else:
            current += "\n" + line
    if current:
        raw_suggestions.append(current.strip())
    return raw_suggestions[:max_suggestions]

View AI Gợi Ý Món Ăn

def ai_meal_suggestions(request):
    query = request.GET.get("ingredients", "")
    suggestions = []
    error_message = None
    if query:
        try:
            ingredients_list = [i.strip() for i in query.split(",") if i.strip()]
            similar_recipes = perform_vector_search(f"Ingredients: {', '.join(ingredients_list)}", limit=10)
            if similar_recipes:
                recipes_data = [
                    {"title": r["title"], "ingredients": r["ingredients"], "score": r["similarity_score"], "id": r["id"]}
                    for r in similar_recipes
                ]
                suggestions = get_claude_suggestions(ingredients_list, recipes_data)
            else:
                error_message = "No similar recipes found."
        except Exception as e:
            error_message = f"An error occurred: {e}"
    return render(request, "ai_suggestions.html", {
        "ingredients": query,
        "suggestions": suggestions,
        "error_message": error_message,
    })

Template ai_suggestions.html :

{% extends 'base.html' %}
{% block content %}
<h1>AI Meal Suggestions</h1>
<form method="GET" action="{% url 'ai_meal_suggestions' %}">
  <textarea name="ingredients" placeholder="e.g., chicken, garlic">{{ ingredients }}</textarea>
  <button type="submit">Get Meal Suggestions</button>
</form>
{% if error_message %}
  <div class="error">{{ error_message }}</div>
{% endif %}
{% if suggestions %}
  <h2>Suggested Meals</h2>
  {% for suggestion in suggestions %}
    <div class="suggestion">{{ suggestion|linebreaks }}</div>
  {% endfor %}
  <p><small>AI-generated suggestions based on your ingredients and similar recipes.</small></p>
{% endif %}
{% endblock %}

Kết Luận

Trong bài viết này, chúng ta đã cùng nhau khám phá cách tích hợp Django và MongoDB qua Django MongoDB Backend để xây dựng một ứng dụng web quản lý công thức nấu ăn hiện đại. Qua ví dụ, bạn có thể thấy sức mạnh của việc kết hợp mô hình dữ liệu linh hoạt của MongoDB với khả năng phát triển nhanh của Django.

Ngoài ra, việc tích hợp các công nghệ AI như Voyage AI để tạo embeddings vector, MongoDB vector search, và mô hình ngôn ngữ lớn Anthropic Claude đã mở ra tiềm năng xây dựng các trải nghiệm người dùng thông minh, cá nhân hóa, như tìm kiếm ngữ nghĩa và gợi ý công thức tự động.

Bạn đã có nền tảng căn bản để tiếp tục phát triển thêm các chức năng nâng cao như quản lý người dùng, CRUD hoàn chỉnh, đa dạng hoá phương thức tìm kiếm với fuzzy search, và tối ưu hiệu năng cho ứng dụng Django + MongoDB.

Hãy thử tải và chạy dự án mẫu từ GitHub repository để nhanh chóng áp dụng và tùy biến theo nhu cầu của bạn!

Tham Khảo

Django Official Website

MongoDB Official Website

Django MongoDB Backend GitHub

Voyage AI Documentation

Anthropic Claude API

William S. Vincent - Django for Professionals, Django for APIs

Michael Dinder - Becoming an Enterprise Django Developer

MongoDB Blog - Announcement of Django MongoDB Backend

Official Django Documentation - Templates

MongoDB Documentation - Atlas Search Indexes