Finalize backend for HF deployment

Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.9-slim
+WORKDIR /app
+COPY . .
+RUN pip install --no-cache-dir -r requirements.txt
+EXPOSE 7860
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "app:app"]

README.md

@@ -1,11 +1,4 @@
 ---
-title: Kurian Portfolio Backend
-emoji: 🏃
-colorFrom: green
-colorTo: red
+title: KurianGPT Backend
 sdk: docker
-pinned: false
-short_description: The flask api backend needed for the chatbot on the portfoli
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---

app.py

@@ -0,0 +1,131 @@
+import os
+import json
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from langchain_community.vectorstores import FAISS
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_groq import ChatGroq
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain.chains import create_retrieval_chain
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.documents import Document
+from dotenv import load_dotenv
+import re
+
+
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+rag_chain = None
+
+def json_to_text(json_data):
+    """
+    A simple function to convert the structured JSON into a single string.
+    This text will be used for creating embeddings.
+    """
+    text = ""
+    for key, value in json_data.items():
+        if isinstance(value, dict):
+            text += f"{key.replace('_', ' ').title()}:\n"
+            for sub_key, sub_value in value.items():
+                text += f"  {sub_key.replace('_', ' ').title()}: {sub_value}\n"
+        elif isinstance(value, list):
+            text += f"{key.replace('_', ' ').title()}:\n"
+            for item in value:
+                if isinstance(item, dict):
+                    for item_key, item_value in item.items():
+                        text += f"  - {item_key.replace('_', ' ').title()}: {item_value}\n"
+                else:
+                    text += f"  - {item}\n"
+        else:
+            text += f"{key.replace('_', ' ').title()}: {value}\n"
+        text += "\n"
+    return text
+
+def initialize_rag_chain():
+    global rag_chain
+    try:
+        # 1. Load data from JSON file
+        print("Loading data from knowledge_base.json...")
+        data_dir = "data"
+        json_path = os.path.join(data_dir, 'knowledge_base.json')
+        
+        with open(json_path, 'r') as f:
+            knowledge_base = json.load(f)
+        
+        # Convert the entire JSON to a single text string
+        text_content = json_to_text(knowledge_base)
+        # Wrap it in a LangChain Document object
+        documents = [Document(page_content=text_content)]
+        
+        # 2. Chunk the documents
+        print("Splitting document into chunks...")
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+        chunks = text_splitter.split_documents(documents)
+        print(f"Created {len(chunks)} text chunks.")
+
+        # 3. Create Embeddings
+        print("Initializing embedding model...")
+        embedding_model = HuggingFaceEmbeddings(model_name="BAAI/bge-small-en-v1.5")
+
+        # 4. Create FAISS Vector Store
+        print("Creating FAISS vector store...")
+        vector_store = FAISS.from_documents(chunks, embedding_model)
+        retriever = vector_store.as_retriever()
+
+        # 5. Initialize LLM
+        print("Initializing Groq LLM...")
+        llm = ChatGroq(temperature=0, model_name="qwen/qwen3-32b")
+
+        # 6. Create RAG Chain
+        print("Creating RAG chain...")
+        prompt = ChatPromptTemplate.from_template("""
+        You are "KurianGPT", an expert and very friendly AI assistant providing information about Kurian Jose based on his resume and project documents.
+        Answer the user's question based only on the following context.
+        Refer too yourself as "KurianGPT" and Kurian as "Kurian".
+        Avoid showing internal reasoning. Do not output <think> tags. Respond directly and professionally.
+        Keep responses **very brief** (1–2 sentences max) unless the user asks for more details or examples.
+        If the answer is not in the context, politely say that you can only answer questions regarding kurian's professional background and projects.
+        refer to the user as "you" and Kurian as "Kurian".
+        <context>
+        {context}
+        </context>
+
+        Question: {input}
+        """)
+        document_chain = create_stuff_documents_chain(llm, prompt)
+        rag_chain = create_retrieval_chain(retriever, document_chain)
+        print("--- RAG Chain Initialized Successfully! ---")
+    except Exception as e:
+        print(f"Error during RAG initialization: {e}")
+
+def strip_think_tags(text):
+    return re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
+
+#App routes
+@app.route('/api/chat', methods=['POST'])
+def chat():
+    if not rag_chain:
+        return jsonify({'error': 'RAG chain is not initialized. Check server logs.'}), 500
+    data = request.get_json()
+    user_message = data.get('message')
+    if not user_message:
+        return jsonify({'error': 'No message provided'}), 400
+    try:
+        result = rag_chain.invoke({"input": user_message})
+        raw_response = result.get('answer', "I couldn't generate a response.")
+        clean_response = strip_think_tags(raw_response)
+        return jsonify({'reply': clean_response})
+    except Exception as e:
+        print(f"Error during chat processing: {e}")
+        return jsonify({'error': 'An error occurred while processing your request.'}), 500
+
+# Initialize the RAG chain when the application starts
+initialize_rag_chain()
+
+# This part is for local development only and will not be used by Vercel
+if __name__ == '__main__':
+    app.run(debug=True, port=5001)

data/knowledge_base.json

@@ -0,0 +1,92 @@
+{
+  "personal_info": {
+    "name": "Kurian Jose",
+    "contact": {
+      "phone": "+91 9354502635",
+      "email": "kurianjoseoff@gmail.com",
+      "linkedin": "linkedin.com/in/Kurian",
+      "github": "github.com/Kurian"
+    },
+    "objective": "AI/ML developer with practical experience in LLMs, Retrieval-Augmented Generation (RAG), NLP, and prompt engineering. Specialized in building legal-tech tools and automation workflows using LangChain, FAISS, and OpenAI/Groq APIs. Eager to drive applied AI solutions in high-impact domains like law, finance, and enterprise automation."
+  },
+  "education": [
+    {
+      "institution": "Galgotias University",
+      "degree": "B.Tech in Computer Science",
+      "specialization": "AI and Machine Learning",
+      "dates": "Oct 2023 - Present",
+      "location": "Greater Noida, UP",
+      "courses": ["Machine Learning", "NLP", "Data Structures", "Algorithms"]
+    },
+    {
+      "institution": "Father Agnel School",
+      "degree": "Senior Secondary Education",
+      "dates": "March 2021 - May 2023",
+      "location": "New Delhi"
+    }
+  ],
+  "experience": [
+    {
+      "company": "Astron Financial Solutions",
+      "role": "AI Intern",
+      "dates": "June 2025 - Present",
+      "responsibilities": [
+        "Built a legal case brief generator using Python, Streamlit, and LangChain with Groq API, reducing manual summarization time by 40%.",
+        "Developed a legal question generator (MCQ + Subjective) from Constitutional Law case briefs using LLM prompt engineering, improving content generation efficiency by 30%.",
+        "Automated legal case retrieval and summarization from Indian Kanoon using Selenium and OpenRouter API with plain-English search.",
+        "Created an AI Model Consolidator to compare and merge LLM outputs (OpenAI, Gemini, DeepSeek) using Streamlit and Meta LLAMA-3.",
+        "Implemented a GSTR vs Purchase Register reconciliation tool in Python using pandas, enhancing GST audit accuracy and compliance."
+      ],
+      "tech_stack": ["Python", "Streamlit", "LangChain", "Groq API", "OpenRouter", "Gemini API", "Selenium", "FAISS", "pandas", "Git"]
+    }
+  ],
+  "projects": [
+    {
+      "title": "Legal Case Brief Generator using LLMs",
+      "description": "Developed a Streamlit-based web application that automates the generation of legal case briefs from PDF documents using a large language model (LLM). The tool allows users to upload legal case files, automatically extracts and chunks the content, and generates structured brief sections including Facts, Issue, Rule, Application, and Conclusion using the ChatGroq model (deepseek-r1-distill-llama-70b).",
+      "tech": ["Python", "Streamlit", "LangChain", "Groq API", "pdfplumber", "dotenv"],
+      "status": "Completed"
+    },
+    {
+        "title": "Legal Scenario-Based Question Generator (MCQ & Subjective)",
+        "description": "Built a web-based application using Streamlit that generates scenario-based legal questions (both MCQs and open-ended) from Indian constitutional law case briefs, specifically focused on Article 21 topics. The app allows users to upload a legal case PDF and generates pedagogically sound questions using a Groq-hosted LLM.",
+        "tech": ["Python", "Streamlit", "Groq API", "pdfplumber", "PyPDF2", "regex", "dotenv"],
+        "status": "Completed"
+    },
+    {
+        "title": "Automated Case Law Finder & PDF Downloader",
+        "description": "Designed a CLI-based automation pipeline that accepts a natural-language legal issue, uses an LLM (via OpenRouter API) to fetch relevant Supreme Court case titles, normalizes them, searches Indian Kanoon, and downloads the judgments as PDFs.",
+        "tech": ["Python", "OpenRouter (LLM API)", "Selenium", "Indian Kanoon", "ChromeDriver", "Regex", "dotenv"],
+        "status": "Completed"
+    },
+    {
+      "title": "AI Lawyer - Legal QA Chatbot (RAG)",
+      "description": "Developed a PDF-querying legal chatbot using Retrieval-Augmented Generation (RAG) architecture. Used FAISS and Ollama for document indexing and vector search; integrated DeepSeek via Groq API. Handled chunking, embedding, and LLM orchestration using LangChain.",
+      "tech": ["LangChain", "FAISS", "Ollama", "DeepSeek", "Groq API"]
+    },
+    {
+      "title": "Surakshita - Real-Time Audio Safety Alert App",
+      "description": "Built a real-time audio-based distress detection app using BiLSTM that triggered automated alerts. Developed a gender classification model to identify female voices in potential threat scenarios and integrated Google Maps API for geolocation-based emergency response.",
+      "tech": ["TensorFlow", "BiLSTM", "Google Maps API"],
+      "date": "August 2024"
+    }
+  ],
+  "skills": {
+    "languages": ["Python", "Java", "C", "SQL"],
+    "ai_ml": ["Transformers", "LLMs", "LangChain", "Retrieval-Augmented Generation (RAG)", "Prompt Engineering", "BiLSTM", "TensorFlow", "NLP (NLTK, Regex)"],
+    "frameworks_tools": ["Streamlit", "Flask", "Selenium", "Git", "VS Code", "PyCharm", "Google Colab", "GCP", "Figma"],
+    "apis_libraries": ["OpenAI", "Groq Cloud", "OpenRouter", "FAISS", "dotenv"],
+    "in_progress": ["Hugging Face Transformers", "Async LLM Orchestration", "Scalable RAG Pipelines"]
+  },
+  "certifications": [
+    {
+      "name": "Python for Data Science, AI & Development",
+      "issuer": "IBM"
+    },
+    {
+      "name": "100 Days of Python Expert",
+      "issuer": "Guvi Education"
+    }
+  ],
+  "soft_skills": "Strong leadership and teamwork from hackathon experiences, adept problem-solver, and highly adaptable with rapid learning of tools like TensorFlow and NLP libraries."
+}

requirements.txt

@@ -0,0 +1,9 @@
+flask
+flask_cors
+langchain
+langchain_community
+langchain_groq
+langchain-text-splitters
+faiss-cpu
+sentence-transformers
+python-dotenv