Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.github/workflows/sync_to_hub.yml

@@ -0,0 +1,19 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        # Added --force to overwrite the default Hugging Face README
+        run: git push --force https://tharu280:$HF_TOKEN@huggingface.co/spaces/tharu280/portfolio-rag-api main

.gitignore

@@ -0,0 +1,24 @@
+# --- Security (NEVER COMMIT THESE) ---
+.env
+firebase_credentials.json
+*.pem
+*.key
+
+# --- Python & OS Junk ---
+__pycache__/
+*.pyc
+venv/
+.venv/
+env/
+.idea/
+.vscode/
+.DS_Store
+
+# --- Hosting / Build ---
+# We generally ignore build artifacts, but for your specific
+# "Local Build -> Cloud Run" strategy, we DO want to commit
+# your database and vector store so Render can see them.
+#
+# DO NOT UNCOMMENT THESE LINES unless you switch to an external DB:
+# backend/portfolio.sqlite
+# backend/vector_store/

Dockerfile

@@ -0,0 +1,22 @@
+# 1. Use the specific Python version matching your local environment
+FROM python:3.10.16-slim
+
+# 2. Set the working directory inside the container
+WORKDIR /code
+
+# 3. Copy requirements first (for better caching)
+COPY ./requirements.txt /code/requirements.txt
+
+# 4. Install dependencies
+# We use --no-cache-dir to keep the image small
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# 5. Copy the rest of your application code
+COPY . /code
+
+# 6. CRITICAL: Give write permissions to the backend folder 
+# This allows SQLite to create lock files and update the DB
+RUN chmod -R 777 /code/backend
+
+# 7. Start the app on port 7860 (Hugging Face default)
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,2 @@
+# portfolio rag
+

app.py

@@ -0,0 +1,405 @@
+import os
+import json
+import requests
+import streamlit as st
+
+
+# --- Configuration ---
+API_URL = "http://127.0.0.1:8000/chat"
+IMAGES_DIR = "images"
+
+# --- Page Setup ---
+st.set_page_config(
+    page_title="Tharushika | AI Portfolio",
+    page_icon="👋",
+    layout="centered",
+    initial_sidebar_state="collapsed"
+)
+
+
+st.markdown("""
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+    
+    html, body, .stApp {
+        background-color: #ffffff !important;
+        font-family: -apple-system, BlinkMacSystemFont, 'Inter', sans-serif !important;
+        color: #1d1d1f !important;
+    }
+
+    p, .stMarkdown, .stText {
+        color: #333333;
+        line-height: 1.6;
+    }
+
+    h1, h2, h3, h4, h5, h6 {
+        font-weight: 600 !important;
+        letter-spacing: -0.02em !important; 
+        color: #1d1d1f !important;
+    }
+    h1 { font-size: 2.8rem !important; margin-bottom: 0.5rem !important;}
+    h2 { font-size: 2.2rem !important; margin-top: 0.5rem !important;}
+    h3 { font-size: 1.5rem !important; margin-top: 2rem !important; margin-bottom: 1rem !important;}
+    h4 { font-size: 1.2rem !important; margin-top: 1rem !important;}
+
+    .centered-title h1, .centered-title h2 {
+        text-align: center;
+        width: 100%;
+    }
+    .centered-title h2 {
+        color: #6e6e73 !important;
+        font-weight: 500 !important;
+        font-size: 1.8rem !important;
+    }
+    .centered-profile-pic {
+        display: flex;
+        justify-content: center;
+        margin-top: 2rem;
+        margin-bottom: 2rem;
+    }
+    .centered-profile-pic img {
+        border-radius: 20px; 
+        box-shadow: 0 4px 20px rgba(0,0,0,0.1);
+        border: 1px solid rgba(0,0,0,0.05);
+    }
+
+    .stChatMessage {
+        background-color: transparent !important;
+        border: none !important;
+        padding: 0.8rem 0 !important;
+    }
+    .stChatMessage [data-testid="stChatMessageContent"] {
+        background-color: #f5f5f7 !important;
+        border-radius: 18px !important;
+        padding: 0.8rem 1.2rem !important;
+        box-shadow: 0 1px 2px rgba(0,0,0,0.05);
+        color: #1d1d1f !important;
+        font-size: 1.0rem !important;
+        line-height: 1.5 !important;
+    }
+    .stChatMessage[data-testid="user-message"] [data-testid="stChatMessageContent"] {
+        background-color: #0071e3 !important;
+        color: white !important;
+    }
+
+    div[data-testid="stVerticalBlock"] > [style*="flex-direction: column;"] > [data-testid="stVerticalBlock"] {
+        background-color: #ffffff;
+        border: 1px solid rgba(0,0,0,0.08);
+        border-radius: 16px !important;
+        padding: 20px !important;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.03);
+        transition: transform 0.2s ease, box-shadow 0.2s ease;
+        margin-bottom: 15px;
+    }
+    
+    div[data-testid="stVerticalBlock"] > [style*="flex-direction: column;"] > [data-testid="stVerticalBlock"]:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 10px 25px rgba(0,0,0,0.08);
+        border-color: rgba(0,0,0,0.15);
+    }
+
+    .stButton > button {
+        border-radius: 12px !important;
+        font-weight: 500 !important;
+        border: 1px solid #d2d2d7 !important;
+        background-color: #ffffff !important;
+        color: #1d1d1f !important;
+        padding: 0.6rem 1rem !important;
+        transition: all 0.2s !important;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+        width: 100%;
+    }
+    .stButton > button:hover {
+        background-color: #f5f5f7 !important;
+        border-color: #c0c0c5 !important;
+        transform: translateY(-1px);
+        box-shadow: 0 2px 6px rgba(0,0,0,0.1);
+    }
+
+    .stTextInput input {
+        border-radius: 12px !important;
+        border: 1px solid #d2d2d7 !important;
+        padding: 12px 15px !important;
+        font-size: 1rem !important;
+        background-color: rgba(255,255,255,0.8) !important;
+        backdrop-filter: blur(10px);
+        color: #1d1d1f !important;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+    }
+    .stTextInput input:focus {
+        border-color: #0071e3 !important;
+        box-shadow: 0 0 0 4px rgba(0,113,227,0.15) !important;
+    }
+    div.stChatInputContainer {
+        padding-top: 15px;
+        background-color: #ffffff;
+        padding-bottom: 1rem;
+    }
+
+    a { color: #0071e3 !important; text-decoration: none !important; }
+    a:hover { text-decoration: underline !important; }
+    
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+
+    .quick-action-button .stButton > button {
+        border-radius: 999px !important;
+        padding: 0.8rem 1.5rem !important;
+        width: auto;
+    }
+    .quick-action-button {
+        display: flex;
+        justify-content: center;
+        margin-top: 2rem;
+        gap: 15px;
+        flex-wrap: wrap;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# --- Helper Functions ---
+
+
+def render_projects(data):
+    st.markdown("### Featured Projects")
+    if not data:
+        st.info("No projects data received.")
+        return
+    cols = st.columns(2)
+    for i, proj in enumerate(data):
+        with cols[i % 2]:
+            with st.container(border=True):
+                img_path = proj.get("image_path", "")
+                if img_path and os.path.exists(img_path):
+                    st.image(img_path, use_container_width=True)
+                else:
+                    st.markdown(f"""<div style='height:140px; background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%); border-radius: 12px; display:flex; align-items:center; justify-content:center; color:#666;'>No Image</div>""", unsafe_allow_html=True)
+
+                st.markdown(f"#### {proj.get('title', 'Untitled')}")
+                st.caption(proj.get('type', 'Project').upper())
+
+                with st.expander("View Details"):
+                    st.write(proj.get('description', ''))
+                    st.markdown(
+                        f"**Tech Stack:** {proj.get('technologies', '')}")
+                    links = []
+                    if proj.get('github_url'):
+                        links.append(f"[GitHub]({proj.get('github_url')})")
+                    if proj.get('demo_url'):
+                        links.append(f"[Live Demo]({proj.get('demo_url')})")
+                    if links:
+                        st.markdown(" &nbsp;•&nbsp; ".join(links))
+
+
+def render_skills(data):
+    st.markdown("### Skills & Expertise")
+    if not data:
+        st.info("No skills data received.")
+        return
+    for category, skills in data.items():
+        with st.container(border=True):
+            st.markdown(f"**{category}**")
+            badges = "".join(
+                [f"<span style='background:#f5f5f7; padding:4px 10px; border-radius:12px; margin:0 5px 5px 0; display:inline-block; font-size:0.85rem;'>{s}</span>" for s in skills])
+            st.markdown(badges, unsafe_allow_html=True)
+
+
+def render_articles(data):
+    st.markdown("### Articles")
+    if not data:
+        st.info("No articles found.")
+        return
+    for item in data:
+        with st.container(border=True):
+            st.markdown(f"**{item.get('title', 'Untitled')}**")
+            st.markdown(
+                f"<p style='color:#666; font-size:0.9rem;'>{item.get('description', '')}</p>", unsafe_allow_html=True)
+            if item.get('url'):
+                st.markdown(f"[Read Article ›]({item['url']})")
+
+
+def render_videos(data):
+    st.markdown("### Video Tutorials")
+    if not data:
+        st.info("No videos found.")
+        return
+    cols = st.columns(2)
+    for i, item in enumerate(data):
+        with cols[i % 2]:
+            with st.container(border=True):
+                thumb = item.get('thumbnail_url', "")
+                if thumb and os.path.exists(thumb):
+                    st.image(thumb, use_container_width=True)
+                st.markdown(f"**{item.get('title', 'Untitled')}**")
+                st.markdown(
+                    f"<p style='color:#666; font-size:0.9rem;'>{item.get('description', '')}</p>", unsafe_allow_html=True)
+                if item.get('url'):
+                    st.markdown(f"[Watch on YouTube ›]({item['url']})")
+
+
+def render_research(data):
+    st.markdown("### Research")
+    if not data:
+        st.info("No research found.")
+        return
+    for item in data:
+        with st.container(border=True):
+            st.markdown(f"**{item.get('title', 'Untitled')}**")
+            st.markdown(
+                f"<p style='color:#666; font-size:0.9rem;'>{item.get('description', '')}</p>", unsafe_allow_html=True)
+            if item.get('url'):
+                st.markdown(f"[View Publication ›]({item['url']})")
+
+
+def render_certifications(data):
+    st.markdown("### Certifications")
+    if not data:
+        st.info("No certifications found.")
+        return
+    for item in data:
+        st.markdown(f"""
+        <div style='display:flex; align-items:center; margin-bottom:10px;'>
+            <span style='font-size:1.2rem; margin-right:10px;'>🎖️</span>
+            <span style='font-size:1rem; font-weight:500;'>{item}</span>
+        </div>
+        """, unsafe_allow_html=True)
+
+# --- NEW: Resume Renderer ---
+
+
+def render_resume(data):
+    st.markdown("### 📄 Resume / CV")
+
+    col1, col2 = st.columns([1, 2])
+
+    with col1:
+        preview_path = data.get("preview_image", "")
+        if preview_path and os.path.exists(preview_path):
+            st.image(preview_path, caption="Preview", use_container_width=True)
+        else:
+            st.markdown("""
+            <div style="height: 200px; background-color: #f5f5f7; border-radius: 12px; display: flex; align-items: center; justify-content: center;">
+                <span style="font-size: 3rem;">📄</span>
+            </div>
+            """, unsafe_allow_html=True)
+
+    with col2:
+        st.markdown(f"#### {data.get('title', 'Resume')}")
+        st.write(data.get('description', ''))
+
+        pdf_path = data.get("file_path", "")
+        if pdf_path and os.path.exists(pdf_path):
+            with open(pdf_path, "rb") as pdf_file:
+                pdf_bytes = pdf_file.read()
+
+            st.download_button(
+                label="📥 Download Resume (PDF)",
+                data=pdf_bytes,
+                file_name="Tharushika_Abedheera_Resume.pdf",
+                mime="application/pdf",
+            )
+        else:
+            st.error("Resume file not found.")
+
+
+def render_content(data):
+    st.markdown("### Content & Research")
+    if not data:
+        return
+    tab1, tab2, tab3 = st.tabs(["Articles", "Videos", "Research"])
+    with tab1:
+        render_articles(data.get('articles', []))
+    with tab2:
+        render_videos(data.get('videos', []))
+    with tab3:
+        render_research(data.get('research', []))
+
+# --- Centralized Chat Logic Function ---
+
+
+def process_chat_message(prompt):
+    with st.spinner("Processing..."):
+        try:
+            response = requests.post(API_URL, json={"message": prompt})
+            if response.status_code == 200:
+                api_data = response.json()
+                st.session_state.last_exchange = {
+                    "user_query": prompt,
+                    "ai_response": api_data.get("response", ""),
+                    "tool_code": api_data.get("tool_code"),
+                    "tool_data": api_data.get("tool_data")
+                }
+            else:
+                st.error(f"Backend Error: {response.status_code}")
+        except Exception as e:
+            st.error(f"Connection Failed: {e}")
+    st.rerun()
+
+# --- Main Layout ---
+
+
+if "last_exchange" not in st.session_state:
+    st.session_state.last_exchange = None
+
+# --- Top Section: Profile and Introduction ---
+if not st.session_state.last_exchange:
+    st.markdown("<div class='centered-profile-pic'>", unsafe_allow_html=True)
+    profile_pic_path = "images/profile.png"
+    if os.path.exists(profile_pic_path):
+        st.image(profile_pic_path, width=160)
+    else:
+        st.markdown(f"""<div style='height:160px; width:160px; background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%); border-radius: 20px; display:flex; align-items:center; justify-content:center; color:#666; font-size:0.8rem; margin: 0 auto;'>Add profile.png</div>""", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    st.markdown("<div class='centered-title'>", unsafe_allow_html=True)
+    st.markdown("<h1>Hey, I'm Tharushika 👋</h1>", unsafe_allow_html=True)
+    st.markdown("<h2>Machine Learning Engineer</h2>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    st.markdown("<div class='quick-action-button'>", unsafe_allow_html=True)
+    if st.button("Me"):
+        process_chat_message("Tell me about yourself")
+    if st.button("Projects"):
+        process_chat_message("Show me your projects")
+    if st.button("Skills"):
+        process_chat_message("What are your skills?")
+    if st.button("Contact"):
+        process_chat_message("How can I contact you?")
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    if prompt := st.chat_input("Ask me anything..."):
+        process_chat_message(prompt)
+
+# --- Conversation Area ---
+if st.session_state.last_exchange:
+    exchange = st.session_state.last_exchange
+
+    with st.chat_message("user"):
+        st.write(exchange["user_query"])
+
+    with st.chat_message("assistant"):
+        st.write(exchange["ai_response"])
+
+        tool_code = exchange.get("tool_code")
+        tool_data = exchange.get("tool_data")
+
+        if tool_code == "show_projects":
+            render_projects(tool_data)
+        elif tool_code == "show_skills":
+            render_skills(tool_data)
+        elif tool_code == "show_content":
+            render_content(tool_data)
+        elif tool_code == "show_videos":
+            render_videos(tool_data)
+        elif tool_code == "show_articles":
+            render_articles(tool_data)
+        elif tool_code == "show_research":
+            render_research(tool_data)
+        elif tool_code == "show_certifications":
+            render_certifications(tool_data)
+        elif tool_code == "show_resume":
+            render_resume(tool_data)  # <--- RESUME HANDLER ADDED
+
+    if prompt := st.chat_input("Ask for more details..."):
+        process_chat_message(prompt)

backend/database.py

@@ -0,0 +1,38 @@
+import sqlite3
+import json
+import os
+from typing import List, Dict, Any, Union
+
+DB_PATH = os.path.join(os.path.dirname(
+    os.path.abspath(__file__)), "portfolio.sqlite")
+
+
+def query_sqlite(table_name: str) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    """Fetches all rows from a SQLite table and formats them."""
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        cursor.execute(f"SELECT * FROM {table_name}")
+        rows = [dict(row) for row in cursor.fetchall()]
+        conn.close()
+
+        if table_name == "skills":
+            formatted_skills = {}
+            for row in rows:
+                try:
+                    # Parse the JSON string back to a list
+                    skills_array = json.loads(row['skill_list'])
+                    formatted_skills[row['category']] = skills_array
+                except:
+                    formatted_skills[row['category']] = []
+            return formatted_skills
+
+        if table_name == "certifications":
+            return [row['name'] for row in rows]
+
+        return rows
+    except Exception as e:
+        print(f"Database Error: {e}")
+        return []

backend/main.py

@@ -0,0 +1,164 @@
+import os
+import sys
+import google.generativeai as genai
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Dict, Any, Union, Optional
+from dotenv import load_dotenv
+
+# Import local modules using relative imports
+# This requires running the app as 'uvicorn backend.main:app ...'
+from . import rag
+from . import tools
+
+# 1. Load Environment Variables
+# 'load_dotenv()' works for local dev. On Render/Cloud, it uses system env vars.
+load_dotenv()
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not GEMINI_API_KEY:
+    print("⚠️  WARNING: GEMINI_API_KEY not found. Check your .env or Cloud Dashboard.")
+    # In production, we might want to crash if no key is found
+    # sys.exit(1)
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Use the fast, free-tier friendly model
+MODEL_NAME = 'gemini-1.5-flash'
+
+# --- API Models ---
+
+
+class ChatRequest(BaseModel):
+    message: str
+
+
+class ChatResponse(BaseModel):
+    response: str
+    tool_code: Optional[str] = None
+    tool_data: Optional[Union[Dict[str, Any], List[Any]]] = None
+
+
+# --- FastAPI App Setup ---
+app = FastAPI(
+    title="Tharushika's AI Portfolio API",
+    description="Backend for AI Portfolio using Gemini & RAG",
+    version="1.0.0"
+)
+
+# --- CORS MIDDLEWARE (Critical for React) ---
+app.add_middleware(
+    CORSMiddleware,
+    # In production, replace ["*"] with your actual frontend URL (e.g., ["https://my-portfolio.vercel.app"])
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods (GET, POST, etc.)
+    allow_headers=["*"],  # Allows all headers
+)
+
+
+@app.on_event("startup")
+async def startup():
+    """Initialize the RAG system when the server boots up."""
+    rag.initialize_rag()
+
+# --- Endpoints ---
+
+
+@app.get("/")
+def health_check():
+    """Simple check to see if the API is running."""
+    return {"status": "ok", "message": "Portfolio API is live"}
+
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    user_msg = request.message
+
+    # 1. Initialize Gemini with our Toolkit
+    model = genai.GenerativeModel(MODEL_NAME, tools=tools.ALL_TOOLS_LIST)
+
+    try:
+        # 2. Ask Gemini the question
+        # We don't provide RAG context yet; we let the model decide if it needs a Tool first.
+        chat = model.start_chat(enable_automatic_function_calling=False)
+        response = chat.send_message(user_msg)
+
+        # 3. Check for Function Calls (The "Router")
+        function_call = None
+        if response.parts:
+            for part in response.parts:
+                if part.function_call:
+                    function_call = part.function_call
+                    break
+
+        # --- PATH A: Tool Triggered (Structured Data) ---
+        if function_call:
+            tool_name = function_call.name
+            print(f"🛠️  Tool Triggered: {tool_name}")
+
+            if tool_name in tools.TOOL_FUNCTIONS:
+                # A. Execute the Python function (e.g., query SQL)
+                data = tools.TOOL_FUNCTIONS[tool_name]()
+
+                # B. Get the frontend signal code (e.g., "show_projects")
+                code = tools.TOOL_CODE_MAP.get(tool_name)
+
+                # C. Generate a polite intro message using RAG context
+                # We retrieve a bit of context so the intro sounds personal
+                context_chunks = rag.retrieve_context(user_msg, k=2)
+                context_text = "\n".join(context_chunks)
+
+                intro_prompt = f"""
+                The user asked: '{user_msg}'. 
+                You just triggered the tool '{tool_name}' to show them visual data.
+                Write a very short (1 sentence), enthusiastic intro for this data.
+                Use this context if relevant: {context_text}
+                """
+
+                intro_model = genai.GenerativeModel(MODEL_NAME)
+                intro_resp = intro_model.generate_content(intro_prompt)
+                intro_text = intro_resp.text.strip()
+
+                return ChatResponse(
+                    response=intro_text,
+                    tool_code=code,
+                    tool_data=data
+                )
+
+        # --- PATH B: Pure RAG Chat (Unstructured Context) ---
+        print("🧠  RAG Path Triggered")
+
+        # 1. Retrieve relevant text chunks from our Vector DB
+        context_chunks = rag.retrieve_context(user_msg, k=4)
+        context_text = "\n\n".join(context_chunks)
+
+        # 2. Construct the Prompt
+        rag_prompt = f"""
+        You are an AI assistant for Tharushika Abedheera's portfolio. 
+        Your goal is to answer the user's question professionally and confidently, acting as Tharushika.
+        
+        STRICT RULES:
+        - Use ONLY the context provided below.
+        - If the answer isn't in the context, say "I don't have that specific info right now, but feel free to ask about my projects or skills!"
+        - Keep answers concise (under 3-4 sentences) unless asked for detail.
+        
+        CONTEXT FROM KNOWLEDGE BASE:
+        {context_text}
+        
+        USER QUESTION:
+        {user_msg}
+        """
+
+        # 3. Generate Answer
+        rag_model = genai.GenerativeModel(MODEL_NAME)
+        text_response = rag_model.generate_content(rag_prompt).text
+
+        return ChatResponse(response=text_response, tool_code=None, tool_data=None)
+
+    except Exception as e:
+        print(f"❌ Error handling chat: {e}")
+        # In production, avoid sending raw error details to the client for security
+        raise HTTPException(status_code=500, detail="Internal Server Error")

backend/rag.py

@@ -0,0 +1,88 @@
+import os
+import pickle
+import faiss
+import numpy as np
+import google.generativeai as genai
+import traceback
+from dotenv import load_dotenv
+
+# --- 1. Force Load API Key ---
+load_dotenv()
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not GEMINI_API_KEY:
+    print("⚠️ WARNING: GEMINI_API_KEY not found in rag.py environment.")
+else:
+    genai.configure(api_key=GEMINI_API_KEY)
+
+# Paths
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+VECTOR_STORE_DIR = os.path.join(BASE_DIR, "vector_store")
+INDEX_PATH = os.path.join(VECTOR_STORE_DIR, "faiss_index.bin")
+METADATA_PATH = os.path.join(VECTOR_STORE_DIR, "chunks_metadata.pkl")
+
+# API Config
+EMBEDDING_MODEL = "models/text-embedding-004"
+
+# Global Components
+faiss_index = None
+chunks = []
+
+
+def initialize_rag():
+    global faiss_index, chunks
+
+    print("--- RAG INITIALIZATION ---")
+    if not os.path.exists(INDEX_PATH) or not os.path.exists(METADATA_PATH):
+        print(f"CRITICAL: Index files not found at {VECTOR_STORE_DIR}")
+        return
+
+    try:
+        faiss_index = faiss.read_index(INDEX_PATH)
+        with open(METADATA_PATH, "rb") as f:
+            data = pickle.load(f)
+            chunks = data['chunks']
+        print(f"✅ RAG Loaded. {len(chunks)} chunks indexed.")
+    except Exception as e:
+        print(f"❌ Error loading RAG files: {e}")
+
+
+def retrieve_context(query: str, k: int = 2):
+    """Retrieves text chunks using Gemini Embeddings."""
+    if not faiss_index:
+        print("⚠️ RAG Retrieval Skipped: Index not loaded.")
+        return []
+
+    try:
+        # 1. Get embedding from API
+        result = genai.embed_content(
+            model=EMBEDDING_MODEL,
+            content=query,
+            task_type="retrieval_query"
+        )
+
+        # 2. Convert to Numpy
+        query_vec = np.array([result['embedding']]).astype("float32")
+
+        # 3. Check Dimensions (Debug Step)
+        if faiss_index.d != query_vec.shape[1]:
+            print(
+                f"❌ DIMENSION MISMATCH: Index expects {faiss_index.d}, but Query is {query_vec.shape[1]}")
+            print(
+                "SOLUTION: Delete backend/vector_store and run create_vector_db.py again.")
+            return []
+
+        # 4. Search FAISS
+        distances, indices = faiss_index.search(query_vec, k)
+
+        retrieved_text = []
+        for i in indices[0]:
+            if i != -1 and i < len(chunks):
+                retrieved_text.append(chunks[i])
+
+        return retrieved_text
+
+    except Exception as e:
+        print(f"❌ RAG ERROR: {e}")
+        traceback.print_exc()  # Prints the full error to the terminal
+        return []

backend/tools.py

@@ -0,0 +1,120 @@
+import google.generativeai as genai
+from .database import query_sqlite
+
+# --- Python Implementation of Tools ---
+
+
+def get_projects(): return query_sqlite("projects")
+def get_skills(): return query_sqlite("skills")
+def get_certifications(): return query_sqlite("certifications")
+def get_articles(): return query_sqlite("articles")
+def get_videos(): return query_sqlite("videos")
+def get_research(): return query_sqlite("research")
+
+
+def get_content():
+    return {
+        "articles": query_sqlite("articles"),
+        "videos": query_sqlite("videos"),
+        "research": query_sqlite("research")
+    }
+
+
+def get_resume():
+    """Returns metadata for the resume file."""
+    return {
+        "file_path": "images/resume.pdf",
+        "preview_image": "images/resume_preview.png",
+        "title": "Tharushika Abedheera - CV",
+        "description": "Machine Learning Engineer & AI Specialist"
+    }
+
+
+# Mapping for execution
+TOOL_FUNCTIONS = {
+    "get_projects": get_projects,
+    "get_skills": get_skills,
+    "get_certifications": get_certifications,
+    "get_articles": get_articles,
+    "get_videos": get_videos,
+    "get_research": get_research,
+    "get_content": get_content,
+    "get_resume": get_resume  # <--- Added
+}
+
+# Mapping for Frontend Action Codes
+TOOL_CODE_MAP = {
+    "get_projects": "show_projects",
+    "get_skills": "show_skills",
+    "get_certifications": "show_certifications",
+    "get_articles": "show_articles",
+    "get_videos": "show_videos",
+    "get_research": "show_research",
+    "get_content": "show_content",
+    "get_resume": "show_resume"  # <--- Added
+}
+
+# --- Gemini Schema Definitions ---
+
+projects_tool = genai.protos.FunctionDeclaration(
+    name="get_projects",
+    description="Retrieve the full list of Tharushika's projects.",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+skills_tool = genai.protos.FunctionDeclaration(
+    name="get_skills",
+    description="Retrieve technical skills.",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+certifications_tool = genai.protos.FunctionDeclaration(
+    name="get_certifications",
+    description="Retrieve certifications.",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+articles_tool = genai.protos.FunctionDeclaration(
+    name="get_articles",
+    description="Retrieve articles.",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+videos_tool = genai.protos.FunctionDeclaration(
+    name="get_videos",
+    description="Retrieve videos.",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+research_tool = genai.protos.FunctionDeclaration(
+    name="get_research",
+    description="Retrieve research.",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+content_tool = genai.protos.FunctionDeclaration(
+    name="get_content",
+    description="Retrieve ALL content (articles, videos, research).",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+resume_tool = genai.protos.FunctionDeclaration(
+    name="get_resume",
+    description="Retrieve Tharushika's official resume/CV. Use this when the user asks to see, download, or get a copy of the resume.",
+    parameters=genai.protos.Schema(
+        type=genai.protos.Type.OBJECT, properties={}, required=[])
+)
+
+# List to pass to the model
+ALL_TOOLS_LIST = [
+    projects_tool, skills_tool, certifications_tool,
+    articles_tool, videos_tool, research_tool, content_tool,
+    resume_tool  # <--- Added
+]

data/articles.json

@@ -0,0 +1,44 @@
+[
+  {
+    "title": "From PDF to API: How I Built a Hybrid RAG Insights Engine for Laptop Specs",
+    "description": "A deep dive into how I created a dynamic and static data-based RAG system for a business.",
+    "url": "https://www.linkedin.com/pulse/from-pdf-api-how-i-built-hybrid-rag-insights-engine-laptop-abedheera-hwwoc",
+    "type": "article"
+  },
+  {
+    "title": "How to Choose the Best Machine Learning Algorithm for Sentiment Analysis",
+    "description": "A guide on how to choose the best machine learning algorithm for sentiment analysis.",
+    "url": "https://www.linkedin.com/pulse/how-choose-best-machine-learning-algorithm-sentiment-abedheera-mvctc",
+    "type": "article"
+  },
+  {
+    "title": "Parallel RAG with LangChain: Three Vector DBs, One Personality.",
+    "description": "Lessons learned building an 'Uncle Iroh' mental healthcare assistant. Covers diverse knowledge sourcing, chunking strategies, and parallel retrievers.",
+    "url": "https://www.linkedin.com/pulse/parallel-rag-langchain-three-vector-dbs-one-tharushika-abedheera-tognc",
+    "type": "article"
+  },
+   {
+    "title": "A Gentle Introduction to LSTMs (Long Short-Term Memory Networks)",
+    "description": "Explore what LSTMs are, why they were created, and how they help machines understand sequences.",
+    "url": "https://www.linkedin.com/pulse/gentle-introduction-lstms-long-short-term-memory-tharushika-abedheera-irvzc",
+    "type": "article"
+  },
+   {
+    "title": "How Does L1 (Lasso) and L2 (Ridge) Regularization Work?",
+    "description": "Explore L1 (Lasso) and L2 (Ridge) regularization techniques to improve model performance by addressing overfitting.",
+    "url": "https://www.linkedin.com/pulse/how-does-l1-lasso-l2-ridge-regularization-work-tharushika-abedheera-upyvc",
+    "type": "article"
+  },
+   {
+    "title": "ROUGE Score: A Key Metric for Evaluating Text Summarisation Models",
+    "description": "Introduction to how ROUGE scores provide valuable insights into how well a model has performed in generating summaries.",
+    "url": "https://www.linkedin.com/pulse/rouge-score-key-metric-evaluating-text-summarisation-models-qirwc",
+    "type": "article"
+  },
+  {
+    "title": "SQuAD Metrics: Evaluating Question-Answering Models Effectively",
+    "description": "Introduction to the SQuAD metric, an essential tool for evaluating question-answering models in NLP.",
+    "url": "https://www.linkedin.com/pulse/how-does-l1-lasso-l2-ridge-regularization-work-tharushika-abedheera-upyvc",
+    "type": "article"
+  }
+]

data/certifications.json

@@ -0,0 +1,9 @@
+[
+  { "name": "Azure Certified AI Engineer Associate (in progress)" },
+  { "name": "Astronomer Certification DAG Authoring for Apache Airflow 3" },
+  { "name": "LinkedIn- Vector Databases for Caching and Retrieval Augmented Generation (RAG)" },
+  { "name": "LinkedIn- Building AI Agents with AutoGen" },
+  { "name": "LinkedIn- Building NLP Apps with Hugging Face Transformers" },
+  { "name": "LinkedIn- Agentic AI for Developers: Concepts and Application for Enterprises" },
+  { "name": "LinkedIn- Getting Started with Hugging Face Transformers ." }
+]

data/education.json

@@ -0,0 +1,14 @@
+[
+  {
+    "id": "uni_plymouth",
+    "degree": "Bachelor of Science (Honours) in Software Engineering",
+    "institution": "University of Plymouth",
+    "details": "Focused on software engineering principles and AI applications."
+  },
+  {
+    "id": "badulla_college",
+    "degree": "GCE Advanced level",
+    "institution": "Badulla central collage",
+    "details": "Includes an 'A' pass for English Language."
+  }
+]

data/experience.json

@@ -0,0 +1,16 @@
+[
+  {
+    "id": "nextgen_intern",
+    "role": "Data Science and Machine Learning Engineer intern",
+    "company": "NextGen CodeX",
+    "duration": "2025/10/15 - Present",
+    "description": "Internship focused on advanced Data Science and ML applications."
+  },
+  {
+    "id": "intelligen_freelance",
+    "role": "Freelance Machine Learning Engineer",
+    "company": "Intelli-Gen AI",
+    "duration": "2024/02/10 - Present",
+    "description": "Freelance work developing custom ML solutions and AI integrations."
+  }
+]

data/profile.json

@@ -0,0 +1,13 @@
+{
+  "contact": {
+    "name": "A.A.D. Tharushika Abedheera",
+    "role": "Machine Learning Engineer / AI Engineer",
+    "email": "tharushika280@gmail.com",
+    "phone": "07655753551",
+    "location": "Badulla, Sri Lanka",
+    "linkedin": "https://www.linkedin.com/in/tharushika-abedheera-3396311a4/",
+    "github": "https://github.com/tharu280",
+    "medium": "https://medium.com/@tharushika280"
+  },
+  "summary": "Machine Learning Engineer with a research-driven approach, specializing in NLP, Generative AI, and AI agent frameworks. Passionate about transforming AI/ML research into real-world applications, with hands-on experience and expertise in Machine learning, Deep learning, large language models (LLMs), retrieval-augmented generation (RAG), and autonomous AI systems. Adept at designing, deploying, and optimizing AI-driven systems to enhance scalability and innovation."
+}

data/projects.json

@@ -0,0 +1,92 @@
+[
+  {
+    "id": "rag-book-recommender",
+    "title": "RAG-based Advanced Book Recommendation System",
+    "type": "AI/ML",
+    "description": "Built a personalized book recommender using LangChain, HuggingFace Sentence Transformers, and ChromaDB, with zero-shot classification to auto-fill missing categories and enrich recommendations. Deployed the system using FastAPI, Docker, and Nginx on AWS Elastic Beanstalk for scalable, low-latency access.",
+    "technologies": ["Python", "Numpy", "Pandas", "HuggingFace Transformers", "LangChain", "ChromaDB", "FastAPI", "Docker", "Nginx", "AWS Elastic Beanstalk"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_book.png"
+  },
+  {
+    "id": "eyecon",
+    "title": "EyeCon – Real-Time Blink Communication System",
+    "type": "AI/ML",
+    "description": "Developed the first system enabling fully paralysed users to communicate without any wearable devices, using only eye blinks detected via webcam. Implemented Eye Aspect Ratio (EAR)–based blink detection to differentiate short (next candidate) and long blinks (select candidate), achieving accurate, real-time interpretation of user intent. Integrated a Gemini LLM for context-aware candidate word suggestions, dynamically updating options as the sentence forms. Enabled automatic summarisation of composed sentences, providing users with coherent text output and facilitating streamlined communication.",
+    "technologies": ["Python", "OpenCV", "MediaPipe", "Kivy", "Custom Morse Decoder", "Gemini LLM", "Contextual Candidate Selection", "FastAPI"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_eyecon.png"
+  },
+  {
+    "id": "youtube-analytics",
+    "title": "End-to-End YouTube Comment Analytics Pipeline",
+    "type": "Data Engineering",
+    "description": "Built an AI-powered pipeline to extract, classify, and visualize YouTube comments. Achieved 95.46% accuracy by fine-tuning BERT; also developed a BiLSTM classifier (90.75%); hosted the best model on HuggingFace Hub. Integrated Azure services (SQL Serverless, Data Factory, Power BI) for automated data flow, storage, and interactive visualisations.",
+    "technologies": ["Python", "TensorFlow", "Keras", "TF-IDF", "BiLSTM", "BERT", "HuggingFace", "FastAPI", "Docker", "YouTube API", "Azure SQL Serverless", "Azure Data Factory", "Power BI", "Azure Data Studio"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_youtube.png"
+  },
+  {
+    "id": "mental-health-chatbot",
+    "title": "Comic Character-based RAG Mental Healthcare Assistant Chatbot",
+    "type": "AI/ML",
+    "description": "Built a RAG-based chatbot modelled after “Uncle Iroh” to provide mental health support using multi-source wisdom and personalized tone. Implemented 3 FAISS stores, with RunnableParallel & Sequential chains -cutting latency from 3.9s to 1.5s accurate and combined context retrieval. Optimised with Redis memory, LangSmith monitoring, and FastAPI; voice cloning via ElevenLabs in progress.",
+    "technologies": ["Python", "LangChain", "HuggingFace Transformers", "Gemini 1.5 Flash", "FAISS", "Redis", "LangSmith", "ElevenLabs", "FastAPI", "Pydantic"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_chatbot.png"
+  },
+  {
+    "id": "cafe-chatbot",
+    "title": "AI-Powered RAG Chatbot for Cafe Business",
+    "type": "Cloud AI",
+    "description": "Built a Retrieval-Augmented Generation (RAG) chatbot using Amazon Bedrock, OpenSearch Serverless, and S3 to answer customer queries based on internal café documents. Preprocessed and embedded data for semantic search; integrated foundation models with prompt engineering for contextual responses. Designed a scalable, secure deployment with proper IAM configuration and AWS-native services to ensure real-world readiness.",
+    "technologies": ["AWS Bedrock", "AWS OpenSearch Serverless", "AWS S3", "Llama 3 70B", "Titan Text G1 – Lite"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_cafe.png"
+  },
+  {
+    "id": "ai-coding-agent",
+    "title": "AI Coding Agent – V (Open Source Project)",
+    "type": "Agentic AI",
+    "description": "Designed and developed an AI coding agent demonstrating Agentic AI design patterns including Tool Use and Reflection Loop. Integrated Google Gemini’s function calling to perform grounded code operations such as reading, writing, and executing Python files. Implemented a 20-iteration reflection loop where the agent plans, acts, critiques, and improves results until completion.",
+    "technologies": ["Python", "Google Gemini API", "Gemini SDK", "Pydantic", "Agentic design patterns"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_agent.png"
+  },
+  {
+    "id": "laptop-intel-engine",
+    "title": "Cross-Marketplace Laptop & Review Intelligence Engine",
+    "type": "AI/ML",
+    "description": "Developed an insights engine to analyse and compare laptops by integrating two distinct data sources: canonical static technical specifications from PDFs(PSREF) and mutable, real time data (price, availability, reviews) from product pages.. Engineered a hybrid Retrieval-Augmented Generation (RAG) pipeline that fuses context from two data stores: a FAISS vector index (for semantic search on PDF specs) and a SQLite database (for structured SQL queries on dynamic market data).",
+    "technologies": ["Python", "FastAPI", "Streamlit", "Google Gemini API", "FAISS", "Sentence Transformers", "SQLite", "Pandas", "Pydantic"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_laptop.png"
+  },
+  {
+    "id": "food-ordering-backend",
+    "title": "Event-Driven Backend for Food Ordering with Real-Time Fraud Detection",
+    "type": "Backend/ML",
+    "description": "Built a scalable event-driven backend using Python, Kafka, and Docker for a food ordering app with real-time processing. Modelled core events like order_placed, order_confirmed, and fraud_alert as Kafka topics across decoupled microservices. Integrated a fraud detection model into the transaction service to detect fraud in real-time and publish alerts via Kafka.",
+    "technologies": ["Python", "Apache Kafka", "kafka-python", "scikit-learn", "Docker", "Pydantic", "MLflow", "FastAPI"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_food.png"
+  },
+  {
+    "id": "tour-planner-agent",
+    "title": "Tour Planner AI Agent",
+    "type": "Agentic AI",
+    "description": "Designed a hybrid AI system using LangGraph to orchestrate a multi-step agentic workflow for dynamic itinerary generation. Engineered a rule-based data ingestion pipeline to chain disparate APIs for gathering geocoding, route, and a broad set of location data. Implemented an “LLM as a Judge\" pattern that semantically analyses the user's qualitative query to rank and filter the raw data, delivering context-aware, personalized recommendations.",
+    "technologies": ["Python", "LangGraph", "FastAPI", "Google Gemini API", "Pydantic", "Geoapify", "OpenRouteService", "Nominatim"],
+    "github_url": "https://github.com/tharu280",
+    "demo_url": null,
+    "image_path": "images/project_tour.png"
+  }
+]

data/research.json

@@ -0,0 +1,20 @@
+[
+  {
+    "title": "AI Voice Assistant for Healthcare (ICIET 2023)",
+    "description": "Published as a conference paper at ICIET 2023. Developed an AI voice assistant using PyTorch and NLTK to handle general and healthcare-related queries.",
+    "url": "https://www.researchgate.net/publication/376522984_A_Deep_Learning_Approach_to_Utilize_AI_Voice_Assistants_In_Healthcare", 
+    "type": "paper"
+  },
+  {
+    "title": "EL_sense: AI Solution for Human-Elephant Conflict (In Progress)",
+    "description": "Proposed a bioacoustics-based system for detecting low-frequency (20Hz) elephant rumbles using live audio streaming via Apache Kafka.",
+    "url": null,
+    "type": "research"
+  },
+  {
+    "title": "EyeCon – Real-Time Blink Communication System",
+    "description": "Developed the first system enabling fully paralysed users to communicate without any wearable devices, using only eye blinks.",
+    "url": null,
+    "type": "paper"
+  }
+]

data/skills.json

@@ -0,0 +1,37 @@
+[
+  {
+    "id": "programming",
+    "category": "Programming",
+    "list": ["Python", "JavaScript", "HTML", "CSS", "C", "SQL"]
+  },
+  {
+    "id": "ml_dl",
+    "category": "Machine Learning & Deep Learning",
+    "list": ["Scikit-learn", "TensorFlow", "Keras", "PyTorch", "Hugging Face", "Transformers", "XGBoost", "Decision Trees", "Random Forest", "SVM", "Naïve Bayes", "KNN", "K-Means Clustering", "PCA", "Model Evaluation", "Hyper-parameter Tuning", "Pandas", "NumPy", "LSTMs", "Transformers", "LLMs", "NLTK", "CNNs", "OpenCV", "MediaPipe", "Vision Transformers (ViTs)", "Yolo"]
+  },
+  {
+    "id": "vector_db",
+    "category": "Vector Search & Databases",
+    "list": ["FAISS", "ANNOY", "Milvus", "ChromaDB", "LlamaIndex", "Pinecone", "Weaviate"]
+  },
+  {
+    "id": "databases",
+    "category": "Databases",
+    "list": ["MySQL", "MongoDB", "Firebase", "Amazon S3", "PostgreSQL"]
+  },
+  {
+    "id": "cloud_devops",
+    "category": "Cloud & CI/CD",
+    "list": ["AWS", "Azure", "GCP", "Docker", "GitHub Actions", "Apache Kafka", "MLflow", "LangSmith", "CI/CD pipelines", "AWS EC2"]
+  },
+  {
+    "id": "agentic_ai",
+    "category": "Agentic AI",
+    "list": ["AutoGen", "LlamaIndex", "Langchain", "LangGraph"]
+  },
+  {
+    "id": "frameworks",
+    "category": "Frameworks",
+    "list": ["FastAPI", "Flask", "Streamlit", "Tkinter", "Kivy", "React.js"]
+  }
+]

data/summaries/about_summary.txt

@@ -0,0 +1 @@
+"My journey into AI is fueled by a desire to solve real-world problems with tangible impact.  I’m deeply passionate about Machine Learning and Artificial Intelligence and have spent the past two years learning and building hands on projects completely self driven and grounded in real world applications.I'm not just interested in model accuracy; I'm passionate about engineering systems that are robust, scalable, and genuinely useful, especially in areas like accessibility  and practical RAG applications. I thrive on the entire AI lifecycle, from developing the initial mathematical concept to containerizing the final FastAPI endpoint for production. The transition from pure research to a deployed product is where I find the most exciting challenges.I’m confident in my ability to learn quickly, adapt to fast paced environments, and contribute meaningfully to your team. Every drop of my knowledge in the domain of AI ML is learned solely through free resources such as youtube  on my own as i am absolutely passionate about this field."

data/summaries/articles_summary.txt

@@ -0,0 +1 @@
+“Above are some of my published articles, where I regularly write about machine learning, deep learning, NLP, RAG systems, evaluation metrics, and practical engineering lessons from real-world AI projects. My writing focuses on breaking down complex concepts, sharing hands-on insights, and documenting the architectures, techniques, and optimizations I use in my own systems. These featured articles represent only part of my work — I continue to publish more guides, explanations, and deep dives to help others understand and build effective AI/ML solutions.”

data/summaries/certifications_summary.txt

@@ -0,0 +1 @@
+“Above are some of my professional certifications, reflecting my ongoing commitment to mastering cloud platforms, AI engineering, workflow orchestration, RAG systems, and agentic AI frameworks. I consistently pursue industry-recognized credentials to stay aligned with modern best practices and deepen my expertise. These listed certifications are only part of my continuous learning journey, and I regularly work toward new ones as the field evolves.”

data/summaries/projects_summary.txt

@@ -0,0 +1 @@
+“Above are some of my most notable projects. I’ve worked across a wide range of AI and engineering areas — including machine learning, deep learning, RAG systems, agentic AI, computer vision, and scalable backend pipelines. My work spans everything from recommendation systems, analytics pipelines, intelligent assistants, and real-time agent frameworks to cloud-native, production-ready AI deployments. I focus heavily on building systems that are not only accurate and reliable, but also cost-efficient, resource-optimized, and scalable. These showcased projects represent only part of my portfolio, and I continue to work on many more innovative solutions in the AI/ML space.”

data/summaries/research_summary.txt

@@ -0,0 +1 @@
+“Above are some of my key research contributions. My work spans applied AI, computer vision, bioacoustics, and assistive technologies — including conference-published studies, novel communication systems, and ongoing experimental projects. I focus on solving real-world problems using deep learning, signal processing, and intelligent systems, with an emphasis on accessibility, healthcare, and environmental applications. These represent only part of my research journey, and I continue to explore new areas and publish work as I advance further in the field.”

data/summaries/skills_summary.txt

@@ -0,0 +1 @@
+“The skills listed above represent my core technical strengths across software engineering, machine learning, deep learning, vector search, cloud infrastructure, and agentic AI. I work extensively with modern ML frameworks, LLM ecosystems, scalable backend tools, and cloud-native architectures. My expertise spans end-to-end AI systems — from model training and evaluation to retrieval pipelines, agent frameworks, and production deployment. I continuously expand my skill set as new tools, frameworks, and AI patterns emerge, so this list reflects only a snapshot of the technologies I actively work with.”

data/summaries/videos_summary.txt

@@ -0,0 +1 @@
+“Above are some of my video tutorials, where I break down complex AI concepts into simple, easy-to-understand explanations. I create educational content focused on RAG systems, agentic AI patterns, embeddings, and practical machine learning ideas — all presented in a clear, beginner-friendly way. These videos represent only a part of what I create, and I continue to produce more content to help others learn modern AI concepts without the jargon.”

data/videos.json

@@ -0,0 +1,16 @@
+[
+  {
+    "id": "01",
+    "title": "RAG and Embeddings Explained in Plain English",
+    "description": "Explaining RAG and embeddings in plain English. No jargon. No math. Just the core concepts, broken down so anyone can understand.",
+    "thumbnail_url": "images/video_thumbnails/01.png",
+    "url": "https://www.linkedin.com/posts/tharushika-abedheera-3396311a4_explaining-rag-and-embeddings-in-plain-english-activity-7379239387819274240-__h6"
+  },
+  {
+    "id": "02",
+    "title": "Reflection Design Pattern in AI Agents Explained Simply!",
+    "description": "In this short tutorial, I walk through how reflection works in AI Agents. You’ll learn how this pattern forms the foundation for self-improving AI systems.",
+    "thumbnail_url": "images/video_thumbnails/02.png",
+    "url": "https://www.linkedin.com/posts/tharushika-abedheera-3396311a4_ai-machinelearning-agents-activity-7390137862027005952-iI2u"
+  }
+]

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+google-generativeai
+faiss-cpu
+numpy
+python-dotenv
+requests
+pydantic

scripts/create_vector_db.py

@@ -0,0 +1,136 @@
+import google.generativeai as genai
+import faiss
+import pickle
+import json
+import os
+import numpy as np
+from dotenv import load_dotenv
+
+# Load env to get API Key
+load_dotenv()
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not GEMINI_API_KEY:
+    print("❌ Error: GEMINI_API_KEY not found in .env")
+    exit(1)
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+# --- Configuration ---
+DATA_DIR = "data"
+SUMMARIES_DIR = os.path.join(DATA_DIR, "summaries")
+OUTPUT_DIR = os.path.join("backend", "vector_store")
+# Google's latest embedding model
+EMBEDDING_MODEL = "models/text-embedding-004"
+
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+
+def load_json(filename):
+    path = os.path.join(DATA_DIR, filename)
+    return json.load(open(path, 'r', encoding='utf-8')) if os.path.exists(path) else []
+
+
+def load_summary_text(filename):
+    path = os.path.join(SUMMARIES_DIR, filename)
+    if os.path.exists(path):
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.read().strip()
+    return ""
+
+
+def get_embedding(text):
+    """Wraps Gemini API to get embeddings"""
+    result = genai.embed_content(
+        model=EMBEDDING_MODEL,
+        content=text,
+        task_type="retrieval_document"
+    )
+    return result['embedding']
+
+
+def main():
+    print("🔄 Creating Cloud-Based Vector Index...")
+    chunks = []
+    metadata = []
+
+    def add_chunk(text, source):
+        if text and len(text) > 5:
+            chunks.append(text)
+            metadata.append({"source": source})
+
+    # --- Load Data (Same logic as before) ---
+    # 1. Profile
+    profile = load_json("profile.json")
+    if isinstance(profile, dict):
+        contact = profile.get("contact", {})
+        c_text = f"Contact Details: Name: {contact.get('name')}. Email: {contact.get('email')}. LinkedIn: {contact.get('linkedin')}."
+        add_chunk(c_text, "profile_contact")
+        if profile.get("summary"):
+            add_chunk(
+                f"Professional Summary: {profile.get('summary')}", "profile_summary")
+
+    # 2. Experience
+    experience = load_json("experience.json")
+    for exp in experience:
+        text = f"Experience: {exp.get('role')} at {exp.get('company')} ({exp.get('duration')}). {exp.get('description')}"
+        add_chunk(text, "experience_entry")
+
+    # 3. Education
+    education = load_json("education.json")
+    for edu in education:
+        text = f"Education: {edu.get('degree')} from {edu.get('institution')}. {edu.get('details')}"
+        add_chunk(text, "education_entry")
+
+    # 4. Skills
+    skills = load_json("skills.json")
+    for s in skills:
+        text = f"Skills in {s.get('category')}: {', '.join(s.get('list', []))}"
+        add_chunk(text, "skills_list")
+
+    # 5. Summaries
+    summary_files = {
+        "about_summary.txt": "profile_about_me",
+        "projects_summary.txt": "ui_trigger_projects",
+        "articles_summary.txt": "ui_trigger_articles",
+        "videos_summary.txt": "ui_trigger_videos",
+        "research_summary.txt": "ui_trigger_research",
+        "skills_summary.txt": "ui_trigger_skills",
+        "certifications_summary.txt": "ui_trigger_certifications"
+    }
+
+    for filename, tag in summary_files.items():
+        text = load_summary_text(filename)
+        if text:
+            add_chunk(text, tag)
+
+    # --- Generate Embeddings ---
+    if not chunks:
+        print("❌ Error: No chunks created.")
+        return
+
+    print(f"🧠 Encoding {len(chunks)} chunks via Gemini API...")
+
+    # Batch processing is better, but simple loop works for small portfolios
+    embeddings = []
+    for i, chunk in enumerate(chunks):
+        if i % 5 == 0:
+            print(f"   Processing chunk {i}/{len(chunks)}...")
+        emb = get_embedding(chunk)
+        embeddings.append(emb)
+
+    embeddings_np = np.array(embeddings).astype("float32")
+
+    # Create FAISS index
+    index = faiss.IndexFlatL2(embeddings_np.shape[1])
+    index.add(embeddings_np)
+
+    faiss.write_index(index, os.path.join(OUTPUT_DIR, "faiss_index.bin"))
+    with open(os.path.join(OUTPUT_DIR, "chunks_metadata.pkl"), "wb") as f:
+        pickle.dump({"chunks": chunks, "metadata": metadata}, f)
+
+    print(f"🎉 Cloud Indexing Complete! Saved to {OUTPUT_DIR}")
+
+
+if __name__ == "__main__":
+    main()

scripts/setup_db.py

@@ -0,0 +1,149 @@
+import os
+import json
+import sqlite3
+
+
+# --- Configuration ---
+# Ensures the DB is created inside the 'backend' folder
+DATABASE_FILE = os.path.join("backend", "portfolio.sqlite")
+DATA_DIR = "data"
+
+
+def create_connection():
+    # Ensure the backend directory exists
+    os.makedirs(os.path.dirname(DATABASE_FILE), exist_ok=True)
+    return sqlite3.connect(DATABASE_FILE)
+
+
+def setup_database():
+    conn = create_connection()
+    cursor = conn.cursor()
+
+    print("🛠️  Building Modular Database...")
+
+    # --- 1. Create Tables ---
+
+    # Projects
+    cursor.execute('''CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY, 
+        title TEXT, 
+        type TEXT, 
+        description TEXT, 
+        technologies TEXT, 
+        github_url TEXT, 
+        demo_url TEXT, 
+        image_path TEXT
+    )''')
+
+    # Articles
+    cursor.execute('''CREATE TABLE IF NOT EXISTS articles (
+        title TEXT, description TEXT, url TEXT, type TEXT
+    )''')
+
+    # Videos
+    cursor.execute('''CREATE TABLE IF NOT EXISTS videos (
+        id TEXT, title TEXT, description TEXT, thumbnail_url TEXT, url TEXT
+    )''')
+
+    # Research
+    cursor.execute('''CREATE TABLE IF NOT EXISTS research (
+        title TEXT, description TEXT, url TEXT, type TEXT
+    )''')
+
+    # Skills (Updated for modular JSON with 3 columns)
+    cursor.execute('''CREATE TABLE IF NOT EXISTS skills (
+        id TEXT PRIMARY KEY, 
+        category TEXT, 
+        skill_list TEXT 
+    )''')
+
+    # Experience (New Table)
+    cursor.execute('''CREATE TABLE IF NOT EXISTS experience (
+        id TEXT PRIMARY KEY, 
+        role TEXT, 
+        company TEXT, 
+        duration TEXT, 
+        description TEXT
+    )''')
+
+    # Education (New Table)
+    cursor.execute('''CREATE TABLE IF NOT EXISTS education (
+        id TEXT PRIMARY KEY, 
+        degree TEXT, 
+        institution TEXT, 
+        details TEXT
+    )''')
+
+    # Certifications
+    cursor.execute('''CREATE TABLE IF NOT EXISTS certifications (
+        name TEXT PRIMARY KEY
+    )''')
+
+    # --- 2. Generic Insert Function ---
+    def insert_from_json(filename, table, columns):
+        filepath = os.path.join(DATA_DIR, filename)
+        if not os.path.exists(filepath):
+            print(f"   ⚠️  Warning: {filename} not found. Skipping.")
+            return
+
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+
+        count = 0
+        for item in data:
+            # --- FIX: Pre-process lists into strings ---
+
+            # 1. Handle 'technologies' list (for projects)
+            if 'technologies' in item and isinstance(item['technologies'], list):
+                item['technologies'] = json.dumps(item['technologies'])
+
+            # 2. Handle 'list' -> 'skill_list' mapping (for skills)
+            # We look for the key 'list' (from JSON) and convert it to 'skill_list' (for DB)
+            if 'list' in item and isinstance(item['list'], list):
+                item['skill_list'] = json.dumps(item['list'])
+
+            # --- FIX: Collect values ---
+            values = []
+            for col in columns:
+                # If the column is 'skill_list', we expect the data might still be in 'list'
+                # if we didn't map it above, but we did map it, so we just grab 'skill_list'.
+                # We use .get() to avoid errors if a field is missing.
+                values.append(item.get(col))
+
+            placeholders = ",".join(["?"] * len(columns))
+            cursor.execute(
+                f"INSERT OR REPLACE INTO {table} VALUES ({placeholders})", values)
+            count += 1
+        print(f"   ✅ Loaded {count} items into '{table}'")
+
+    # --- 3. Run Inserts ---
+    print("📥 Inserting modular data...")
+
+    # Projects
+    insert_from_json("projects.json", "projects", [
+                     "id", "title", "type", "description", "technologies", "github_url", "demo_url", "image_path"])
+
+    # Standard Content
+    insert_from_json("articles.json", "articles", [
+                     "title", "description", "url", "type"])
+    insert_from_json("videos.json", "videos", [
+                     "id", "title", "description", "thumbnail_url", "url"])
+    insert_from_json("research.json", "research", [
+                     "title", "description", "url", "type"])
+
+    # New Modular Files
+    # Note: 'skill_list' maps to the 'list' key in the json via the fix above
+    insert_from_json("skills.json", "skills", ["id", "category", "skill_list"])
+    insert_from_json("experience.json", "experience", [
+                     "id", "role", "company", "duration", "description"])
+    insert_from_json("education.json", "education", [
+                     "id", "degree", "institution", "details"])
+    insert_from_json("certifications.json", "certifications", ["name"])
+
+    conn.commit()
+    conn.close()
+    print(f"🎉 Database updated at {DATABASE_FILE}")
+
+
+if __name__ == "__main__":
+    setup_database()