Download app.py from Ahmad140/RAGSYSTEM: direct link, hf CLI and curl.
- Browser
- Download file 7.97 kB
-
https://huggingface.co/spaces/Ahmad140/RAGSYSTEM/resolve/main/app.py
- Command line
-
hf download hf://spaces/Ahmad140/RAGSYSTEM/app.py
-
curl -L -o app.py https://huggingface.co/spaces/Ahmad140/RAGSYSTEM/resolve/main/app.py
7.97 kB
| # ============================================================ | |
| # app.py – AI Knowledge Assistant (RAG) Flask Backend | |
| # ============================================================ | |
| import os, re, textwrap, shutil, csv, time | |
| import numpy as np | |
| from PyPDF2 import PdfReader | |
| import torch | |
| from transformers import AutoTokenizer, AutoModel, AutoModelForCausalLM | |
| from openai import OpenAI | |
| from docx import Document | |
| from flask import Flask, request, jsonify, send_from_directory | |
| app = Flask(__name__, static_folder='static', static_url_path='/') | |
| OPENROUTER_KEY = os.environ["OPENROUTER_KEY"] | |
| # ---------- Embedding Model ---------- | |
| model_name = "sentence-transformers/all-MiniLM-L6-v2" | |
| tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| model = AutoModel.from_pretrained(model_name) | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| model = model.to(device) | |
| def mean_pooling(model_output, attention_mask): | |
| token_embeddings = model_output[0] | |
| input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() | |
| return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9) | |
| def embed_sentences(sentences, batch_size=32): | |
| all_emb = [] | |
| for i in range(0, len(sentences), batch_size): | |
| batch = sentences[i:i+batch_size] | |
| encoded = tokenizer(batch, padding=True, truncation=True, max_length=128, return_tensors='pt').to(device) | |
| with torch.no_grad(): | |
| out = model(**encoded) | |
| emb = mean_pooling(out, encoded['attention_mask']) | |
| all_emb.append(emb.cpu().numpy()) | |
| return np.concatenate(all_emb, axis=0) | |
| class CustomEmbedder: | |
| def encode(self, texts, **kwargs): | |
| if isinstance(texts, str): | |
| texts = [texts] | |
| return embed_sentences(texts) | |
| embedder = CustomEmbedder() | |
| # ---------- Vector Store ---------- | |
| class SimpleVectorStore: | |
| def __init__(self): | |
| self.documents = [] | |
| self.embeddings = [] | |
| def add(self, embeddings, documents, ids): | |
| for emb, doc in zip(embeddings, documents): | |
| self.embeddings.append(np.array(emb)) | |
| self.documents.append(doc) | |
| def query(self, query_embedding, n_results=3): | |
| query_vec = np.array(query_embedding).flatten() | |
| if not self.embeddings: | |
| return [] | |
| matrix = np.stack(self.embeddings) | |
| dot = np.dot(matrix, query_vec) | |
| norms = np.linalg.norm(matrix, axis=1) * np.linalg.norm(query_vec) | |
| sims = dot / (norms + 1e-9) | |
| top = np.argsort(sims)[::-1][:n_results] | |
| return [self.documents[i] for i in top] | |
| store = SimpleVectorStore() | |
| # ---------- Text Extraction (PDF, DOCX, TXT, CSV) ---------- | |
| def extract_text_from_file(file_path): | |
| fname = file_path.lower() | |
| text = "" | |
| if fname.endswith('.pdf'): | |
| reader = PdfReader(file_path) | |
| for page in reader.pages: | |
| t = page.extract_text() | |
| if t: | |
| text += t + "\n" | |
| elif fname.endswith('.docx'): | |
| doc = Document(file_path) | |
| for para in doc.paragraphs: | |
| text += para.text + "\n" | |
| elif fname.endswith('.txt'): | |
| with open(file_path, 'r', encoding='utf-8') as f: | |
| text = f.read() | |
| elif fname.endswith('.csv'): | |
| with open(file_path, 'r', encoding='utf-8') as f: | |
| reader = csv.reader(f) | |
| for row in reader: | |
| text += ", ".join(row) + "\n" | |
| else: | |
| with open(file_path, 'rb') as f: | |
| raw = f.read() | |
| try: | |
| text = raw.decode('utf-8') | |
| except: | |
| text = raw.decode('latin-1', errors='ignore') | |
| return text | |
| def split_text(text, chunk_size=500, overlap=50): | |
| chunks = [] | |
| for i in range(0, len(text), chunk_size - overlap): | |
| chunk = text[i:i+chunk_size] | |
| if len(chunk) > 100: | |
| chunks.append(chunk) | |
| return chunks | |
| def ingest_document(file_path): | |
| text = extract_text_from_file(file_path) | |
| chunks = split_text(text) | |
| if not chunks: | |
| return 0 | |
| emb = embedder.encode(chunks).tolist() | |
| store.add(emb, chunks, [f"doc_{i}" for i in range(len(chunks))]) | |
| return len(chunks) | |
| def retrieve(query, top_k=3): | |
| q_emb = embedder.encode([query]).tolist() | |
| return store.query(q_emb[0], n_results=top_k) | |
| # ---------- LLM Functions ---------- | |
| def setup_gemini(): | |
| return OpenAI(base_url="https://openrouter.ai/api/v1", api_key=OPENROUTER_KEY) | |
| def gemini_answer(client, context, question): | |
| prompt = f"""You are an AI assistant. Answer STRICTLY from the context. | |
| If answer not in context, say 'Not found in documents'. | |
| Context: | |
| {context} | |
| Question: {question} | |
| Answer with source citations.""" | |
| models = [ | |
| "google/gemma-4-31b-it:free", | |
| "google/gemini-2.0-flash-exp:free", | |
| "google/gemma-2-2b-it:free", | |
| "google/gemini-1.5-flash:free" | |
| ] | |
| for m in models: | |
| try: | |
| resp = client.chat.completions.create( | |
| model=m, messages=[{"role":"user","content":prompt}], temperature=0.1) | |
| return resp.choices[0].message.content | |
| except Exception as e: | |
| if "429" in str(e) or "rate" in str(e).lower(): | |
| time.sleep(5) | |
| return "All models busy. Try later." | |
| def setup_openrouter(): | |
| return OpenAI(base_url="https://openrouter.ai/api/v1", api_key=OPENROUTER_KEY) | |
| def openrouter_answer(client, context, question): | |
| prompt = f"""You are an AI assistant. Answer STRICTLY from the context. | |
| If answer not in context, say 'Not found in documents'. | |
| Context: | |
| {context} | |
| Question: {question}""" | |
| resp = client.chat.completions.create( | |
| model="openrouter/owl-alpha", | |
| messages=[{"role":"user","content":prompt}], | |
| temperature=0.1) | |
| return resp.choices[0].message.content | |
| def setup_local_model(): | |
| model_name = "gpt2" | |
| tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| model = AutoModelForCausalLM.from_pretrained(model_name) | |
| tokenizer.pad_token = tokenizer.eos_token | |
| if torch.cuda.is_available(): | |
| model = model.to("cuda") | |
| return model, tokenizer | |
| def local_answer(model, tokenizer, context, question): | |
| prompt = f"Context: {context}\nQuestion: {question}\nAnswer:" | |
| inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512) | |
| if torch.cuda.is_available(): | |
| inputs = {k: v.to("cuda") for k, v in inputs.items()} | |
| outputs = model.generate( | |
| **inputs, max_new_tokens=100, do_sample=False, | |
| pad_token_id=tokenizer.eos_token_id) | |
| full = tokenizer.decode(outputs[0], skip_special_tokens=True) | |
| return full.split("Answer:")[-1].strip() | |
| # ---------- Routes ---------- | |
| def index(): | |
| return send_from_directory('.', 'index.html') | |
| def upload(): | |
| try: | |
| file = request.files['file'] | |
| file_path = f"/tmp/{file.filename}" | |
| file.save(file_path) | |
| num = ingest_document(file_path) | |
| return jsonify({"message": f"✅ {num} chunks processed." if num else "❌ No text could be extracted."}) | |
| except Exception as e: | |
| return jsonify({"message": f"❌ Error: {str(e)}"}) | |
| def chat(): | |
| data = request.get_json() | |
| query = data.get('query','') | |
| choice = data.get('model_choice','local') | |
| try: | |
| chunks = retrieve(query, top_k=3) | |
| ctx = "\n\n".join(chunks) | |
| if choice == "gemini": | |
| ans = gemini_answer(setup_gemini(), ctx, query) | |
| elif choice == "openrouter": | |
| ans = openrouter_answer(setup_openrouter(), ctx, query) | |
| else: | |
| m, t = setup_local_model() | |
| ans = local_answer(m, t, ctx, query) | |
| return jsonify({"answer": ans, "sources": chunks}) | |
| except Exception as e: | |
| return jsonify({"answer": f"Error: {str(e)}", "sources": []}) | |
| if __name__ == "__main__": | |
| app.run(host="0.0.0.0", port=7860) |