chatbot with UI

.gitignore

@@ -0,0 +1 @@
+config.yaml

README.md

@@ -0,0 +1,39 @@
+# Demo RAG Chatbot
+
+A Python demo chatbot that:
+
+- loads `config.yaml` with `sambanova_api_key` and `website`
+- scrapes the configured website
+- builds embeddings using HuggingFace models
+- retrieves relevant chunks (RAG)
+- generates answers using SambaNova API
+- returns formatted text output with citations
+
+## Setup
+
+1. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. Configure `config.yaml`:
+   - `sambanova_api_key`: your SambaNova API key
+   - `website`: the URL to scrape
+   - `embedding_model`: HuggingFace model (default: `sentence-transformers/all-MiniLM-L6-v2`)
+   - `system_prompt`: optional behavior prompt
+
+## Run CLI Mode
+
+```bash
+python chatbot.py
+```
+
+Type a question and press Enter. Type `exit` to quit.
+
+## Run with Streamlit UI
+
+```bash
+streamlit run ui.py
+```
+
+Interactive web interface with real-time answers and context display.

app.py

@@ -0,0 +1,96 @@
+import gradio as gr
+from pathlib import Path
+from sambanova import SambaNova
+from langchain_huggingface import HuggingFaceEmbeddings
+
+from chatbot import (
+    load_config,
+    build_rag_corpus,
+    retrieve_relevant_chunks,
+    build_prompt,
+    ask_model,
+    format_answer,
+)
+
+CONFIG_PATH = Path(__file__).parent / "config.yaml"
+RESOURCE_STATE = {}
+
+
+def init_resources():
+    if RESOURCE_STATE:
+        return RESOURCE_STATE
+
+    if not CONFIG_PATH.exists():
+        raise FileNotFoundError(f"Missing config file: {CONFIG_PATH}")
+
+    config = load_config(CONFIG_PATH)
+    llm_api_key = config.get("sambanova_api_key")
+    website = config.get("website")
+    system_prompt = config.get("system_prompt", "You are a helpful assistant.")
+
+    if not llm_api_key or not website:
+        raise ValueError("Please set sambanova_api_key and website in config.yaml")
+
+    embed_model = HuggingFaceEmbeddings(model_name=config.get("embedding_model"))
+    corpus = build_rag_corpus(config, embed_model, website)
+    client = SambaNova(
+        api_key=llm_api_key,
+        base_url="https://api.sambanova.ai/v1",
+        timeout=30,
+    )
+
+    RESOURCE_STATE.update(
+        config=config,
+        website=website,
+        system_prompt=system_prompt,
+        embed_model=embed_model,
+        corpus=corpus,
+        client=client,
+    )
+    return RESOURCE_STATE
+
+
+def answer_question(question: str):
+    resources = init_resources()
+    selected = retrieve_relevant_chunks(
+        resources["corpus"],
+        question,
+        resources["embed_model"],
+        top_k=4,
+    )
+    prompt = build_prompt(resources["system_prompt"], question, selected)
+    raw_answer = ask_model(prompt, resources["client"])
+    response = format_answer(raw_answer, selected)
+    citations = "\n\n".join(
+        [f"Chunk {i+1}: {chunk.text[:300]}..." for i, chunk in enumerate(selected)]
+    )
+    return response, citations
+
+
+def main():
+    resources = init_resources()
+
+    with gr.Blocks(title="RAG Chatbot") as demo:
+        gr.Markdown("# 🤖 RAG-Powered Chatbot")
+        gr.Markdown(f"**Website:** {resources['website']}  \n**Chunks:** {len(resources['corpus'])}")
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                question_input = gr.Textbox(label="Ask a question", placeholder="What services do you provide?", lines=2)
+                submit_button = gr.Button("Ask")
+                answer_output = gr.Textbox(label="Answer", lines=12, interactive=False)
+
+            with gr.Column(scale=1):
+                citations_output = gr.Textbox(label="Citations", lines=20, interactive=False)
+
+        submit_button.click(
+            answer_question,
+            inputs=[question_input],
+            outputs=[answer_output, citations_output],
+        )
+
+    demo.launch()
+
+
+if __name__ == "__main__":
+    main()

chatbot.py

@@ -0,0 +1,158 @@
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+import bs4
+import numpy as np
+import requests
+from sambanova import SambaNova
+import yaml
+from langchain_huggingface import HuggingFaceEmbeddings
+
+@dataclass
+class DocumentChunk:
+    text: str
+    source: str
+    vector: np.ndarray
+
+
+def load_config(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def scrape_website(url: str) -> str:
+    response = requests.get(url, timeout=15)
+    response.raise_for_status()
+    soup = bs4.BeautifulSoup(response.text, "html.parser")
+    for tag in soup(["script", "style", "header", "footer", "nav", "aside"]):
+        tag.decompose()
+    text = soup.get_text(separator="\n")
+    text = re.sub(r"\n{2,}", "\n", text).strip()
+    return text
+
+
+def split_into_chunks(text: str, chunk_size: int = 400, overlap: int = 100) -> list[str]:
+    sentences = [s.strip() for s in re.split(r"(?<=[\.\?\!])\s+", text) if s.strip()]
+    chunks = []
+    current = ""
+    for sentence in sentences:
+        if len(current) + len(sentence) + 1 > chunk_size and current:
+            chunks.append(current.strip())
+            current = current[-overlap:] if overlap < len(current) else current
+        current += " " + sentence
+    if current.strip():
+        chunks.append(current.strip())
+    return chunks
+
+
+def embed_texts(texts: list[str], embed_model: HuggingFaceEmbeddings = None) -> list[np.ndarray]:
+    if not texts:
+        return []
+    if embed_model:
+        return embed_model.embed_documents(texts)
+
+
+def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
+    if np.linalg.norm(a) == 0 or np.linalg.norm(b) == 0:
+        return 0.0
+    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
+
+
+def build_rag_corpus(config: dict, embed_model: HuggingFaceEmbeddings, url: str) -> list[DocumentChunk]:
+    print(f"Scraping website: {url}")
+    page_text = scrape_website(url)
+    chunks = split_into_chunks(page_text)
+    print(f"Split content into {len(chunks)} chunks")
+    embeddings = embed_texts(chunks, embed_model)
+    return [DocumentChunk(text=chunk, source=url, vector=np.array(vector)) for chunk, vector in zip(chunks, embeddings)]
+
+
+def retrieve_relevant_chunks(chunks: list[DocumentChunk], question: str, embed_model: HuggingFaceEmbeddings, top_k: int = 4) -> list[DocumentChunk]:
+    question_embeddings = embed_texts([question], embed_model)
+    if not question_embeddings:
+        return chunks[:top_k]
+    question_vector = np.array(question_embeddings[0])
+    scored = [
+        (chunk, cosine_similarity(question_vector, chunk.vector))
+        for chunk in chunks
+    ]
+    scored.sort(key=lambda item: item[1], reverse=True)
+    return [chunk for chunk, _ in scored[:top_k]]
+
+
+def build_prompt(system_prompt: str, question: str, context_chunks: list[DocumentChunk]) -> str:
+    context_text = "\n---\n".join(chunk.text for chunk in context_chunks)
+    return (
+        f"{system_prompt}\n\n"
+        f"Use the following extracted website text to answer the question clearly.\n"
+        f"Context:\n{context_text}\n\n"
+        f"Question: {question}\n"
+    )
+
+
+def create_llm_client(config: dict) -> SambaNova:
+    return SambaNova(
+        api_key=config.get("sambanova_api_key"),
+        base_url="https://api.sambanova.ai/v1",
+        timeout=30,
+    )
+
+
+def ask_model(prompt: str, client: SambaNova) -> str:
+    response = client.chat.completions.create(
+        model="DeepSeek-V3.1",
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=1056,
+        temperature=0.2,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def format_answer(raw: str, chunks: list[DocumentChunk]) -> str:
+    return raw
+
+
+def main() -> int:
+    config_path = Path(__file__).parent / "config.yaml"
+    if not config_path.exists():
+        print(f"Missing config file: {config_path}")
+        return 1
+
+    config = load_config(config_path)
+    llm_api_key = config.get("sambanova_api_key")
+    website = config.get("website")
+    system_prompt = config.get("system_prompt", "You are a helpful assistant.")
+
+    if not llm_api_key or not website:
+        print("Please set sambanova_api_key and website in config.yaml")
+        return 1
+    embed_model = HuggingFaceEmbeddings(model_name=config.get("embedding_model"))
+    chunks = build_rag_corpus(config, embed_model, website)
+    client = create_llm_client(config)
+    print("RAG corpus ready. Ask a question or type 'exit'.")
+
+    while True:
+        try:
+            question = input("Question> ").strip()
+        except EOFError:
+            break
+        if not question:
+            continue
+        if question.lower() in {"exit", "quit"}:
+            break
+
+        selected = retrieve_relevant_chunks(chunks, question, embed_model)
+        prompt = build_prompt(system_prompt, question, selected)
+        raw_answer = ask_model(prompt, client)
+        response = format_answer(raw_answer, selected)
+
+        print(response)
+        print()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

requirements.txt

@@ -0,0 +1,8 @@
+PyYAML>=6.0
+requests>=2.30.0
+beautifulsoup4>=4.12.2
+numpy>=1.25.0
+openai>=1.0.0
+sambanova>=0.1.0
+gradio>=3.0.0
+langchain-huggingface>=0.0.1