Upload mcp_server.py

Server/mcp_server.py

@@ -0,0 +1,596 @@
+import os
+import logging
+import socket
+from typing import List, Tuple, Dict
+
+import numpy as np
+import pandas as pd
+import fitz  # PyMuPDF
+
+from fastmcp import FastMCP
+from openai import OpenAI
+from langchain_community.document_loaders import WebBaseLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+# ---------- Config ----------
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(asctime)s] %(levelname)-7s %(message)s",
+    datefmt="%m/%d/%y %H:%M:%S",
+)
+logger = logging.getLogger("rag-mcp-server")
+
+mcp = FastMCP(name="rag-mcp-server", version="1.1.0")
+
+# Paths
+EXCEL_PATH = "Data/IIT_Opening_Closing_Ranks.xlsx"
+
+PDF_FILES: Dict[str, str] = {
+    "eng_design": "Data/Engineering_design_Course_Details.pdf",
+    "aero_curriculum": "Data/Aerospace_curriculum.pdf",
+    "nirf_2024": "Data/IR2024_Report.pdf",
+    "iitm_curriculum_2024": "Data/Curriculum_-_2024_Batch_B.Tech_Version_1 (1).pdf",
+    "iitb_cse_curriculum": "Data/IITB_CSE_Btech_Curriculum.pdf",
+    "iitb_civil_curriculum": "Data/IITB_Civil_Btech_Curriculum.pdf",
+    "iitb_mech_curriculum": "Data/IITB_Mechanical_Engg_Curriculum.pdf",
+    "iitb_elec_curriculum": "Data/IITD_Electrical_Btech_Curriculum.pdf",
+    "iitd_allprogrammes_curriculum": "Data/IITD_Programmes_Curriculum.pdf"
+    
+}
+
+LINK_FILES: Dict[str, str] = {
+    "linkedin_profile_iit_d": "https://alumni.iitd.ac.in/distinguished-alum-awards",
+    "linkedin_profile_iit_m": "https://www.vaave.com/blog/iit-madras-notable-alumni/",
+    "linkedin_profile_iit_b": "https://acr.iitbombay.org/distinguished-alumnus/",
+    "linkedin_profile_iit_kgp": "http://alumni.iitkgp.ac.in/",
+                    }
+
+# Models
+EMBED_MODEL = "text-embedding-3-small"
+CHAT_MODEL  = "gpt-4o-mini"
+TOP_K       = 5
+
+client = OpenAI(api_key = "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")
+
+# ---------- Utility ----------
+def _cosine_similarity(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    a_norm = a / (np.linalg.norm(a) + 1e-12)
+    b_norm = b / (np.linalg.norm(b, axis=1, keepdims=True) + 1e-12)
+    return b_norm @ a_norm
+
+
+#                           EXCEL PIPELINE
+
+EXCEL_INDEX = {
+    "texts": None,
+    "embeddings": None,
+    "row_ids": None,
+    "columns": None,
+}
+
+def _excel_to_texts(excel_path: str, sheet: int | str = 0) -> Tuple[List[str], List[int], List[str]]:
+    df = pd.read_excel(excel_path, sheet_name=sheet)  # requires openpyxl
+    df = df.fillna("")
+    cols = list(df.columns)
+
+    texts, row_ids = [], []
+    for i, row in df.iterrows():
+        parts = [f"Row {i}"]
+        for c in cols:
+            parts.append(f"{c}: {row[c]}")
+        texts.append(" | ".join(parts))
+        row_ids.append(i)
+    return texts, row_ids, cols
+
+def _build_excel_index(force: bool = False, sheet: int | str = 0):
+    if not force and EXCEL_INDEX["texts"] is not None and EXCEL_INDEX["embeddings"] is not None:
+        return
+    if not os.path.exists(EXCEL_PATH):
+        raise FileNotFoundError(f"Excel not found at {EXCEL_PATH}")
+
+    logger.info("Loading Excel and building embeddings index...")
+    texts, row_ids, cols = _excel_to_texts(EXCEL_PATH, sheet)
+    emb = client.embeddings.create(model=EMBED_MODEL, input=texts)
+    vectors = np.array([e.embedding for e in emb.data], dtype=np.float32)
+
+    EXCEL_INDEX.update({
+        "texts": texts,
+        "embeddings": vectors,
+        "row_ids": row_ids,
+        "columns": cols,
+    })
+    logger.info(f"[EXCEL INDEX] rows={len(texts)} emb.shape={vectors.shape} cols={len(cols)}")
+
+def _retrieve_excel(question: str, top_k: int = TOP_K) -> List[Tuple[int, str]]:
+    q_emb = client.embeddings.create(model=EMBED_MODEL, input=[question]).data[0].embedding
+    q = np.array(q_emb, dtype=np.float32)
+    sims = _cosine_similarity(q, EXCEL_INDEX["embeddings"])
+    idxs = np.argsort(sims)[::-1][:top_k]
+    out = [(int(EXCEL_INDEX["row_ids"][i]), EXCEL_INDEX["texts"][i]) for i in idxs]
+    top_info = [(int(EXCEL_INDEX["row_ids"][i]), float(sims[i])) for i in idxs]
+    logger.info(f"[EXCEL RETRIEVE] q='{question[:80]}...' top_k={top_k} -> {top_info}")
+    return out
+
+
+def _make_excel_prompt(question: str, retrieved_rows: List[Tuple[int, str]], subquery_context: str = None) -> List[dict]:
+    context_lines = [f"[Row {rid}] {rtext}" for rid, rtext in retrieved_rows]
+    context = "\n".join(context_lines) or "(no relevant rows found)"
+    logger.info(f"[EXCEL PROMPT] context_len={len(context)}; preview:\n{context[:500]}")
+
+    system = (
+        "You are a helpful assistant. Answer the user's question STRICTLY using the provided Excel context. "
+        "If the answer is not present, say you don't have enough information."
+    )
+
+    # ✅ Append subquery_context if provided
+    user = (
+        f"Context (from Excel):\n{context}\n\n"
+        f"User question: {question}\n\n"
+    )
+    if subquery_context:
+        user += f"Additional context:\n{subquery_context}\n\n"
+
+    user += (
+        "Instructions:\n"
+        "- Use only the context above.\n"
+        "- Keep answers concise and accurate.\n"
+        "- Do not include any bracketed tags or citations."
+    )
+
+    return [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+
+@mcp.tool("ask_excel", description="RAG over an Excel file; answer questions grounded in the sheet.")
+
+def ask_excel(question: str, top_k: int = TOP_K, sheet: int | str = 0, temperature: float = 0.1, subquery_context: str = None) -> str:
+    try:
+        _build_excel_index(False, sheet)
+        retrieved = _retrieve_excel(question, top_k)
+        messages = _make_excel_prompt(question, retrieved, subquery_context)
+        for m in messages:
+            logger.info(f"[EXCEL MESSAGES] role={m['role']} len={len(m['content'])}")
+        completion = client.chat.completions.create(model=CHAT_MODEL, messages=messages, temperature=temperature)
+        answer = completion.choices[0].message.content or "I couldn't generate an answer."
+        logger.info(f"[EXCEL ANSWER] len={len(answer)}; preview: {answer[:200]}")
+        return answer.strip()
+    except Exception as e:
+        logger.exception("ask_excel failed: %s", e)
+        return f"❌ Error: {e}"
+
+
+# PDF PIPELINE (Multi-file)
+
+
+# Per-PDF indices
+PDF_INDEXES: Dict[str, Dict[str, object]] = {key: {"chunks": None, "embeddings": None, "chunk_ids": None} for key in PDF_FILES}
+
+# Router: keyword heuristics to quickly select a PDF
+PDF_ROUTER_KEYWORDS: Dict[str, List[str]] = {
+    "eng_design": [
+        "finite element", "non-linear", "lagrangian", "continuum mechanics", "contact mechanics",
+        "ed5015", "ed5012", "ergonomics", "human factors", "design", "galerkin", "variational"
+    ],
+    "aero_curriculum": [
+        "aerospace", "b.tech", "semester", "credits", "as1010", "fluid mechanics", "gas dynamics",
+        "strength of materials", "lab", "workshop", "curriculum"
+    ],
+    "nirf_2024": [
+        "nirf", "ranking", "perception", "outreach", "inclusivity", "graduation outcome",
+        "research", "teaching", "learning", "resources", "department of higher education"
+    ],
+    "iitm_curriculum_2024": [
+        "curriculum", "credit requirements", "branch-wise", "data science", "computer science",
+        "electrical", "mechanical", "metallurgical", "naval architecture", "engineering physics",
+        "2024 batch", "2023 batch", "programme"
+    ],
+}
+
+# Descriptors used for embedding-based fallback routing (short, representative strings)
+PDF_DESCRIPTORS: Dict[str, str] = {
+    "eng_design": "Engineering Design course details including ED5015 finite element methods and ED5012 human factors.",
+    "aero_curriculum": "IIT Madras Aerospace Engineering B.Tech curriculum semester-wise credits and course list.",
+    "nirf_2024": "India Rankings 2024 NIRF categories: teaching, research, graduation outcomes, outreach, inclusivity, perception.",
+    "iitm_curriculum_2024": "IIT Madras B.Tech curriculum 2024 batch branch-wise credit requirements across departments.",
+    "iitb_cse_curriculum": "IIT Bombay Computer Science Engineering B.Tech curriculum semester-wise credits and course list.",
+    "iitb_civil_curriculum": "IIT Bombay Civil Engineering B.Tech curriculum semester-wise credits and course list.",
+    "iitb_mech_curriculum": "IIT Bombay Mechanical Engineering B.Tech curriculum semester-wise credits and course list.",
+    "iitb_elec_curriculum": "IIT Bombay Electrical Engineering B.Tech curriculum semester-wise credits and course list.",
+    "iitd_allprogrammes_curriculum": "IIT Delhi All B.Tech programmes curriculum semester-wise credits and course list."
+}
+
+
+PDF_DESC_EMB: Dict[str, np.ndarray] = {}  # cached descriptor embeddings
+
+def _build_pdf_router_embeddings():
+    if PDF_DESC_EMB:
+        return
+    inputs = [PDF_DESCRIPTORS[k] for k in PDF_FILES.keys()]
+    emb = client.embeddings.create(model=EMBED_MODEL, input=inputs)
+    vecs = [np.array(e.embedding, dtype=np.float32) for e in emb.data]
+    for k, v in zip(PDF_FILES.keys(), vecs):
+        PDF_DESC_EMB[k] = v
+    logger.info(f"[PDF ROUTER] cached descriptor embeddings for {len(PDF_DESC_EMB)} PDFs")
+
+def _pdf_to_chunks(pdf_path: str) -> List[str]:
+    doc = fitz.open(pdf_path)
+    chunks: List[str] = []
+    for pno, page in enumerate(doc, start=1):
+        text = page.get_text("text")
+        if not text:
+            continue
+        # Split into paragraphs to improve retrieval granularity
+        paras = [p.strip() for p in text.split("\n\n") if p.strip()]
+        for para in paras:
+            para = " ".join(para.split())  # collapse whitespace
+            chunks.append(f"Page {pno}: {para}")
+    return chunks
+
+def _build_pdf_index(pdf_key: str, force: bool = False):
+    idx = PDF_INDEXES[pdf_key]
+    if not force and idx["chunks"] is not None and idx["embeddings"] is not None:
+        return
+
+    pdf_path = PDF_FILES[pdf_key]
+    if not os.path.exists(pdf_path):
+        raise FileNotFoundError(f"PDF not found: {pdf_path}")
+
+    logger.info(f"[PDF INDEX] building for '{pdf_key}' -> {pdf_path}")
+    chunks = _pdf_to_chunks(pdf_path)
+    if not chunks:
+        logger.warning(f"[PDF INDEX] No text extracted for '{pdf_key}'.")
+        idx["chunks"], idx["embeddings"], idx["chunk_ids"] = [], np.zeros((0, 1), dtype=np.float32), []
+        return
+
+    emb = client.embeddings.create(model=EMBED_MODEL, input=chunks)
+    vectors = np.array([e.embedding for e in emb.data], dtype=np.float32)
+
+    idx["chunks"] = chunks
+    idx["embeddings"] = vectors
+    idx["chunk_ids"] = list(range(len(chunks)))
+    logger.info(f"[PDF INDEX] '{pdf_key}' chunks={len(chunks)} emb.shape={vectors.shape}")
+
+def _retrieve_pdf(pdf_key: str, question: str, top_k: int = TOP_K) -> List[Tuple[int, str]]:
+    idx = PDF_INDEXES[pdf_key]
+    embeddings = idx["embeddings"]
+    if embeddings is None or len(embeddings) == 0:
+        logger.warning(f"[PDF RETRIEVE] Empty embeddings for '{pdf_key}'.")
+        return []
+
+    q_emb = client.embeddings.create(model=EMBED_MODEL, input=[question]).data[0].embedding
+    q = np.array(q_emb, dtype=np.float32)
+    sims = _cosine_similarity(q, embeddings)
+    idxs = np.argsort(sims)[::-1][:top_k]
+    out = [(int(i), idx["chunks"][i]) for i in idxs]
+    top_info = [(int(i), float(sims[i])) for i in idxs]
+    logger.info(f"[PDF RETRIEVE] '{pdf_key}' q='{question[:80]}...' top_k={top_k} -> {top_info}")
+    return out
+
+def _route_pdf(question: str) -> str:
+    q_lower = question.lower()
+
+    # 1) Keyword heuristic
+    for key, kws in PDF_ROUTER_KEYWORDS.items():
+        if any(k in q_lower for k in kws):
+            logger.info(f"[PDF ROUTER] keyword matched '{key}'")
+            return key
+
+    # 2) Embedding fallback (compare question to PDF descriptors)
+    _build_pdf_router_embeddings()
+    q_emb = client.embeddings.create(model=EMBED_MODEL, input=[question]).data[0].embedding
+    q_vec = np.array(q_emb, dtype=np.float32)
+    q_vec = q_vec / (np.linalg.norm(q_vec) + 1e-12)
+
+    keys = list(PDF_DESC_EMB.keys())
+    desc_mat = np.stack([PDF_DESC_EMB[k] / (np.linalg.norm(PDF_DESC_EMB[k]) + 1e-12) for k in keys], axis=0)
+    sims = desc_mat @ q_vec
+    best_idx = int(np.argmax(sims))
+    chosen = keys[best_idx]
+    logger.info(f"[PDF ROUTER] embed sims={[(k, float(s)) for k, s in zip(keys, sims.tolist())]} -> '{chosen}'")
+    return chosen
+
+
+
+
+def _make_pdf_prompt(question: str, retrieved_chunks: List[Tuple[int, str]], pdf_key: str, subquery_context: str = None) -> List[dict]:
+    tagged_preview = [f"[{pdf_key} | Chunk {cid}] {text}" for cid, text in retrieved_chunks]
+    logger.info(f"[PDF PROMPT] '{pdf_key}' preview:\n{'\n'.join(tagged_preview)[:500]}")
+
+    context_lines = [text for _, text in retrieved_chunks]
+    context = "\n\n".join(context_lines) or "(no relevant chunks found)"
+
+    system = (
+        "You are a helpful assistant. Answer the user's question STRICTLY using the provided PDF context. "
+        "If the answer is not present, say you don't have enough information. "
+        "Do not include file names, chunk ids, or any bracketed metadata in your answer."
+    )
+
+    user = (
+        f"Context:\n{context}\n\n"
+        f"User question: {question}\n\n"
+    )
+    if subquery_context:
+        user += f"Additional context:\n{subquery_context}\n\n"
+
+    user += (
+        "Instructions:\n"
+        "- Use only the context above.\n"
+        "- Keep answers concise.\n"
+        "- Do not include any bracketed tags or source identifiers."
+    )
+
+    return [
+        {"role": "system", "content": system},
+        {"role": "user", "content": user},
+    ]
+
+
+@mcp.tool("ask_pdf", description="RAG over multiple PDFs; auto-select the best-matching document and answer.")
+
+def ask_pdf(question: str, top_k: int = TOP_K, temperature: float = 0.1, pdf_key: str = None, subquery_context: str = None) -> str:
+    try:
+        chosen = pdf_key or _route_pdf(question)
+        print(_route_pdf(question))
+        _build_pdf_index(chosen, force=False)
+        retrieved = _retrieve_pdf(chosen, question, top_k)
+        messages = _make_pdf_prompt(question, retrieved, chosen, subquery_context)
+        for m in messages:
+            logger.info(f"[PDF MESSAGES] role={m['role']} len={len(m['content'])}")
+        completion = client.chat.completions.create(model=CHAT_MODEL, messages=messages, temperature=temperature)
+        answer = completion.choices[0].message.content or "I couldn't generate an answer."
+        logger.info(f"[PDF ANSWER] '{chosen}' len={len(answer)}; preview: {answer[:200]}")
+        return answer.strip()
+    except Exception as e:
+        logger.exception("ask_pdf failed: %s", e)
+        return f"❌ Error: {e}"
+
+
+
+'''
+@mcp.tool("ask_link", description="RAG over a webpage (LinkedIn or any site); answer questions grounded in the page content.")
+def ask_link(
+    question: str,
+    link_key: str = "linkedin_profile",
+    url: str | None = None,
+    temperature: float = 0.1,
+    subquery_context: str | None = None,
+    top_k: int = TOP_K
+) -> str:
+    """
+    Implements RAG for a webpage:
+    - Loads content using LangChain WebBaseLoader.
+    - Splits into chunks.
+    - Embeds chunks and retrieves top_k relevant ones.
+    - Builds prompt with retrieved chunks + optional subquery_context.
+    """
+    try:
+        # ✅ Resolve URL
+        target_url = url or LINK_FILES.get(link_key)
+        if not target_url:
+            return f"❌ Error: No URL resolved for link_key='{link_key}'."
+
+        logger.info(f"[LINK TOOL] Fetching and processing content from: {target_url}")
+
+        # ✅ Load webpage content
+        loader = WebBaseLoader(target_url, verify_ssl=False)
+        documents = loader.load()
+        if not documents or not documents[0].page_content.strip():
+            return "❌ Error: Could not extract readable content from the URL."
+
+        page_text = documents[0].page_content.strip()
+
+        # ✅ Split into chunks using langchain-text-splitters
+        splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        chunks = splitter.split_text(page_text)
+        if not chunks:
+            return "❌ Error: No chunks generated from page content."
+
+        # ✅ Embed chunks
+        emb = client.embeddings.create(model=EMBED_MODEL, input=chunks)
+        chunk_vectors = np.array([e.embedding for e in emb.data], dtype=np.float32)
+
+        # ✅ Embed question
+        q_emb = client.embeddings.create(model=EMBED_MODEL, input=[question]).data[0].embedding
+        q_vec = np.array(q_emb, dtype=np.float32)
+
+        # ✅ Compute cosine similarity correctly
+        chunk_norms = np.linalg.norm(chunk_vectors, axis=1)
+        q_norm = np.linalg.norm(q_vec)
+        sims = (chunk_vectors @ q_vec) / (chunk_norms * q_norm + 1e-12)
+
+        # ✅ Sort and select top_k safely
+        idxs = np.argsort(sims)[::-1][:min(top_k, len(chunks))]
+        retrieved_chunks = [(i, chunks[i]) for i in idxs]
+
+        logger.info(f"[LINK RETRIEVE] top_k={top_k} -> {[ (i, float(sims[i])) for i in idxs ]}")
+
+        # ✅ Build prompt
+        context_lines = [text for _, text in retrieved_chunks]
+        context = "\n\n".join(context_lines) or "(no relevant chunks found)"
+
+        system = (
+            "You are a helpful assistant. Answer the user's question STRICTLY using the provided webpage context. "
+            "If the answer is not present, say you don't have enough information. "
+            "Do not include URLs or any bracketed metadata in your answer."
+        )
+
+        user = (
+            f"Context:\n{context}\n\n"
+            f"User question: {question}\n\n"
+        )
+        if subquery_context:
+            user += f"Additional context:\n{subquery_context}\n\n"
+
+        user += (
+            "Instructions:\n"
+            "- Use only the context above.\n"
+            "- Keep answers concise.\n"
+            "- Do not include any bracketed tags or source identifiers."
+        )
+
+        messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+        # ✅ LLM call
+        completion = client.chat.completions.create(model=CHAT_MODEL, messages=messages, temperature=temperature)
+        answer = completion.choices[0].message.content or "I couldn't generate an answer."
+        logger.info(f"[LINK ANSWER] len={len(answer)}; preview: {answer[:200]}")
+        return answer.strip()
+
+    except Exception as e:
+        logger.exception("ask_link failed: %s", e)
+        return f"❌ Error: {e}"
+'''
+
+
+########################################################################################################################################################################################################################################################################################
+
+
+LINK_DESCRIPTORS: Dict[str, str] = {
+    "linkedin_profile_iit_m": "IIT Madras Alumni.",
+    "linkedin_profile_iit_d": "IIT Delhi Alumni.",
+    "linkedin_profile_iit_b": "IIT Bombay Alumni.",
+    "linkedin_profile_iit_kgp": "IIT Kharagpur Alumni.",
+
+                                    }
+LINK_DESC_EMB: Dict[str, np.ndarray] = {}  
+
+
+
+def _build_link_router_embeddings():
+    if LINK_DESC_EMB:
+        return
+    inputs = [LINK_DESCRIPTORS[k] for k in LINK_FILES.keys()]
+    emb = client.embeddings.create(model=EMBED_MODEL, input=inputs)
+    vecs = [np.array(e.embedding, dtype=np.float32) for e in emb.data]
+    for k, v in zip(LINK_FILES.keys(), vecs):
+        LINK_DESC_EMB[k] = v
+
+
+
+def _route_link(question: str) -> str:
+    q_lower = question.lower()
+
+    _build_link_router_embeddings()
+    q_emb = client.embeddings.create(model=EMBED_MODEL, input=[question]).data[0].embedding
+    q_vec = np.array(q_emb, dtype=np.float32)
+    q_vec = q_vec / (np.linalg.norm(q_vec) + 1e-12)
+
+    keys = list(LINK_DESC_EMB.keys())
+    desc_mat = np.stack([LINK_DESC_EMB[k] / (np.linalg.norm(LINK_DESC_EMB[k]) + 1e-12) for k in keys], axis=0)
+    sims = desc_mat @ q_vec
+    best_idx = int(np.argmax(sims))
+    chosen = keys[best_idx]
+    return chosen
+
+
+@mcp.tool("ask_link", description="RAG over a webpage (LinkedIn or any site); answer questions grounded in the page content.")
+
+def ask_link(
+    query: str,
+    link_key: str = "linkedin_profile",
+    url: str | None = None,
+    temperature: float = 0.1,
+    subquery_context: str | None = None,
+    top_k: int = TOP_K
+) -> str:
+    """
+    Implements RAG for a webpage:
+    - Loads content using LangChain WebBaseLoader.
+    - Splits into chunks.
+    - Embeds chunks and retrieves top_k relevant ones.
+    - Builds prompt with retrieved chunks + optional subquery_context.
+    """
+    try:
+        # ✅ Resolve URL
+        target_url_key = url or _route_link(query)
+        target_url = LINK_FILES[target_url_key]
+        if not target_url:
+            return f"❌ Error: No URL resolved for link_key='{link_key}'."
+
+        # logger.info(f"[LINK TOOL] Fetching and processing content from: {target_url}")
+
+        # ✅ Load webpage content
+        loader = WebBaseLoader(target_url, verify_ssl=False)
+        documents = loader.load()
+        if not documents or not documents[0].page_content.strip():
+            return "❌ Error: Could not extract readable content from the URL."
+
+        page_text = documents[0].page_content.strip()
+
+        # ✅ Split into chunks using langchain-text-splitters
+        splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        chunks = splitter.split_text(page_text)
+        if not chunks:
+            return "❌ Error: No chunks generated from page content."
+
+        # ✅ Embed chunks
+        emb = client.embeddings.create(model=EMBED_MODEL, input=chunks)
+        chunk_vectors = np.array([e.embedding for e in emb.data], dtype=np.float32)
+
+        # ✅ Embed question
+        q_emb = client.embeddings.create(model=EMBED_MODEL, input=[query]).data[0].embedding
+        q_vec = np.array(q_emb, dtype=np.float32)
+
+        # ✅ Compute cosine similarity correctly
+        chunk_norms = np.linalg.norm(chunk_vectors, axis=1)
+        q_norm = np.linalg.norm(q_vec)
+        sims = (chunk_vectors @ q_vec) / (chunk_norms * q_norm + 1e-12)
+
+        # ✅ Sort and select top_k safely
+        idxs = np.argsort(sims)[::-1][:min(top_k, len(chunks))]
+        retrieved_chunks = [(i, chunks[i]) for i in idxs]
+
+        # logger.info(f"[LINK RETRIEVE] top_k={top_k} -> {[ (i, float(sims[i])) for i in idxs ]}")
+
+        # ✅ Build prompt
+        context_lines = [text for _, text in retrieved_chunks]
+        context = "\n\n".join(context_lines) or "(no relevant chunks found)"
+
+        system = (
+            "You are a helpful assistant. Answer the user's question STRICTLY using the provided webpage context. "
+            "If the answer is not present, say you don't have enough information. "
+            "Do not include URLs or any bracketed metadata in your answer."
+        )
+
+        user = (
+            f"Context:\n{context}\n\n"
+            f"User question: {query}\n\n"
+        )
+        if subquery_context:
+            user += f"Additional context:\n{subquery_context}\n\n"
+
+        user += (
+            "Instructions:\n"
+            "- Use only the context above.\n"
+            "- Keep answers concise.\n"
+            "- Do not include any bracketed tags or source identifiers."
+        )
+
+        messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
+
+        # ✅ LLM call
+        completion = client.chat.completions.create(model=CHAT_MODEL, messages=messages, temperature=temperature)
+        answer = completion.choices[0].message.content or "I couldn't generate an answer."
+        # logger.info(f"[LINK ANSWER] len={len(answer)}; preview: {answer[:200]}")
+        return answer.strip()
+
+    except Exception as e:
+        # logger.exception("ask_link failed: %s", e)
+        return f"❌ Error: {e}"
+
+
+def find_available_port(start_port=8001) -> int:
+    port = start_port
+    while True:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            if s.connect_ex(("127.0.0.1", port)) != 0:
+                return port
+        port += 1
+
+if __name__ == "__main__":
+    try:
+        port = find_available_port(8001)
+        logger.info(f"Starting RAG MCP server (Excel + multi-PDF) on port {port}")
+        mcp.run(transport="sse", host="127.0.0.1", port=port)
+    except Exception as e:
+        logger.error(f"Failed to start server: {e}")
+        print(f"Error starting server: {e}")