RAGSYSTEM / app.py
Ahmad140's picture
Update app.py
aac0cf8 verified
Raw History Blame Contribute Delete
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 ----------
@app.route('/')
def index():
return send_from_directory('.', 'index.html')
@app.route('/upload', methods=['POST'])
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)}"})
@app.route('/chat', methods=['POST'])
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)