First commit

.envTemplate

@@ -0,0 +1,2 @@
+API_KEY=your_api_key
+PROJECT_ID=your_project_id

.gitignore

@@ -0,0 +1,196 @@
+
+.env
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+.venv/
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+# End of https://www.toptal.com/developers/gitignore/api/visualstudiocode,python
+Untitled.java

README.md

@@ -0,0 +1,125 @@
+## How to Chat with a Website Using WatsonX
+
+Hello everyone! Today, we're going to create an exciting web app that allows us to chat with any website using Watsonx.ai.
+
+Watsonx.ai is a powerful SaaS service that leverages the full capabilities of IBM's cloud infrastructure. This tool provides a robust platform for integrating advanced AI functionalities into your applications, making it easier than ever to enhance user interactions with intelligent, context-aware responses.
+
+
+## Step 1: Environment Creation
+
+There are several ways to create an environment in Python. Follow these steps to set up your environment locally:
+
+1. **Install Python 3.10**
+   - Download and install Python 3.10 from [here](https://www.python.org/downloads/windows/).
+
+2. **Create a Virtual Environment**
+   - Open your terminal or command prompt and navigate to your project directory.
+   - Run the following command to create a virtual environment:
+     ```bash
+     python -m venv .venv
+     ```
+   - This command creates a new directory named `.venv` in your current working directory.
+
+3. **Activate the Virtual Environment**
+   - **Windows:**
+     ```bash
+     .venv\Scripts\activate.bat
+     ```
+   - **Linux:**
+     ```bash
+     source .venv/bin/activate
+     ```
+
+4. **Upgrade pip**
+   - Run the following command to upgrade pip:
+     ```bash
+     python -m pip install --upgrade pip
+     ```
+
+5. **Optional: Install JupyterLab for Development and Testing**
+   - If you want to use JupyterLab, install it by running:
+     ```bash
+     pip install ipykernel jupyterlab
+     ```
+
+## Step 2: Setup Libraries
+
+Once you have your environment set up and activated, you need to install the necessary libraries. Run the following command to install the required packages:
+
+```bash
+pip install streamlit python-dotenv  ibm_watson_machine_learning requests chromadb
+```
+
+IMPORTANT: Be aware of the disk space that will be taken up by documents when they're loaded into
+chromadb on your laptop. The size in chroma will likely be the same as .txt file size
+
+
+
+
+## Step 3: Getting API from IBM Cloud
+
+### Obtaining an API Key
+
+To obtain an API key from IBM Cloud, follow these steps:
+
+1. **Sign In**
+   - Go to [IBM Cloud](https://cloud.ibm.com) and sign in to your account.
+
+2. **Navigate to Account Settings**
+   - Click on your account name in the top right corner of the IBM Cloud dashboard.
+   - From the dropdown menu, select "Manage" to go to the Account settings.
+
+3. **Access API Keys**
+   - In the left-hand menu, click on “IBM Cloud API keys” under the “Access (IAM)” section.
+
+4. **Create an API Key**
+   - On the “API keys” page, click on the “Create an IBM Cloud API key” button.
+   - Provide a name and an optional description for your API key.
+   - Select the appropriate access policies if needed.
+   - Click on the “Create” button to generate the API key.
+
+5. **Save Your API Key**
+   - Once the API key is created, a dialog box displaying the API key value will appear.
+   - Make sure to copy and save this key as it will not be shown again.
+
+> Note: The steps above are based on the current IBM Cloud interface. They may vary slightly depending on any updates or changes. If you encounter any difficulties or if the steps do not match your IBM Cloud interface, refer to the IBM Cloud documentation or contact IBM support for assistance.
+
+### Retrieving the Project ID for IBM Watsonx
+
+To obtain the Project ID for IBM Watsonx, you will need access to the IBM Watson Machine Learning (WML) service. Follow these steps:
+
+1. **Log In**
+   - Log in to the [IBM Cloud Console](https://cloud.ibm.com) using your IBM Cloud credentials.
+
+2. **Navigate to Watson Machine Learning**
+   - Go to the Watson Machine Learning service.
+
+3. **Access Service Instance**
+   - Click on the service instance associated with your Watsonx project.
+
+4. **Find Service Credentials**
+   - In the left-hand menu, click on “Service credentials”.
+   - Under the “Credentials” tab, you will find a list of service credentials associated with your Watsonx project.
+
+5. **Retrieve Project ID**
+   - Click on the name of the service credential you want to use.
+   - In the JSON object, find the “project_id” field. The value of this field is your Project ID.
+
+### Adding Credentials to Your Project
+
+Add the API key and Project ID to the `.env` file in your project directory:
+
+```plaintext
+API_KEY=your_api_key
+PROJECT_ID=your_project_id
+```
+
+This will configure your project to connect to Watsonx.ai using the obtained credentials.
+
+Step 4: Creation of app.py
+
+In the followig section we are going to  invoke Large Language Models (LLMs) deployed in watsonx.ai. Documentation: [here](https://ibm.github.io/watson-machine-learning-sdk/foundation_models.html)
+This example shows a Question and Answer use case for a provided web site
+
+
+

env.bat

@@ -0,0 +1 @@
+.venv\Scripts\activate.bat

env.sh

@@ -0,0 +1 @@
+source .venv/Scripts/activate

streamlit_webchat.py

@@ -0,0 +1,51 @@
+# For reading credentials from the .env file
+import os
+from dotenv import load_dotenv
+import streamlit as st
+import webchat
+# URL of the hosted LLMs is hardcoded because at this time all LLMs share the same endpoint
+url = "https://us-south.ml.cloud.ibm.com"
+
+# These global variables will be updated in get_credentials() function
+watsonx_project_id = ""
+# Replace with your IBM Cloud key
+api_key = ""
+
+def get_credentials():
+
+    load_dotenv()
+    # Update the global variables that will be used for authentication in another function
+    globals()["api_key"] = os.getenv("api_key", None)
+    globals()["watsonx_project_id"] = os.getenv("project_id", None)
+
+
+def main():
+
+    # Get the API key and project id and update global variables
+    get_credentials()
+
+    # Use the full page instead of a narrow central column
+    st.set_page_config(layout="wide")
+
+    # Streamlit app title
+    st.title("🌠Demo of RAG with a Web page")
+
+    user_url = st.text_input('Provide a URL')
+
+    collection_name = st.text_input('Provide a unique name for this website (lower case). Use the same name for the same URL to avoid loading data multiple times.')
+
+    # UI component to enter the question
+    question = st.text_area('Question',height=100)
+    button_clicked = st.button("Answer the question")
+
+    st.subheader("Response")
+
+    # Invoke the LLM when the button is clicked
+    if button_clicked:
+        response = webchat.answer_questions_from_web(api_key,watsonx_project_id,user_url,question,collection_name)
+        st.write(response)
+
+if __name__ == "__main__":
+    main()
+
+

webchat.py

@@ -0,0 +1,221 @@
+# For reading credentials from the .env file
+import os
+from dotenv import load_dotenv
+
+from sentence_transformers import SentenceTransformer
+from chromadb.api.types import EmbeddingFunction
+
+# WML python SDK
+from ibm_watson_machine_learning.foundation_models import Model
+from ibm_watson_machine_learning.metanames import GenTextParamsMetaNames as GenParams
+from ibm_watson_machine_learning.foundation_models.utils.enums import ModelTypes, DecodingMethods
+
+import requests
+from bs4 import BeautifulSoup
+import spacy
+import chromadb
+import en_core_web_md
+
+# Important: hardcoding the API key in Python code is not a best practice. We are using
+# this approach for the ease of demo setup. In a production application these variables
+# can be stored in an .env or a properties file
+
+# URL of the hosted LLMs is hardcoded because at this time all LLMs share the same endpoint
+url = "https://us-south.ml.cloud.ibm.com"
+
+# These global variables will be updated in get_credentials() function
+watsonx_project_id = ""
+# Replace with your IBM Cloud key
+api_key = ""
+
+def get_credentials():
+
+    load_dotenv()
+    # Update the global variables that will be used for authentication in another function
+    globals()["api_key"] = os.getenv("api_key", None)
+    globals()["watsonx_project_id"] = os.getenv("project_id", None)
+
+# The get_model function creates an LLM model object with the specified parameters
+
+def get_model(model_type, max_tokens, min_tokens, decoding, temperature, top_k, top_p):
+    generate_params = {
+        GenParams.MAX_NEW_TOKENS: max_tokens,
+        GenParams.MIN_NEW_TOKENS: min_tokens,
+        GenParams.DECODING_METHOD: decoding,
+        GenParams.TEMPERATURE: temperature,
+        GenParams.TOP_K: top_k,
+        GenParams.TOP_P: top_p,
+    }
+
+    model = Model(
+        model_id=model_type,
+        params=generate_params,
+        credentials={
+            "apikey": api_key,
+            "url": url
+        },
+        project_id=watsonx_project_id
+    )
+
+    return model
+
+def get_model_test(model_type, max_tokens, min_tokens, decoding, temperature):
+    generate_params = {
+        GenParams.MAX_NEW_TOKENS: max_tokens,
+        GenParams.MIN_NEW_TOKENS: min_tokens,
+        GenParams.DECODING_METHOD: decoding,
+        GenParams.TEMPERATURE: temperature
+    }
+
+    model = Model(
+        model_id=model_type,
+        params=generate_params,
+        credentials={
+            "apikey": api_key,
+            "url": url
+        },
+        project_id=watsonx_project_id
+    )
+
+    return model
+
+
+# Embedding function
+class MiniLML6V2EmbeddingFunction(EmbeddingFunction):
+    MODEL = SentenceTransformer('all-MiniLM-L6-v2')
+
+    def __call__(self, texts):
+        return MiniLML6V2EmbeddingFunction.MODEL.encode(texts).tolist()
+
+
+def extract_text(url):
+    try:
+        # Send an HTTP GET request to the URL
+        response = requests.get(url)
+
+        # Check if the request was successful
+        if response.status_code == 200:
+            # Parse the HTML content of the page using BeautifulSoup
+            soup = BeautifulSoup(response.text, 'html.parser')
+
+            # Extract contents of <p> elements
+            p_contents = [p.get_text() for p in soup.find_all('p')]
+
+            # Print the contents of <p> elements
+            print("\nContents of <p> elements: \n")
+            for content in p_contents:
+                print(content)
+            raw_web_text = " ".join(p_contents)
+            # remove \xa0 which is used in html to avoid words break acorss lines.
+            cleaned_text = raw_web_text.replace("\xa0", " ")
+            return cleaned_text
+
+        else:
+            print(f"Failed to retrieve the page. Status code: {response.status_code}")
+
+    except Exception as e:
+        print(f"An error occurred: {str(e)}")
+
+
+def split_text_into_sentences(text):
+    nlp = spacy.load("en_core_web_md")
+    doc = nlp(text)
+    sentences = [sent.text for sent in doc.sents]
+    cleaned_sentences = [s.strip() for s in sentences]
+    return cleaned_sentences
+
+
+def create_embedding(url, collection_name):
+    cleaned_text = extract_text(url)
+    cleaned_sentences = split_text_into_sentences(cleaned_text)
+
+    client = chromadb.Client()
+
+    collection = client.get_or_create_collection(collection_name)
+
+    # Upload text to chroma
+    collection.upsert(
+        documents=cleaned_sentences,
+        metadatas=[{"source": str(i)} for i in range(len(cleaned_sentences))],
+        ids=[str(i) for i in range(len(cleaned_sentences))],
+    )
+
+    return collection
+
+
+def create_prompt(url, question, collection_name):
+    # Create embeddings for the text file
+    collection = create_embedding(url, collection_name)
+
+    # query relevant information
+    relevant_chunks = collection.query(
+        query_texts=[question],
+        n_results=5,
+    )
+    context = "\n\n\n".join(relevant_chunks["documents"][0])
+    # Please note that this is a generic format. You can change this format to be specific to llama
+    prompt = (f"{context}\n\nPlease answer the following question in one sentence using this "
+              + f"text. "
+              + f"If the question is unanswerable, say \"unanswerable\". Do not include information that's not relevant to the question."
+              + f"Question: {question}")
+
+    return prompt
+
+
+def main():
+
+    # Get the API key and project id and update global variables
+    get_credentials()
+
+    # Try diffrent URLs and questions
+    url = "https://www.usbank.com/financialiq/manage-your-household/buy-a-car/own-electric-vehicles-learned-buying-driving-EVs.html"
+
+    question = "What are the incentives for purchasing EVs?"
+    # question = "What is the percentage of driving powered by hybrid cars?"
+    # question = "Can an EV be plugged in to a household outlet?"
+    collection_name = "test_web_RAG"
+
+    answer_questions_from_web(api_key, watsonx_project_id, url, question, collection_name)
+
+
+def answer_questions_from_web(request_api_key, request_project_id, url, question, collection_name):
+    # Update the global variable
+    globals()["api_key"] = request_api_key
+    globals()["watsonx_project_id"] = request_project_id
+
+    # Specify model parameters
+    model_type = "meta-llama/llama-2-70b-chat"
+    max_tokens = 100
+    min_tokens = 50
+    top_k = 50
+    top_p = 1
+    decoding = DecodingMethods.GREEDY
+    temperature = 0.7
+
+    # Get the watsonx model = try both options
+    model = get_model(model_type, max_tokens, min_tokens, decoding, temperature, top_k, top_p)
+
+    # Get the prompt
+    complete_prompt = create_prompt(url, question, collection_name)
+
+    # Let's review the prompt
+    print("----------------------------------------------------------------------------------------------------")
+    print("*** Prompt:" + complete_prompt + "***")
+    print("----------------------------------------------------------------------------------------------------")
+
+    generated_response = model.generate(prompt=complete_prompt)
+    response_text = generated_response['results'][0]['generated_text']
+
+    # Remove trailing white spaces
+    response_text = response_text.strip()
+
+    # print model response
+    print("--------------------------------- Generated response -----------------------------------")
+    print(response_text)
+    print("*********************************************************************************************")
+
+    return response_text
+
+# Invoke the main function
+if __name__ == "__main__":
+    main()