Update app.py

app.py

@@ -1,5 +1,5 @@
-# app.py
-import os, io, re, json
+# app.py (Gradio)
+import os, io, re, json, traceback
 import gradio as gr
 from pdfminer.high_level import extract_text
 from sentence_transformers import SentenceTransformer
@@ -7,42 +7,55 @@ from qdrant_client import QdrantClient
 from qdrant_client.http import models as qmodels
 import requests
 
-EMBED_MODEL_ID = "intfloat/multilingual-e5-small"
+EMBED_MODEL_ID = "intfloat/multilingual-e5-small"  # 384-dim, multilingual
 _embedder = None
 _client = None
-_collection = None
+_collection = "docs"
 
 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
-    _client = QdrantClient(url=url, api_key=api_key) if url else None
-    _collection = collection
-    if _client:
-        try:
-            _client.get_collection(collection)
-        except Exception:
-            _client.recreate_collection(
-                collection_name=collection,
-                vectors_config=qmodels.VectorParams(size=384, distance=qmodels.Distance.COSINE)
-            )
-    return True
-
 def chunk_text(text: str, size: int = 1500, overlap: int = 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: str, api_key: str, collection: str):
+    """Create client and ensure collection exists; return human message."""
+    global _client, _collection
+    if not url or not api_key:
+        return "❌ Zadaj QDRANT_URL a QDRANT_API_KEY.", ""
+
+    _collection = collection or "docs"
+    try:
+        print(f"[qdrant] connecting to {url} coll={_collection}", flush=True)
+        _client = QdrantClient(url=url, api_key=api_key)
+        # ping: ensure collection exists and is usable
+        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()
@@ -53,25 +66,28 @@ def embed_query(text: str):
 
 def ingest_pdfs(files, topic: str, chunk_chars: int, overlap: int):
     if not _client:
-        return "❌ Najprv nastav QDRANT_URL a QDRANT_API_KEY vľavo.", 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 = []
-        for c, v in zip(chunks, vecs):
-            points.append(qmodels.PointStruct(vector=v, payload={"text": c, "topic": topic}))
+        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}"
 
 def search_local(query: str, topk: int, topic: str):
     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
+    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)
     return [{"score": r.score, "text": r.payload.get("text",""), "payload": r.payload} for r in res]
 
@@ -80,10 +96,7 @@ def web_search(query: str, n: int = 3, api_key: str | None = None):
     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": n
     }, timeout=30)
     data = r.json()
     out = []
@@ -93,58 +106,53 @@ def web_search(query: str, n: int = 3, api_key: str | None = None):
     return out
 
 def answer_from_context(question: str, local_hits, web_snips):
-    parts = ["**Otázka:** " + question, "\n**Odpoveď (kompilované zo zdrojov):**"]
+    lines = [f"**Otázka:** {question}", "\n**Odpoveď (zo zdrojov):**"]
     if local_hits:
-        parts.append("- Z lokálnych PDF vyplýva:")
+        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("- Z webu:")
+        lines.append("- Web:")
         for j,w in enumerate(web_snips):
-            snippet = w['text'][:300].strip().replace('\n',' ')
-            parts.append(f"  [W{j+1}] {snippet} … (zdroj: {w['url']})")
-    parts.append("\n**Poznámka:** Toto je súhrn citovaných pasáží. Pre presnejšiu odpoveď pridaj viac PDF alebo zapni lepší model neskôr.")
-    return "\n".join(parts)
-
-def on_connect(url, key, collection):
-    try:
-        connect_qdrant(url, key, collection)
-        return f"✅ Pripojené k Qdrant: {url}", ""
-    except Exception as e:
-        return "❌ Chyba pripojenia", str(e)
+            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._")
+    return "\n".join(lines)
 
 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", ""))
-            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",""))
+            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.Textbox(label="Status")
-            err = gr.Textbox(label="Error")
+            status_md = gr.Markdown()
+            err_md = gr.Markdown()
 
             def _connect(u,k,c):
-                s,e = on_connect(u,k,c)
-                return s,e
-            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.Textbox(label="Výstup")
+            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)