RAG Chatbot on docs.md

samples/RAG-chatbot/.devcontainer/Dockerfile

@@ -0,0 +1 @@
+FROM mcr.microsoft.com/devcontainers/python:3.12-bookworm

samples/RAG-chatbot/.devcontainer/devcontainer.json

@@ -0,0 +1,10 @@
+{
+  "build": {
+    "dockerfile": "Dockerfile",
+    "context": ".."
+  },
+  "features": {
+    "ghcr.io/defanglabs/devcontainer-feature/defang-cli:1.0.4": {},
+    "ghcr.io/devcontainers/features/docker-in-docker:2": {}
+  }
+}

samples/RAG-chatbot/.dockerignore

@@ -0,0 +1 @@
+myenv

samples/RAG-chatbot/.github/workflows/deploy.yaml

@@ -0,0 +1,24 @@
+name: Deploy
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+    - name: Checkout Repo
+      uses: actions/checkout@v4
+
+    - name: Deploy
+      uses: DefangLabs/[email protected]
+      with:
+        config-env-vars: OPENAI_API_KEY
+      env:
+        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}

samples/RAG-chatbot/.gitignore

@@ -0,0 +1 @@
+myenv/

samples/RAG-chatbot/README.md

@@ -0,0 +1,38 @@
+# Scikit RAG + OpenAI
+
+This sample demonstrates how to deploy a Flask-based Retrieval-Augmented Generation (RAG) chatbot using OpenAI's GPT model. The chatbot retrieves relevant documents from a knowledge base using scikit-learn and Sentence Transformers and then generates responses using OpenAI's GPT model. There is an LRU caching scheme of 128 queries.
+
+## Prerequisites
+
+1. Download [Defang CLI](https://github.com/DefangLabs/defang)
+2. (Optional) If you are using [Defang BYOC](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) authenticated with your AWS account
+3. (Optional - for local development) [Docker CLI](https://docs.docker.com/engine/install/)
+
+## Deploying
+
+1. Open the terminal and type `defang login`
+2. Type `defang compose up` in the CLI.
+3. Your app will be running within a few minutes.
+
+## Local Development
+
+1. Clone the repository.
+2. Create a `.env` file in the root directory and set your OpenAI API key or add the OPENAI_API_KEY into your .zshrc or .bashrc file:
+3. Run the command `docker compose up --build` to spin up a docker container for this RAG chatbot
+
+## Configuration
+
+- The knowledge base is acquired via parsing an sitemap located at "https://docs.defang.io/sitemap.xml".
+- The file `scrape_sitemap.py` parses every webpage as specified into paragraphs and writes to `knowledge_base.json` for the RAG retrieval.
+- To obtain your own knowledge base, either use another sitemap or write your own parsing scheme to parse into knowledge_base.json.
+- A least recently used (LRU) caching scheme is also in place as can be seen in `rag_system.py`. This caches common queries to have a faster response time. Feel free to adjust as needed.
+
+---
+
+Title: Scikit RAG + OpenAI
+
+Short Description: A short hello world application demonstrating how to deploy a Flask-based Retrieval-Augmented Generation (RAG) chatbot using OpenAI's GPT model onto Defang.
+
+Tags: Flask, Scikit, Python, RAG, OpenAI, GPT, Machine Learning
+
+Languages: python

samples/RAG-chatbot/app/Dockerfile

@@ -0,0 +1,28 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file first to leverage Docker's cache
+COPY requirements.txt /app/
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN pip install gunicorn
+
+# Install additional packages
+RUN pip install sentence-transformers openai
+
+# Copy the current directory contents into the container at /app
+COPY . /app
+
+# Make port 5000 available to the world outside this container
+EXPOSE 5000
+
+# Define environment variable
+ENV FLASK_APP=app.py
+
+# Run app.py when the container launches
+CMD ["flask", "run", "--host=0.0.0.0"]

samples/RAG-chatbot/app/app.py

@@ -0,0 +1,36 @@
+from flask import Flask, request, jsonify, render_template
+from rag_system import rag_system
+
+app = Flask(__name__)
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        query = request.form.get('query')
+        if not query:
+            return render_template('index.html', query=None, response="No query provided")
+
+        try:
+            response = rag_system.answer_query(query)
+            return render_template('index.html', query=query, response=response)
+        except Exception as e:
+            print(f"Error in /ask endpoint: {e}")
+            return render_template('index.html', query=query, response="Internal Server Error")
+    return render_template('index.html', query=None, response=None)
+
+@app.route('/ask', methods=['POST'])
+def ask():
+    data = request.get_json()
+    query = data.get('query')
+    if not query:
+        return jsonify({"error": "No query provided"}), 400
+
+    try:
+        response = rag_system.answer_query(query)
+        return jsonify({"response": response})
+    except Exception as e:
+        print(f"Error in /ask endpoint: {e}")
+        return jsonify({"error": "Internal Server Error"}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)

samples/RAG-chatbot/app/parse_basic.py

@@ -0,0 +1,128 @@
+import re
+import json
+import os
+
+# Function to reset knowledge_base.json
+def reset_knowledge_base():
+    with open('knowledge_base.json', 'w') as output_file:
+        json.dump([], output_file)
+
+def parse_markdown_file_to_json(file_path):
+    try:
+        # Load existing content if the file exists
+        with open('knowledge_base.json', 'r') as existing_file:
+            json_output = json.load(existing_file)
+            current_id = len(json_output) + 1  # Start ID from the next available number
+    except (FileNotFoundError, json.JSONDecodeError):
+        # If the file doesn't exist or is empty, start fresh
+        json_output = []
+        current_id = 1
+
+    with open(file_path, 'r', encoding='utf-8') as file:
+        lines = file.readlines()
+
+    # Skip the first 5 lines
+    markdown_content = "".join(lines[5:])
+
+    # First pass: Determine headers for 'about' section
+    sections = []
+    current_section = {"about": [], "text": []}
+    has_main_header = False
+
+    for line in markdown_content.split('\n'):
+        header_match = re.match(r'^(#{1,6}|\*\*+)\s+(.*)', line)  # Match `#`, `##`, ..., `######` and `**`
+        if header_match:
+            header_level = len(header_match.group(1).strip())
+            header_text = header_match.group(2).strip()
+
+            if header_level == 1 or header_match.group(1).startswith('**'):  # Treat `**` as a main header
+                if current_section["about"] or current_section["text"]:
+                    sections.append(current_section)
+                current_section = {"about": [header_text], "text": []}
+                has_main_header = True
+            else:
+                if has_main_header:
+                    current_section["about"].append(header_text)
+                else:
+                    if header_level == 2:
+                        if current_section["about"] or current_section["text"]:
+                            sections.append(current_section)
+                        current_section = {"about": [header_text], "text": []}
+                    else:
+                        current_section["about"].append(header_text)
+        else:
+            current_section["text"].append(line.strip())
+
+    if current_section["about"] or current_section["text"]:
+        sections.append(current_section)
+
+    # Second pass: Combine text while ignoring headers and discard entries with empty 'about' or 'text'
+    for section in sections:
+        about = ", ".join(section["about"])
+        text = " ".join(line for line in section["text"] if line)
+
+        if about and text:  # Only insert if both 'about' and 'text' are not empty
+            json_output.append({
+                "id": current_id,
+                "about": about,
+                "text": text
+            })
+            current_id += 1
+
+    # Write the augmented JSON output to knowledge_base.json
+    with open('knowledge_base.json', 'w', encoding='utf-8') as output_file:
+        json.dump(json_output, output_file, indent=2, ensure_ascii=False)
+
+def parse_cli_markdown(file_path):
+    try:
+        # Load existing content if the file exists
+        with open('knowledge_base.json', 'r') as existing_file:
+            json_output = json.load(existing_file)
+            current_id = len(json_output) + 1  # Start ID from the next available number
+    except (FileNotFoundError, json.JSONDecodeError):
+        # If the file doesn't exist or is empty, start fresh
+        json_output = []
+        current_id = 1
+
+    with open(file_path, 'r', encoding='utf-8') as file:
+        lines = file.readlines()
+
+    if len(lines) < 5:
+        print(f"File {file_path} does not have enough lines to parse.")
+        return
+
+    # Extract 'about' from the 5th line (index 4)
+    about = lines[4].strip()
+
+    # Combine all remaining lines after the first 5 lines into 'text'
+    text_lines = lines[5:]
+    text = "".join(text_lines).strip()
+
+    # Only append if both 'about' and 'text' are not empty
+    if about and text:
+        json_output.append({
+            "id": current_id,
+            "about": about,
+            "text": text
+        })
+        current_id += 1
+
+    # Write the augmented JSON output to knowledge_base.json
+    with open('knowledge_base.json', 'w', encoding='utf-8') as output_file:
+        json.dump(json_output, output_file, indent=2, ensure_ascii=False)
+
+def recursive_parse_directory(root_dir):
+    for dirpath, dirnames, filenames in os.walk(root_dir):
+        for filename in filenames:
+            file_path = os.path.join(dirpath, filename)
+            if filename.lower().endswith('.md'):
+                if 'cli' in dirpath.lower() or 'cli' in filename.lower():
+                    parse_cli_markdown(file_path)
+                else:
+                    parse_markdown_file_to_json(file_path)
+
+# Example usage:
+if __name__ == "__main__":
+    reset_knowledge_base()  # Reset knowledge_base.json to empty at the start
+    recursive_parse_directory('/Users/chris/Desktop/tmp')  # Parse the entire directory
+    print("Parsing completed successfully.")