rag-app/doc_rag_app.py

# doc_rag_app.py
import os
import json
import uvicorn
import requests
from dotenv import load_dotenv
from typing import Optional
from openai import OpenAI
from fastapi import FastAPI, HTTPException
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings

# Load .env
load_dotenv()

# -----------------------
# Configuration
# -----------------------
GITPASHA_HOST = os.getenv(
    "GITPASHA_HOST",
    "https://app1-f06df021060b.hosted.ghaymah.systems"
)  # remote GitPasha endpoint you provided
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")  # used only for final LLM summarization if needed
DOC_FILE = os.getenv("DOC_FILE", "full_ghaymah_docs.txt")

# -----------------------
# FastAPI + client
# -----------------------
app = FastAPI(title="Ghaymah Docs RAG API (Restarted)", version="1.0")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # or ["http://127.0.0.1:5500"] if serving HTML with Live Server
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# optional remote LLM client (only required if you want final answer generation)
client = None
if OPENAI_API_KEY:
    client = OpenAI(api_key=OPENAI_API_KEY, base_url="https://genai.ghaymah.systems")

# -----------------------
# Embedding model (512 dims)
# -----------------------
print("Initializing local embedding model (sentence-transformers/distiluse-base-multilingual-cased)...")
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/distiluse-base-multilingual-cased")
print("Embedding model loaded.")

# -----------------------
# Request Models
# -----------------------
class QueryRequest(BaseModel):
    query: str
    k: Optional[int] = 10   # allow overriding k

class IngestRequest(BaseModel):
    # keep for future if want dynamic file name content ingestion
    filename: Optional[str] = None

# -----------------------
# Helpers
# -----------------------
def _embed_texts(texts):
    """Return list of embeddings for given texts."""
    return embeddings.embed_documents(texts)

def _embed_query(text):
    """Return single embedding for query (list)."""
    return embeddings.embed_query(text)

def store_text_chunks_remote(text: str) -> bool:
    """Split text, embed chunks, and insert to remote GitPasha."""
    if not text:
        print("No text provided to store.")
        return False

    # Split
    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
    chunks = splitter.split_text(text)
    print(f"[store] Split into {len(chunks)} chunks.")

    # Create embeddings
    try:
        chunk_vectors = _embed_texts(chunks)
    except Exception as e:
        print(f"[store] Embedding creation error: {e}")
        raise HTTPException(status_code=500, detail=f"Failed to create embeddings: {e}")

    # Log embedding dimension sanity check
    if chunk_vectors and isinstance(chunk_vectors[0], list):
        print(f"[store] Embedding vector dimension: {len(chunk_vectors[0])}")
    else:
        print(f"[store] Unexpected embedding format. First vector: {type(chunk_vectors[0])}")

    payloads = [{"text_chunk": chunk} for chunk in chunks]

    # Send to GitPasha
    try:
        resp = requests.post(
            f"{GITPASHA_HOST.rstrip('/')}/insert",
            json={"vectors": chunk_vectors, "payloads": payloads},
            headers={"Content-Type": "application/json"},
            timeout=60
        )
        resp.raise_for_status()
        print(f"[store] Remote insert status: {resp.status_code}")
        return True
    except requests.exceptions.RequestException as e:
        print(f"[store] Error calling remote insert: {e} / Response: {getattr(e, 'response', None)}")
        raise HTTPException(status_code=500, detail=f"Failed to insert to remote vector store: {e}")

def search_remote_by_vector(vector, k=10):
    """Call remote /search with given vector and return parsed JSON (raw)."""
    try:
        resp = requests.post(
            f"{GITPASHA_HOST.rstrip('/')}/search",
            json={"vector": vector, "k": k},
            headers={"Content-Type": "application/json"},
            timeout=30
        )
        resp.raise_for_status()
        return resp.json()
    except requests.exceptions.RequestException as e:
        print(f"[search] Error calling remote search: {e}")
        raise HTTPException(status_code=500, detail=f"Remote search failed: {e}")

def build_context_from_search_results(search_results, min_score: Optional[float] = None):
    """Given remote search results, optionally filter by min_score and return context text and metadata."""
    if not search_results or "results" not in search_results:
        return "", []

    items = []
    for r in search_results["results"]:
        score = r.get("score", None)
        payload = r.get("payload", {})
        text_chunk = payload.get("text_chunk", "")
        if min_score is None or (score is not None and score >= min_score):
            items.append({"score": score, "text": text_chunk})
    context = "\n\n".join([it["text"] for it in items])
    return context, items

# -----------------------
# Startup: optionally auto-ingest file on startup
# -----------------------
@app.on_event("startup")
def startup_ingest():
    """On startup, attempt to ingest DOC_FILE automatically (non-fatal)."""
    print(f"[startup] Attempting to ingest '{DOC_FILE}' on startup (if present).")
    if not os.path.exists(DOC_FILE):
        print(f"[startup] File '{DOC_FILE}' not found; skipping automatic ingestion.")
        return
    try:
        with open(DOC_FILE, "r", encoding="utf-8") as f:
            text = f.read()
        ok = store_text_chunks_remote(text)
        if ok:
            print(f"[startup] Ingested '{DOC_FILE}' successfully.")
    except Exception as e:
        # do not prevent server from starting
        print(f"[startup] Ingest error (non-fatal): {e}")

# -----------------------
# Endpoints
# -----------------------
@app.post("/ingest-docs/")
async def ingest_docs(req: IngestRequest = None):
    """Read full_ghaymah_docs.txt and store it remotely. Returns success message."""
    filename = DOC_FILE
    try:
        with open(filename, "r", encoding="utf-8") as f:
            text = f.read()
    except FileNotFoundError:
        raise HTTPException(status_code=404, detail=f"{filename} not found in working folder.")

    ok = store_text_chunks_remote(text)
    if ok:
        return JSONResponse(content={"message": f"Successfully ingested '{filename}' into vector store."})
    raise HTTPException(status_code=500, detail="Ingestion failed.")
@app.post("/query/")
async def query_docs(request: QueryRequest):
    query = request.query
    k = request.k or 10
    print(f"[query] Received query: {query} (k={k})")

    # Embed query
    qvec = _embed_query(query)

    # Remote vector search
    search_results = search_remote_by_vector(qvec, k=k)
    payloads = [p["text_chunk"] for p in search_results.get("payloads", [])]

    if not payloads:
        return {"answer": "No relevant chunks found.", "search_results": search_results}

    # Deduplicate chunks (keep first occurrence)
    seen = set()
    context_chunks = []
    for chunk in payloads:
        if chunk not in seen:
            context_chunks.append(chunk)
            seen.add(chunk)

    context = "\n\n".join(context_chunks)

    # Use LLM if available
    if client:
        try:
            completion = client.chat.completions.create(
                model="DeepSeek-V3-0324",
                messages=[
                    {"role": "system", "content": "You are a helpful assistant for Ghaymah Cloud. Answer the question using the context provided."},
                    {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {query}"}
                ],
                temperature=0.0,
            )
            answer = completion.choices[0].message.content
            return {"answer": answer, "context": context_chunks, "scores": search_results.get("scores", [])}
        except Exception as e:
            print(f"[query] LLM failed: {e}")
            return {"answer": context, "context": context_chunks, "scores": search_results.get("scores", [])}
    else:
        return {"answer": context, "context": context_chunks, "scores": search_results.get("scores", [])}


@app.post("/debug-search/")
async def debug_search(request: QueryRequest):
    """
    Debug endpoint: returns raw search response from remote vector store for the provided query.
    Use this to inspect exact 'results' and scores returned remotely.
    """
    query = request.query
    k = request.k or 10
    print(f"[debug-search] Query: {query} (k={k})")

    try:
        qvec = _embed_query(query)
        print(f"[debug-search] Query embedding length: {len(qvec)}")
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Embedding failed: {e}")

    raw = search_remote_by_vector(qvec, k=k)
    return JSONResponse(content={"search_response": raw})

@app.get("/")
def read_root():
    return {"message": "Ghaymah Docs RAG API. Use /docs for interactive UI."}

# -----------------------
# Run
# -----------------------
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)