Create app.py

app.py

@@ -0,0 +1,188 @@
+# app.py
+import os
+import streamlit as st
+import numpy as np
+import faiss
+from sentence_transformers import SentenceTransformer
+from typing import List, Tuple
+from pathlib import Path
+from langchain.schema import SystemMessage, HumanMessage
+from dotenv import load_dotenv
+load_dotenv()
+
+import google.generativeai as genai  # official Google GenAI SDK
+
+# -------------------------
+# Configuration
+# -------------------------
+st.set_page_config(page_title="SystemVerilog Chatbot (Modern LangChain)", layout="wide")
+
+# Set API keys from environment (ensure these are set in your environment / .env)
+GENAI_API_KEY = os.getenv("googleapikey")
+HF_TOKEN = os.getenv("hf")  # if you need HuggingFace for other tasks
+
+if not GENAI_API_KEY:
+    st.error("Please set environment variable googleapikey")
+    st.stop()
+
+genai.configure(api_key=GENAI_API_KEY)
+
+# -------------------------
+# Utilities: text load + splitting
+# -------------------------
+def load_text(path: str) -> str:
+    p = Path(path)
+    if not p.exists():
+        st.error(f"File not found: {path}")
+        st.stop()
+    return p.read_text(encoding="utf-8")
+
+def simple_recursive_split(text: str, chunk_size: int = 1000, overlap: int = 200) -> List[str]:
+    """A simple recursive character text splitter. Keeps splits at whitespace when possible."""
+    chunks = []
+    start = 0
+    text_len = len(text)
+    while start < text_len:
+        end = min(start + chunk_size, text_len)
+        # try to not cut a word
+        if end < text_len:
+            last_space = text.rfind(" ", start, end)
+            if last_space > start:
+                end = last_space
+        chunk = text[start:end].strip()
+        if chunk:
+            chunks.append(chunk)
+        start = end - overlap
+        if start < 0:
+            start = 0
+        if start >= text_len:
+            break
+    return chunks
+
+# -------------------------
+# Embeddings + FAISS index
+# -------------------------
+@st.experimental_singleton
+def load_embedding_model(model_name: str = "sentence-transformers/all-MiniLM-L6-v2"):
+    return SentenceTransformer(model_name)
+
+@st.experimental_singleton
+def build_faiss_index(texts: List[str], embed_model: SentenceTransformer) -> Tuple[faiss.IndexFlatIP, np.ndarray]:
+    # Encode and normalize
+    embeddings = embed_model.encode(texts, show_progress_bar=True, convert_to_numpy=True)
+    # normalize for cosine similarity
+    norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+    norms[norms == 0] = 1.0
+    embeddings = embeddings / norms
+    d = embeddings.shape[1]
+    index = faiss.IndexFlatIP(d)  # inner product on normalized vectors = cosine similarity
+    index.add(embeddings.astype("float32"))
+    return index, embeddings
+
+def retrieve_top_k(query: str, k: int, index: faiss.IndexFlatIP, embed_model: SentenceTransformer, texts: List[str]) -> List[Tuple[int, float, str]]:
+    q_emb = embed_model.encode([query], convert_to_numpy=True)
+    q_emb = q_emb / np.linalg.norm(q_emb, axis=1, keepdims=True)
+    D, I = index.search(q_emb.astype("float32"), k)
+    results = []
+    for idx, score in zip(I[0], D[0]):
+        results.append((int(idx), float(score), texts[idx]))
+    return results
+
+# -------------------------
+# Google GenAI call (wrap it so easy to adapt if SDK changes)
+# -------------------------
+def call_gemini(prompt: str, model: str = "gemini-2.0-flash", temperature: float = 0.2, max_output_tokens: int = 600) -> str:
+    """
+    Use the google.generativeai SDK to generate text.
+    NOTE: SDK function names vary between versions. If this exact call fails for your installed SDK,
+    replace the body with the appropriate `genai` call. Example alternatives appear in comments below.
+    """
+    # Example - the SDK exposes a .generate or .chat.create in different versions.
+    # Option A (common pattern):
+    resp = genai.generate(
+        model=model,
+        temperature=temperature,
+        max_output_tokens=max_output_tokens,
+        # The SDK may expect a 'prompt' string or a structured 'input' object.
+        # Using plain text input here.
+        input=prompt
+    )
+    # Inspect resp and adapt as needed. Commonly the text is in resp.output[0].content[0].text
+    # Defensive extraction:
+    try:
+        # Newer SDKs put text in resp.candidates[0].output[0].content[0].text
+        if hasattr(resp, "candidates"):
+            return resp.candidates[0].output[0].content[0].text
+        # Older/newer might have resp.output_text
+        if hasattr(resp, "output_text"):
+            return resp.output_text
+        # Generic fallback: str(resp)
+        return str(resp)
+    except Exception:
+        return str(resp)
+
+# -------------------------
+# Load document and build index (once)
+# -------------------------
+DOC_PATH = "pdf_extracted_text.txt"
+raw_text = load_text(DOC_PATH)
+chunks = simple_recursive_split(raw_text, chunk_size=1000, overlap=500)
+
+embed_model = load_embedding_model()
+index, embeddings = build_faiss_index(chunks, embed_model)
+
+# -------------------------
+# Streamlit UI and chat logic
+# -------------------------
+st.title("🤖 SystemVerilog Documentation Chatbot (Modern LangChain-style)")
+
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+user_query = st.chat_input("Enter your SystemVerilog question...")
+
+if user_query:
+    # retrieve
+    k = 6
+    retrieved = retrieve_top_k(user_query, k, index, embed_model, chunks)
+    context_text = "\n\n".join([f"Chunk {idx} (score {score:.3f}):\n{txt}" for idx, score, txt in retrieved])
+
+    # Compose system prompt using LangChain message classes for clarity (but we send plain text to Gemini)
+    system_msg = SystemMessage(content=(
+        "You are an expert SystemVerilog Verification Engineer and technical educator. "
+        "Answer the user's question using ONLY the provided context. If the context does not contain the answer, say you don't know. "
+        "Be concise, include examples when useful, and annotate code blocks as SystemVerilog."
+    ))
+    human_msg = HumanMessage(content=f"User question: {user_query}\n\nUse the following context:\n{context_text}")
+
+    # Build the final prompt to send to Gemini
+    prompt = f"""SYSTEM:
+{system_msg.content}
+
+CONTEXT:
+{context_text}
+
+USER QUESTION:
+{user_query}
+
+INSTRUCTIONS:
+- Use only the CONTEXT above for factual content.
+- Provide SystemVerilog code blocks where appropriate, label them as `systemverilog`.
+- If the context lacks the answer, explicitly say: "I don't have enough information in the document to answer that."
+"""
+
+    # Call Gemini (via the wrapper)
+    gen_text = call_gemini(prompt, model="gemini-2.0-flash", temperature=0.3, max_output_tokens=700)
+
+    # Save to chat
+    st.session_state.chat_history.append({"role": "user", "content": user_query})
+    st.session_state.chat_history.append({"role": "assistant", "content": gen_text})
+
+# Render chat
+for msg in st.session_state.chat_history:
+    if msg["role"] == "user":
+        with st.chat_message("user"):
+            st.markdown(msg["content"])
+    else:
+        with st.chat_message("assistant"):
+            st.markdown(msg["content"])