RAG-api / app /api /routes.py
Minh Be
deploy FastAPI backend
3e1cbf3
Raw History Blame Contribute Delete
17.6 kB
"""Các endpoint HTTP."""
from __future__ import annotations
import json
import threading
import uuid
from datetime import datetime, timezone
from pathlib import Path
from fastapi import APIRouter, Depends, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from sqlalchemy import func, select
from sqlalchemy.orm import Session
from app.agent.pipeline import run_chat
from app.db.base import get_db
from app.db.models import LegalDocument, LegalNode, Thread
from app.llm.router import get_router
from app.sse import sse
router = APIRouter()
# ---------- Health ----------
@router.get("/health")
def health(db: Session = Depends(get_db)):
try:
n_docs = db.scalar(select(func.count()).select_from(LegalDocument)) or 0
n_nodes = db.scalar(select(func.count()).select_from(LegalNode)) or 0
db_ok = True
except Exception: # noqa: BLE001
n_docs = n_nodes = 0
db_ok = False
return {
"status": "ok",
"db": db_ok,
"documents": n_docs,
"nodes": n_nodes,
"data_loaded": n_nodes > 0,
"llm": get_router().available_providers(),
}
# ---------- Tra cứu điều luật ----------
@router.get("/api/law/{node_id}")
def get_law(node_id: str, db: Session = Depends(get_db)):
node = db.get(LegalNode, node_id)
if not node:
raise HTTPException(status_code=404, detail=f"Không tìm thấy node {node_id}")
return {
"node_id": node.node_id,
"doc_id": node.doc_id,
"level": node.level,
"heading": node.heading,
"text": node.text,
"effective_from": node.effective_from,
"effective_to": node.effective_to,
}
@router.get("/api/documents")
def list_documents(db: Session = Depends(get_db)):
docs = db.scalars(select(LegalDocument)).all()
return [
{"doc_id": d.doc_id, "title": d.title, "doc_type": d.doc_type, "status": d.status}
for d in docs
]
# ---------- Tìm kiếm (M2 sẽ hoàn thiện) ----------
class SearchRequest(BaseModel):
query: str
top_k: int = 5
@router.post("/api/search")
def search(req: SearchRequest, db: Session = Depends(get_db)):
from app.rag.search import search_nodes
hits = search_nodes(db, req.query, top_k=req.top_k)
return {"query": req.query, "hits": hits}
# ---------- Hiệu lực theo thời gian + sửa đổi (M4) ----------
@router.get("/api/law_as_of")
def law_as_of_route(date: str, topic: str | None = None, db: Session = Depends(get_db)):
from datetime import date as _date
from app.amend.store import law_as_of
rows = law_as_of(db, _date.fromisoformat(date), topic=topic)
return {"date": date, "topic": topic, "count": len(rows), "nodes": rows}
@router.get("/api/node/{node_id}/history")
def node_history_route(node_id: str, db: Session = Depends(get_db)):
from app.amend.store import node_history
return {"node_id": node_id, "history": node_history(db, node_id)}
class DiffRequest(BaseModel):
old_doc_id: str
new_doc_id: str
write: bool = False
@router.post("/api/admin/diff")
def diff_route(req: DiffRequest, db: Session = Depends(get_db)):
from app.amend.store import diff_documents
diffs = diff_documents(db, req.old_doc_id, req.new_doc_id, write=req.write)
changed = [d for d in diffs if d["change_type"] != "unchanged"]
return {"total": len(diffs), "changed": len(changed), "diffs": changed[:200]}
# ---------- Soạn thảo văn bản NĐ30 (M5) ----------
class DraftRequest(BaseModel):
doc_type: str = "quyet_dinh"
org_name: str = ""
org_parent: str | None = None
number: str | None = None
place: str = "Hà Nội"
subject: str = ""
bases: list[str] = []
body: str = ""
signer_title: str = "GIÁM ĐỐC"
signer_name: str = ""
recipients: list[str] = ["Như trên", "Lưu: VT."]
auto_bases: bool = True
def _suggest_bases(db: Session) -> list[str]:
"""Gợi ý 'Căn cứ' từ các văn bản còn hiệu lực trong kho."""
from app.db.models import LegalDocument
docs = db.scalars(
select(LegalDocument).where(LegalDocument.status == "active")
).all()
out = []
for d in docs:
if d.doc_type == "luat":
out.append(f"{d.title} số {d.number}")
elif d.doc_type:
out.append(f"{d.title}")
return out
def _to_input(req: DraftRequest, db: Session):
from app.draft.nd30 import DraftInput
bases = list(req.bases)
if req.auto_bases and not bases:
bases = _suggest_bases(db)
return DraftInput(
doc_type=req.doc_type, org_name=req.org_name, org_parent=req.org_parent,
number=req.number, place=req.place, subject=req.subject, bases=bases,
body=req.body, signer_title=req.signer_title, signer_name=req.signer_name,
recipients=req.recipients,
)
@router.post("/api/draft/preview")
def draft_preview(req: DraftRequest, db: Session = Depends(get_db)):
from app.draft.nd30 import format_check, render_text
d = _to_input(req, db)
return {"text": render_text(d), "issues": format_check(d), "bases": d.bases}
@router.post("/api/draft/export")
def draft_export(req: DraftRequest, db: Session = Depends(get_db)):
from app.draft.nd30 import render_docx
data = render_docx(_to_input(req, db))
from fastapi.responses import Response
return Response(
content=data,
media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
headers={"Content-Disposition": 'attachment; filename="van-ban.docx"'},
)
# ---------- Tổng hợp án lệ (M6b) ----------
class PrecedentRequest(BaseModel):
query: str
top_k: int = 4
@router.post("/api/precedent")
def precedent_route(req: PrecedentRequest):
from app.agent.precedent import synthesize
return synthesize(req.query, top_k=req.top_k)
# ---------- Báo cáo nhiều văn bản (M6) ----------
class ReportRequest(BaseModel):
topic: str
top_k: int = 15
@router.post("/api/report")
def report_route(req: ReportRequest):
from app.report.multi_doc import build_report
return build_report(req.topic, top_k=req.top_k)
@router.post("/api/report/export")
def report_export_route(req: ReportRequest):
from fastapi.responses import Response
from app.report.multi_doc import build_report, report_to_docx
data = report_to_docx(build_report(req.topic, top_k=req.top_k))
return Response(
content=data,
media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
headers={"Content-Disposition": 'attachment; filename="bao-cao.docx"'},
)
# ---------- Chat (SSE) ----------
class ChatMessage(BaseModel):
role: str
content: str
class ChatRequest(BaseModel):
message: str
thread_id: str | None = None
history: list[ChatMessage] = []
@router.post("/api/chat")
def chat(req: ChatRequest):
history = [{"role": m.role, "content": m.content} for m in req.history]
def gen():
thread_id = req.thread_id or uuid.uuid4().hex
yield sse("start", {"thread_id": thread_id})
try:
for event, data in run_chat(req.message, history):
yield sse(event, data)
except Exception as exc: # noqa: BLE001
yield sse("error", {"message": str(exc)})
return StreamingResponse(
gen(),
media_type="text/event-stream",
headers={"Cache-Control": "no-cache, no-transform", "X-Accel-Buffering": "no"},
)
# ---------- Threads (tối giản) ----------
@router.get("/api/threads")
def list_threads(db: Session = Depends(get_db)):
rows = db.scalars(select(Thread).order_by(Thread.updated_at.desc())).all()
return [{"id": t.id, "title": t.title} for t in rows]
# ---------- Knowledge Graph ----------
@router.get("/api/graph")
def graph_route(query: str = "", top_k: int = 150, db: Session = Depends(get_db)):
"""Trả về nodes + edges cho knowledge graph theo từ khóa.
Sau khi lấy hits, tự mở rộng:
- thêm node cha (Điều) của mọi Khoản/Điểm trong kết quả
- thêm tất cả Khoản con của mọi Điều trong kết quả
→ đảm bảo cạnh Điều–Khoản luôn hiện đầy đủ.
"""
from app.rag.search import search_nodes, _display
from app.db.models import (
LegalNode, NodeSupersession, LegalDocument, DocumentRelation,
)
from sqlalchemy import select as sa_select
from sqlalchemy import text as sa_text
# ── 1. Initial fetch ──────────────────────────────────────────────────────
if query.strip():
hits = search_nodes(db, query, top_k=top_k)
else:
rows = db.execute(
sa_text(
"SELECT node_id, doc_id, article_no, clause_no, point_letter, heading, text, level, parent_id "
"FROM legal_node "
"ORDER BY CASE level WHEN 'article' THEN 0 WHEN 'clause' THEN 1 ELSE 2 END, node_id "
"LIMIT :k"
),
{"k": top_k},
).all()
hits = []
for r in rows:
d = dict(r._mapping)
d["display"] = _display(d)
d["score"] = 0.0
hits.append(d)
if not hits:
return {"nodes": [], "edges": [], "query": query}
id_set: set[str] = {h["node_id"] for h in hits}
def _node_dict(n: LegalNode, score: float = 0.0, ghost: bool = False) -> dict:
row = {
"node_id": n.node_id, "doc_id": n.doc_id,
"article_no": n.article_no, "clause_no": n.clause_no,
"point_letter": n.point_letter,
}
label = _display(row)
return {
"id": n.node_id, "label": label, "doc_id": n.doc_id,
"level": n.level, "type": n.level, "heading": n.heading or "",
"text": (n.text or "")[:300], "score": score, "ghost": ghost,
}
def _hit_dict(h: dict) -> dict:
lvl = h.get("level") or "article"
return {
"id": h["node_id"],
"label": h.get("display") or h["node_id"],
"doc_id": h["doc_id"],
"level": lvl,
"type": lvl,
"heading": h.get("heading", ""),
"text": (h.get("text") or "")[:300],
"score": round(h.get("score", 0.0), 3),
}
nodes: list[dict] = [_hit_dict(h) for h in hits]
# ── 2. Expand: fetch parent articles of clauses/points ────────────────────
child_parent_rows = db.execute(
sa_select(LegalNode.node_id, LegalNode.parent_id)
.where(LegalNode.node_id.in_(list(id_set)))
.where(LegalNode.parent_id.isnot(None))
).all()
missing_parents = {pid for _, pid in child_parent_rows if pid not in id_set}
if missing_parents:
parent_objs = db.execute(
sa_select(LegalNode).where(LegalNode.node_id.in_(list(missing_parents)))
).scalars().all()
for p in parent_objs:
nodes.append(_node_dict(p, ghost=False))
id_set.add(p.node_id)
# ── 3. Expand: fetch children of article nodes in set ────────────────────
article_ids = [n["id"] for n in nodes if n["level"] == "article"]
if article_ids:
child_objs = db.execute(
sa_select(LegalNode)
.where(LegalNode.parent_id.in_(article_ids))
.where(~LegalNode.node_id.in_(list(id_set)))
).scalars().all()
for c in child_objs:
nodes.append(_node_dict(c, ghost=False))
id_set.add(c.node_id)
all_ids = [n["id"] for n in nodes]
# ── 4. Edges ──────────────────────────────────────────────────────────────
edges: list[dict] = []
seen_edges: set[tuple] = set()
def add_edge(src: str, tgt: str, etype: str) -> None:
key = (src, tgt)
if key not in seen_edges and src != tgt and src in id_set and tgt in id_set:
seen_edges.add(key)
edges.append({"source": src, "target": tgt, "type": etype})
# 4a. Parent → child (all nodes now in set)
all_parent_rows = db.execute(
sa_select(LegalNode.node_id, LegalNode.parent_id)
.where(LegalNode.node_id.in_(all_ids))
.where(LegalNode.parent_id.isnot(None))
).all()
for nid, pid in all_parent_rows:
add_edge(pid, nid, "contains")
# 4b. Supersession — cạnh mang đúng loại thay đổi (reworded/tightened/…)
sup_rows = db.execute(
sa_select(
NodeSupersession.old_id,
NodeSupersession.new_id,
NodeSupersession.change_type,
).where(
NodeSupersession.old_id.in_(all_ids) |
NodeSupersession.new_id.in_(all_ids)
)
).all()
for old_id, new_id, change_type in sup_rows:
for nid in (old_id, new_id):
if nid not in id_set:
obj = db.get(LegalNode, nid)
if obj:
nodes.append(_node_dict(obj, ghost=True))
id_set.add(nid)
add_edge(old_id, new_id, change_type or "superseded_by")
# 4c. Siblings: clauses of same article not already connected via parent
art_children: dict[str, list[str]] = {}
for nid, pid in all_parent_rows:
if pid:
art_children.setdefault(pid, []).append(nid)
for siblings in art_children.values():
siblings.sort()
for i in range(len(siblings) - 1):
add_edge(siblings[i], siblings[i + 1], "sibling")
# ── 5. Document nodes: type thứ 4 của ontology ───────────────────────────
doc_ids = sorted({n["doc_id"] for n in nodes if n.get("doc_id")})
doc_type_by_id: dict[str, str] = {}
if doc_ids:
doc_objs = db.execute(
sa_select(LegalDocument).where(LegalDocument.doc_id.in_(doc_ids))
).scalars().all()
doc_type_by_id = {d.doc_id: (d.doc_type or "") for d in doc_objs}
for d in doc_objs:
did = f"doc:{d.doc_id}"
nodes.append({
"id": did, "label": d.doc_id, "doc_id": d.doc_id,
"level": "document", "type": "document",
"doc_type": d.doc_type or "",
"heading": d.title or d.doc_id,
"text": d.title or "", "score": 0.0, "ghost": False,
})
id_set.add(did)
# văn bản → Điều
for n in nodes:
if n.get("type") == "article":
add_edge(f"doc:{n['doc_id']}", n["id"], "contains")
# văn bản → văn bản (REPLACES / AMENDS / GUIDES)
rel_rows = db.execute(
sa_select(
DocumentRelation.from_doc, DocumentRelation.to_doc, DocumentRelation.rel,
)
.where(DocumentRelation.from_doc.in_(doc_ids))
.where(DocumentRelation.to_doc.in_(doc_ids))
).all()
for f_doc, t_doc, rel in rel_rows:
add_edge(f"doc:{f_doc}", f"doc:{t_doc}", (rel or "related").lower())
# doc_type trên mọi node để gom cụm
for n in nodes:
n.setdefault("doc_type", doc_type_by_id.get(n.get("doc_id", ""), ""))
return {"nodes": nodes, "edges": edges, "query": query}
# ---------- Human-in-loop: Escalation (câu hỏi không đủ căn cứ) ----------
_ESC_FILE = Path("/app/data/escalations.json")
_esc_lock = threading.Lock()
def _load_esc() -> list[dict]:
try:
if _ESC_FILE.exists():
return json.loads(_ESC_FILE.read_text(encoding="utf-8"))
except Exception: # noqa: BLE001
pass
return []
def _save_esc(rows: list[dict]) -> None:
_ESC_FILE.parent.mkdir(parents=True, exist_ok=True)
_ESC_FILE.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")
class EscalateRequest(BaseModel):
question: str
thread_id: str | None = None
class EscalateUpdate(BaseModel):
status: str # "approved" | "denied"
@router.post("/api/escalate")
def escalate(req: EscalateRequest):
"""Ghi nhận câu hỏi không đủ căn cứ để nhà phát hành xem xét."""
row = {
"id": uuid.uuid4().hex,
"question": req.question,
"thread_id": req.thread_id,
"status": "pending",
"created_at": datetime.now(timezone.utc).isoformat(),
}
with _esc_lock:
rows = _load_esc()
rows.insert(0, row)
_save_esc(rows)
return {"id": row["id"], "status": "pending"}
@router.get("/api/escalations")
def list_escalations():
"""Lấy danh sách câu hỏi chờ phê duyệt."""
with _esc_lock:
return _load_esc()
@router.patch("/api/escalations/{esc_id}")
def update_escalation(esc_id: str, req: EscalateUpdate):
"""Cập nhật trạng thái: approved / denied."""
with _esc_lock:
rows = _load_esc()
for r in rows:
if r["id"] == esc_id:
r["status"] = req.status
r["resolved_at"] = datetime.now(timezone.utc).isoformat()
break
else:
raise HTTPException(status_code=404, detail="Không tìm thấy escalation")
_save_esc(rows)
return {"id": esc_id, "status": req.status}