Update note services logic

.gitignore

@@ -1,4 +1,7 @@
-NOTE_SERVICE_FLOW.md
 .myvenv
 __pycache__/
-*.pyc
+*.pyc
+*.json
+.env
+*.txt
+docs/

Dockerfile

@@ -1,10 +1,14 @@
 FROM python:3.11-slim
 WORKDIR /app
 
-# install dependencies
-COPY requirements.txt ./
+COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s \
+  CMD curl -f http://localhost:7860/health || exit 1
+
 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/folders/folders_create.py

@@ -0,0 +1,26 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from app.services.folder_store import create_folder
+from app.utils.id import new_id
+from app.utils.time import now_ts
+
+
+router = APIRouter(prefix="/folders", tags=["folders"])
+
+
+class CreateFolderRequest(BaseModel):
+    name: str
+    color_hex: str | None = None
+
+
+@router.post("")
+def create(req: CreateFolderRequest):
+    folder = {
+    "folder_id": new_id(),
+    "name": req.name,
+    "color_hex": req.color_hex,
+    "created_at": now_ts(),
+    "updated_at": now_ts(),
+    }
+    create_folder(folder)
+    return folder

app/api/folders/folders_delete.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter, HTTPException
+from app.services.folder_store import get_folder, delete_folder
+
+router = APIRouter(prefix="/folders", tags=["folders"])
+
+
+@router.delete("/{folder_id}")
+def delete_folder_api(folder_id: str):
+    folder = get_folder(folder_id)
+    if not folder:
+        raise HTTPException(status_code=404, detail="Folder not found")
+
+    delete_folder(folder_id)
+    return {"folder_id": folder_id, "deleted": True}

app/api/folders/folders_get.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter, HTTPException
+from app.services.folder_store import get_folder, list_folders
+
+router = APIRouter(prefix="/folders", tags=["folders"])
+
+
+@router.get("")
+def get_folders():
+    return list_folders()
+
+
+@router.get("/{folder_id}")
+def get_folder_by_id(folder_id: str):
+    folder = get_folder(folder_id)
+    if not folder:
+        raise HTTPException(status_code=404, detail="Folder not found")
+    return folder

app/api/folders/folders_update.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+from app.services.folder_store import get_folder, update_folder
+from app.utils.time import now_ts
+
+router = APIRouter(prefix="/folders", tags=["folders"])
+
+
+class UpdateFolderRequest(BaseModel):
+    name: Optional[str] = None
+    color_hex: Optional[str] = None
+
+
+@router.patch("/{folder_id}")
+def update_folder_api(folder_id: str, req: UpdateFolderRequest):
+    folder = get_folder(folder_id)
+    if not folder:
+        raise HTTPException(status_code=404, detail="Folder not found")
+
+    updates = req.dict(exclude_unset=True)
+    updates["updated_at"] = now_ts()
+
+    update_folder(folder_id, updates)
+    return {"folder_id": folder_id, "updated": True}

app/api/notes.py

@@ -1,35 +0,0 @@
-from fastapi import APIRouter, BackgroundTasks, HTTPException
-from pydantic import BaseModel
-from typing import Optional, List
-from app.services.storage import create_note as storage_create_note, get_note
-from app.jobs.enrichment_job import run_enrichment
-
-router = APIRouter(prefix="/notes")
-
-class CreateNoteRequest(BaseModel):
-    note_id: str
-    raw_text: str
-    normalized_text: Optional[str] = None
-    keywords: List[str] = []
-    chunks: list = []
-    duration: Optional[float] = None
-    sample_rate: Optional[int] = None
-    asr_model: Optional[str] = None
-    normalization_model: Optional[str] = None
-    generate: List[str] = []
-
-@router.post("")
-async def create_note(req: CreateNoteRequest, bg: BackgroundTasks):
-    storage_create_note(req.note_id, req.dict())
-
-    if req.generate:
-        bg.add_task(run_enrichment, req.note_id, req.generate)
-
-    return {"note_id": req.note_id, "status": "stored"}
-
-@router.get("/{note_id}")
-def fetch_note(note_id: str):
-    note = get_note(note_id)
-    if not note:
-        raise HTTPException(404, "Note not found")
-    return note

app/api/notes/notes_audio.py

@@ -0,0 +1,43 @@
+from fastapi import APIRouter, BackgroundTasks, HTTPException
+from pydantic import BaseModel
+from typing import Dict, List, Optional
+from app.services.note_store import create_note
+from app.jobs.enrichment_job import enrich_note
+from app.models.enums import NoteType, NoteStatus
+from app.utils.time import now_ts
+
+
+router = APIRouter(prefix="/internal/notes", tags=["internal"])
+
+
+class CreateAudioNoteRequest(BaseModel):
+    note_id: str
+    raw_text: str
+    metadata: Dict
+    generate: List[str] = []
+
+    
+@router.post("/audio")
+async def create_audio_note(req: CreateAudioNoteRequest, bg: BackgroundTasks):
+    now = now_ts()
+    has_enrichment = bool(req.generate)
+
+    note = {
+        "note_id": req.note_id,
+        "type": NoteType.audio,
+        "raw_text": req.raw_text,
+        "metadata": req.metadata,
+        "status": NoteStatus.processing if has_enrichment else NoteStatus.created,
+        "created_at": now,
+        "updated_at": now,
+    }
+
+    create_note(note)
+
+    if has_enrichment:
+        bg.add_task(enrich_note, req.note_id, req.generate)
+
+    return {
+        "note_id": req.note_id,
+        "status": note["status"],
+    }

app/api/notes/notes_get.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter, HTTPException
+from app.services.note_store import get_note, list_notes
+
+
+router = APIRouter(prefix="/notes", tags=["notes"])
+
+
+@router.get("")
+def get_notes(folder_id: str | None = None):
+    return list_notes(folder_id)
+
+
+@router.get("/{note_id}")
+def get_note_by_id(note_id: str):
+    note = get_note(note_id)
+    if not note:
+        raise HTTPException(404, "Note not found")
+    return note

app/api/notes/notes_regenerate.py

@@ -0,0 +1,34 @@
+from app.models.enums import NoteStatus
+from app.utils.time import now_ts
+from fastapi import APIRouter, BackgroundTasks, HTTPException
+from pydantic import BaseModel
+from typing import List
+from app.services.note_store import get_note, update_note
+from app.jobs.enrichment_job import enrich_note
+
+
+router = APIRouter(prefix="/notes", tags=["notes"])
+
+
+class RegenerateRequest(BaseModel):
+    generate: List[str]
+
+
+@router.post("/{note_id}/regenerate")
+def regenerate_note(note_id: str, req: RegenerateRequest, bg: BackgroundTasks):
+    note = get_note(note_id)
+    if not note:
+        raise HTTPException(404, "Note not found")
+
+    # mark processing immediately
+    update_note(note_id, {
+        "status": NoteStatus.processing,
+        "updated_at": now_ts(),
+    })
+
+    bg.add_task(enrich_note, note_id, req.generate)
+
+    return {
+        "note_id": note_id,
+        "status": NoteStatus.processing,
+    }

app/api/notes/notes_text.py

@@ -0,0 +1,45 @@
+from fastapi import APIRouter, BackgroundTasks
+from pydantic import BaseModel
+from typing import List, Optional
+from app.services.note_store import create_note
+from app.jobs.enrichment_job import enrich_note
+from app.models.enums import NoteType, NoteStatus
+from app.utils.id import new_id
+from app.utils.time import now_ts
+
+
+router = APIRouter(prefix="/notes", tags=["notes"])
+
+
+class CreateTextNoteRequest(BaseModel):
+    raw_text: str
+    folder_id: Optional[str] = None
+    generate: List[str] = []
+
+
+@router.post("/text")
+async def create_text_note(req: CreateTextNoteRequest, bg: BackgroundTasks):
+    note_id = new_id()
+    now = now_ts()
+
+    has_enrichment = bool(req.generate)
+
+    note = {
+        "note_id": note_id,
+        "type": NoteType.text,
+        "raw_text": req.raw_text,
+        "folder_id": req.folder_id,
+        "status": NoteStatus.processing if has_enrichment else NoteStatus.created,
+        "created_at": now,
+        "updated_at": now,
+    }
+
+    create_note(note)
+
+    if has_enrichment:
+        bg.add_task(enrich_note, note_id, req.generate)
+
+    return {
+        "note_id": note_id,
+        "status": note["status"],
+    }

app/api/notes/notes_update.py

@@ -0,0 +1,30 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+from app.services.note_store import get_note, update_note
+from app.utils.time import now_ts
+
+
+router = APIRouter(prefix="/notes", tags=["notes"])
+
+
+class UpdateNoteRequest(BaseModel):
+    folder_id: Optional[str] = None
+    title: Optional[str] = None
+
+
+@router.patch("/{note_id}")
+def update_note_api(note_id: str, req: UpdateNoteRequest):
+    note = get_note(note_id)
+    if not note:
+        raise HTTPException(404, "Note not found")
+
+    updates = req.dict(exclude_unset=True)
+
+    # ❗ Không cho client sửa status trực tiếp
+    updates.pop("status", None)
+
+    updates["updated_at"] = now_ts()
+
+    update_note(note_id, updates)
+    return {"note_id": note_id, "updated": True}

app/config.py

@@ -1,5 +1,9 @@
 import os
 
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
-GEMINI_MODEL = os.getenv("GEMINI_MODEL", "")
-FIREBASE_SERVICE_ACCOUNT = os.getenv("FIREBASE_SERVICE_ACCOUNT", "")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+if not GEMINI_API_KEY:
+    raise RuntimeError("GEMINI_API_KEY is required")
+
+GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
+
+FIREBASE_SERVICE_ACCOUNT = os.getenv("FIREBASE_SERVICE_ACCOUNT", "")

app/infra/auth.py

@@ -0,0 +1,10 @@
+from fastapi import Request
+
+def get_current_user_id(request: Request) -> str | None:
+    """
+    Placeholder for auth context.
+    Later:
+    - Extract from JWT
+    - Or API Gateway headers
+    """
+    return request.headers.get("x-user-id")

app/{services → infra}/firebase.py

@@ -1,13 +1,9 @@
 import firebase_admin
 from firebase_admin import credentials, firestore
-import json
-from app.config import FIREBASE_SERVICE_ACCOUNT
+import os, json
 
 if not firebase_admin._apps:
-    if not FIREBASE_SERVICE_ACCOUNT:
-        raise RuntimeError("Missing FIREBASE_SERVICE_ACCOUNT")
-
-    cred = credentials.Certificate(json.loads(FIREBASE_SERVICE_ACCOUNT))
+    cred = credentials.Certificate(json.loads(os.environ["FIREBASE_SERVICE_ACCOUNT"]))
     firebase_admin.initialize_app(cred)
 
-db = firestore.client()
+db = firestore.client()

app/jobs/enrichment_job.py

@@ -1,53 +1,54 @@
-# from app.services.storage import get_note, update_note
-# from app.services.summary_service import generate_summary
-# from app.services.mindmap_service import generate_mindmap
-
-# async def run_enrichment(note_id: str, tasks: list):
-#     note = get_note(note_id)
-#     if not note:
-#         return
-
-#     text = note.get("normalized_text") or note["raw_text"]
-
-#     update_note(note_id, status="processing")
-#     updates = {}
-
-#     if "summary" in tasks:
-#         updates["summary"] = await generate_summary(text)
-
-#     if "mindmap" in tasks:
-#         updates["mindmap"] = await generate_mindmap(text)
+import logging
+from app.services.note_store import get_note, update_note
+from app.services.enrichment.pipeline import run_pipeline
+from app.models.enums import NoteStatus
+from app.utils.time import now_ts
 
-#     update_note(note_id, data=updates, status="ready")
+logger = logging.getLogger(__name__)
 
-import logging
-from app.services.storage import get_note, update_note
-from app.services.summary_service import generate_summary
-from app.services.mindmap_service import generate_mindmap
 
-async def run_enrichment(note_id: str, tasks: list):
+async def enrich_note(note_id: str, tasks: list[str]):
     note = get_note(note_id)
     if not note:
-        logging.warning(f"[enrichment] Note not found: {note_id}")
         return
 
-    text = note.get("normalized_text") or note["raw_text"]
-
-    update_note(note_id, status="processing")
-    updates = {}
+    # Mark as processing
+    update_note(
+        note_id,
+        {
+            "status": NoteStatus.processing,
+            "updated_at": now_ts(),
+        },
+    )
 
     try:
-        if "summary" in tasks:
-            try:
-                updates["summary"] = await generate_summary(text)
-            except Exception as e:
-                logging.exception(f"[enrichment] generate_summary failed for note_id={note_id}: {e}")
-
-        if "mindmap" in tasks:
-            try:
-                updates["mindmap"] = await generate_mindmap(text)
-            except Exception as e:
-                logging.exception(f"[enrichment] generate_mindmap failed for note_id={note_id}: {e}")
-    finally:
-        # Dù thành công hay thất bại, vẫn set status=ready để client ngừng poll
-        update_note(note_id, data=updates, status="ready")
+        # Run NLP pipeline (mutates a copy of note)
+        enriched = await run_pipeline(note, tasks)
+
+        updates = {}
+
+        # Only persist known enrichment fields
+        for field in (
+            "title",
+            "normalized_text",
+            "keywords",
+            "summary",
+            "mindmap",
+        ):
+            if field in enriched:
+                updates[field] = enriched[field]
+
+        updates["status"] = NoteStatus.ready
+        updates["updated_at"] = now_ts()
+
+        update_note(note_id, updates)
+
+    except Exception:
+        logger.exception("Enrichment failed note_id=%s", note_id)
+        update_note(
+            note_id,
+            {
+                "status": NoteStatus.error,
+                "updated_at": now_ts(),
+            },
+        )

app/main.py

@@ -1,9 +1,22 @@
 from fastapi import FastAPI
-from app.api.notes import router as notes_router
+from app.api.notes import notes_text, notes_audio, notes_get, notes_update, notes_regenerate
+from app.api.folders import folders_create, folders_get, folders_update, folders_delete
 
-app = FastAPI(title="Note Services API")
-app.include_router(notes_router)
+app = FastAPI(title="Note Service API")
+
+# Notes
+app.include_router(notes_text.router)
+app.include_router(notes_audio.router)
+app.include_router(notes_get.router)
+app.include_router(notes_update.router)
+app.include_router(notes_regenerate.router)
+
+# Folders
+app.include_router(folders_create.router)
+app.include_router(folders_get.router)
+app.include_router(folders_update.router)
+app.include_router(folders_delete.router)
 
 @app.get("/health")
 def health():
-    return {"status": "ok"}
+    return {"status": "ok"}

app/models/enums.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class NoteType(str, Enum):
+    audio = "audio"
+    text = "text"
+
+class NoteStatus(str, Enum):
+    created = "created"
+    processing = "processing"
+    ready = "ready"
+    error = "error"

app/models/folder.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+class Folder(BaseModel):
+    folder_id: str
+    name: str
+    color_hex: str | None = None
+    user_id: str | None = None
+    created_at: int
+    updated_at: int

app/models/note.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict
+from app.models.enums import NoteType, NoteStatus
+
+class AudioMetadata(BaseModel):
+    duration: Optional[float] = None
+    chunks: Optional[list] = None
+    sample_rate: Optional[int] = None
+    asr_model: Optional[str] = None
+
+class NoteMetadata(BaseModel):
+    audio: Optional[AudioMetadata] = None
+    client: Optional[Dict] = None
+
+class Note(BaseModel):
+    note_id: str
+    type: NoteType
+    
+    title: Optional[str] = None
+    raw_text: Optional[str] = None
+    normalized_text: Optional[str] = None
+    keywords: Optional[List[str]] = None
+    summary: Optional[str] = None
+    mindmap: Optional[Dict] = None
+
+    folder_id: Optional[str] = None
+    metadata: Optional[NoteMetadata] = None
+
+    status: NoteStatus
+    created_at: int
+    updated_at: int

app/services/{mindmap_service.py → enrichment/mindmap.py}

@@ -1,11 +1,11 @@
 import asyncio
-import json
-import logging
-import random
 import re
-import time
-
-from app.config import GEMINI_API_KEY
+import logging
+from random import random
+from time import time
+import google.genai as genai
+import json
+from app.config import GEMINI_API_KEY, GEMINI_MODEL
 
 try:
     import google.genai as genai
@@ -23,8 +23,7 @@ try:
 except Exception:
     GoogleAPIError = Exception
 
-_MINDMAP_MODEL = "gemini-2.5-flash"
-_gemini_client = None
+gemini_client = None
 
 if not genai:
     logging.warning("[mindmap_service] google.genai not available, mindmap generation will be disabled")
@@ -32,23 +31,18 @@ elif not GEMINI_API_KEY:
     logging.warning("[mindmap_service] GEMINI_API_KEY is not set, mindmap generation will be disabled")
 else:
     try:
-        _gemini_client = genai.Client(api_key=GEMINI_API_KEY)
-        logging.info(f"[mindmap_service] Initialized google.genai client with model={_MINDMAP_MODEL}")
+        gemini_client = genai.Client(api_key=GEMINI_API_KEY)
+        logging.info(f"[mindmap_service] Initialized google.genai client with model={GEMINI_MODEL}")
     except Exception as e:
         logging.exception(f"[mindmap_service] Failed to init google.genai client: {e}")
-        _gemini_client = None
-
+        gemini_client = None
 
 async def generate_mindmap(text: str) -> dict:
-    """Sinh cấu trúc mindmap JSON từ văn bản.
-    Fallback: trả {{}} nếu không có model hoặc lỗi.
-    """
-    if not _gemini_client:
+    if not text:
         return {}
 
     prompt = f"""
 Bạn là chuyên gia tạo Sơ đồ tư duy. Hãy phân tích văn bản sau và tạo CẤU TRÚC JSON Mindmap.
-
 Yêu cầu:
 1. Xác định Ý chính làm Root.
 2. Phân tách ý phụ thành nhánh con (tối đa 3 cấp).
@@ -57,7 +51,6 @@ Yêu cầu:
    - Root: "#6200EE"
    - Các nhánh con: sử dụng một trong các màu: "#F59E2B", "#2ECF9A", "#2F9BFF"
 5. CHỈ TRẢ VỀ JSON, không giải thích thêm.
-
 Cấu trúc JSON bắt buộc:
 {{
   "root": {{
@@ -85,8 +78,8 @@ Văn bản:
         last_exc = None
         for attempt in range(1, MAX_RETRIES + 1):
             try:
-                resp = _gemini_client.models.generate_content(
-                    model=_MINDMAP_MODEL,
+                resp = gemini_client.models.generate_content(
+                    model=GEMINI_MODEL,
                     contents=prompt,
                 )
                 return resp.text or ""
@@ -160,4 +153,3 @@ Văn bản:
         return fallback
     except Exception:
         return {}
-

app/services/enrichment/normalize.py

@@ -0,0 +1,148 @@
+import asyncio
+import os
+import logging
+import json
+import re
+import time
+import random
+from app.config import GEMINI_API_KEY, GEMINI_MODEL
+
+try:
+    import google.genai as genai
+    try:
+        from google.genai import errors as genai_errors
+    except Exception:
+        genai_errors = None
+except Exception:
+    genai = None
+    genai_errors = None
+    logging.warning("[normalize_service] google.genai module not found; normalization disabled")
+
+try:
+    from google.api_core.exceptions import GoogleAPIError
+except Exception:
+    GoogleAPIError = Exception
+
+gemini_client = None
+
+if not genai:
+    logging.warning("[normalize_service] google.genai not available, normalization will be disabled")
+elif not GEMINI_API_KEY:
+    logging.warning("[normalize_service] GEMINI_API_KEY is not set, normalization will be disabled")
+else:
+    try:
+        gemini_client = genai.Client(api_key=GEMINI_API_KEY)
+        logging.info(f"[normalize_service] Initialized google.genai client with model={GEMINI_MODEL}")
+    except Exception as e:
+        logging.exception(f"[normalize_service] Failed to init google.genai client: {e}")
+        gemini_client = None
+
+
+async def normalize_text(raw_text: str) -> str:
+    if not raw_text:
+        return raw_text
+
+    prompt = f"""
+Bạn là một hệ thống Xử lý Hậu kỳ NLP (NLP Post-Processing) Tiếng Việt.
+Đầu vào là văn bản thô (raw transcript), có thể thiếu dấu câu và sai chính tả do nhận dạng giọng nói.
+
+Nhiệm vụ:
+- Sửa lỗi chính tả do ASR.
+- Thêm dấu câu phù hợp.
+- Viết hoa đúng chuẩn tiếng Việt (đầu câu, tên riêng nếu suy luận được).
+- Loại bỏ các từ/cụm từ bị lặp lại vô nghĩa.
+- Giữ nguyên nội dung và ý nghĩa gốc, không rút gọn, không thêm thông tin mới.
+
+YÊU CẦU ĐẦU RA:
+- Chỉ trả về văn bản đã chuẩn hóa
+- KHÔNG JSON, KHÔNG giải thích, KHÔNG markdown
+
+Văn bản đầu vào:
+\"\"\"{raw_text}\"\"\"
+"""
+
+    loop = asyncio.get_event_loop()
+
+    MAX_RETRIES = 3
+    BASE_DELAY = 1.0
+
+    def call():
+        last_exc = None
+        for attempt in range(1, MAX_RETRIES + 1):
+            try:
+                if gemini_client:
+                    resp = gemini_client.models.generate_content(
+                        model=GEMINI_MODEL,
+                        contents=prompt,
+                    )
+                    return resp.text or ""
+                else:
+                    model = genai.GenerativeModel(GEMINI_MODEL) if genai else None
+                    if model:
+                        resp = model.generate_content(prompt)
+                        return getattr(resp, "text", "") or ""
+                    return ""
+            except Exception as e:
+                last_exc = e
+                msg = str(e)
+                if "503" in msg or "UNAVAILABLE" in msg:
+                    if attempt < MAX_RETRIES:
+                        delay = BASE_DELAY * (2 ** (attempt - 1))
+                        delay += random.uniform(0, 0.5 * delay)
+                        logging.warning(
+                            f"[normalize_service] model overloaded "
+                            f"(attempt {attempt}/{MAX_RETRIES}), retrying after {delay:.2f}s"
+                        )
+                        time.sleep(delay)
+                        continue
+                logging.exception(
+                    f"[normalize_service] normalize call failed on attempt {attempt}: {e}"
+                )
+                break
+
+        if last_exc:
+            raise last_exc
+        return ""
+
+    try:
+        raw = await loop.run_in_executor(None, call)
+
+        if raw:
+            text = raw.strip()
+
+            # defensive cleanup (trường hợp model vẫn lỡ trả markdown)
+            text = re.sub(r"^```.*?\n", "", text, flags=re.DOTALL)
+            text = re.sub(r"```$", "", text)
+            text = text.strip('"').strip("'").strip()
+
+            if text:
+                return text
+
+    except GoogleAPIError as e:
+        logging.error(f"[normalize_service] Gemini API error: {e}")
+    except Exception as e:
+        logging.exception(f"[normalize_service] normalize_text failed: {e}")
+
+    # ===== fallback: best-effort local normalization =====
+    try:
+        text = raw_text.strip()
+        text = re.sub(r"\s+", " ", text)
+
+        if text and text[-1] not in ".!?":
+            text += "."
+
+        def cap_sentences(s: str) -> str:
+            parts = re.split(r'([.!?]\s+)', s)
+            out = ""
+            for i in range(0, len(parts), 2):
+                sentence = parts[i].strip()
+                sep = parts[i + 1] if i + 1 < len(parts) else ""
+                if sentence:
+                    sentence = sentence[0].upper() + sentence[1:]
+                out += sentence + sep
+            return out
+
+        return cap_sentences(text)
+
+    except Exception:
+        return raw_text

app/services/enrichment/pipeline.py

@@ -0,0 +1,49 @@
+from app.services.enrichment.normalize import normalize_text
+from app.services.enrichment.title_keywords import extract_title_and_keywords
+from app.services.enrichment.summary import generate_summary
+from app.services.enrichment.mindmap import generate_mindmap
+
+async def run_pipeline(note: dict, tasks: list[str]):
+    raw_text = note.get("raw_text") or ""
+    if not raw_text.strip():
+        # Nothing to process
+        return note
+
+    text = raw_text
+
+    # 1️⃣ Normalize
+    if "normalize" in tasks:
+        try:
+            text = await normalize_text(text)
+            note["normalized_text"] = text
+        except Exception:
+            # Fail-safe: keep raw_text
+            note["normalized_text"] = text
+
+    # 2️⃣ Title + Keywords (same AI call)
+    if "keywords" in tasks:
+        try:
+            title, keywords = await extract_title_and_keywords(text)
+            if title:
+                note["title"] = title
+            if keywords:
+                note["keywords"] = keywords
+        except Exception:
+            # Fail-safe: skip title & keywords
+            pass
+
+    # 3️⃣ Summary
+    if "summary" in tasks:
+        try:
+            note["summary"] = await generate_summary(text)
+        except Exception:
+            pass
+
+    # 4️⃣ Mindmap
+    if "mindmap" in tasks:
+        try:
+            note["mindmap"] = await generate_mindmap(text)
+        except Exception:
+            pass
+
+    return note

app/services/{summary_service.py → enrichment/summary.py}

@@ -1,10 +1,11 @@
 import asyncio
+import os
 import logging
 import random
-import re
 import time
+import re
 
-from app.config import GEMINI_API_KEY
+from app.config import GEMINI_API_KEY, GEMINI_MODEL
 
 try:
     import google.genai as genai
@@ -15,45 +16,41 @@ try:
 except Exception:
     genai = None
     genai_errors = None
-    logging.warning("[summary_service] google.genai module not found; summaries disabled")
+    logging.warning("[summary_service] google.genai module not found; summary generation disabled")
 
 try:
     from google.api_core.exceptions import GoogleAPIError
 except Exception:
     GoogleAPIError = Exception
 
-_SUMMARY_MODEL = "gemini-2.5-flash"
-_gemini_client = None
+gemini_client = None
 
 if not genai:
-    logging.warning("[summary_service] google.genai not available, summary will be empty")
+    logging.warning("[summary_service] google.genai not available, summary generation will be disabled")
 elif not GEMINI_API_KEY:
-    logging.warning("[summary_service] GEMINI_API_KEY is not set, summary will be empty")
+    logging.warning("[summary_service] GEMINI_API_KEY is not set, summary generation will be disabled")
 else:
     try:
-        _gemini_client = genai.Client(api_key=GEMINI_API_KEY)
-        logging.info(f"[summary_service] Initialized google.genai client with model={_SUMMARY_MODEL}")
+        gemini_client = genai.Client(api_key=GEMINI_API_KEY)
+        logging.info(f"[summary_service] Initialized google.genai client with model={GEMINI_MODEL}")
     except Exception as e:
         logging.exception(f"[summary_service] Failed to init google.genai client: {e}")
-        _gemini_client = None
-
+        gemini_client = None
 
 async def generate_summary(text: str) -> str:
-    """Tạo tóm tắt ngắn gọn 3-5 câu, một đoạn văn duy nhất.
-    Fallback: trả "" nếu không có model hoặc lỗi.
-    """
-    if not _gemini_client:
+    if not gemini_client:
+        return ""
+    
+    if not text:
         return ""
 
     prompt = f"""
 Bạn là chuyên gia tóm tắt. Hãy tóm tắt văn bản sau thành một đoạn văn duy nhất.
-
 Yêu cầu:
 1. Viết khoảng 3-5 câu, tổng hợp đầy đủ chủ đề và các ý chính.
 2. Viết liền mạch, KHÔNG xuống dòng, KHÔNG dùng gạch đầu dòng hay đánh số.
 3. Chỉ dựa trên thông tin được cung cấp, tuyệt đối KHÔNG tự thêm thông tin bên ngoài.
 4. Trả về VĂN BẢN THUẦN (plain text), không bọc trong ``` hoặc JSON.
-
 Văn bản:
 \"\"\"{text}\"\"\"
 """
@@ -67,8 +64,8 @@ Văn bản:
         last_exc = None
         for attempt in range(1, MAX_RETRIES + 1):
             try:
-                resp = _gemini_client.models.generate_content(
-                    model=_SUMMARY_MODEL,
+                resp = gemini_client.models.generate_content(
+                    model=GEMINI_MODEL,
                     contents=prompt,
                 )
                 return (resp.text or "").strip()
@@ -121,4 +118,4 @@ Văn bản:
         logging.info("[summary_service] Returning fallback summary after errors")
         return fallback
     except Exception:
-        return ""
+        return ""

app/services/enrichment/title_keywords.py

@@ -0,0 +1,187 @@
+import os
+import logging
+import json
+import asyncio
+import time
+import random
+import re
+from app.config import GEMINI_API_KEY, GEMINI_MODEL
+
+try:
+    import google.genai as genai
+    try:
+        from google.genai import errors as genai_errors
+    except Exception:
+        genai_errors = None
+except Exception:
+    genai = None
+    genai_errors = None
+    logging.warning("[keywords_service] google.genai module not found; keyword extraction disabled")
+
+try:
+    from google.api_core.exceptions import GoogleAPIError
+except Exception:
+    GoogleAPIError = Exception
+
+gemini_client = None
+
+if not genai:
+    logging.warning("[keywords_service] google.genai not available, keyword extraction will be disabled")
+elif not GEMINI_API_KEY:
+    logging.warning("[keywords_service] GEMINI_API_KEY is not set, keyword extraction will be disabled")
+else:
+    try:
+        gemini_client = genai.Client(api_key=GEMINI_API_KEY)
+        logging.info(f"[keywords_service] Initialized google.genai client with model={GEMINI_MODEL}")
+    except Exception as e:
+        logging.exception(f"[keywords_service] Failed to init google.genai client: {e}")
+        gemini_client = None
+
+
+async def extract_title_and_keywords(text: str) -> tuple[str | None, list[str]]:
+    if not text or not text.strip():
+        return None, []
+
+    if not gemini_client and not genai:
+        # AI not available → safe fallback
+        return None, []
+
+    prompt = f"""
+Bạn là một hệ thống Xử lý Hậu kỳ NLP (NLP Post-Processing) Tiếng Việt.
+
+Nhiệm vụ:
+1. Sinh **tiêu đề (title)** ngắn gọn phản ánh đúng chủ đề chính của văn bản:
+   - Độ dài tối đa **10 từ**
+   - Mang tính mô tả, trung tính, phù hợp làm tiêu đề ghi chú (note)
+   - KHÔNG giật tít, KHÔNG suy diễn quá mức
+
+2. Rút trích các **từ khóa quan trọng** phản ánh đúng **chủ đề và nội dung chính** của văn bản.
+- Mỗi từ khóa dài từ **1–4 từ**.
+- Ưu tiên danh từ, cụm danh từ, thuật ngữ, khái niệm chính.
+- Loại bỏ từ chung chung, từ đệm, từ cảm thán, từ lặp nghĩa.
+- KHÔNG diễn giải, KHÔNG tóm tắt, KHÔNG chuẩn hóa lại văn bản.
+- KHÔNG tạo từ khóa không xuất hiện hoặc không suy luận hợp lý từ văn bản.
+
+Quy tắc:
+- Số lượng từ khóa: 3–10 (tùy độ dài và nội dung văn bản).
+- Giữ nguyên chữ thường/hoa theo cách viết phổ biến.
+- KHÔNG trùng lặp từ khóa.
+- KHÔNG sắp xếp theo bảng chữ cái; ưu tiên theo mức độ quan trọng.
+
+Văn bản đầu vào:
+\"\"\"{text}\"\"\"
+
+YÊU CẦU ĐẦU RA:
+- Chỉ trả về **JSON hợp lệ**
+- KHÔNG giải thích
+- KHÔNG markdown
+- KHÔNG thêm trường khác ngoài schema dưới đây
+
+Cấu trúc JSON bắt buộc:
+{{
+    "title": "Tiêu đề ngắn gọn",
+    "keywords": ["Từ khóa 1", "Từ khóa 2", "..."]
+}}
+"""
+
+    loop = asyncio.get_event_loop()
+
+    MAX_RETRIES = 3
+    BASE_DELAY = 1.0
+
+    def call():
+        last_exc = None
+        for attempt in range(1, MAX_RETRIES + 1):
+            try:
+                if gemini_client:
+                    resp = gemini_client.models.generate_content(
+                        model=GEMINI_MODEL,
+                        contents=prompt,
+                    )
+                    return getattr(resp, "text", "") or ""
+                else:
+                    model = genai.GenerativeModel(GEMINI_MODEL) if genai else None
+                    if model:
+                        resp = model.generate_content(prompt)
+                        return getattr(resp, "text", "") or ""
+                    return ""
+            except Exception as e:
+                last_exc = e
+                is_server_error = False
+                try:
+                    if genai_errors and isinstance(e, genai_errors.ServerError):
+                        is_server_error = True
+                except Exception:
+                    pass
+
+                msg = str(e)
+                if "503" in msg or "UNAVAILABLE" in msg or is_server_error:
+                    if attempt < MAX_RETRIES:
+                        delay = BASE_DELAY * (2 ** (attempt - 1))
+                        delay = delay + random.uniform(0, 0.5 * delay)
+                        logging.warning(f"[keywords_service] model overloaded (attempt {attempt}/{MAX_RETRIES}), retrying after {delay:.2f}s")
+                        time.sleep(delay)
+                        continue
+                logging.exception(f"[keywords_service] extract_keywords call failed on attempt {attempt}: {e}")
+                break
+
+        if last_exc:
+            raise last_exc
+        return ""
+
+    try:
+        raw = await loop.run_in_executor(None, call)
+        title, keywords = _parse_response(raw)
+        return title, keywords
+    except GoogleAPIError as e:
+        logging.error("[title_keywords_service] Gemini API error: %s", e)
+    except Exception as e:
+        logging.exception("[title_keywords_service] extract failed: %s", e)
+
+    return None, []
+
+def _parse_response(raw: str) -> tuple[str | None, list[str]]:
+    if not raw:
+        return None, []
+
+    raw = raw.strip()
+
+    # Try extracting JSON block
+    start = raw.find("{")
+    end = raw.rfind("}")
+
+    if start != -1 and end != -1 and end > start:
+        raw_json = raw[start : end + 1]
+    else:
+        raw_json = raw
+
+    try:
+        parsed = json.loads(raw_json)
+    except Exception as e:
+        logging.warning(
+            "[title_keywords_service] Failed to parse JSON: %s | raw=%r",
+            e,
+            raw[:300],
+        )
+        return None, []
+
+    title = parsed.get("title")
+    keywords = parsed.get("keywords")
+
+    # Validate title
+    if not isinstance(title, str) or not title.strip():
+        title = None
+    else:
+        title = title.strip()
+
+    # Validate keywords
+    if not isinstance(keywords, list):
+        keywords = []
+    else:
+        keywords = [
+            k.strip()
+            for k in keywords
+            if isinstance(k, str) and k.strip()
+        ]
+
+    return title, keywords

app/services/folder_store.py

@@ -0,0 +1,23 @@
+from app.infra.firebase import db
+
+COL = "folders"
+
+def create_folder(folder: dict):
+    db.collection(COL).document(folder["folder_id"]).set(folder)
+
+
+def get_folder(folder_id: str):
+    doc = db.collection(COL).document(folder_id).get()
+    return doc.to_dict() if doc.exists else None
+
+
+def list_folders():
+    return [d.to_dict() for d in db.collection(COL).stream()]
+
+
+def update_folder(folder_id: str, data: dict):
+    db.collection(COL).document(folder_id).update(data)
+
+
+def delete_folder(folder_id: str):
+    db.collection(COL).document(folder_id).delete()

app/services/note_store.py

@@ -0,0 +1,26 @@
+from app.infra.firebase import db
+
+COL = "notes"
+
+def create_note(note: dict):
+    ref = db.collection(COL).document(note["note_id"])
+    if ref.get().exists:
+        raise ValueError(f"Note already exists: {note['note_id']}")
+    ref.set(note)
+
+
+def update_note(note_id: str, data: dict):
+    if not data:
+        return
+    db.collection(COL).document(note_id).update(data)
+
+def get_note(note_id: str):
+    doc = db.collection(COL).document(note_id).get()
+    return doc.to_dict() if doc.exists else None
+
+
+def list_notes(folder_id: str | None = None):
+    q = db.collection(COL)
+    if folder_id:
+        q = q.where("folder_id", "==", folder_id)
+    return [d.to_dict() for d in q.stream()]

app/services/storage.py

@@ -1,33 +0,0 @@
-from datetime import datetime
-from app.services.firebase import db
-
-COLLECTION = "notes"
-
-import logging
-
-def create_note(note_id: str, payload: dict):
-    now = datetime.utcnow()
-    payload.update({
-        "status": "created",
-        "created_at": now,
-        "updated_at": now
-    })
-    logging.info(f"[NoteService] create_note: id={note_id}, keys={list(payload.keys())}")
-    db.collection(COLLECTION).document(note_id).set(payload)
-    logging.info(f"[NoteService] create_note: saved id={note_id}")
-
-
-def update_note(note_id: str, data: dict = None, status: str = None):
-    updates = {"updated_at": datetime.utcnow()}
-    if data:
-        updates.update(data)
-    if status:
-        updates["status"] = status
-
-    db.collection(COLLECTION).document(note_id).update(updates)
-
-def get_note(note_id: str):
-    logging.info(f"[NoteService] get_note: id={note_id}")
-    doc = db.collection(COLLECTION).document(note_id).get()
-    logging.info(f"[NoteService] get_note: exists={doc.exists}")
-    return doc.to_dict() if doc.exists else None

app/utils/id.py

@@ -0,0 +1,4 @@
+import uuid
+
+def new_id() -> str:
+    return uuid.uuid4().hex

app/utils/time.py

@@ -0,0 +1,4 @@
+import time
+
+def now_ts() -> int:
+    return int(time.time() * 1000)

requirements.txt

@@ -2,3 +2,4 @@ fastapi
 uvicorn
 google-genai
 firebase-admin
+pydantic