Fullstack Python
Trang chủ / Module 17
🤖 Module 17 / 19 · 5 ngày 📅 Tuần 12 ●●●○ Khó

AI & data cho fullstack Python: LLM, RAG, structured output, pipeline dữ liệu

Lợi thế lớn nhất của fullstack Python năm 2026: tích hợp AI vào sản phẩm một cách có trách nhiệm — gọi LLM và stream kết quả, structured output với Pydantic, tool calling, RAG với pgvector, đánh giá chất lượng, kiểm soát chi phí và bảo mật; cùng pipeline dữ liệu (import/export, ETL, báo cáo) bằng polars.

LLM APIRAGpgvectorStructured outputEvaluationPolars/ETL
📌 Vì sao module này quan trọng

Gần như mọi sản phẩm SaaS năm 2026 đều có tính năng AI, và Python là ngôn ngữ của hệ sinh thái AI. Một fullstack Python biết đưa LLM vào sản phẩm thật — với phân quyền, chi phí, độ trễ, đánh giá chất lượng — có giá cao hơn hẳn developer chỉ làm CRUD. Đồng thời, nhiều công việc Python lương cao là "backend + dữ liệu": import file lớn, ETL, báo cáo — lĩnh vực Python mạnh nhất.

🎯 Mục tiêu học tập

  • Gọi API LLM, stream kết quả qua SSE, xử lý timeout/retry/rate limit
  • Dùng structured output và tool calling với schema Pydantic, validate đầu ra
  • Xây RAG: chia đoạn, embedding, pgvector, hybrid search, lọc theo quyền
  • Đánh giá chất lượng bằng bộ câu hỏi mẫu; kiểm soát chi phí và rủi ro bảo mật
  • Xây pipeline dữ liệu: import/export file lớn, ETL và báo cáo bằng polars

Gọi LLM và stream

@router.post("/projects/{project_id}/ask")
async def ask(project_id: int, body: AskIn, session: SessionDep, user: UserDep):
    await quota.consume(user.org_id, feature="ai", units=1)            # giới hạn theo gói — chi phí là thật
    project = await repo.get_for_user(session, project_id, user)        # kiểm tra quyền trước
    context = await retrieve(session, org_id=user.org_id, project_id=project.id, query=body.question, k=8)

    async def gen():
        async with llm.stream(system=SYSTEM_PROMPT, messages=[{"role": "user", "content": build_prompt(body.question, context)}],
                              max_tokens=800) as stream:
            async for text in stream.text_stream:
                yield f"data: {json.dumps({'text': text})}\n\n"
        yield f"data: {json.dumps({'sources': [c.source_id for c in context]})}\n\n"
    return StreamingResponse(gen(), media_type="text/event-stream")
  • Dùng SDK chính thức của nhà cung cấp (đều có async client), hoặc lớp trừu tượng (LiteLLM, PydanticAI, LangChain — cân nhắc độ phức tạp).
  • Timeout, retry có backoff cho 429/5xx, ghi log token và chi phí mỗi lần gọi theo tenant/tính năng.
  • Việc AI dài (tóm tắt 200 tài liệu) chạy trong Celery, báo tiến độ qua SSE.

Structured output và tool calling

class TaskSuggestion(BaseModel):
    title: str = Field(max_length=200)
    priority: Literal["low", "medium", "high"]
    estimate_minutes: int = Field(ge=5, le=480)

class Plan(BaseModel):
    tasks: list[TaskSuggestion] = Field(max_length=20)

# Yêu cầu model trả JSON theo schema (nhiều SDK nhận thẳng Pydantic model), rồi LUÔN validate lại
raw = await llm.generate_json(prompt, schema=Plan.model_json_schema())
plan = Plan.model_validate_json(raw)          # sai schema → retry hoặc báo lỗi, không ghi bừa vào DB
  • Tool calling: model đề xuất gọi hàm (tìm task, tạo task); hàm thực thi với quyền của người dùng hiện tại và thao tác ghi cần người dùng xác nhận.
  • Đầu ra của model là dữ liệu không tin cậy: escape khi hiển thị, không đưa vào SQL/shell/eval.

RAG với pgvector

class Chunk(Base):
    __tablename__ = "chunks"
    id: Mapped[int] = mapped_column(primary_key=True)
    org_id: Mapped[int] = mapped_column(index=True)
    source_id: Mapped[int]
    content: Mapped[str]
    embedding: Mapped[list[float]] = mapped_column(Vector(1536))
    __table_args__ = (Index("ix_chunks_embedding", "embedding", postgresql_using="hnsw",
                            postgresql_ops={"embedding": "vector_cosine_ops"}),)

async def retrieve(session, org_id: int, project_id: int, query: str, k: int = 8) -> list[Chunk]:
    qvec = await embed(query)
    stmt = (select(Chunk).where(Chunk.org_id == org_id, Chunk.project_id == project_id)   # LỌC QUYỀN trong truy vấn
            .order_by(Chunk.embedding.cosine_distance(qvec)).limit(k))
    return list((await session.scalars(stmt)).all())
  • Pipeline nạp: trích văn bản (PDF/DOCX) → chia đoạn có chồng lấp theo cấu trúc tài liệu → embedding theo lô trong job → lưu kèm phiên bản model.
  • Hybrid search (full-text + vector) tốt hơn vector thuần cho tên riêng, mã số; rerank khi cần độ chính xác cao.
  • pgvector đủ cho hàng triệu đoạn văn; vector DB riêng khi quy mô rất lớn.

Đánh giá, chi phí và bảo mật

Vấn đềCách xử lý
Chất lượngBộ 50-200 câu hỏi mẫu có đáp án/nguồn mong đợi; chạy tự động khi đổi prompt, model, cách chia đoạn; đo độ bám nguồn, tỷ lệ "không biết" đúng; thu phản hồi người dùng
Chi phíQuota theo gói, cache câu trả lời lặp và prompt caching, giới hạn token và số bước agent, model nhỏ cho phân loại/tóm tắt
Độ trễStream, truy xuất song song, model nhỏ hơn cho bước trung gian
Prompt injectionNội dung tài liệu không được coi là chỉ dẫn; tool có quyền tối thiểu; xác nhận trước thao tác ghi
Rò dữ liệu giữa tenantLọc quyền trong truy xuất, test tự động; không đưa dữ liệu tenant khác vào ngữ cảnh/cache chung
Quyền riêng tưThoả thuận xử lý dữ liệu với nhà cung cấp, che PII khi log, tuỳ chọn tắt AI cho khách enterprise

Pipeline dữ liệu: import, export, báo cáo

import polars as pl

def import_tasks_csv(path: str, org_id: int) -> ImportReport:
    df = (pl.scan_csv(path)                                   # lazy: không đọc hết vào RAM
            .with_columns(pl.col("title").str.strip_chars(),
                          pl.col("due_at").str.to_datetime(strict=False).alias("due_at_parsed"))
            .filter(pl.col("title").str.len_chars() > 0))
    bad_date = pl.col("due_at").is_not_null() & pl.col("due_at_parsed").is_null()
    errors = df.filter(bad_date).collect()
    valid = df.filter(~bad_date).collect(engine="streaming")
    for batch in valid.iter_slices(5_000):                    # ghi theo lô (COPY / bulk insert)
        bulk_insert_tasks(batch, org_id)
    return ImportReport(rows=valid.height, errors=errors.height)
  • Import file người dùng: chạy trong job, validate từng dòng, trả báo cáo lỗi có thể tải về, idempotent khi chạy lại.
  • Báo cáo nặng đọc từ read replica hoặc kho phân tích (DuckDB cho quy mô nhỏ, ClickHouse/BigQuery cho lớn).
  • Polars nhanh và tiết kiệm bộ nhớ hơn pandas cho đa số tác vụ ETL; pandas vẫn phổ biến trong codebase hiện có.

🏋️ Bài tập thực hành

Tính năng AI và dữ liệu cho capstone

(1) "Hỏi AI về project": RAG trên task, bình luận và tài liệu đính kèm (pgvector + full-text), stream SSE, trích nguồn, quota theo gói, lọc quyền có test. (2) "Gợi ý chia nhỏ công việc": structured output validate bằng Pydantic, người dùng xác nhận trước khi tạo task. (3) Bộ 30 câu hỏi đánh giá chạy tự động trong CI (dùng model nhỏ/giả lập khi cần), báo cáo điểm. (4) Import 200.000 task từ CSV bằng polars trong Celery, có báo cáo lỗi tải về. (5) Dashboard chi phí AI theo tổ chức.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Gọi LLM có timeout, retry, stream, ghi chi phí
  • Structured output luôn được validate bằng Pydantic
  • RAG lọc quyền trong truy xuất, có test chống rò dữ liệu
  • Có bộ đánh giá chất lượng tự động và pipeline import theo lô