* initial

.gitignore

@@ -0,0 +1 @@
+venv

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY ./requirements.txt /app/requirements.txt
+
+RUN pip3 install --upgrade pip
+RUN pip3 install -r requirements.txt
+RUN python3 -m spacy download en_core_web_trf
+
+EXPOSE 7860
+
+COPY . /app
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
+
+CMD python -m streamlit run app.py --server.port=7860 --server.address=0.0.0.0

README.md

@@ -1,11 +1,38 @@
 ---
-title: Llm Guard Demo
+title: LLM Guard Demo
 emoji: 🏢
-colorFrom: red
-colorTo: red
+colorFrom: blue
+colorTo: gray
 sdk: docker
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Simple demo website for LLM Guard
+
+Here's a simple app, written in pure Python, to create a demo website for LLM Guard.
+The app is based on the [streamlit](https://streamlit.io/) package.
+
+A live version can be found here: https://huggingface.co/spaces/laiyer/llm-guard-demo
+
+## Requirements
+
+1. Clone the repo and move to the `examples/demo` folder
+
+2. Install dependencies (preferably in a virtual environment)
+
+```sh
+pip install -r requirements.txt
+```
+
+3. Start the app:
+
+```sh
+streamlit run app.py
+```
+
+## Output
+
+Output should be similar to this screenshot:
+![image](./screenshot.png)
+

app.py

@@ -0,0 +1,139 @@
+import logging
+import time
+import traceback
+from datetime import timedelta
+
+import pandas as pd
+import spacy
+import streamlit as st
+from output import init_settings as init_output_settings
+from output import scan as scan_output
+from prompt import init_settings as init_prompt_settings
+from prompt import scan as scan_prompt
+
+from llm_guard.vault import Vault
+
+if not spacy.util.is_package("en_core_web_trf"):
+    spacy.cli.download("en_core_web_trf")
+
+PROMPT = "prompt"
+OUTPUT = "output"
+vault = Vault()
+
+st.set_page_config(
+    page_title="LLM Guard demo",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        "About": "https://laiyer-ai.github.io/llm-guard/",
+    },
+)
+
+logger = logging.getLogger("llm-guard-demo")
+logger.setLevel(logging.INFO)
+
+# Sidebar
+st.sidebar.header(
+    """
+Scanning prompt and output using [LLM Guard](https://laiyer-ai.github.io/llm-guard/)
+"""
+)
+
+scanner_type = st.sidebar.selectbox("Type", [PROMPT, OUTPUT], index=0)
+
+enabled_scanners = None
+settings = None
+if scanner_type == PROMPT:
+    enabled_scanners, settings = init_prompt_settings()
+elif scanner_type == OUTPUT:
+    enabled_scanners, settings = init_output_settings()
+
+# Main pannel
+with st.expander("About this demo", expanded=False):
+    st.info(
+        """LLM-Guard is a comprehensive tool designed to fortify the security of Large Language Models (LLMs).
+        \n\n[Code](https://github.com/laiyer-ai/llm-guard) |
+        [Documentation](https://laiyer-ai.github.io/llm-guard/)"""
+    )
+
+    st.markdown(
+        "[![Pypi Downloads](https://img.shields.io/pypi/dm/llm-guard.svg)](https://img.shields.io/pypi/dm/llm-guard.svg)"  # noqa
+        "[![MIT license](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT)"
+        "![GitHub Repo stars](https://img.shields.io/github/stars/laiyer-ai/llm-guard?style=social)"
+    )
+
+analyzer_load_state = st.info("Starting LLM Guard...")
+
+analyzer_load_state.empty()
+
+# Read default text
+with open("prompt_text.txt") as f:
+    demo_prompt_text = f.readlines()
+
+with open("output_text.txt") as f:
+    demo_output_text = f.readlines()
+
+# Before:
+st.subheader("Guard Prompt" if scanner_type == PROMPT else "Guard Output")
+
+if scanner_type == PROMPT:
+    st_prompt_text = st.text_area(
+        label="Enter prompt", value="".join(demo_prompt_text), height=200, key="prompt_text_input"
+    )
+elif scanner_type == OUTPUT:
+    col1, col2 = st.columns(2)
+    st_prompt_text = col1.text_area(
+        label="Enter prompt", value="".join(demo_prompt_text), height=300, key="prompt_text_input"
+    )
+
+    st_output_text = col2.text_area(
+        label="Enter output", value="".join(demo_output_text), height=300, key="output_text_input"
+    )
+
+st_result_text = None
+st_analysis = None
+st_is_valid = None
+st_time_delta = None
+
+try:
+    with st.form("text_form", clear_on_submit=False):
+        submitted = st.form_submit_button("Process")
+        if submitted:
+            results_valid = {}
+            results_score = {}
+
+            start_time = time.monotonic()
+            if scanner_type == PROMPT:
+                st_result_text, results_valid, results_score = scan_prompt(
+                    vault, enabled_scanners, settings, st_prompt_text
+                )
+            elif scanner_type == OUTPUT:
+                st_result_text, results_valid, results_score = scan_output(
+                    vault, enabled_scanners, settings, st_prompt_text, st_output_text
+                )
+            end_time = time.monotonic()
+            st_time_delta = timedelta(seconds=end_time - start_time)
+
+            st_is_valid = all(results_valid.values())
+            st_analysis = [
+                {"scanner": k, "is valid": results_valid[k], "risk score": results_score[k]}
+                for k in results_valid
+            ]
+
+except Exception as e:
+    logger.error(e)
+    traceback.print_exc()
+    st.error(e)
+
+# After:
+if st_is_valid is not None:
+    execution_time_ms = round(st_time_delta.total_seconds() * 1000)
+    st.subheader(f"Results - {'valid' if st_is_valid else 'invalid'} ({execution_time_ms} ms)")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.text_area(label="Sanitized text", value=st_result_text, height=400)
+
+    with col2:
+        st.table(pd.DataFrame(st_analysis))

output.py

@@ -0,0 +1,381 @@
+import logging
+from typing import Dict, List
+
+import streamlit as st
+from streamlit_tags import st_tags
+
+from llm_guard.input_scanners.anonymize import default_entity_types
+from llm_guard.output_scanners import (
+    BanSubstrings,
+    BanTopics,
+    Bias,
+    Code,
+    Deanonymize,
+    MaliciousURLs,
+    NoRefusal,
+    Refutation,
+    Regex,
+    Relevance,
+    Sensitive,
+)
+from llm_guard.output_scanners.sentiment import Sentiment
+from llm_guard.output_scanners.toxicity import Toxicity
+from llm_guard.vault import Vault
+
+logger = logging.getLogger("llm-guard-demo")
+
+
+def init_settings() -> (List, Dict):
+    all_scanners = [
+        "BanSubstrings",
+        "BanTopics",
+        "Bias",
+        "Code",
+        "Deanonymize",
+        "MaliciousURLs",
+        "NoRefusal",
+        "Refutation",
+        "Regex",
+        "Relevance",
+        "Sensitive",
+        "Sentiment",
+        "Toxicity",
+    ]
+
+    st_enabled_scanners = st.sidebar.multiselect(
+        "Select scanners",
+        options=all_scanners,
+        default=all_scanners,
+        help="The list can be found here: https://laiyer-ai.github.io/llm-guard/output_scanners/bias/",
+    )
+
+    settings = {}
+
+    if "BanSubstrings" in st_enabled_scanners:
+        st_bs_expander = st.sidebar.expander(
+            "Ban Substrings",
+            expanded=False,
+        )
+
+        with st_bs_expander:
+            st_bs_substrings = st.text_area(
+                "Enter substrings to ban (one per line)",
+                value="test\nhello\nworld\n",
+                height=200,
+            ).split("\n")
+
+            st_bs_match_type = st.selectbox("Match type", ["str", "word"])
+            st_bs_case_sensitive = st.checkbox("Case sensitive", value=False)
+
+        settings["BanSubstrings"] = {
+            "substrings": st_bs_substrings,
+            "match_type": st_bs_match_type,
+            "case_sensitive": st_bs_case_sensitive,
+        }
+
+    if "BanTopics" in st_enabled_scanners:
+        st_bt_expander = st.sidebar.expander(
+            "Ban Topics",
+            expanded=False,
+        )
+
+        with st_bt_expander:
+            st_bt_topics = st_tags(
+                label="List of topics",
+                text="Type and press enter",
+                value=["politics", "religion", "money", "crime"],
+                suggestions=[],
+                maxtags=30,
+                key="bt_topics",
+            )
+
+            st_bt_threshold = st.slider(
+                label="Threshold",
+                value=0.75,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="ban_topics_threshold",
+            )
+
+        settings["BanTopics"] = {"topics": st_bt_topics, "threshold": st_bt_threshold}
+
+    if "Bias" in st_enabled_scanners:
+        st_bias_expander = st.sidebar.expander(
+            "Bias",
+            expanded=False,
+        )
+
+        with st_bias_expander:
+            st_bias_threshold = st.slider(
+                label="Threshold",
+                value=0.75,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="bias_threshold",
+            )
+
+        settings["Bias"] = {"threshold": st_bias_threshold}
+
+    if "Code" in st_enabled_scanners:
+        st_cd_expander = st.sidebar.expander(
+            "Code",
+            expanded=False,
+        )
+
+        with st_cd_expander:
+            st_cd_languages = st.multiselect(
+                "Programming languages",
+                options=["python", "java", "javascript", "go", "php", "ruby"],
+                default=["python"],
+            )
+
+            st_cd_mode = st.selectbox("Mode", ["allowed", "denied"], index=0)
+
+        settings["Code"] = {"languages": st_cd_languages, "mode": st_cd_mode}
+
+    if "MaliciousURLs" in st_enabled_scanners:
+        st_murls_expander = st.sidebar.expander(
+            "Malicious URLs",
+            expanded=False,
+        )
+
+        with st_murls_expander:
+            st_murls_threshold = st.slider(
+                label="Threshold",
+                value=0.75,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="murls_threshold",
+            )
+
+        settings["MaliciousURLs"] = {"threshold": st_murls_threshold}
+
+    if "NoRefusal" in st_enabled_scanners:
+        st_no_ref_expander = st.sidebar.expander(
+            "No refusal",
+            expanded=False,
+        )
+
+        with st_no_ref_expander:
+            st_no_ref_threshold = st.slider(
+                label="Threshold",
+                value=0.5,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="no_ref_threshold",
+            )
+
+        settings["NoRefusal"] = {"threshold": st_no_ref_threshold}
+
+    if "Refutation" in st_enabled_scanners:
+        st_refu_expander = st.sidebar.expander(
+            "Refutation",
+            expanded=False,
+        )
+
+        with st_refu_expander:
+            st_refu_threshold = st.slider(
+                label="Threshold",
+                value=0.5,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="refu_threshold",
+            )
+
+        settings["Refutation"] = {"threshold": st_refu_threshold}
+
+    if "Regex" in st_enabled_scanners:
+        st_regex_expander = st.sidebar.expander(
+            "Regex",
+            expanded=False,
+        )
+
+        with st_regex_expander:
+            st_regex_patterns = st.text_area(
+                "Enter patterns to ban (one per line)",
+                value="Bearer [A-Za-z0-9-._~+/]+",
+                height=200,
+            ).split("\n")
+
+            st_regex_type = st.selectbox(
+                "Match type",
+                ["good", "bad"],
+                index=1,
+                help="good: allow only good patterns, bad: ban bad patterns",
+            )
+
+        settings["Regex"] = {"patterns": st_regex_patterns, "type": st_regex_type}
+
+    if "Relevance" in st_enabled_scanners:
+        st_rele_expander = st.sidebar.expander(
+            "Relevance",
+            expanded=False,
+        )
+
+        with st_rele_expander:
+            st_rele_threshold = st.slider(
+                label="Threshold",
+                value=0.5,
+                min_value=-1.0,
+                max_value=1.0,
+                step=0.05,
+                key="rele_threshold",
+                help="The minimum cosine similarity (-1 to 1) between the prompt and output for the output to be considered relevant.",
+            )
+
+        settings["Relevance"] = {"threshold": st_rele_threshold}
+
+    if "Sensitive" in st_enabled_scanners:
+        st_sens_expander = st.sidebar.expander(
+            "Sensitive",
+            expanded=False,
+        )
+
+        with st_sens_expander:
+            st_sens_entity_types = st_tags(
+                label="Sensitive entities",
+                text="Type and press enter",
+                value=default_entity_types,
+                suggestions=default_entity_types
+                + ["DATE_TIME", "NRP", "LOCATION", "MEDICAL_LICENSE", "US_PASSPORT"],
+                maxtags=30,
+                key="sensitive_entity_types",
+            )
+            st.caption(
+                "Check all supported entities: https://microsoft.github.io/presidio/supported_entities/#list-of-supported-entities"
+            )
+
+        settings["Sensitive"] = {"entity_types": st_sens_entity_types}
+
+    if "Sentiment" in st_enabled_scanners:
+        st_sent_expander = st.sidebar.expander(
+            "Sentiment",
+            expanded=False,
+        )
+
+        with st_sent_expander:
+            st_sent_threshold = st.slider(
+                label="Threshold",
+                value=-0.1,
+                min_value=-1.0,
+                max_value=1.0,
+                step=0.1,
+                key="sentiment_threshold",
+                help="Negative values are negative sentiment, positive values are positive sentiment",
+            )
+
+        settings["Sentiment"] = {"threshold": st_sent_threshold}
+
+    if "Toxicity" in st_enabled_scanners:
+        st_tox_expander = st.sidebar.expander(
+            "Toxicity",
+            expanded=False,
+        )
+
+        with st_tox_expander:
+            st_tox_threshold = st.slider(
+                label="Threshold",
+                value=0.0,
+                min_value=-1.0,
+                max_value=1.0,
+                step=0.05,
+                key="toxicity_threshold",
+                help="A negative value (closer to 0 as the label output) indicates toxicity in the text, while a positive logit (closer to 1 as the label output) suggests non-toxicity.",
+            )
+
+        settings["Toxicity"] = {"threshold": st_tox_threshold}
+
+    return st_enabled_scanners, settings
+
+
+def get_scanner(scanner_name: str, vault: Vault, settings: Dict):
+    logger.debug(f"Initializing {scanner_name} scanner")
+
+    if scanner_name == "BanSubstrings":
+        return BanSubstrings(
+            substrings=settings["substrings"],
+            match_type=settings["match_type"],
+            case_sensitive=settings["case_sensitive"],
+        )
+
+    if scanner_name == "BanTopics":
+        return BanTopics(topics=settings["topics"], threshold=settings["threshold"])
+
+    if scanner_name == "Bias":
+        return Bias(threshold=settings["threshold"])
+
+    if scanner_name == "Deanonymize":
+        return Deanonymize(vault=vault)
+
+    if scanner_name == "Code":
+        mode = settings["mode"]
+
+        allowed_languages = None
+        denied_languages = None
+        if mode == "allowed":
+            allowed_languages = settings["languages"]
+        elif mode == "denied":
+            denied_languages = settings["languages"]
+
+        return Code(allowed=allowed_languages, denied=denied_languages)
+
+    if scanner_name == "MaliciousURLs":
+        return MaliciousURLs(threshold=settings["threshold"])
+
+    if scanner_name == "NoRefusal":
+        return NoRefusal(threshold=settings["threshold"])
+
+    if scanner_name == "Refutation":
+        return Refutation(threshold=settings["threshold"])
+
+    if scanner_name == "Regex":
+        match_type = settings["type"]
+
+        good_patterns = None
+        bad_patterns = None
+        if match_type == "good":
+            good_patterns = settings["patterns"]
+        elif match_type == "bad":
+            bad_patterns = settings["patterns"]
+
+        return Regex(good_patterns=good_patterns, bad_patterns=bad_patterns)
+
+    if scanner_name == "Relevance":
+        return Relevance(threshold=settings["threshold"])
+
+    if scanner_name == "Sensitive":
+        return Sensitive(entity_types=settings["entity_types"])
+
+    if scanner_name == "Sentiment":
+        return Sentiment(threshold=settings["threshold"])
+
+    if scanner_name == "Toxicity":
+        return Toxicity(threshold=settings["threshold"])
+
+    raise ValueError("Unknown scanner name")
+
+
+def scan(
+    vault: Vault, enabled_scanners: List[str], settings: Dict, prompt: str, text: str
+) -> (str, Dict[str, bool], Dict[str, float]):
+    sanitized_output = text
+    results_valid = {}
+    results_score = {}
+
+    with st.status("Scanning output...", expanded=True) as status:
+        for scanner_name in enabled_scanners:
+            st.write(f"{scanner_name} scanner...")
+            scanner = get_scanner(
+                scanner_name, vault, settings[scanner_name] if scanner_name in settings else {}
+            )
+            sanitized_output, is_valid, risk_score = scanner.scan(prompt, sanitized_output)
+            results_valid[scanner_name] = is_valid
+            results_score[scanner_name] = risk_score
+        status.update(label="Scanning complete", state="complete", expanded=False)
+
+    return sanitized_output, results_valid, results_score

output_text.txt

@@ -0,0 +1,20 @@
+Alright, given the tables have already been created, here's how you can construct an SQL INSERT query to insert a customer record, ensuring the company is stored in a different table and that the location is one of the allowed ones:
+
+```sql
+-- Insert Company or get its ID
+INSERT INTO Companies (company_name)
+VALUES ('Laiyer')
+ON DUPLICATE KEY UPDATE company_id = LAST_INSERT_ID(company_id);
+
+-- Insert Customer with given values and ensure the location is allowed
+INSERT INTO Customers (first_name, IP, company_id, location_id)
+SELECT 'John Doe', '127.0.0.1', LAST_INSERT_ID(), location_id
+FROM AllowedLocations
+WHERE location_name = 'New York, US';
+```
+
+Note:
+
+1. LAST_INSERT_ID() fetches the ID of the last inserted row or the existing company's ID due to the ON DUPLICATE KEY UPDATE statement.
+2. This approach relies on the assumption that the company_name column in the Companies table has a unique constraint to avoid duplicate entries.
+3. The customer insert uses a SELECT statement from the AllowedLocations table to ensure that only valid/allowed locations are used for inserting the customer. If location doesn't exist in the AllowedLocations table, then no insert will occur for the customer.

prompt.py

@@ -0,0 +1,338 @@
+import logging
+from typing import Dict, List
+
+import streamlit as st
+from streamlit_tags import st_tags
+
+from llm_guard.input_scanners import (
+    Anonymize,
+    BanSubstrings,
+    BanTopics,
+    Code,
+    PromptInjection,
+    Secrets,
+    Sentiment,
+    TokenLimit,
+    Toxicity,
+)
+from llm_guard.input_scanners.anonymize import default_entity_types
+from llm_guard.vault import Vault
+
+logger = logging.getLogger("llm-guard-demo")
+
+
+def init_settings() -> (List, Dict):
+    all_scanners = [
+        "Anonymize",
+        "BanSubstrings",
+        "BanTopics",
+        "Code",
+        "PromptInjection",
+        "Secrets",
+        "Sentiment",
+        "TokenLimit",
+        "Toxicity",
+    ]
+
+    st_enabled_scanners = st.sidebar.multiselect(
+        "Select scanners",
+        options=all_scanners,
+        default=all_scanners,
+        help="The list can be found here: https://laiyer-ai.github.io/llm-guard/input_scanners/anonymize/",
+    )
+
+    settings = {}
+
+    if "Anonymize" in st_enabled_scanners:
+        st_anon_expander = st.sidebar.expander(
+            "Anonymize",
+            expanded=False,
+        )
+
+        with st_anon_expander:
+            st_anon_entity_types = st_tags(
+                label="Anonymize entities",
+                text="Type and press enter",
+                value=default_entity_types,
+                suggestions=default_entity_types
+                + ["DATE_TIME", "NRP", "LOCATION", "MEDICAL_LICENSE", "US_PASSPORT"],
+                maxtags=30,
+                key="anon_entity_types",
+            )
+            st.caption(
+                "Check all supported entities: https://microsoft.github.io/presidio/supported_entities/#list-of-supported-entities"
+            )
+            st_anon_hidden_names = st_tags(
+                label="Hidden names to be anonymized",
+                text="Type and press enter",
+                value=[],
+                suggestions=[],
+                maxtags=30,
+                key="anon_hidden_names",
+            )
+            st.caption("These names will be hidden e.g. [REDACTED_CUSTOM1].")
+            st_anon_allowed_names = st_tags(
+                label="Allowed names to ignore",
+                text="Type and press enter",
+                value=[],
+                suggestions=[],
+                maxtags=30,
+                key="anon_allowed_names",
+            )
+            st.caption("These names will be ignored even if flagged by the detector.")
+            st_anon_preamble = st.text_input(
+                "Preamble", value="Text to prepend to sanitized prompt: "
+            )
+            st_anon_use_faker = st.checkbox(
+                "Use Faker", value=False, help="Use Faker library to generate fake data"
+            )
+
+        settings["Anonymize"] = {
+            "entity_types": st_anon_entity_types,
+            "hidden_names": st_anon_hidden_names,
+            "allowed_names": st_anon_allowed_names,
+            "preamble": st_anon_preamble,
+            "use_faker": st_anon_use_faker,
+        }
+
+    if "BanSubstrings" in st_enabled_scanners:
+        st_bs_expander = st.sidebar.expander(
+            "Ban Substrings",
+            expanded=False,
+        )
+
+        with st_bs_expander:
+            st_bs_substrings = st.text_area(
+                "Enter substrings to ban (one per line)",
+                value="test\nhello\nworld",
+                height=200,
+            ).split("\n")
+
+            st_bs_match_type = st.selectbox("Match type", ["str", "word"])
+            st_bs_case_sensitive = st.checkbox("Case sensitive", value=False)
+
+        settings["BanSubstrings"] = {
+            "substrings": st_bs_substrings,
+            "match_type": st_bs_match_type,
+            "case_sensitive": st_bs_case_sensitive,
+        }
+
+    if "BanTopics" in st_enabled_scanners:
+        st_bt_expander = st.sidebar.expander(
+            "Ban Topics",
+            expanded=False,
+        )
+
+        with st_bt_expander:
+            st_bt_topics = st_tags(
+                label="List of topics",
+                text="Type and press enter",
+                value=["politics", "religion", "money", "crime"],
+                suggestions=[],
+                maxtags=30,
+                key="bt_topics",
+            )
+
+            st_bt_threshold = st.slider(
+                label="Threshold",
+                value=0.75,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="ban_topics_threshold",
+            )
+
+        settings["BanTopics"] = {
+            "topics": st_bt_topics,
+            "threshold": st_bt_threshold,
+        }
+
+    if "Code" in st_enabled_scanners:
+        st_cd_expander = st.sidebar.expander(
+            "Code",
+            expanded=False,
+        )
+
+        with st_cd_expander:
+            st_cd_languages = st.multiselect(
+                "Programming languages",
+                ["python", "java", "javascript", "go", "php", "ruby"],
+                default=["python"],
+            )
+
+            st_cd_mode = st.selectbox("Mode", ["allowed", "denied"], index=0)
+
+        settings["Code"] = {
+            "languages": st_cd_languages,
+            "mode": st_cd_mode,
+        }
+
+    if "PromptInjection" in st_enabled_scanners:
+        st_pi_expander = st.sidebar.expander(
+            "Prompt Injection",
+            expanded=False,
+        )
+
+        with st_pi_expander:
+            st_pi_threshold = st.slider(
+                label="Threshold",
+                value=0.75,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="prompt_injection_threshold",
+            )
+
+        settings["PromptInjection"] = {
+            "threshold": st_pi_threshold,
+        }
+
+    if "Secrets" in st_enabled_scanners:
+        st_sec_expander = st.sidebar.expander(
+            "Secrets",
+            expanded=False,
+        )
+
+        with st_sec_expander:
+            st_sec_redact_mode = st.selectbox("Redact mode", ["all", "partial", "hash"])
+
+        settings["Secrets"] = {
+            "redact_mode": st_sec_redact_mode,
+        }
+
+    if "Sentiment" in st_enabled_scanners:
+        st_sent_expander = st.sidebar.expander(
+            "Sentiment",
+            expanded=False,
+        )
+
+        with st_sent_expander:
+            st_sent_threshold = st.slider(
+                label="Threshold",
+                value=-0.1,
+                min_value=-1.0,
+                max_value=1.0,
+                step=0.1,
+                key="sentiment_threshold",
+                help="Negative values are negative sentiment, positive values are positive sentiment",
+            )
+
+        settings["Sentiment"] = {
+            "threshold": st_sent_threshold,
+        }
+
+    if "TokenLimit" in st_enabled_scanners:
+        st_tl_expander = st.sidebar.expander(
+            "Token Limit",
+            expanded=False,
+        )
+
+        with st_tl_expander:
+            st_tl_limit = st.number_input(
+                "Limit", value=4096, min_value=0, max_value=10000, step=10
+            )
+            st_tl_encoding_name = st.selectbox(
+                "Encoding name",
+                ["cl100k_base", "p50k_base", "r50k_base"],
+                index=0,
+                help="Read more: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb",
+            )
+
+        settings["TokenLimit"] = {
+            "limit": st_tl_limit,
+            "encoding_name": st_tl_encoding_name,
+        }
+
+    if "Toxicity" in st_enabled_scanners:
+        st_tox_expander = st.sidebar.expander(
+            "Toxicity",
+            expanded=False,
+        )
+
+        with st_tox_expander:
+            st_tox_threshold = st.slider(
+                label="Threshold",
+                value=0.75,
+                min_value=0.0,
+                max_value=1.0,
+                step=0.05,
+                key="toxicity_threshold",
+            )
+
+        settings["Toxicity"] = {
+            "threshold": st_tox_threshold,
+        }
+
+    return st_enabled_scanners, settings
+
+
+def get_scanner(scanner_name: str, vault: Vault, settings: Dict):
+    logger.debug(f"Initializing {scanner_name} scanner")
+
+    if scanner_name == "Anonymize":
+        return Anonymize(
+            vault=vault,
+            allowed_names=settings["allowed_names"],
+            hidden_names=settings["hidden_names"],
+            entity_types=settings["entity_types"],
+            preamble=settings["preamble"],
+            use_faker=settings["use_faker"],
+        )
+
+    if scanner_name == "BanSubstrings":
+        return BanSubstrings(
+            substrings=settings["substrings"],
+            match_type=settings["match_type"],
+            case_sensitive=settings["case_sensitive"],
+        )
+
+    if scanner_name == "BanTopics":
+        return BanTopics(topics=settings["topics"], threshold=settings["threshold"])
+
+    if scanner_name == "Code":
+        mode = settings["mode"]
+
+        allowed_languages = None
+        denied_languages = None
+        if mode == "allowed":
+            allowed_languages = settings["languages"]
+        elif mode == "denied":
+            denied_languages = settings["languages"]
+
+        return Code(allowed=allowed_languages, denied=denied_languages)
+
+    if scanner_name == "PromptInjection":
+        return PromptInjection(threshold=settings["threshold"])
+
+    if scanner_name == "Secrets":
+        return Secrets(redact_mode=settings["redact_mode"])
+
+    if scanner_name == "Sentiment":
+        return Sentiment(threshold=settings["threshold"])
+
+    if scanner_name == "TokenLimit":
+        return TokenLimit(limit=settings["limit"], encoding_name=settings["encoding_name"])
+
+    if scanner_name == "Toxicity":
+        return Toxicity(threshold=settings["threshold"])
+
+    raise ValueError("Unknown scanner name")
+
+
+def scan(
+    vault: Vault, enabled_scanners: List[str], settings: Dict, text: str
+) -> (str, Dict[str, bool], Dict[str, float]):
+    sanitized_prompt = text
+    results_valid = {}
+    results_score = {}
+
+    with st.status("Scanning prompt...", expanded=True) as status:
+        for scanner_name in enabled_scanners:
+            st.write(f"{scanner_name} scanner...")
+            scanner = get_scanner(scanner_name, vault, settings[scanner_name])
+            sanitized_prompt, is_valid, risk_score = scanner.scan(sanitized_prompt)
+            results_valid[scanner_name] = is_valid
+            results_score[scanner_name] = risk_score
+        status.update(label="Scanning complete", state="complete", expanded=False)
+
+    return sanitized_prompt, results_valid, results_score

prompt_text.txt

@@ -0,0 +1,15 @@
+Given the personal profile of Johnathan Edward Doe:
+
+Full Name: Johnathan Edward Doe
+Date of Birth: April 12, 1990
+Address: 123 Elm Street, Springfield, IL, 62701
+Email: john.doe@example.com
+Phone Number: (123) 456-7890
+Educational Background:
+    Springfield High School, Graduated in 2008
+    Springfield University, B.Sc. Computer Science, Graduated in 2012
+Employment:
+    ABC Tech Solutions, Software Engineer, 2012-2015
+    XYZ Global Systems, Senior Software Developer, 2015-2021
+
+Please create a summarized version of his resume.

requirements.txt

@@ -0,0 +1,4 @@
+llm-guard==0.1.3
+pandas==2.1.0
+streamlit==1.26.0
+streamlit-tags==1.2.8