Initial commit: FastAPI RAG API

.gitignore

@@ -1,6 +1,12 @@
-venv/
+venv/
 .venv/
 __pycache__/
 *.pyc
 *.pyo
 *.pyd
+*.log
+.env
+data/uploads/
+data/index/
+.git
+.gitignore

app/api.py

@@ -0,0 +1,76 @@
+# app/api.py
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pathlib import Path
+import shutil
+import traceback
+
+from .rag_system import SimpleRAG, UPLOAD_DIR
+from .schemas import AskRequest, AskResponse, UploadResponse, HistoryResponse, HistoryItem
+from .store import add_history, get_history
+from .utils import ensure_session, http400
+
+app = FastAPI(title="RAG API", version="1.0.0")
+
+# CORS (Streamlit/UI üçün)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # prod-da domeninlə dəyiş
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+rag = SimpleRAG()
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+@app.post("/upload_pdf", response_model=UploadResponse)
+async def upload_pdf(file: UploadFile = File(...)):
+    try:
+        if not file.filename.lower().endswith(".pdf"):
+            http400("Yalnız PDF faylları qəbul olunur.")
+        dest = UPLOAD_DIR / file.filename
+        with dest.open("wb") as f:
+            shutil.copyfileobj(file.file, f)
+        chunks_added = rag.add_pdf(dest)
+        return UploadResponse(filename=file.filename, chunks_added=chunks_added)
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(status_code=500, content={"detail": f"Server xətası: {str(e)}"})
+
+@app.post("/ask_question", response_model=AskResponse)
+async def ask_question(payload: AskRequest):
+    try:
+        session_id = ensure_session(payload.session_id)
+        add_history(session_id, "user", payload.question)
+        results = rag.search(payload.question, k=payload.top_k)
+        contexts = [c for c, _ in results]
+        answer = rag.synthesize_answer(payload.question, contexts) if hasattr(rag, "synthesize_answer") else None
+        if answer is None:
+            # rag_system.synthesize_answer funksiyasını birbaşa import etməmişiksə:
+            from .rag_system import synthesize_answer
+            answer = synthesize_answer(payload.question, contexts)
+        add_history(session_id, "assistant", answer)
+        return AskResponse(answer=answer, contexts=contexts, session_id=session_id)
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(status_code=500, content={"detail": f"Server xətası: {str(e)}"})
+
+@app.get("/get_history", response_model=HistoryResponse)
+async def get_history_endpoint(session_id: str):
+    try:
+        hist_raw = get_history(session_id)
+        history = [HistoryItem(**h) for h in hist_raw]
+        return HistoryResponse(session_id=session_id, history=history)
+    except Exception as e:
+        traceback.print_exc()
+        return JSONResponse(status_code=500, content={"detail": f"Server xətası: {str(e)}"})
+from fastapi.responses import RedirectResponse
+
+@app.get("/")
+def root():
+    return RedirectResponse(url="/docs")

app/rag_system.py

@@ -0,0 +1,93 @@
+# app/rag_system.py
+from pathlib import Path
+from typing import List, Tuple
+import os
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from pypdf import PdfReader
+
+DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+UPLOAD_DIR = DATA_DIR / "uploads"
+INDEX_DIR = DATA_DIR / "index"
+INDEX_DIR.mkdir(parents=True, exist_ok=True)
+UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+MODEL_NAME = os.getenv("EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+
+class SimpleRAG:
+    def __init__(self, index_path: Path = INDEX_DIR / "faiss.index", meta_path: Path = INDEX_DIR / "meta.npy"):
+        self.model = SentenceTransformer(MODEL_NAME)
+        self.index_path = index_path
+        self.meta_path = meta_path
+        self.index = None
+        self.chunks: List[str] = []
+        self._load()
+
+    def _load(self):
+        # meta (chunks) yüklə
+        if self.meta_path.exists():
+            self.chunks = np.load(self.meta_path, allow_pickle=True).tolist()
+        # faiss index yüklə
+        if self.index_path.exists():
+            # dim modelin çıxış ölçüsü
+            dim = self.model.get_sentence_embedding_dimension()
+            self.index = faiss.read_index(str(self.index_path))
+            # təhlükəsizlik: ölçüsü uyğun olmalıdır
+            if self.index.d != dim:
+                # uyğunsuzluqda sıfırdan başla
+                self.index = faiss.IndexFlatIP(dim)
+        else:
+            dim = self.model.get_sentence_embedding_dimension()
+            self.index = faiss.IndexFlatIP(dim)
+
+    def _persist(self):
+        faiss.write_index(self.index, str(self.index_path))
+        np.save(self.meta_path, np.array(self.chunks, dtype=object))
+
+    @staticmethod
+    def _pdf_to_texts(pdf_path: Path) -> List[str]:
+        reader = PdfReader(str(pdf_path))
+        full_text = []
+        for page in reader.pages:
+            t = page.extract_text() or ""
+            if t.strip():
+                full_text.append(t)
+        # sadə parçalama: ~500 hərf
+        chunks = []
+        for txt in full_text:
+            step = 800
+            for i in range(0, len(txt), step):
+                chunks.append(txt[i:i+step])
+        return chunks
+
+    def add_pdf(self, pdf_path: Path) -> int:
+        texts = self._pdf_to_texts(pdf_path)
+        if not texts:
+            return 0
+        emb = self.model.encode(texts, convert_to_numpy=True, normalize_embeddings=True)
+        self.index.add(emb)
+        self.chunks.extend(texts)
+        self._persist()
+        return len(texts)
+
+    def search(self, query: str, k: int = 5) -> List[Tuple[str, float]]:
+        q = self.model.encode([query], convert_to_numpy=True, normalize_embeddings=True)
+        D, I = self.index.search(q, k)
+        results = []
+        if I.size > 0 and len(self.chunks) > 0:
+            for idx, score in zip(I[0], D[0]):
+                if 0 <= idx < len(self.chunks):
+                    results.append((self.chunks[idx], float(score)))
+        return results
+
+# sadə cavab formalaşdırıcı (LLM yoxdursa, kontekst + heuristika)
+def synthesize_answer(question: str, contexts: List[str]) -> str:
+    if not contexts:
+        return "Kontekst tapılmadı. Sualı daha dəqiq verin və ya PDF yükləyin."
+    joined = "\n---\n".join(contexts[:3])
+    return (
+        f"Sual: {question}\n\n"
+        f"Cavab (kontekstdən çıxarış):\n{joined}\n\n"
+        f"(Qeyd: Demo rejimi — LLM inteqrasiyası üçün / later: OpenAI/Groq və s.)"
+    )

app/schemas.py

@@ -0,0 +1,25 @@
+# app/schemas.py
+from pydantic import BaseModel, Field
+from typing import Optional, List
+
+class AskRequest(BaseModel):
+    question: str = Field(..., min_length=2)
+    session_id: Optional[str] = None
+    top_k: int = 5
+
+class AskResponse(BaseModel):
+    answer: str
+    contexts: List[str]
+    session_id: str
+
+class UploadResponse(BaseModel):
+    filename: str
+    chunks_added: int
+
+class HistoryItem(BaseModel):
+    role: str
+    content: str
+
+class HistoryResponse(BaseModel):
+    session_id: str
+    history: List[HistoryItem]

app/store.py

@@ -0,0 +1,12 @@
+# app/store.py
+from collections import defaultdict
+from typing import List, Dict
+
+# in-memory chat tarixi (prod üçün Redis/Postgres məsləhətdir)
+_history: Dict[str, List[dict]] = defaultdict(list)
+
+def add_history(session_id: str, role: str, content: str):
+    _history[session_id].append({"role": role, "content": content})
+
+def get_history(session_id: str) -> List[dict]:
+    return _history.get(session_id, [])

app/utils.py

@@ -0,0 +1,9 @@
+# app/utils.py
+import uuid
+from fastapi import HTTPException
+
+def ensure_session(session_id: str | None) -> str:
+    return session_id or str(uuid.uuid4())
+
+def http400(msg: str):
+    raise HTTPException(status_code=400, detail=msg)

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn[standard]
+python-multipart
+pydantic==2.*
+pydantic-settings
+sentence-transformers
+faiss-cpu
+pypdf
+python-dotenv

saa

@@ -0,0 +1,21 @@
+diff.astextplain.textconv=astextplain
+filter.lfs.clean=git-lfs clean -- %f
+filter.lfs.smudge=git-lfs smudge -- %f
+filter.lfs.process=git-lfs filter-process
+filter.lfs.required=true
+http.sslbackend=schannel
+core.autocrlf=true
+core.fscache=true
+core.symlinks=false
+pull.rebase=false
+credential.helper=manager
+credential.https://dev.azure.com.usehttppath=true
+init.defaultbranch=master
+user.name=HamidOmarov
+[email protected]
+core.repositoryformatversion=0
+core.filemode=false
+core.bare=false
+core.logallrefupdates=true
+core.symlinks=false
+core.ignorecase=true

tests/test_requests.http

@@ -0,0 +1,9 @@
+# PDF yüklə
+curl -X POST "http://127.0.0.1:8000/upload_pdf" \
+ -H "accept: application/json" -H "Content-Type: multipart/form-data" \
+ -F "file=@/path/to/file.pdf"
+
+# Sual ver
+curl -X POST "http://127.0.0.1:8000/ask_question" \
+ -H "Content-Type: application/json" \
+ -d '{"question":"Bu sənəd nədən bəhs edir?","top_k":5}'