Update app.py

app.py

@@ -1,28 +1,23 @@
-import os, io, re, json, traceback
-# --- vypni Gradio analytiku / telemetriu, nech nepadá API schéma ---
+import os, io, re, traceback
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
 
 import gradio as gr
 from pdfminer.high_level import extract_text
 from sentence_transformers import SentenceTransformer
-from qdrant_client import QdrantClient
-from qdrant_client.http import models as qmodels
-import requests
+import numpy as np
 
 print("[gradio] version:", gr.__version__, flush=True)
 
-# ==== SEM VLOŽ SVOJE HODNOTY (alebo nechaj prázdne a použi Secrets) ====
-AUTO_QDRANT_URL = "https://1101644d-bb1d-4aad-adf1-ee86ad1de2dc.europe-west3-0.gcp.cloud.qdrant.io:6333"
-AUTO_QDRANT_API_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.vWc7ei94LhQZF9pIFYRyFZS9r9T5rFZ16Wv7V3lhhzo"
-# ======================================================================
+EMBED_MODEL_ID = "intfloat/multilingual-e5-small"  # 384-dim, multilingual
 
-EMBED_MODEL_ID = "intfloat/multilingual-e5-small"  # 384-dim
+# -------- in-memory store --------
+library_chunks = []         # list[str]
+library_meta = []           # list[{source, idx}]
+library_embeddings = None   # np.ndarray [N, D] normalized
 _embedder = None
-_client = None
-_collection = "docs"
 
-# ----------------- helpers -----------------
+# -------- helpers --------
 def get_embedder():
     global _embedder
     if _embedder is None:
@@ -30,179 +25,119 @@ def get_embedder():
         _embedder = SentenceTransformer(EMBED_MODEL_ID)
     return _embedder
 
-def chunk_text(text, size=1500, overlap=200):
-    text = re.sub(r"\s+", " ", text)
+def clean_text(t: str) -> str:
+    return re.sub(r"\s+", " ", t).strip()
+
+def chunk_text(text: str, size: int = 1500, overlap: int = 200):
+    text = clean_text(text)
     chunks, i = [], 0
     step = max(1, size - overlap)
-    while i < len(text):
+    L = len(text)
+    while i < L:
         seg = text[i:i+size]
         if seg.strip():
             chunks.append(seg)
         i += step
     return chunks
 
-def connect_qdrant(url, api_key, collection):
-    """Create client and ensure collection exists; return (status_text, error_md)."""
-    global _client, _collection
-    url = (url or "").strip()
-    api_key = (api_key or "").strip()
-    _collection = (collection or "docs").strip()
-
-    if not url or not api_key:
-        return "❌ Zadaj QDRANT_URL a QDRANT_API_KEY.", ""
-
-    try:
-        print(f"[qdrant] connecting to {url} coll={_collection}", flush=True)
-        _client = QdrantClient(url=url, api_key=api_key)
-        # ping / ensure collection
-        try:
-            _client.get_collection(_collection)
-            print("[qdrant] collection exists", flush=True)
-        except Exception:
-            print("[qdrant] creating collection", flush=True)
-            _client.recreate_collection(
-                collection_name=_collection,
-                vectors_config=qmodels.VectorParams(size=384, distance=qmodels.Distance.COSINE),
-            )
-        return f"✅ Connected to Qdrant: {_collection}", ""
-    except Exception as e:
-        tb = traceback.format_exc()
-        print("[qdrant] connect error:\n", tb, flush=True)
-        return "❌ Connection error", f"```\n{e}\n```"
-
 def embed_passages(texts):
     emb = get_embedder()
-    return emb.encode([f"passage: {t}" for t in texts], normalize_embeddings=True).tolist()
+    vecs = emb.encode([f"passage: {t}" for t in texts], normalize_embeddings=True)
+    return np.asarray(vecs, dtype=np.float32)
 
-def embed_query(text):
+def embed_query(q):
     emb = get_embedder()
-    return emb.encode([f"query: {text}"], normalize_embeddings=True)[0].tolist()
-
-def ingest_pdfs(files, topic, chunk_chars, overlap):
-    if not _client:
-        return "❌ Najprv pripoj Qdrant (auto-connect prebieha pri štarte)."
-    total = 0
-    for f in files or []:
-        data = f.read()
-        text = extract_text(io.BytesIO(data))
-        chunks = chunk_text(text, chunk_chars, overlap)
-        vecs = embed_passages(chunks)
-        points = [
-            qmodels.PointStruct(vector=v, payload={"text": c, "topic": topic})
-            for c, v in zip(chunks, vecs)
-        ]
-        _client.upsert(collection_name=_collection, points=points)
-        total += len(chunks)
-    return f"✅ Index hotový. Uložených chunkov: {total}"
-
-def search_local(query, topk, topic):
-    if not _client:
-        return []
-    qvec = embed_query(query)
-    qfilter = qmodels.Filter(must=[qmodels.FieldCondition(
-        key="topic", match=qmodels.MatchValue(value=topic)
-    )]) if topic else None
-    res = _client.search(collection_name=_collection, query_vector=qvec, limit=int(topk), query_filter=qfilter)
-    return [{"score": r.score, "text": r.payload.get("text",""), "payload": r.payload} for r in res]
-
-def web_search(query, n=3, api_key=None):
-    key = api_key or os.getenv("TAVILY_API_KEY", "")
-    if not key:
-        return []
-    r = requests.post("https://api.tavily.com/search", json={
-        "api_key": key, "query": query, "search_depth": "basic", "max_results": int(n)
-    }, timeout=30)
-    try:
-        data = r.json()
-    except Exception:
+    vec = emb.encode([f"query: {q}"], normalize_embeddings=True)[0]
+    return np.asarray(vec, dtype=np.float32)
+
+def add_to_library(chunks, source_name):
+    global library_chunks, library_meta, library_embeddings
+    vecs = embed_passages(chunks)
+    if library_embeddings is None:
+        library_embeddings = vecs
+    else:
+        library_embeddings = np.vstack([library_embeddings, vecs])
+    start = len(library_chunks)
+    library_chunks.extend(chunks)
+    library_meta.extend({"source": source_name, "idx": i} for i in range(start, start+len(chunks)))
+    return len(chunks)
+
+def reset_library():
+    global library_chunks, library_meta, library_embeddings
+    library_chunks = []
+    library_meta = []
+    library_embeddings = None
+
+def top_k(query, k=5):
+    if library_embeddings is None or len(library_chunks) == 0:
         return []
-    out = []
-    for item in data.get("results", [])[:int(n)]:
-        text = (item.get("title","") + "\n" + item.get("content",""))[:1500]
-        out.append({"url": item.get("url"), "text": text})
-    return out
+    qv = embed_query(query)
+    # cosine since embeddings are normalized -> dot product
+    scores = library_embeddings @ qv
+    idx = np.argsort(-scores)[:k]
+    return [(float(scores[i]), library_chunks[i], library_meta[i]) for i in idx]
 
-def answer_from_context(question, local_hits, web_snips):
+def build_answer(question, hits):
     lines = [f"**Otázka:** {question}", "\n**Odpoveď (zo zdrojov):**"]
-    if local_hits:
-        lines.append("- PDF:")
-        for i,h in enumerate(local_hits):
-            snippet = h['text'][:400].strip().replace("\n"," ")
-            lines.append(f"  [{i+1}] {snippet} … (score {h['score']:.2f})")
-    if web_snips:
-        lines.append("- Web:")
-        for j,w in enumerate(web_snips):
-            snippet = w['text'][:300].strip().replace("\n"," ")
-            lines.append(f"  [W{j+1}] {snippet} … ({w['url']})")
-    if not local_hits and not web_snips:
-        lines.append("_Nenašli sa relevantné pasáže – skús spresniť otázku alebo pridať PDF._")
+    if not hits:
+        lines.append("_Nenašli sa relevantné pasáže. Nahraj PDF alebo skús inú formuláciu._")
+    for i,(s,txt,meta) in enumerate(hits, start=1):
+        snippet = clean_text(txt)[:400]
+        src = meta.get("source", "PDF")
+        lines.append(f"[{i}] {snippet} … (score {s:.2f}, zdroj: {src})")
     return "\n".join(lines)
 
-# ----------------- UI -----------------
-with gr.Blocks(title="EDM & Fanuc – Hybrid RAG (PDF + Web)") as demo:
-    gr.Markdown("# 🔧 EDM & Fanuc – Hybrid RAG (PDF + Web)")
+# -------- UI --------
+with gr.Blocks(title="EDM & Fanuc – PDF RAG (bez Qdrant)") as demo:
+    gr.Markdown("# 🔧 EDM & Fanuc – PDF RAG (bez Qdrant)")
 
     with gr.Row():
-        # LEFT
         with gr.Column(scale=1):
-            gr.Markdown("### Qdrant nastavenie")
-            q_url = gr.Textbox(label="QDRANT_URL", value=AUTO_QDRANT_URL or os.getenv("QDRANT_URL",""), lines=2)
-            q_key = gr.Textbox(label="QDRANT_API_KEY", value=AUTO_QDRANT_API_KEY or os.getenv("QDRANT_API_KEY",""), type="password")
-            collection_tb = gr.Textbox(label="Collection", value="docs")
-            connect_btn = gr.Button("🔌 Connect (manuálne)")
-            status_md = gr.Markdown()
-            err_md = gr.Markdown()
-
-            def _connect(u,k,c):
-                s,e = connect_qdrant(u,k,c)
-                return s, e
-            connect_btn.click(_connect, inputs=[q_url,q_key,collection_tb], outputs=[status_md, err_md])
-
-            gr.Markdown("### Ingest PDF")
-            topic_dd = gr.Dropdown(["EDM","FANUC","general"], value="EDM", label="Topic")
+            gr.Markdown("### 📥 Ingest PDF (textové, nie skeny)")
+            topic_dd = gr.Dropdown(["EDM","FANUC","general"], value="EDM", label="Topic (len štítok)")
             chunk_chars = gr.Slider(800, 2500, value=1500, step=100, label="Chunk size")
             overlap = gr.Slider(0, 400, value=200, step=20, label="Overlap")
             upload = gr.File(file_count="multiple", file_types=[".pdf"], label="📁 PDF súbory")
-            ingest_btn = gr.Button("📥 Indexovať do Qdrant")
+            ingest_btn = gr.Button("📥 Pridať do knižnice")
+            reset_btn = gr.Button("🗑️ Vyčistiť knižnicu")
             ingest_out = gr.Markdown()
 
             def _ingest(files, topic, size, ov):
-                return ingest_pdfs(files, topic, size, ov)
+                if not files:
+                    return "⚠️ Nahraj aspoň jedno PDF."
+                total_chunks = 0
+                for f in files:
+                    name = getattr(f, "name", "document.pdf")
+                    try:
+                        text = extract_text(io.BytesIO(f.read()))
+                    except Exception as e:
+                        return f"❌ Chyba pri čítaní {name}: {e}"
+                    chunks = chunk_text(text, size, ov)
+                    added = add_to_library(chunks, f"{topic}:{name}")
+                    total_chunks += added
+                return f"✅ Pridané chunky: {total_chunks}. Aktuálna knižnica: {len(library_chunks)} pasáží."
+
+            def _reset():
+                reset_library()
+                return "✅ Knižnica vyčistená."
+
             ingest_btn.click(_ingest, inputs=[upload, topic_dd, chunk_chars, overlap], outputs=ingest_out)
+            reset_btn.click(_reset, outputs=ingest_out)
 
-        # RIGHT
         with gr.Column(scale=2):
-            gr.Markdown("### Chat (PDF + voliteľne web)")
+            gr.Markdown("### 💬 Chat z lokálnej knižnice")
             question = gr.Textbox(label="Otázka", placeholder="Napr. G41 vs G42 na Fanuc…", lines=3)
-            topic_chat = gr.Dropdown(["EDM","FANUC","general"], value="EDM", label="Topic filter")
-            topk = gr.Slider(1, 8, value=5, step=1, label="Top-K")
-            minscore = gr.Slider(0, 1, value=0.35, step=0.01, label="Min lokálne score pre vypnutie webu")
-            use_web = gr.Checkbox(value=True, label="Povoliť web doplnenie (Tavily)")
-            tavily_key = gr.Textbox(label="TAVILY_API_KEY (nepovinné)", value=os.getenv("TAVILY_API_KEY",""), type="password")
+            topk = gr.Slider(1, 10, value=5, step=1, label="Top-K pasáží")
             ask_btn = gr.Button("💬 Spýtať sa")
             answer_md = gr.Markdown()
 
-            def _ask(q, topic, k, thr, web, tkey):
-                local_hits = search_local(q, int(k), topic)
-                good = any(h.get("score",0) >= float(thr) for h in local_hits)
-                web_snips = web_search(q, n=3, api_key=tkey) if (web and not good) else []
-                return answer_from_context(q, local_hits, web_snips)
-
-            ask_btn.click(_ask, inputs=[question, topic_chat, topk, minscore, use_web, tavily_key], outputs=answer_md)
-
-    # --- AUTO CONNECT po nahratí UI (ak sú vyplnené hodnoty) ---
-    def _auto_connect():
-        url = AUTO_QDRANT_URL or os.getenv("QDRANT_URL","")
-        key = AUTO_QDRANT_API_KEY or os.getenv("QDRANT_API_KEY","")
-        if url and key:
-            s, e = connect_qdrant(url, key, "docs")
-            return s + ("\n\n" + e if e else "")
-        return "ℹ️ Zadaj QDRANT_URL a QDRANT_API_KEY (alebo vyplň AUTO_… priamo v kóde)."
+            def _ask(q, k):
+                hits = top_k(q, int(k))
+                return build_answer(q, hits)
 
-    demo.load(_auto_connect, inputs=None, outputs=status_md)
+            ask_btn.click(_ask, inputs=[question, topk], outputs=answer_md)
 
 if __name__ == "__main__":
-    # show_api=False => obíde bug s generovaním OpenAPI / “No API found”
     demo.launch(
         server_name="0.0.0.0",
         server_port=int(os.environ.get("PORT", 7860)),