Update app.py

app.py

@@ -1,5 +1,4 @@
-# app.py
-import os, io, re
+import os, io, re, json, traceback
 import gradio as gr
 from pdfminer.high_level import extract_text
 from sentence_transformers import SentenceTransformer
@@ -7,155 +6,158 @@ from qdrant_client import QdrantClient
 from qdrant_client.http import models as qmodels
 import requests
 
-# ------------ Global ------------
 EMBED_MODEL_ID = "intfloat/multilingual-e5-small"  # 384-dim, multilingual
 _embedder = None
 _client = None
-_collection = None
+_collection = "docs"
 
-# ------------ Helpers ------------
 def get_embedder():
     global _embedder
     if _embedder is None:
+        print("[embedder] loading:", EMBED_MODEL_ID, flush=True)
         _embedder = SentenceTransformer(EMBED_MODEL_ID)
     return _embedder
 
-def connect_qdrant(url: str, api_key: str, collection: str):
-    global _client, _collection
-    if not url or not api_key:
-        raise ValueError("QDRANT_URL a API_KEY sú povinné")
-    _client = QdrantClient(url=url.strip(), api_key=api_key.strip())
-    _collection = collection.strip()
-    try:
-        _client.get_collection(_collection)
-    except Exception:
-        _client.recreate_collection(
-            collection_name=_collection,
-            vectors_config=qmodels.VectorParams(size=384, distance=qmodels.Distance.COSINE)
-        )
-    return f"✅ Pripojené k Qdrant: {_collection}", ""
-
-def chunk_text(text: str, size: int = 1500, overlap: int = 200):
+def chunk_text(text, size=1500, overlap=200):
     text = re.sub(r"\s+", " ", text)
     chunks, i = [], 0
     step = max(1, size - overlap)
     while i < len(text):
-        chunk = text[i:i+size]
-        if chunk.strip():
-            chunks.append(chunk)
+        seg = text[i:i+size]
+        if seg.strip():
+            chunks.append(seg)
         i += step
     return chunks
 
+def connect_qdrant(url, api_key, collection):
+    global _client, _collection
+    if not url or not api_key:
+        return "❌ Zadaj QDRANT_URL a QDRANT_API_KEY.", ""
+    _collection = (collection or "docs").strip()
+    try:
+        print(f"[qdrant] connecting to {url} coll={_collection}", flush=True)
+        _client = QdrantClient(url=url.strip(), api_key=api_key.strip())
+        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:", 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()
 
-def embed_query(text: str):
+def embed_query(text):
     emb = get_embedder()
     return emb.encode([f"query: {text}"], normalize_embeddings=True)[0].tolist()
 
-# ------------ Ingest ------------
-def ingest_pdfs(files, topic: str, chunk_chars: int, overlap: int):
+def ingest_pdfs(files, topic, chunk_chars, overlap):
     if not _client:
-        return "❌ Najprv sa pripoj k Qdrant (Connect)", None
-    total_chunks = 0
+        return "❌ Najprv klikni 🔌 Connect (Qdrant URL + API key)."
+    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)]
+        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_chunks += len(chunks)
-    return f"✅ Uložené chunky: {total_chunks}", None
+        total += len(chunks)
+    return f"✅ Index hotový. Uložených chunkov: {total}"
 
-# ------------ Search & Web ------------
-def search_local(query: str, topk: int, topic: str):
+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=topk, query_filter=qfilter)
+    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: str, n: int = 3, api_key: str | None = None):
+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": n
+        "api_key": key, "query": query, "search_depth": "basic", "max_results": int(n)
     }, timeout=30)
     try:
         data = r.json()
     except Exception:
         return []
     out = []
-    for item in data.get("results", [])[:n]:
+    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
 
-# ------------ Answer synthesis ------------
-def answer_from_context(question: str, local_hits, web_snips):
-    parts = [f"**Otázka:** {question}", "\n**Odpoveď (zo zdrojov):**"]
+def answer_from_context(question, local_hits, web_snips):
+    lines = [f"**Otázka:** {question}", "\n**Odpoveď (zo zdrojov):**"]
     if local_hits:
-        parts.append("- PDF:")
+        lines.append("- PDF:")
         for i,h in enumerate(local_hits):
-            snippet = h['text'][:400].strip().replace('\n',' ')
-            parts.append(f"  [{i+1}] {snippet} … (score {h['score']:.2f})")
+            snippet = h['text'][:400].strip().replace("\n"," ")
+            lines.append(f"  [{i+1}] {snippet} … (score {h['score']:.2f})")
     if web_snips:
-        parts.append("- Web:")
+        lines.append("- Web:")
         for j,w in enumerate(web_snips):
-            snippet = w['text'][:300].strip().replace('\n',' ')
-            parts.append(f"  [W{j+1}] {snippet} … ({w['url']})")
+            snippet = w['text'][:300].strip().replace("\n"," ")
+            lines.append(f"  [W{j+1}] {snippet} … ({w['url']})")
     if not local_hits and not web_snips:
-        parts.append("_Nenašli sa relevantné pasáže._")
-    return "\n".join(parts)
+        lines.append("_Nenašli sa relevantné pasáže – skús spresniť otázku alebo pridať PDF._")
+    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)")
 
     with gr.Row():
+        # LEFT
         with gr.Column(scale=1):
             gr.Markdown("### Qdrant nastavenie")
-            q_url = gr.Textbox(label="QDRANT_URL", value=os.getenv("QDRANT_URL", ""), lines=2)
-            q_key = gr.Textbox(label="QDRANT_API_KEY", value=os.getenv("QDRANT_API_KEY", ""), type="password")
+            q_url = gr.Textbox(label="QDRANT_URL", value=os.getenv("QDRANT_URL",""), lines=2)
+            q_key = gr.Textbox(label="QDRANT_API_KEY", value=os.getenv("QDRANT_API_KEY",""), type="password")
             collection_tb = gr.Textbox(label="Collection", value="docs")
             connect_btn = gr.Button("🔌 Connect")
-            status = gr.Markdown()
-            err = gr.Markdown()
+            status_md = gr.Markdown()
+            err_md = gr.Markdown()
 
             def _connect(u,k,c):
-                try:
-                    s,e = connect_qdrant(u,k,c)
-                    return s, e
-                except Exception as ex:
-                    return "❌ Chyba pripojenia", f"```{ex}```"
-            connect_btn.click(_connect, inputs=[q_url,q_key,collection_tb], outputs=[status, err])
+                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")
             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")
+            upload = gr.File(file_count="multiple", file_types=[".pdf"], label="📁 PDF súbory")
             ingest_btn = gr.Button("📥 Indexovať do Qdrant")
             ingest_out = gr.Markdown()
 
             def _ingest(files, topic, size, ov):
-                msg,_ = ingest_pdfs(files, topic, size, ov)
-                return msg
+                return ingest_pdfs(files, topic, size, ov)
             ingest_btn.click(_ingest, inputs=[upload, topic_dd, chunk_chars, overlap], outputs=ingest_out)
 
+        # RIGHT
         with gr.Column(scale=2):
             gr.Markdown("### Chat (PDF + voliteľne web)")
             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 score pre vypnutie webu")
+            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")
             ask_btn = gr.Button("💬 Spýtať sa")
@@ -170,4 +172,4 @@ with gr.Blocks(title="EDM & Fanuc – Hybrid RAG (PDF + Web)") as demo:
             ask_btn.click(_ask, inputs=[question, topic_chat, topk, minscore, use_web, tavily_key], outputs=answer_md)
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))