Upload folder using huggingface_hub

src/agent_graph.py

@@ -0,0 +1,62 @@
+"""
+Enterprise Knowledge Assistant - Multi-Agent Graph
+Router -> Hybrid Retrieval -> Generation, orchestrated via LangGraph.
+"""
+
+from langgraph.graph import StateGraph, END
+from typing import TypedDict
+
+class AgentState(TypedDict):
+    query: str
+    domain: str
+    confidence: float
+    retrieved_chunks: list
+    answer: str
+
+
+def build_agent_graph(router_model, tokenizer, label_encoder, embedding_model, 
+                       domain_indices, domain_chunks_map, index, all_chunks, groq_client,
+                       classify_query_fn, retrieve_hybrid_fn, generate_with_groq_fn):
+    
+    def router_node(state):
+        domain, confidence_or_probs = classify_query_fn(state['query'], router_model, tokenizer, label_encoder)
+        if hasattr(confidence_or_probs, 'shape') and confidence_or_probs.numel() > 1:
+            confidence = float(confidence_or_probs.max())
+        else:
+            confidence = float(confidence_or_probs)
+        print(f"[Router] Domain: {domain} (confidence: {confidence:.2f})")
+        return {**state, 'domain': domain, 'confidence': confidence}
+
+    def retrieval_node(state):
+        results = retrieve_hybrid_fn(
+            state['query'], state['domain'],
+            embedding_model, domain_indices, domain_chunks_map, index, all_chunks
+        )
+        return {**state, 'retrieved_chunks': results}
+
+    def generation_node(state):
+        context_text = "\n\n".join([f"[Source: {c['domain']} - {c['title']}]\n{c['text']}"
+                                      for dist, c in state['retrieved_chunks']])
+        prompt = f"""You are an enterprise knowledge assistant. Answer using ONLY the context below.
+If the context doesn't fully answer the question, say what's missing honestly.
+
+Context:
+{context_text}
+
+Question: {state['query']}
+
+Answer:"""
+        answer = generate_with_groq_fn(prompt, groq_client)
+        return {**state, 'answer': answer}
+
+    graph = StateGraph(AgentState)
+    graph.add_node("router", router_node)
+    graph.add_node("retrieval", retrieval_node)
+    graph.add_node("generation", generation_node)
+
+    graph.set_entry_point("router")
+    graph.add_edge("router", "retrieval")
+    graph.add_edge("retrieval", "generation")
+    graph.add_edge("generation", END)
+
+    return graph.compile()

src/eva_chatbot.py

@@ -0,0 +1,81 @@
+"""
+EVA - Enterprise Virtual Assistant
+Complete chatbot: greeting handling + router + memory + hybrid retrieval + extraction
+"""
+
+def is_small_talk(query, groq_client, generate_with_groq_fn):
+    prompt = f"""Is this message small talk/greeting/casual conversation (like "hi", "hello", "how are you", "thanks", "bye") 
+rather than an actual question needing information lookup? Answer ONLY "yes" or "no".
+
+Message: {query}"""
+    response = generate_with_groq_fn(prompt, groq_client).strip().lower()
+    return "yes" in response
+
+
+def handle_small_talk(query, groq_client, generate_with_groq_fn, bot_name="EVA"):
+    prompt = f"""You are {bot_name}, a friendly enterprise knowledge assistant chatbot for HR, Legal, Finance, and IT questions.
+Respond naturally and briefly to this casual message. If it's a greeting, introduce yourself briefly and invite them to ask a question.
+
+Message: {query}
+
+Response:"""
+    return generate_with_groq_fn(prompt, groq_client)
+
+
+def ask_eva(query, conversation_history, embedding_model, index, all_chunks, groq_client,
+            router_model, tokenizer, label_encoder, domain_indices, domain_chunks_map,
+            qa_model, qa_tokenizer, classify_query_fn, retrieve_hybrid_fn, generate_with_groq_fn, 
+            extract_exact_answer_fn, top_k=5, hallucination_threshold=0.95, bot_name="EVA"):
+    
+    if is_small_talk(query, groq_client, generate_with_groq_fn):
+        answer = handle_small_talk(query, groq_client, generate_with_groq_fn, bot_name)
+        conversation_history.append({'question': query, 'answer': answer})
+        return {'answer': answer, 'exact_quote': None, 'source': None, 'domain': None}
+    
+    domain, confidence_or_probs = classify_query_fn(query, router_model, tokenizer, label_encoder)
+    
+    history_text = ""
+    if conversation_history:
+        history_text = "\n".join([f"User: {h['question']}\nAssistant: {h['answer']}" 
+                                    for h in conversation_history[-3:]])
+    
+    rewrite_prompt = f"""Given this conversation history:
+{history_text}
+
+Rewrite the NEW question to be a clear, standalone, explicit search query — resolving any references 
+to earlier parts of the conversation. Keep it short. Only output the rewritten question.
+
+New question: {query}
+
+Rewritten question:"""
+    rewritten = generate_with_groq_fn(rewrite_prompt, groq_client).strip()
+    
+    results = retrieve_hybrid_fn(rewritten, domain, embedding_model, domain_indices, domain_chunks_map, 
+                                   index, all_chunks, top_k=top_k)
+    
+    best_distance = results[0][0]
+    if best_distance > hallucination_threshold:
+        answer = f"I'm {bot_name}, and I couldn't find information about this in my current knowledge base. Could you rephrase, or ask about HR, Legal, Finance, or IT topics?"
+        conversation_history.append({'question': query, 'answer': answer})
+        return {'answer': answer, 'exact_quote': None, 'source': None, 'domain': domain}
+    
+    context_text = "\n\n".join([f"[Source: {c['domain']} - {c['title']}]\n{c['text']}" for dist, c in results])
+    prompt = f"""You are {bot_name}, an enterprise knowledge assistant having an ongoing conversation.
+
+Conversation so far:
+{history_text}
+
+Answer using ONLY the context below. Directly explain what it says, in clear detail.
+
+Context:
+{context_text}
+
+New question: {query}
+
+Answer:"""
+    answer = generate_with_groq_fn(prompt, groq_client)
+    
+    exact_quote, _ = extract_exact_answer_fn(rewritten, results[0][1]['text'], qa_model, qa_tokenizer)
+    
+    conversation_history.append({'question': query, 'answer': answer})
+    return {'answer': answer, 'exact_quote': exact_quote, 'source': results[0][1]['title'], 'domain': domain}

src/extractive_qa.py

@@ -0,0 +1,57 @@
+"""
+Enterprise Knowledge Assistant - Extractive QA Layer
+Combines generative narration with exact-quote extraction for verifiable answers.
+"""
+
+import torch
+
+def extract_exact_answer(question, context, qa_model, qa_tokenizer):
+    inputs = qa_tokenizer(question, context, return_tensors="pt", truncation=True, max_length=384)
+    
+    with torch.no_grad():
+        outputs = qa_model(**inputs)
+    
+    answer_start = torch.argmax(outputs.start_logits)
+    answer_end = torch.argmax(outputs.end_logits) + 1
+    
+    answer_tokens = inputs['input_ids'][0][answer_start:answer_end]
+    answer_text = qa_tokenizer.decode(answer_tokens, skip_special_tokens=True)
+    
+    confidence = torch.softmax(outputs.start_logits, dim=1).max().item()
+    
+    return answer_text, confidence
+
+
+def ask_with_extraction(query, domain, embedding_model, domain_indices, domain_chunks_map,
+                          index, all_chunks, groq_client, qa_model, qa_tokenizer, 
+                          retrieve_hybrid_fn, generate_with_groq_fn, top_k=5):
+    
+    results = retrieve_hybrid_fn(query, domain, embedding_model, domain_indices, domain_chunks_map, 
+                                   index, all_chunks, top_k=top_k)
+    
+    context_text = "\n\n".join([f"[Source: {c['domain']} - {c['title']}]\n{c['text']}" for dist, c in results])
+    
+    prompt = f"""You are an enterprise knowledge assistant. Answer using ONLY the context below.
+
+IMPORTANT: Do not just tell the user "refer to source X" or "see document Y." Instead, directly explain 
+WHAT the clause/policy/fact actually says, in your own words, synthesizing the actual content. 
+Only mention source names as supporting citations after explaining the substance.
+
+Context:
+{context_text}
+
+Question: {query}
+
+Answer (explain the actual content directly, then cite sources):"""
+    
+    generative_answer = generate_with_groq_fn(prompt, groq_client)
+    
+    best_chunk_text = results[0][1]['text']
+    exact_answer, confidence = extract_exact_answer(query, best_chunk_text, qa_model, qa_tokenizer)
+    
+    return {
+        'narrated_answer': generative_answer,
+        'exact_quote': exact_answer,
+        'quote_confidence': confidence,
+        'source': results[0][1]['title']
+    }

src/final_chatbot.py

@@ -0,0 +1,49 @@
+"""
+Enterprise Knowledge Assistant - FINAL Complete Chatbot Function (v2)
+Fixed: query rewriting now preserves intent instead of drifting/elaborating.
+"""
+
+def ask_chatbot_final_v2(query, embedding_model, index, all_chunks, groq_client,
+                        router_model, tokenizer, label_encoder,
+                        domain_indices, domain_chunks_map,
+                        qa_model, qa_tokenizer,
+                        classify_query_fn, retrieve_hybrid_fn, generate_with_groq_fn, extract_exact_answer_fn,
+                        top_k=5, hallucination_threshold=0.95):
+    
+    domain, confidence_or_probs = classify_query_fn(query, router_model, tokenizer, label_encoder)
+    router_confidence = float(confidence_or_probs.max()) if hasattr(confidence_or_probs, 'shape') else float(confidence_or_probs)
+
+    rewrite_prompt = f"""Rewrite this question to be clearer for a document search system.
+Keep it SHORT and preserve the EXACT original meaning. Do not add new concepts, legal terms, or expand the scope.
+If the question uses casual phrasing (e.g. "become a mother"), just convert it to the standard term (e.g. "maternity leave"), nothing more.
+
+Original question: {query}
+
+Rewritten question (short, same meaning):"""
+    rewritten = generate_with_groq_fn(rewrite_prompt, groq_client).strip()
+
+    results = retrieve_hybrid_fn(rewritten, domain, embedding_model, domain_indices, domain_chunks_map,
+                                   index, all_chunks, top_k=top_k)
+
+    best_distance = results[0][0]
+    if best_distance > hallucination_threshold:
+        return {'narrated_answer': "I couldn't find information about this in the available documents.",
+                'exact_quote': None, 'quote_confidence': None, 'source': None, 'domain': domain}
+
+    context_text = "\n\n".join([f"[Source: {c['domain']} - {c['title']}]\n{c['text']}" for dist, c in results])
+    prompt = f"""You are an enterprise knowledge assistant. Answer using ONLY the context below.
+Directly explain WHAT the policy/content actually says, in clear detail. Cite sources after explaining substance.
+
+Context:
+{context_text}
+
+Question: {query}
+
+Answer:"""
+    generative_answer = generate_with_groq_fn(prompt, groq_client)
+
+    best_chunk_text = results[0][1]['text']
+    exact_answer, extract_confidence = extract_exact_answer_fn(rewritten, best_chunk_text, qa_model, qa_tokenizer)
+
+    return {'narrated_answer': generative_answer, 'exact_quote': exact_answer,
+            'quote_confidence': extract_confidence, 'source': results[0][1]['title'], 'domain': domain}

src/hybrid_retrieval.py

@@ -0,0 +1,28 @@
+"""
+Enterprise Knowledge Assistant - Hybrid Domain-Aware Retrieval
+Tries domain-specific search first; falls back to global search if the match is weak.
+"""
+
+def retrieve_from_domain_index(query, domain, embedding_model, domain_indices, domain_chunks_map, top_k=5):
+    query_embedding = embedding_model.encode([query], convert_to_numpy=True)
+    distances, indices = domain_indices[domain].search(query_embedding.astype('float32'), top_k)
+    
+    results = []
+    for dist, idx in zip(distances[0], indices[0]):
+        results.append((dist, domain_chunks_map[domain][idx]))
+    
+    return results
+
+
+def retrieve_hybrid(query, domain, embedding_model, domain_indices, domain_chunks_map, 
+                     index, all_chunks, top_k=5, domain_fallback_threshold=0.95):
+    
+    domain_results = retrieve_from_domain_index(query, domain, embedding_model, domain_indices, domain_chunks_map, top_k)
+    best_domain_distance = domain_results[0][0]
+    
+    if best_domain_distance <= domain_fallback_threshold:
+        return domain_results
+    else:
+        query_embedding = embedding_model.encode([query], convert_to_numpy=True)
+        distances, indices = index.search(query_embedding.astype('float32'), top_k)
+        return [(dist, all_chunks[idx]) for dist, idx in zip(distances[0], indices[0])]

src/rag_pipeline.py

@@ -0,0 +1,74 @@
+"""
+Enterprise Knowledge Assistant - Core RAG Pipeline (v2)
+Improved hallucination guard: checks both original and rewritten query distances.
+"""
+
+def retrieve_relevant_chunks(query, embedding_model, index, all_chunks, top_k=5):
+    query_embedding = embedding_model.encode([query], convert_to_numpy=True)
+    distances, indices = index.search(query_embedding.astype('float32'), top_k)
+    results = [all_chunks[idx] for idx in indices[0]]
+    return results, distances[0][0]
+
+
+def generate_with_groq(prompt, groq_client, model="llama-3.3-70b-versatile"):
+    response = groq_client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content
+
+
+def ask_chatbot_v4(query, embedding_model, index, all_chunks, groq_client,
+                     conversation_history, top_k=5, similarity_threshold=0.88):
+    history_text = ""
+    if conversation_history:
+        history_text = "\n".join([f"User: {h['question']}\nAssistant: {h['answer']}"
+                                    for h in conversation_history[-3:]])
+
+    rewrite_prompt = f"""Given this conversation history:
+{history_text}
+
+Rewrite the new question to be clearer and more explicit for a document search system, resolving any references to earlier parts of the conversation.
+Only output the rewritten question, nothing else.
+
+New question: {query}"""
+
+    rewritten = generate_with_groq(rewrite_prompt, groq_client).strip()
+
+    original_embedding = embedding_model.encode([query], convert_to_numpy=True)
+    rewritten_embedding = embedding_model.encode([rewritten], convert_to_numpy=True)
+
+    orig_distances, orig_indices = index.search(original_embedding.astype('float32'), top_k)
+    rewrite_distances, rewrite_indices = index.search(rewritten_embedding.astype('float32'), top_k)
+
+    if orig_distances[0][0] <= rewrite_distances[0][0]:
+        best_distance = orig_distances[0][0]
+        indices = orig_indices
+    else:
+        best_distance = rewrite_distances[0][0]
+        indices = rewrite_indices
+
+    if best_distance > similarity_threshold:
+        answer = "I couldn't find information about this in the available documents. This question may be outside the scope of the current knowledge base."
+    else:
+        relevant_chunks = [all_chunks[idx] for idx in indices[0]]
+        context_text = "\n\n".join([f"[Source: {c['domain']} - {c['title']}]\n{c['text']}"
+                                      for c in relevant_chunks])
+
+        answer_prompt = f"""You are an enterprise knowledge assistant having an ongoing conversation.
+
+Conversation so far:
+{history_text}
+
+Answer using ONLY the context below. If the context doesn't fully answer the question, say what's missing honestly.
+
+Context:
+{context_text}
+
+New question: {query}
+
+Answer:"""
+        answer = generate_with_groq(answer_prompt, groq_client)
+
+    conversation_history.append({'question': query, 'answer': answer})
+    return answer, rewritten, best_distance

src/reload_session.py

@@ -0,0 +1,35 @@
+"""Run this at the start of every session to instantly restore everything."""
+
+from google.colab import drive
+drive.mount('/content/drive')
+
+import pickle, numpy as np, faiss, torch
+from sentence_transformers import SentenceTransformer
+from google.colab import userdata
+from groq import Groq
+import sys
+
+PROJECT_ROOT = "/content/drive/MyDrive/Enterprise_Knowledge_Assistant"
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+print(f"Using device: {device}")
+
+index = faiss.read_index(f"{PROJECT_ROOT}/embeddings/faiss_index.bin")
+
+with open(f"{PROJECT_ROOT}/embeddings/all_chunks_metadata.pkl", 'rb') as f:
+    all_chunks = pickle.load(f)
+
+embeddings = np.load(f"{PROJECT_ROOT}/embeddings/embeddings.npy")
+
+embedding_model = SentenceTransformer(f"{PROJECT_ROOT}/models/embedding_model", device=device)
+
+groq_client = Groq(api_key=userdata.get('GROQ_API_KEY'))
+
+sys.path.append(f"{PROJECT_ROOT}/src")
+from rag_pipeline import retrieve_relevant_chunks, generate_with_groq, ask_chatbot_v4
+from router_utils import classify_query
+
+conversation_history = []
+
+print("Everything reloaded successfully. Ready to chat.")
+print(f"Total chunks in index: {index.ntotal}")

src/reranker_utils.py

@@ -0,0 +1,18 @@
+"""
+Enterprise Knowledge Assistant - Cross-Encoder Reranking
+"""
+
+def retrieve_with_reranking(query, domain, embedding_model, domain_indices, domain_chunks_map,
+                              index, all_chunks, reranker, retrieve_hybrid_fn,
+                              initial_k=15, final_k=5, domain_fallback_threshold=0.95):
+    
+    initial_results = retrieve_hybrid_fn(query, domain, embedding_model, domain_indices, domain_chunks_map,
+                                           index, all_chunks, top_k=initial_k, domain_fallback_threshold=domain_fallback_threshold)
+    
+    pairs = [[query, chunk['text']] for dist, chunk in initial_results]
+    rerank_scores = reranker.predict(pairs)
+    
+    scored_results = list(zip(rerank_scores, [chunk for dist, chunk in initial_results]))
+    scored_results.sort(key=lambda x: x[0], reverse=True)
+    
+    return scored_results[:final_k]

src/router_utils.py

@@ -0,0 +1,16 @@
+"""
+Enterprise Knowledge Assistant - Query Router
+Uses fine-tuned DistilBERT to classify queries into HR/Legal/Finance/IT domains.
+"""
+
+import torch
+
+def classify_query(query, model, tokenizer, label_encoder):
+    inputs = tokenizer(query, return_tensors="pt", truncation=True, padding=True, max_length=64)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    predicted_class = torch.argmax(outputs.logits, dim=1).item()
+    predicted_domain = label_encoder.inverse_transform([predicted_class])[0]
+    probs = torch.nn.functional.softmax(outputs.logits, dim=1)[0]
+    confidence = probs[predicted_class].item()
+    return predicted_domain, confidence