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.
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ượng | Bộ 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 injection | Nộ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 tenant | Lọ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
(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
-
pgvector-pythonpgvector với SQLAlchemy/DjangoRepo
-
PydanticAIFramework agent/LLM dựa trên PydanticDocs
-
OWASP Top 10 for LLM ApplicationsRủi ro bảo mật khi tích hợp LLMGuide
-
PolarsXử lý dữ liệu nhanhDocs
-
Khoá AI Engineer trong cùng lộ trìnhĐi sâu RAG, agent, evaluationKhoá học
✅ 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ô